Go语言在极小硬件上的运用（一）

Go 语言，能在多低下的配置上运行并发挥作用呢？

我最近购买了一个特别便宜的开发板：

 

STM32F030F4P6

我购买它的理由有三个。首先，我（作为程序员）从未接触过 STM320 系列的开发板。其次，STM32F10x 系列使用也有点少了。STM320 系列的 MCU 很便宜，有更新一些的外设，对系列产品进行了改进，问题修复也做得更好了。最后，为了这篇文章，我选用了这一系列中最低配置的开发板，整件事情就变得有趣起来了。

硬件部分

STM32F030F4P6 给人留下了很深的印象：

• CPU: Cortex M0 48 MHz（最低配置，只有 12000 个逻辑门电路）
• RAM: 4 KB，
• Flash: 16 KB，
• ADC、SPI、I2C、USART 和几个定时器

以上这些采用了 TSSOP20 封装。正如你所见，这是一个很小的 32 位系统。

软件部分

如果你想知道如何在这块开发板上使用 Go 编程，你需要反复阅读硬件规范手册。你必须面对这样的真实情况：在 Go 编译器中给 Cortex-M0 提供支持的可能性很小。而且，这还仅仅只是第一个要解决的问题。

我会使用 Emgo，但别担心，之后你会看到，它如何让 Go 在如此小的系统上尽可能发挥作用。

在我拿到这块开发板之前，对 stm32/hal 系列下的 F0 MCU 没有任何支持。在简单研究参考手册后，我发现 STM32F0 系列是 STM32F3 削减版，这让在新端口上开发的工作变得容易了一些。

如果你想接着本文的步骤做下去，需要先安装 Emgo

cd $HOME
git clone https://github.com/ziutek/emgo/
cd emgo/egc
go install

然后设置一下环境变量

export EGCC=path_to_arm_gcc      # eg. /usr/local/arm/bin/arm-none-eabi-gcc
export EGLD=path_to_arm_linker   # eg. /usr/local/arm/bin/arm-none-eabi-ld
export EGAR=path_to_arm_archiver # eg. /usr/local/arm/bin/arm-none-eabi-ar
 
export EGROOT=$HOME/emgo/egroot
export EGPATH=$HOME/emgo/egpath
 
export EGARCH=cortexm0
export EGOS=noos
export EGTARGET=f030x6

更详细的说明可以在 Emgo 官网上找到。

egcPATHgo buildgo installegc$HOME/bin/usr/local/bin

现在，为你的第一个 Emgo 程序创建一个新文件夹，随后把示例中链接器脚本复制过来：

mkdir $HOME/firstemgo
cd $HOME/firstemgo
cp $EGPATH/src/stm32/examples/f030-demo-board/blinky/script.ld .

最基本程序

main.go

package main
 
func main() {
}

文件编译没有出现任何问题：

$ egc
$ arm-none-eabi-size cortexm0.elf
   text    data     bss     dec     hex filename
   7452     172     104    7728    1e30 cortexm0.elf

第一次编译可能会花点时间。编译后产生的二进制占用了 7624 个字节的 Flash 空间（文本 + 数据）。对于一个什么都没做的程序来说，占用的空间有些大。还剩下 8760 字节，可以用来做些有用的事。

不妨试试传统的 “Hello, World!” 程序：

package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

不幸的是，这次结果有些糟糕：

