TinyGo - Raspberry PICO - using SVD files to program

[Gustavomurta]

I'm very happy today. Because I finally learned how to program TinyGo on the Raspberry Pico using SVD files. It's amazing how much easier it is to access and manipulate registers.
With questions and answers to and from ChatGPT, I learned how this programming works.

As easy as PEEK and POKE on the Commodore 64!

[Gustavomurta]

Accessing the SVD file and looking for the already defined registers, I was able to successfully perform my first test.

(https://github.com/cmsis-svd/cmsis-svd-data/blob/main/data/RaspberryPi/rp2040.svd)

"The CMSIS (Common Microcontroller Software Interface Standard) is a set of APIs, software components, tools, and workflows that help to simplify software re-use, reduce the learning curve for microcontroller developers, speed-up project build and debug, and thus reduce the time to market for new applications."

"The CMSIS System View Description format(CMSIS-SVD) formalizes the description of the system contained in ARM Cortex-M processor-based microcontrollers, in particular, the memory-mapped registers of peripherals."

Accessing the RP2040 Voltage Regulator Registers:

(https://github.com/Gustavomurta/tinyGo_my_experiments/tree/main/Raspberry_Pico/Pico_Voltage_Regulatos/pico_vreg_V2)

package main

import (
	"device/rp"
	"fmt"
	"machine"
	"time"
)

func main() {

	machine.InitSerial()        // Initialize serial for debug output
	time.Sleep(3 * time.Second) // Sleep to catch prints on serial
	println("Get PICO Voltage Regulators registers:")
	println()

	// --- Read VREG Register ---///////////////////////////////////
	vselValue := rp.VREG_AND_CHIP_RESET.VREG.Get() // Voltage regulator control and status
	fmt.Printf("VREG (Voltage Regulator) Register Value: 0x%08X \n", vselValue)

	// --- Read BOD Register ---////////////////////////////////////
	bodValue := rp.VREG_AND_CHIP_RESET.BOD.Get() // brown-out detection control
	fmt.Printf("BOD (brown-out detection) Register Value: 0x%08X \n", bodValue)

	// --- Read CHIP_RESET Register ---/////////////////////////////
	chipResetValue := rp.VREG_AND_CHIP_RESET.CHIP_RESET.Get() // Chip reset control and status
	fmt.Printf("CHIP_RESET (Chip Reset Status) Register Value: 0x%08X \n", chipResetValue)	
}

`---- Opened the serial port COM6 ----

Get PICO Voltage Regulators registers:

VREG (Voltage Regulator) Register Value: 0x000010C1
BOD (brown-out detection) Register Value: 0x00000091
CHIP_RESET (Chip Reset Status) Register Value: 0x00010000`

[Gustavomurta]

RP240 Datasheet:

https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf

2.10. Core Supply Regulator

"RP2040 includes an on-chip voltage regulator, allowing the digital core supply (DVDD) to be generated from an external, nominally 1.8V to 3.3V, power supply. In most cases, the regulator’s input supply will share an external power source with the chip’s digital IO supply IOVDD, simplifying the overall power supply requirements."

2.10.6. List of Registers

"The VREG_AND_CHIP_RESET registers start at a base address of 0x40064000 (defined as VREG_AND_CHIP_RESET_BASE
in SDK)."

[Gustavomurta]

2.15.7. List of Registers (RP2040 Datasheet.pdf)
The Clocks registers start at a base address of 0x40008000 (defined as CLOCKS_BASE in SDK).

package main

import (
	"device/rp"
	"fmt"
	"machine"
	"time"
)

func main() {

	machine.InitSerial()        // Initialize serial for debug output
	time.Sleep(3 * time.Second) // Sleep to catch prints on serial
	fmt.Printf("Get PICO CLOCKs registers: \n")

	// CLOCKS registers /////////////////////////////////////////////

	clockRefControl := rp.CLOCKS.CLK_REF_CTRL.Get() // 0x30
	fmt.Printf("1) Clock Reference Control: 0x%08X \n", clockRefControl)

	clockRefDivisor := rp.CLOCKS.CLK_REF_DIV.Get() // 0x34
	fmt.Printf("2) Clock Reference Divisor: 0x%08X \n", clockRefDivisor)

	clockRefSelected := rp.CLOCKS.CLK_REF_SELECTED.Get() // 0x38
	fmt.Printf("3) Clock Reference source selected: 0x%08X \n", clockRefSelected)

	clockSysControl := rp.CLOCKS.CLK_SYS_CTRL.Get() // 0x3C
	fmt.Printf("4) Clock System Control: 0x%08X \n", clockSysControl)

	clockSysDivisor := rp.CLOCKS.CLK_SYS_DIV.Get() // 0x40
	fmt.Printf("5) Clock System Divisor: 0x%08X \n", clockSysDivisor)

	clockSysSelected := rp.CLOCKS.CLK_SYS_SELECTED.Get() // 0x44
	fmt.Printf("6) Clock System source selected: 0x%08X \n", clockSysSelected)

	fc0RefKHz := rp.CLOCKS.FC0_REF_KHZ.Get() // 0x8C
	fmt.Printf("7) Frequency Counter Reference clock frequency in kHz: 0x%08X \n", fc0RefKHz)

	fc0MinKHz := rp.CLOCKS.FC0_MIN_KHZ.Get() // 0x90
	fmt.Printf("8) Frequency Counter Minimum pass frequency in kHz: 0x%08X \n", fc0MinKHz)

	fc0MaxKHz := rp.CLOCKS.FC0_MAX_KHZ.Get() // 0x94
	fmt.Printf("9) Frequency Counter Maximum pass frequency in kHz: 0x%08X \n", fc0MaxKHz)

	fc0Delay := rp.CLOCKS.FC0_DELAY.Get() // 0x98
	fmt.Printf("10) Delays the start of the frequency counting: 0x%08X \n", fc0Delay)

	fc0Interval := rp.CLOCKS.FC0_INTERVAL.Get() // 0x9C
	fmt.Printf("11) Test interval of the frequency counter: 0x%08X \n", fc0Interval)

	fc0SRC := rp.CLOCKS.FC0_SRC.Get() // 0xA0
	fmt.Printf("12) Clock sent to frequency counter: 0x%08X \n", fc0SRC)

	fc0Status := rp.CLOCKS.FC0_STATUS.Get() // 0xA4
	fmt.Printf("13) Frequency counter status: 0x%08X \n", fc0Status)

	fc0Result := rp.CLOCKS.FC0_RESULT.Get() // 0xA8
	fmt.Printf("14) Result of frequency measurement: 0x%08X \n", fc0Result)

	// XOSC registers ///////////////////////////////////////////////////////

	xOSCControl := rp.XOSC.CTRL.Get() // 0x00
	fmt.Printf("15) Crystal Oscillator Control: 0x%08X \n", xOSCControl)

	xOSCStatus := rp.XOSC.STATUS.Get() // 0x04
	fmt.Printf("16) Crystal Oscillator Status: 0x%08X \n", xOSCStatus)

	xOSCCount := rp.XOSC.COUNT.Get() // 0x10
	fmt.Printf("17) Down counter running - counts to zero and stops: 0x%08X \n", xOSCCount)

	// PLL SYS registers ///////////////////////////////////////////////////

	pllSysControlStatus := rp.PLL_SYS.CS.Get() // 0x00
	fmt.Printf("18) PLL SYS Control and Status: 0x%08X \n", pllSysControlStatus)

	pllSysPower := rp.PLL_SYS.PWR.Get() // 0x04
	fmt.Printf("19) Controls the PLL SYS power modes: 0x%08X \n", pllSysPower)

	pllSysFdbkDivisor := rp.PLL_SYS.FBDIV_INT.Get() // 0x08
	fmt.Printf("20) PLL SYS Feedback divisor: 0x%08X \n", pllSysFdbkDivisor)

	pllSysPostDivisor := rp.PLL_SYS.PRIM.Get() // 0x10
	fmt.Printf("21) PLL SYS post dividers for the primary output: 0x%08X \n", pllSysPostDivisor)
}

**Running at Raspberry Pico (RP2040)** PLL SYS = 200 MHz

Get PICO CLOCKs registers: 
1) Clock Reference Control: 0x00000002 
2) Clock Reference Divisor: 0x00000100 
3) Clock Reference source selected: 0x00000004 
4) Clock System Control: 0x00000001 
5) Clock System Divisor: 0x00000100 
6) Clock System source selected: 0x00000002 
7) Frequency Counter Reference clock frequency in kHz: 0x00000000 
8) Frequency Counter Minimum pass frequency in kHz: 0x00000000 
9) Frequency Counter Maximum pass frequency in kHz: 0x01FFFFFF 
10) Delays the start of the frequency counting: 0x00000001 
11) Test interval of the frequency counter: 0x00000008 
12) Clock sent to frequency counter: 0x00000000 
13) Frequency counter status: 0x00000011 
14) Result of frequency measurement: 0x00000000 
15) Crystal Oscillator Control: 0x00FABAA0 
16) Crystal Oscillator Status: 0x81001001 
17) Down counter running - counts to zero and stops: 0x00000000 
18) PLL SYS Control and Status: 0x80000001 
19) Controls the PLL SYS power modes: 0x00000004 
20) PLL SYS Feedback divisor: 0x00000064 
21) PLL SYS post dividers for the primary output: 0x00061000 

