【GO记录】从零开始GO语言——用GO语言做一个示波器（二）基于arduino的简易示波器

演示视频

用TinyGO语言做一个基于arduino的简易示波器

原理

原理就是用arduino获取高低电平模拟值的跳变，这就是示波器的电压值了，然后再来判断跳变的时间，来达到获取PWM或者触发信号的效果。

理论上应该用定时器加外部中断会比较号一点，但是我在TinGo中没找到定时器计时和外部中断的代码，所以就没做出来，然后arduino的时钟频率实在太低了，才16M。

示例代码地址：https://tinygo.org/docs/reference/microcontrollers/machine/bluepill/

思路

/* *思路：PWM波形是这样的： *__ __ __ * |__| |__| *我只需要捕获上升沿以及下降沿、周期的时间就可以计算出他的频率了 *电压使用ADC中获取的数值就可以了 */

代码

package main

import (
	"machine" //支持包
	"time"    //时间函数
)

//变量
var (
	//串口变量
	uart   = machine.Serial
	tx     = machine.UART_TX_PIN
	rx     = machine.UART_RX_PIN
	sensor machine.ADC

	//自定义变量
	//时间变量
	OS_time       uint64
	last_time     uint64
	now_time      uint64
	sys_time      time.Time
	delay1s       uint64 = 1000000000
	led_test_time uint64 = 0

	Pwm_time [10]uint64
	Pwm_Down uint64
	Pwm_Rise uint64

	//电压变量
	Vol_times     int
	voltage       uint16 = 0
	Vol_arr       [5]uint16
	Vol_default   uint16
	Vol_Down      uint16
	Vol_Rise      uint16
	Last_Vol_Rise uint16
)

//调试代码
func My_time() {
    
	sys_time := time.Now()
	now_time = sys_time.Nsec1()      //现在的计数周期 速度是16M 实际上测试并不准确
	OS_time = (now_time - last_time) //单位：10ns 精度在百微秒级
	last_time = now_time

	// println(now_time)
	//println(sys_time.Nanosecond())
	//println(OS_time) //系统运行周期所占时间
}

func led_test(led machine.Pin) {
    

	led_time := (now_time - led_test_time)
	if led_time > delay1s*2 {
    
		led.High()
		led_test_time = now_time
		//print("\r\nledtime:")
		//print(led_test_time)

		print("\r\n")
		/* for i := 0; i <= Vol_times; i++ { print("\r\n") print(i) print(":") print(Vol_arr[i]) }*/
		print("\r\n")

	} else {
    
		// println(now_time - led_test_time)
		// println(led_test_time)
		led.Low()
	}

}

func main() {
    

	//led引脚初始化 PD13
	led := machine.LED
	led.Configure(machine.PinConfig{
    Mode: machine.PinOutput})

	//串口1波特率：9600
	uart.Configure(machine.UARTConfig{
    TX: tx, RX: rx})
	uart.Write([]byte("UART_init BaudRate:9600\r\n"))

	//ADC初始化
	machine.InitADC()
	sensor = machine.ADC{
    machine.ADC0}
	sensor.Configure(machine.ADCConfig{
    }) //配置 参考电压、转换bit、单次采样次数 16bit：（0--5V）min=0 x=65535
	voltage := sensor.Get()               //获取电压值
	uart.Write([]byte("\r\nvol:"))        //打印电压
	print(voltage)

	sys_time := time.Now()       //获取时间值
	last_time = sys_time.Nsec1() //获取纳秒
	led_test_time = last_time
	uart.Write([]byte("\r\nsys_time:")) //打印时间
	print(last_time)

	for {
    
		//获取系统时间
		My_time()

		//获取ADC
		//AD_Sample() //电压采样调试
		AD_Pwm_Sample(sensor) //PWM捕获

		//led_test(led)
	}
}

func AD_Sample() {
    

	voltage := sensor.Get()
	//str1 := strconv.Itoa(int(voltage)) //整转串 方便打印
	//println("adc0:" + str1)
	voltage1 := uint32(voltage)
	voltage1 = ((voltage1 * 1000) / 65472) * 5 //此公式为 ((ADC的模拟值电压*精度)/转换bit)*参考电压 bit原理上应该为65535 但是实测5V时只有65472
	voltage = uint16(voltage1 / 1)
	//str1 = strconv.Itoa(int(voltage)) //整转串 方便打印
	//println("vol:" + str1)
	println(voltage)
	Vol_arr[Vol_times] = voltage
	println(Vol_arr[Vol_times])

	if Vol_times >= 99 {
    
		Vol_times = 0
	} else {
    
		Vol_times++
	}

	//uart.Write([]byte("\r\nvol:"))
	//print(voltage)

}

