tinygo and esp01 on raspico（ドラフト）

以下を成功したのでget ?t=21.1&h=45をmock get reqしよう

 package main

import (

"machine"

"time"

)

var uart = machine.UART0

var buf = make([]byte, 256)

// --------------------

// コマンド送信

// --------------------

func send(cmd string) {

for i := 0; i < len(cmd); i++ {

uart.WriteByte(cmd[i])

}

uart.WriteByte('\r')

uart.WriteByte('\n')

}

// --------------------

// 応答待ち

// --------------------

func waitFor(expected string, timeout time.Duration) bool {

start := time.Now()

data := ""

for time.Since(start) < timeout {

n, _ := uart.Read(buf)

if n > 0 {

part := string(buf[:n])

print(part)

data += part

if contains(data, expected) {

return true

}

if contains(data, "ERROR") {

return false

}

}

}

return false

}

// --------------------

// 文字列検索

// --------------------

func contains(s, sub string) bool {

for i := 0; i <= len(s)-len(sub); i++ {

if s[i:i+len(sub)] == sub {

return true

}

}

return false

}

func main() {

// ★ ESP-01はまず115200か9600を試す

uart.Configure(machine.UARTConfig{

BaudRate: 115200, // ← 合わなければ115200に変更

TX:       machine.GPIO0,

RX:       machine.GPIO1,

})

time.Sleep(5 * time.Second)

// --------------------

// AT確認

// --------------------

send("AT")

if !waitFor("OK", 3*time.Second) {

println("AT failed")

return

}

// --------------------

// リセット

// --------------------

send("AT+RST")

time.Sleep(5 * time.Second)

// 再確認

send("AT")

if !waitFor("OK", 3*time.Second) {

println("AT after reset failed")

return

}

// --------------------

// ステーションモード

// --------------------

send("AT+CWMODE=1")

if !waitFor("OK", 3*time.Second) {

println("CWMODE failed")

return

}

// --------------------

// WiFi接続

// --------------------

send(`AT+CWJAP="Buffalo-2G-8340","636nsa535ds3v"`)

// ★ busy p... の後に OK が出れば成功

if !waitFor("OK", 30*time.Second) {

println("WiFi connect failed")

return

}

println("\nWiFi Connected!")

for {

time.Sleep(10 * time.Second)

}

}

-----------ntp問い合わせ成功--------------------------------------------------

package main

import (

"machine"

"time"

)

var uart = machine.UART0

var buf = make([]byte, 1024)

// ====================

// UART送信

// ====================

func send(cmd string) {

println("\n>> " + cmd)

for i := 0; i < len(cmd); i++ {

uart.WriteByte(cmd[i])

}

uart.WriteByte('\r')

uart.WriteByte('\n')

}

// ====================

// RAW送信

// ====================

func sendRaw(data []byte) {

for i := 0; i < len(data); i++ {

uart.WriteByte(data[i])

}

}

// ====================

// contains

// ====================

func contains(s, sub string) bool {

if len(sub) == 0 {

return true

}

if len(s) < len(sub) {

return false

}

for i := 0; i <= len(s)-len(sub); i++ {

match := true

for j := 0; j < len(sub); j++ {

if s[i+j] != sub[j] {

match = false

break

}

}

if match {

return true

}

}

return false

}

// ====================

// waitFor

// ====================

func waitFor(expect string, timeout time.Duration) (bool, string) {

start := time.Now()

data := ""

for time.Since(start) < timeout {

n, _ := uart.Read(buf)

if n > 0 {

part := string(buf[:n])

print(part)

data += part

if contains(data, expect) {

return true, data

}

}

time.Sleep(10 * time.Millisecond)

}

return false, data

}

// ====================

// cmd

// ====================

func cmd(command string, expect string, timeout time.Duration) bool {

send(command)

ok, _ := waitFor(expect, timeout)

return ok

}

// ====================

// NTP parse

// ====================

func parseNTP(packet []byte) uint32 {

secs :=

uint32(packet[40])<<24 |

uint32(packet[41])<<16 |

uint32(packet[42])<<8 |

uint32(packet[43])

return secs - 2208988800

}

// ====================

// main

// ====================

func main() {

// UART

uart.Configure(machine.UARTConfig{

BaudRate: 115200,

TX:       machine.GPIO0,

RX:       machine.GPIO1,

})

time.Sleep(5 * time.Second)

println("UART READY")

// --------------------

// AT

// --------------------

if !cmd("AT", "OK", 3*time.Second) {

return

}

// --------------------

// RESET

// --------------------

send("AT+RST")

time.Sleep(5 * time.Second)

waitFor("ready", 5*time.Second)

// --------------------

// WIFI MODE

// --------------------

if !cmd("AT+CWMODE=1", "OK", 3*time.Second) {

return

}

// --------------------

// WIFI CONNECT

// --------------------

send(`AT+CWJAP="Buffalo-2G-8340","636nsa535ds3v"`)

ok, _ := waitFor("WIFI GOT IP", 40*time.Second)

if !ok {

println("WiFi FAIL")

return

}

waitFor("OK", 10*time.Second)

println("\nWiFi Connected!")

// --------------------

// UDP START

// --------------------

send(`AT+CIPSTART="UDP","ntp.nict.jp",123`)

ok, _ = waitFor("OK", 10*time.Second)

if !ok {

println("UDP FAIL")

return

}

println("\nUDP CONNECTED")

// --------------------

// NTP PACKET

// --------------------

var ntp [48]byte

ntp[0] = 0x1B

// --------------------

// SEND LENGTH

// --------------------

send("AT+CIPSEND=48")

ok, _ = waitFor(">", 5*time.Second)

if !ok {

println("SEND PREP FAIL")

return

}

// --------------------

// SEND DATA

// --------------------

sendRaw(ntp[:])

ok, _ = waitFor("SEND OK", 5*time.Second)

if !ok {

println("SEND FAIL")

return

}

println("\nNTP REQUEST SENT")

// --------------------

// RECEIVE

// --------------------

start := time.Now()

data := make([]byte, 0)

for time.Since(start) < 10*time.Second {

n, _ := uart.Read(buf)

if n > 0 {

// 表示

print(string(buf[:n]))

// 保存

for i := 0; i < n; i++ {

data = append(data, buf[i])

}

// +IPD探索

for i := 0; i < len(data)-5; i++ {

// ':' 探索

if data[i] == ':' {

// ':' の後ろに48byteあるか

if i+1+48 <= len(data) {

packet := data[i+1 : i+1+48]

unixTime := parseNTP(packet)

println("\n===== UNIX TIME =====")

println(unixTime)

jst := unixTime + 9*3600

println("\n===== JST UNIX TIME =====")

println(jst)

println("========================")

for {

time.Sleep(time.Second)

}

}

}

}

}

time.Sleep(10 * time.Millisecond)

}

println("NTP TIMEOUT")

}