**Running at Raspberry Pico2 (RP2350)** PLL SYS = 150 MHz

Get PICO CLOCKs registers: 
1) Clock Reference Control: 0x00000002 
2) Clock Reference Divisor: 0x00010000 
3) Clock Reference source selected: 0x00000004 
4) Clock System Control: 0x00000001 
5) Clock System Divisor: 0x00010000 
6) Clock System source selected: 0x00000002 
7) Frequency Counter Reference clock frequency in kHz: 0x00000000 
8) Frequency Counter Minimum pass frequency in kHz: 0x00000000 
9) Frequency Counter Maximum pass frequency in kHz: 0x01FFFFFF 
10) Delays the start of the frequency counting: 0x00000001 
11) Test interval of the frequency counter: 0x00000008 
12) Clock sent to frequency counter: 0x00000000 
13) Frequency counter status: 0x00000011 
14) Result of frequency measurement: 0x00000000 
15) Crystal Oscillator Control: 0x00FABAA0 
16) Crystal Oscillator Status: 0x81001000 
17) Down counter running - counts to zero and stops: 0x00000000 
18) PLL SYS Control and Status: 0x80000001 
19) Controls the PLL SYS power modes: 0x00000004 
20) PLL SYS Feedback divisor: 0x0000007D 
21) PLL SYS post dividers for the primary output: 0x00052000 