func AD_Sample2() (v uint16) {
    

	voltage := sensor.Get()
	voltage1 := uint32(voltage)
	voltage1 = ((voltage1 * 1000) / 65472) * 5 //此公式为 ((ADC的模拟值电压*精度)/转换bit)*参考电压 bit原理上应该为65535 但是实测5V时只有65472
	voltage = uint16(voltage1 / 1)             //可取精度1~1000 1000时单位为V
	//println(voltage)
	return voltage
}

/* *思路：PWM波形是这样的： *__ __ __ * |__| |__| *我只需要捕获上升沿以及下降沿、周期的时间就可以计算出他的频率了 *电压使用ADC中获取的数值就可以了 */
func AD_Pwm_Sample(sen machine.ADC) {
    
	i := 0

	for {
    
		voltage = AD_Sample2()
		//print("\r\nVol:")
		//print(voltage)
		//第一次上升沿
		if voltage > 4990 {
     //如果电压大于5000mV 默认触发电平为5000
			sys_time = time.Now()
			Pwm_time[0] = sys_time.Nsec1() //记录现在的时间
			Vol_arr[0] = voltage           //记录现在的电压值
			//记录PWM中第一次下降沿时间
			for {
    
				voltage = AD_Sample2() //获取电压
				if voltage < 130 {
         //如果电压小于30mv(防止BUG，本应该是0v)
					sys_time = time.Now()
					Pwm_time[1] = sys_time.Nsec1() //记录现在的时间
					Vol_arr[1] = voltage           //记录现在的电压值
					break                          // 退出for循环
				}
			}
			//记录PWM中第二次上升沿的时间
			for {
    
				voltage = AD_Sample2() //获取电压
				if voltage > 4990 {
        //如果电压大于3000mV
					sys_time = time.Now()
					Pwm_time[2] = sys_time.Nsec1() //记录现在的时间
					Vol_arr[2] = voltage           //记录现在的电压值
					i = 1
					break // 退出for循环
				}
			}
		}

		if i == 1 {
    

			Vol_default = Vol_arr[0]
			Vol_Down = Vol_arr[1]
			Vol_Rise = Vol_arr[2]
			Pwm_Down = (Pwm_time[1] - Pwm_time[0]) / 1000000 //下降沿时间 单位是ms
			Pwm_Rise = (Pwm_time[2] - Pwm_time[0]) / 1000000 //上升沿时间 单位是ms

			//软件debug
			Pwm_time[3] = Pwm_Rise
			Pwm_time[4] = Pwm_time[3]
			Pwm_time[5] = Pwm_time[4]
			Pwm_time[6] = Pwm_time[5]
			Pwm_time[7] = Pwm_time[6]

			if Pwm_time[3] == Pwm_time[4] {
    
				if Pwm_time[4] == Pwm_time[5] {
    
					if Pwm_time[5] == Pwm_time[6] {
    
						if Pwm_time[6] == Pwm_time[7] {
    
							//Last_Vol_Rise = Vol_Rise
							print_debug()
							break
						}
					}
				}
			}

			/* if Vol_Rise != Last_Vol_Rise { flag++ if flag >= 50 { //如果检测的脉冲总时长变化 需要检测50次才可确认 以此滤波 防止干扰信号 flag = 0 Last_Vol_Rise = Vol_Rise } } else if Vol_Rise == Last_Vol_Rise { //Last_Vol_Rise = Vol_Rise flag = 0 print_debug() break }*/

		}
	}

}

func print_debug() {
    

	print("\rVol:")
	print(voltage)
	print(" Pwm_Down:")
	print(Pwm_Down)
	print(" Pwm_Rise:")
	print(Pwm_Rise)
	print(" Pwm:")
	print(Pwm_Down * 100 / Pwm_Rise)
	print(" ")

}

其实本质上和C++开发没什么区别，只不过GO语言的易用性和规范性，相当于其他语言，更简洁高效一些。