$ egc
/usr/local/arm/bin/arm-none-eabi-ld: /home/michal/P/go/src/github.com/ziutek/emgo/egpath/src/stm32/examples/f030-demo-board/blog/cortexm0.elf section `.text' will not fit in region `Flash'
/usr/local/arm/bin/arm-none-eabi-ld: region `Flash' overflowed by 10880 bytes
exit status 1

“Hello, World!” 需要 STM32F030x6 上至少 32KB 的 Flash 空间。

fmtstrconvreflectstrconv

闪烁

我们的开发板上有一个与 PA4 引脚和 VCC 相连的 LED。这次我们的代码稍稍长了一些：

package main
 
import (
    "delay"
 
    "stm32/hal/gpio"
    "stm32/hal/system"
    "stm32/hal/system/timer/systick"
)
 
var led gpio.Pin
 
func init() {
    system.SetupPLL(8, 1, 48/8)
    systick.Setup(2e6)
 
    gpio.A.EnableClock(false)
    led = gpio.A.Pin(4)
 
    cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
    led.Setup(cfg)
}
 
func main() {
    for {
        led.Clear()
        delay.Millisec(100)
        led.Set()
        delay.Millisec(900)
    }
}

init

system.SetupPLL(8, 1, 48/8)

systick.Setup(2e6)

gpio.A.EnableClock(false)False

led.Setup(cfg)

led.Clear()

led.Set()

编译这个代码：

$ egc
$ arm-none-eabi-size cortexm0.elf
   text    data     bss     dec     hex filename
   9772     172     168   10112    2780 cortexm0.elf

正如你所看到的，这个闪烁程序占用了 2320 字节，比最基本程序占用空间要大。还有 6440 字节的剩余空间。

看看代码是否能运行：

$ openocd -d0 -f interface/stlink.cfg -f target/stm32f0x.cfg -c 'init; program cortexm0.elf; reset run; exit'
Open On-Chip Debugger 0.10.0+dev-00319-g8f1f912a (2018-03-07-19:20)
Licensed under GNU GPL v2
For bug reports, read
        http://openocd.org/doc/doxygen/bugs.html
debug_level: 0
adapter speed: 1000 kHz
adapter_nsrst_delay: 100
none separate
adapter speed: 950 kHz
target halted due to debug-request, current mode: Thread 
xPSR: 0xc1000000 pc: 0x0800119c msp: 0x20000da0
adapter speed: 4000 kHz
** Programming Started **
auto erase enabled
target halted due to breakpoint, current mode: Thread 
xPSR: 0x61000000 pc: 0x2000003a msp: 0x20000da0
wrote 10240 bytes from file cortexm0.elf in 0.817425s (12.234 KiB/s)
** Programming Finished **
adapter speed: 950 kHz

在这篇文章中，这是我第一次，将一个短视频转换成动画 PNG。我对此印象很深，再见了 YouTube。 对于 IE 用户，我很抱歉，更多信息请看 apngasm。我本应该学习 HTML5，但现在，APNG 是我最喜欢的，用来播放循环短视频的方法了。

 

STM32F030F4P6

更多的 Go 语言编程

如果你不是一个 Go 程序员，但你已经听说过一些关于 Go 语言的事情，你可能会说：“Go 语法很好，但跟 C 比起来，并没有明显的提升。让我看看 Go 语言的通道和协程！”

接下来我会一一展示:

import (
    "delay"
 
    "stm32/hal/gpio"
    "stm32/hal/system"
    "stm32/hal/system/timer/systick"
)
 
var led1, led2 gpio.Pin
 
func init() {
    system.SetupPLL(8, 1, 48/8)
    systick.Setup(2e6)
 
    gpio.A.EnableClock(false)
    led1 = gpio.A.Pin(4)
    led2 = gpio.A.Pin(5)
 
    cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
    led1.Setup(cfg)
    led2.Setup(cfg)
}
 
func blinky(led gpio.Pin, period int) {
    for {
        led.Clear()
        delay.Millisec(100)
        led.Set()
        delay.Millisec(period - 100)
    }
}
 
func main() {
    go blinky(led1, 500)
    blinky(led2, 1000)
}

mainblinkymainblinkygpio.Pin

goroutines(tasks)script.ld

ISRStack = 1024;
MainStack = 1024;
TaskStack = 1024;
MaxTasks = 2;
 
INCLUDE stm32/f030x4
INCLUDE stm32/loadflash
INCLUDE noos-cortexm

栈的大小需要靠猜，现在还不用关心这一点。

$ egc
$ arm-none-eabi-size cortexm0.elf
   text    data     bss     dec     hex filename
  10020     172     172   10364    287c cortexm0.elf

另一个 LED 和协程一共占用了 248 字节的 Flash 空间。

 

STM32F030F4P6

通道

通道是 Go 语言中协程之间相互通信的一种推荐方式。Emgo 甚至能允许通过中断处理来使用缓冲通道。下一个例子就展示了这种情况。

package main
 
import (
    "delay"
    "rtos"
 
    "stm32/hal/gpio"
    "stm32/hal/irq"
    "stm32/hal/system"
    "stm32/hal/system/timer/systick"
    "stm32/hal/tim"
)
 
var (
    leds  [3]gpio.Pin
    timer *tim.Periph
    ch    = make(chan int, 1)
)
 
func init() {
    system.SetupPLL(8, 1, 48/8)
    systick.Setup(2e6)
 
    gpio.A.EnableClock(false)
    leds[0] = gpio.A.Pin(4)
    leds[1] = gpio.A.Pin(5)
    leds[2] = gpio.A.Pin(9)
 
    cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
    for _, led := range leds {
        led.Set()
        led.Setup(cfg)
    }
 
    timer = tim.TIM3
    pclk := timer.Bus().Clock()
    if pclk < system.AHB.Clock() {
        pclk *= 2
    }
    freq := uint(1e3) // Hz
    timer.EnableClock(true)
    timer.PSC.Store(tim.PSC(pclk/freq - 1))
    timer.ARR.Store(700) // ms
    timer.DIER.Store(tim.UIE)
    timer.CR1.Store(tim.CEN)
 
    rtos.IRQ(irq.TIM3).Enable()
}
 
func blinky(led gpio.Pin, period int) {
    for range ch {
        led.Clear()
        delay.Millisec(100)
        led.Set()
        delay.Millisec(period - 100)
    }
}
 
func main() {
    go blinky(leds[1], 500)
    blinky(leds[2], 500)
}
 
func timerISR() {
    timer.SR.Store(0)
    leds[0].Set()
    select {
    case ch <- 0:
        // Success
    default:
        leds[0].Clear()
    }
}
 
//c:__attribute__((section(".ISRs")))
var ISRs = [...]func(){
    irq.TIM3: timerISR,
}

与之前例子相比较下的不同:

TIM3timerISRirq.TIM3timerISRblinkyISRsblinkyforrange

leds

APBCLK = AHBCLKAPBCLKAPBCLK

如果 CNT 寄存器增加 1 kHz，那么 ARR 寄存器的值等于更新事件（重载事件）在毫秒中的计数周期。 为了让更新事件产生中断，必须要设置 DIER 寄存器中的 UIE 位。CEN 位能启动时钟。

timer.EnableClock(true)

timerISRirq.TIM3timer.SR.Store(0)

下面的这几行代码：

select {
case ch <- 0:
    // Success
default:
    leds[0].Clear()
}

default

ISRs//c:__attribute__((section(".ISRs"))).ISRs

blinkyfor

for range ch {
    led.Clear()
    delay.Millisec(100)
    led.Set()
    delay.Millisec(period - 100)
}

等价于：

for {
    _, ok := <-ch
    if !ok {
        break // Channel closed.
    }
    led.Clear()
    delay.Millisec(100)
    led.Set()
    delay.Millisec(period - 100)
}

intstruct{}struct{}{}

让我们来编译一下代码:

$ egc
$ arm-none-eabi-size cortexm0.elf
   text    data     bss     dec     hex filename
  11096     228     188   11512    2cf8 cortexm0.elf

新的例子占用了 11324 字节的 Flash 空间，比上一个例子多占用了 1132 字节。

timerISRselect

 

STM32F030F4P6

开发板上的 LED 一直没有亮起，说明通道从未出现过溢出。

timer.ARR.Store(700)timer.ARR.Store(200)timerISR

 

STM32F030F4P6

timerISR

第一部分到这里就结束了。你应该知道，这一部分并未展示 Go 中最重要的部分，接口。

协程和通道只是一些方便好用的语法。你可以用自己的代码来替换它们，这并不容易，但也可以实现。接口是Go 语言的基础。这是文章中 第二部分所要提到的.

在 Flash 上我们还有些剩余空间。