[Gustavomurta]

Preparing the development of the RP2040 Internal Frequency Counter program:

2.15.6.2. Using the frequency counter (RP2040 Datasheet.pdf) :
To use the frequency counter, the programmer must:
• Set the reference frequency: clk_ref
• Set the mux position of the source they want to measure. See FC0_SRC
• Wait for the DONE status bit in FC0_STATUS to be set
• Read the result

package main

import (
	"device/rp"
	"fmt"
	"machine"
	"time"
)

func main() {

	machine.InitSerial()        // Initialize serial for debug output
	time.Sleep(3 * time.Second) // Sleep to catch prints on serial
	fmt.Printf("Raspberry Pico internal Frequency Counter \n")

	fc0RefKHz := rp.CLOCKS.FC0_REF_KHZ.Get()
	fmt.Printf("1) Reference clock frequency in KHz: 0x%08X \n", fc0RefKHz)

	fc0MinKHz := rp.CLOCKS.FC0_MIN_KHZ.Get()
	fmt.Printf("2) Minimum pass frequency in kHz: 0x%08X \n", fc0MinKHz) // This is optional. Set to 0 if you are not using

	fc0MaxKHz := rp.CLOCKS.FC0_MAX_KHZ.Get()
	fmt.Printf("3) Maximum pass frequency in kHz: 0x%08X \n", fc0MaxKHz) // This is optional. Set to 0x1ffffff if you are not using

	fc0Delay := rp.CLOCKS.FC0_DELAY.Get()
	fmt.Printf("4) Delays the start of the frequency counting: 0x%08X \n", fc0Delay) // Delay is measured in multiples of the reference clock period

	fc0Interval := rp.CLOCKS.FC0_INTERVAL.Get()
	fmt.Printf("5) Test interval of the frequency counter: 0x%08X \n", fc0Interval) // The default gives a test interval of 250us

	fc0SRC := rp.CLOCKS.FC0_SRC.Get()
	fmt.Printf("6) Clock sent to frequency counter: 0x%08X \n", fc0SRC) // Writing to this register initiates the frequency count

	fc0Status := rp.CLOCKS.FC0_STATUS.Get()
	fmt.Printf("7) Frequency counter status: 0x%08X \n", fc0Status)

	fc0Result := rp.CLOCKS.FC0_RESULT.Get()
	fmt.Printf("8) Result of frequency measurement: 0x%08X \n", fc0Result) // only valid when status_done=1
}

///////////////////////////////////////////////////////
Raspberry Pico RP2040 - A 

---- Opened the serial port COM6 ----
Raspberry Pico internal Frequency Counter
 1) Reference clock frequency in KHz: 0x00000000 
 2) Minimum pass frequency in kHz: 0x00000000 
 3) Maximum pass frequency in kHz: 0x01FFFFFF 
 4) Delays the start of the frequency counting: 0x00000001 
 5) Test interval of the frequency counter: 0x00000008 
 6) Clock sent to frequency counter: 0x00000000 
 7) Frequency counter status: 0x00000011 
 8) Result of frequency measurement: 0x00000000 


///////////////////////////////////////////////////////
Raspberry Pico2 RP2350 - A 

---- Opened the serial port COM6 ----
Raspberry Pico internal Frequency Counter 
 1) Reference clock frequency in KHz: 0x00000000 
 2) Minimum pass frequency in kHz: 0x00000000 
 3) Maximum pass frequency in kHz: 0x01FFFFFF 
 4) Delays the start of the frequency counting: 0x00000001 
 5) Test interval of the frequency counter: 0x00000008 
 6) Clock sent to frequency counter: 0x00000000 
 7) Frequency counter status: 0x00000011 
 8) Result of frequency measurement: 0x00000000 
 

[Gustavomurta]

Preparing program to Overclock Raspberry Pico - RP2040:

/*
RP2040 Datasheet.pdf
2.10. Core Supply Regulator
2.15. Clocks
2.18. PLL

 * There are two PLLs in RP2040. They are:
 *   - pll_sys - Used to generate up to a 133MHz system clock
 *   - pll_usb - Used to generate a 48MHz USB reference clock

Default PLL configuration:
                  REF     FBDIV VCO            POSTDIV
PLL SYS: 12 / 1 = 12MHz * 125 = 1500MHz / 6 / 2 = 125MHz
PLL USB: 12 / 1 = 12MHz * 100 = 1200MHz / 5 / 5 =  48MHz
*/

package main

import (
	"device/rp"
	"fmt"
	"machine"
	"time"
)

func decodeVsel(vregVsel uint32) float32 {

	switch vregVsel {
	case 0x6:
		return 0.85
	case 0x7:
		return 0.90
	case 0x8:
		return 0.95
	case 0x9:
		return 1.00
	case 0xA:
		return 1.05
	case 0xB:
		return 1.10
	case 0xC:
		return 1.15
	case 0xD:
		return 1.20
	case 0xE:
		return 1.25
	case 0xF:
		return 1.30
	default:
		return 0.80
	}
}

func main() {

	machine.InitSerial()        // Initialize serial for debug output
	time.Sleep(3 * time.Second) // Sleep to catch prints on serial
	fmt.Printf("Raspberry Pico Overclock: \n")

	// --- Read VREG Register ---///////////////////////////////////
	vregCtrlStatus := rp.VREG_AND_CHIP_RESET.VREG.Get() // Voltage regulator control and status
	fmt.Printf("Voltage Regulator Register Value: 0x%08X \n", vregCtrlStatus)

	vregVsel := (vregCtrlStatus >> 4) & 0xF // Voltage select bits
	fmt.Printf("Voltage Select = 0x%X -> %.2f V\n", vregVsel, decodeVsel(vregVsel))

	// PLL SYS registers ///////////////////////////////////////////////////

	pllSysControlStatus := rp.PLL_SYS.CS.Get() // Control and Status
	fmt.Printf("PLL SYS Control and Status: 0x%08X \n", pllSysControlStatus)

	pllSysPower := rp.PLL_SYS.PWR.Get() // Controls the PLL power modes
	fmt.Printf("Controls the PLL SYS power modes: 0x%08X \n", pllSysPower)

	pllSysFdbkDivisor := rp.PLL_SYS.FBDIV_INT.Get() // For XOSC=12 MHz Feedback divider min=63, max=133
	fmt.Printf("PLL SYS Feedback divisor: %d \n", pllSysFdbkDivisor)
	fmt.Printf("PLL VCO frequency: %d MHz \n", (pllSysFdbkDivisor * 12)) // Divisor * 12 MHz

	pllSysPostDivisor := rp.PLL_SYS.PRIM.Get() // Controls the PLL post dividers for the primary output
	fmt.Printf("PLL SYS post dividers for the primary output: 0x%08X \n", pllSysPostDivisor)

	postDiv1 := (pllSysPostDivisor >> 16) & 0x7
	fmt.Printf("PLL SYS post divider 1: %d \n", postDiv1)

	postDiv2 := (pllSysPostDivisor >> 12) & 0x7
	fmt.Printf("PLL SYS post divider 2: %d \n", postDiv2)

	// PLL SYS = (XOSC * FedbkDivisor) / postDiv1 / postDiv2
	pllSysFrequency := (12 * pllSysFdbkDivisor) / postDiv1 / postDiv2
	fmt.Printf("PLL SYS - System Clock frequency: %d MHz \n", pllSysFrequency)
}

Running at Raspberry Pico - RP2040:

Raspberry Pico Overclock: 
Voltage Regulator Register Value: 0x000010C1 
Voltage Select = 0xC -> 1.15 V
PLL SYS Control and Status: 0x80000001 
Controls the PLL SYS power modes: 0x00000004 
PLL SYS Feedback divisor: 100 
PLL VCO frequency: 1200 MHz 
PLL SYS post dividers for the primary output: 0x00061000 
PLL SYS post divider 1: 6 
PLL SYS post divider 2: 1 
PLL SYS - System Clock frequency: 200 MHz