lora: add starting point for US915 settings

Signed-off-by: deadprogram <ron@hybridgroup.com>
2026-08-10 01:43:40 +00:00 · 2023-09-17 19:50:39 +02:00
196 changed files with 16877 additions and 10536 deletions
@@ -1,165 +1,3 @@
 0.28.0
 ---
 - **new devices**
    - **epd2in66b**
        - Waveshare 2.66inch E-Paper Display Module (B) for Raspberry Pi Pico (#673)
    - **mcp9808**
        - Add driver for MCP9808 i2c temperature sensor (#676)
 - **enhancements**
    - **encoders**
        - add atsamd21, atsamd51, atsame5x
    - **pixel**
        - add support for Monochrome types such as the SSD1306 display
    - **rtl8720dn**
        - implement ConnectModeAP
    - **servo**
        - add function SetAngle() to simplify API for most common use case
    - **ssd1306**
        - add DrawBitmap() function to complete Displayer interface
        - add rotation functions for Displayer interface
        - add Sleep() function for Displayer interface
    - **uc8151**
        - improvements to speed and also add flicker-free mode based on @antirez code example
        - update to support all functions needed by tinygl and board package Displayer interface
    - **wifinina**
        - implement ConnectModeAP
 - **bugfixes**
    - **ft6336**
        - ignore bogus touch events
    - **pixel**
        - fix Image[Monochrome].Set for larger images
    - **uc8151**
        - correct DrawBitmap() also refactor SendCommand() and SendData() for clarity
    - **ws2812**
        - Fix typo and move initialization of neo to init()
 - **examples**
    - **ws2812**
        - Simplify examples/ws2812
 0.27.0
 ---
 - **core**
    - prepare for CGo changes in TinyGo
 - **new devices**
    - **adafruit4650**
        - support for Adafruit 4650 feather OLED
    - **net**
        - new networking support based on tinygo net package
    - **pixel**
        - add package for efficiently working with raw pixel buffers
    - **rotary**
        - Adding driver for rotary encoder support
    - **seesaw**
        - Adding support for Adafruit Seesaw platform
    - **sgp30**
        - add SGP30 air quality sensor
    - **sk6812**
        - added support for SK6812 to WS2812 device (#610)
 - **enhancements**
    - **epd2in13**
        - add Sleep method like other displays
        - unify rotation configuration with other displays
        - use better black/white approximation
    - **ili9341**
        - add DrawBitmap method
    - **lora/lorawan**
        - LoRa WAN US915 Support
        - LoRa WAN add setter functions
        - refactor shared functionality for channels/regions
    - **mcp2515**
        - Add more line speeds to mcp2515.go (#626)
    - **rtl8720dn**
        - use drivers package version as the driver version
    - **ssd1306**
        - improvements needed for Thumby SPI display
    - **st7735**
        - make the display generic over RGB565 and RGB444
    - **st7789**
        - add DrawBitmap method
        - make the display generic over RGB565 and RGB444
    - **wifinina**
        - add ResetIsHigh cfg switch for MKR 1010 (copied from #561)
        - maintenence. Also see PR #4085 in the main TinyGo repo
        - use drivers package version as the driver version
 - **bugfixes**
    - **adxl345**
        - Use int16 for ADXL345 readings (#656)
    - **at24cx**
        - fixed the description of the device struct
    - **rtl8720dn**
        - allow connecting to open wifi access points
        - fix check for bad Wifi connect
    - **sh1106**
        - fix I2C interface and add smoketest
        - fixed the description of the device struct
    - **wifinina**
        - add 'unknown failure' reason code for AP connect
        - fix concurrency issues with multiple sockets
        - fix wifinina UDP send
 - **examples**
    - **ds3231**
        - fix the description in the example
    - **lorawan**
        - add missing functions for simulated interface
        - modify atcmd and basic demo to support choosing any one of the supported regions at compile time by using ldflags
    - **net**
        - all networking examples now using netdev and netlink.
 - **build**
    - **all**
        - fix broken testrunner
        - migrated legacy I2C
        - add natiu package for tests
    - **smoketest**
        - add stack-size param for net tests.
        - allow stack-size flag as it is needed for net examples
 0.26.0
 ---
 - **core**
    - i2c iface refactor: Resolve #559
    - fix uses of legacy i2c WriteRegister calls
    - add correct Tx implementation for mock I2C interfaces
    - bump golang.org/x/net version
 - **new devices**
    - **bma42x**
        - add new BMA421/BMA425 driver
    - **ndir**
        - add Sandbox Electronics NDIR CO2 sensor driver (#580)
    - **mpu9150**
        - implement driver for Mpu9150 (#596)
    - **sht4x**
        - implement driver for sht4x (#597)
    - **pcf8523**
        - implement driver for pcf8523 (#599)
 - **enhancements**
    - **ssd1306**
        - improve bus error handling
 - **bugfixes**
    - **st7789**
        - fix scrolling when rotated by 180°
    - **st7789**
        - fix incorrect Rotation configuration
        - fix SetScrollArea
    - **ili9341**
        - fix SetScrollArea
 - **build**
    - use latest tag of tinygo-dev container for running tests
 0.25.0
 ---
@@ -1,4 +1,4 @@
-Copyright (c) 2018-2024 The TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2023 The TinyGo Authors. All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -19,7 +19,7 @@ rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst
 # Recursively find all *_test.go files from cwd & reduce to unique dir names
 HAS_TESTS = $(sort $(dir $(call rwildcard,,*_test.go)))
 # Exclude anything we explicitly don't want to test for whatever reason
-EXCLUDE_TESTS = image waveshare-epd/epd2in66b
+EXCLUDE_TESTS = image
 TESTS = $(filter-out $(addsuffix /%,$(EXCLUDE_TESTS)),$(HAS_TESTS))
 unit-test:
@@ -1,233 +0,0 @@
 ### Table of Contents
 - ["net" Package](#net-package)
 - [Using "net" Package](#using-net-package)
 - [Using "net/http" Package](#using-nethttp-package)
 - [Using "crypto/tls" Package](#using-cryptotls-package)
 - [Using Sockets](#using-sockets)
 ## "net" Package
 TinyGo's "net" package is ported from Go.  The port offers a subset of Go's
 "net" package.  The subset maintains Go 1 compatiblity guarantee.  A Go
 application that uses "net" will most-likey just work on TinyGo if the usage is
 within the subset offered.  (There may be external constraints such as limited
 SRAM on some targets that may limit full "net" functionality).
 Continue below for details on using "net" and "net/http" packages.
 See src/net/READMD.md in the TinyGo repo for more details on maintaining
 TinyGo's "net" package.
 ## Using "net" Package
 Ideally, TinyGo's "net" package would be Go's "net" package and applications
 using "net" would just work, as-is.  TinyGo's net package is a partial port of
 Go's net package, so some things may not work because they have not been
 ported.
 There are a few features excluded during the porting process, in particular:
 - No IPv6 support
 - No DualStack support
 Run ```go doc -all ./src/net``` in TinyGo repo to see full listing of what has
 been ported.  Here is a list of things known to work.  You can find examples
 of these at [examples/net](examples/net/).
 ### What is Known to Work
 (These are all IPv4 only).
 - TCP client and server
 - UDP client
 - TLS client
 - HTTP client and server
 - HTTPS client
 - NTP client (UDP)
 - MQTT client (paho & natiu)
 - WebSocket client and server
 Multiple sockets can be opened in a single app.  For example, the app could run
 as an http server listen on port :80 and also use NTP to get the current time
 or send something over MQTT.  There is a practical limit to the number of
 active sockets per app, around 8 or 10, so don't go crazy.
 Applications using Go's net package will need a few setup steps to work with
 TinyGo's net package.  The steps are required before using "net".
 ### Step 1: Probe to Load Network Driver
 Call Probe() to load the correct network driver for your target.  Probe()
 allows the app to work on multiple targets.
 ```go
 package main
 import (
 	"tinygo.org/x/drivers/netlink/probe"
 )
 func main() {
 	// load network driver for target
 	link, dev := probe.Probe()
 	...	
 }
 ```
 Probe() will load the driver with default configuration for the target.  For
 custom configuration, the app can open code Probe() for the target
 requirements.
 Probe() returns a [Netlinker](netlink/README.md) and a
 [Netdever](netdev/README.md), interfaces implemented by the network driver.
 Next, we'll use the Netlinker interface to connect the target to an IP network.
 ### Step 2: Connect to an IP Network
 Before the net package is fully functional, we need to connect the target to an
 IP network.
 ```go
 package main
 import (
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 func main() {
 	// load network driver for target
 	link, _ := probe.Probe()
 	// Connect target to IP network
 	link.NetConnect(&netlink.ConnectParams{
 		Ssid:       "my SSID",
 		Passphrase: "my passphrase",
 	})
 	// OK to use "net" from here on
 	...	
 }
 ```
 Optionally, get notified of IP network connects and disconnects:
 ```go
 	link.Notify(func(e netlink.Event) {
 		switch e {
 		case netlink.EventNetUp:   println("Network UP")
 		case netlink.EventNetDown: println("Network DOWN")
 	})
 ```
 Here is an example of an http server listening on port :8080:
 ```go
 package main
 import (
 	"fmt"
 	"net/http"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 func HelloServer(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
 }
 func main() {
 	// load network driver for target
 	link, _ := probe.Probe()
 	// Connect target to IP network
 	link.NetConnect(&netlink.ConnectParams{
 		Ssid:       "my SSID",
 		Passphrase: "my passphrase",
 	})
 	// Serve it up
 	http.HandleFunc("/", HelloServer)
 	http.ListenAndServe(":8080", nil)
 }
 ```
 ## Using "net/http" Package
 TinyGo's net/http package is a partial port of Go's net/http package, providing
 a subset of the full net/http package.  There are a few features excluded
 during the porting process, in particular:
 - No HTTP/2 support
 - No TLS support for HTTP servers (no https servers)
 - HTTP client request can't be reused
 HTTP client methods (http.Get, http.Head, http.Post, and http.PostForm) are
 functional.  Dial clients support both HTTP and HTTPS URLs.
 HTTP server methods and objects are mostly ported, but for HTTP only; HTTPS
 servers are not supported.
 HTTP request and response handling code is mostly ported, so most the intricacy
 of parsing and writing headers is handled as in the full net/http package.
 Run ```go doc -all ./src/net/http``` in TinyGo repo to see full listing.
 ## Using "crypto/tls" Package
 TinyGo's TLS support (crypto/tls) relies on hardware offload of the TLS
 protocol.  This is different from Go's crypto/tls package which handles the TLS
 protocol in software.
 TinyGo's TLS support is only available for client applications.  You can
 http.Get() to an https:// address, but you cannot http.ListenAndServeTLS() an
 https server.
 The offloading hardware has pre-defined TLS certificates built-in.
 ## Using Sockets
 The Netdever interface is a BSD socket-like interface so an application can make direct
 socket calls, bypassing the "net" package for the lowest overhead.
 Here is a simple TCP client application using direct sockets:
 ```go
 package main
 import (
 	"net"  // only need to parse IP address
 	"tinygo.org/x/drivers/netdev"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 func main() {
 	// load network driver for target
 	link, dev := probe.Probe()
 	// Connect target to IP network
 	link.NetConnect(&netlink.ConnectParams{
 		Ssid:       "my SSID",
 		Passphrase: "my passphrase",
 	})
 	// omit error handling
 	sock, _ := dev.Socket(netdev.AF_INET, netdev.SOCK_STREAM, netdev.IPPROTO_TCP)
        dev.Connect(sock, "", net.ParseIP("10.0.0.100"), 8080)
 	dev.Send(sock, []bytes("hello"), 0, 0)
 	dev.Close(sock)
 	link.NetDisconnect()
 }
 ```
@@ -3,10 +3,7 @@
 [![PkgGoDev](https://pkg.go.dev/badge/tinygo.org/x/drivers)](https://pkg.go.dev/tinygo.org/x/drivers) [![Build](https://github.com/tinygo-org/drivers/actions/workflows/build.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/drivers/actions/workflows/build.yml)
-This package provides a collection of over 100 different hardware drivers for devices such as sensors, displays, wireless adaptors, and actuators, that can be used together with [TinyGo](https://tinygo.org).
+This package provides a collection of hardware drivers for devices such as sensors and displays that can be used together with [TinyGo](https://tinygo.org).
 For the complete list, please see:
 https://tinygo.org/docs/reference/devices/
 ## Installing
@@ -53,6 +50,11 @@ func main() {
 }
 ```
 ## Supported devices
 There are currently 96 devices supported. For the complete list, please see:
 https://tinygo.org/docs/reference/devices/
 ## Contributing
 Your contributions are welcome!
@@ -1,196 +0,0 @@
 // Package adafruit4650 implements a driver for the Adafruit FeatherWing OLED - 128x64 OLED display.
 // The display is backed itself by a SH1107 driver chip.
 //
 // Store: https://www.adafruit.com/product/4650
 //
 // Documentation: https://learn.adafruit.com/adafruit-128x64-oled-featherwing
 package adafruit4650
 import (
 	"image/color"
 	"time"
 	"tinygo.org/x/drivers"
 )
 const DefaultAddress = 0x3c
 const (
 	commandSetLowColumn  = 0x00
 	commandSetHighColumn = 0x10
 	commandSetPage       = 0xb0
 )
 const (
 	width  = 128
 	height = 64
 )
 // Device represents an Adafruit 4650 device
 type Device struct {
 	bus     drivers.I2C
 	Address uint8
 	buffer  []byte
 	width   int16
 	height  int16
 }
 // New creates a new device, not configuring anything yet.
 func New(bus drivers.I2C) Device {
 	return Device{
 		bus:     bus,
 		Address: DefaultAddress,
 		width:   width,
 		height:  height,
 	}
 }
 // Configure initializes the display with default configuration
 func (d *Device) Configure() error {
 	bufferSize := d.width * d.height / 8
 	d.buffer = make([]byte, bufferSize)
 	// This sequence is an amalgamation of the datasheet, official Arduino driver, CircuitPython driver and other drivers
 	initSequence := []byte{
 		0xae, // display off, sleep mode
 		//0xd5, 0x41, // set display clock divider (from original datasheet)
 		0xd5, 0x51, // set display clock divider (from Adafruit driver)
 		0xd9, 0x22, // pre-charge/dis-charge period mode: 2 DCLKs/2 DCLKs (POR)
 		0x20,       // memory mode
 		0x81, 0x4f, // contrast setting = 0x4f
 		0xad, 0x8a, // set dc/dc pump
 		0xa0,       // segment remap, flip-x
 		0xc0,       // common output scan direction
 		0xdc, 0x00, // set display start line 0 (POR=0)
 		0xa8, 0x3f, // multiplex ratio, height - 1 = 0x3f
 		0xd3, 0x60, // set display offset mode = 0x60
 		0xdb, 0x35, // VCOM deselect level = 0.770 (POR)
 		0xa4, // entire display off, retain RAM, normal status (POR)
 		0xa6, // normal (not reversed) display
 		0xaf, // display on
 	}
 	err := d.writeCommands(initSequence)
 	if err != nil {
 		return err
 	}
 	// recommended in the datasheet, same in other drivers
 	time.Sleep(100 * time.Millisecond)
 	return nil
 }
 // ClearDisplay clears the image buffer as well as the actual display
 func (d *Device) ClearDisplay() error {
 	d.ClearBuffer()
 	return d.Display()
 }
 // ClearBuffer clears the buffer
 func (d *Device) ClearBuffer() {
 	bzero(d.buffer)
 }
 // SetPixel modifies the internal buffer. Since this display has a bit-depth of 1 bit any non-zero
 // color component will be treated as 'on',  otherwise 'off'.
 func (d *Device) SetPixel(x int16, y int16, c color.RGBA) {
 	if x < 0 || x >= d.width || y < 0 || y >= d.height {
 		return
 	}
 	// RAM layout
 	//    *-----> y
 	//    |
 	//   x|     col0  col1  ... col63
 	//    v  p0  a0    b0         ..
 	//           a1    b1         ..
 	//           ..    ..         ..
 	//           a7    b7         ..
 	//       p1  a0    b0
 	//           a1    b1
 	//
 	//flip y - so the display orientation matches the silk screen labeling etc.
 	y = d.height - y - 1
 	page := x / 8
 	bytesPerPage := d.height
 	byteIndex := y + bytesPerPage*page
 	bit := x % 8
 	if (c.R | c.G | c.B) != 0 {
 		d.buffer[byteIndex] |= 1 << uint8(bit)
 	} else {
 		d.buffer[byteIndex] &^= 1 << uint8(bit)
 	}
 }
 // Display sends the whole buffer to the screen
 func (d *Device) Display() error {
 	bytesPerPage := d.height
 	pages := (d.width + 7) / 8
 	for page := int16(0); page < pages; page++ {
 		err := d.setRAMPosition(uint8(page), 0)
 		if err != nil {
 			return err
 		}
 		offset := page * bytesPerPage
 		err = d.writeRAM(d.buffer[offset : offset+bytesPerPage])
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // setRAMPosition updates the device's current page and column position
 func (d *Device) setRAMPosition(page uint8, column uint8) error {
 	if page > 15 {
 		panic("page out of bounds")
 	}
 	if column > 127 {
 		panic("column out of bounds")
 	}
 	setPage := commandSetPage | (page & 0xF)
 	lo := column & 0xF
 	setLowColumn := commandSetLowColumn | lo
 	hi := (column >> 4) & 0x7
 	setHighColumn := commandSetHighColumn | hi
 	cmds := []byte{
 		setPage,
 		setLowColumn,
 		setHighColumn,
 	}
 	return d.writeCommands(cmds)
 }
 // Size returns the current size of the display.
 func (d *Device) Size() (w, h int16) {
 	return d.width, d.height
 }
 func (d *Device) writeCommands(commands []byte) error {
 	onlyCommandsFollowing := byte(0x00)
 	return d.bus.Tx(uint16(d.Address), append([]byte{onlyCommandsFollowing}, commands...), nil)
 }
 func (d *Device) writeRAM(data []byte) error {
 	onlyRAMFollowing := byte(0x40)
 	return d.bus.Tx(uint16(d.Address), append([]byte{onlyRAMFollowing}, data...), nil)
 }
 func bzero(buf []byte) {
 	for i := range buf {
 		buf[i] = 0
 	}
 }
@@ -1,176 +0,0 @@
 package adafruit4650
 import (
 	"bytes"
 	_ "embed"
 	"encoding/hex"
 	"fmt"
 	"image"
 	"image/color"
 	"image/draw"
 	"image/png"
 	"os"
 	"testing"
 	"time"
 	"tinygo.org/x/drivers"
 	"tinygo.org/x/tinyfont"
 	"tinygo.org/x/tinyfont/freemono"
 )
 //go:embed expected_hello_world.png
 var expectedHelloWorld []byte
 // mockBus mocks a fake i2c device adafruit4650 display.
 // The memory layout assumes that clients set up the device in a particular way and always send complete
 // pages to the device buffer.
 type mockBus struct {
 	img           draw.Image
 	line          int
 	addr          uint8
 	currentPage   int
 	currentColumn int
 }
 func (m *mockBus) Tx(addr uint16, w, r []byte) error {
 	if addr != uint16(m.addr) {
 		panic("unexpected address")
 	}
 	if r != nil {
 		panic("mock does not support reads")
 	}
 	if w[0] == 0x00 {
 		if w[1]&0xf0 == 0xb0 {
 			m.currentPage = int(w[1] & 0x0f)
 			lo := w[2] & 0x0f
 			hi := w[2] & 0x07
 			m.currentColumn = int(hi<<4 | lo)
 		}
 		return nil
 	}
 	if w[0] != 0x40 {
 		panic("unexpected first byte: " + hex.EncodeToString(w[0:1]))
 	}
 	return m.writeRAM(w[1:])
 }
 func newMock() *mockBus {
 	m := image.NewRGBA(image.Rect(0, 0, width, height))
 	return &mockBus{img: m, addr: DefaultAddress, currentPage: -1, currentColumn: -1}
 }
 func (m *mockBus) writeRAM(data []byte) error {
 	// RAM layout
 	//    *-----> y
 	//    |
 	//   x|     col0  col1  ... col63
 	//    v  p0  a0    b0         ..
 	//           a1    b1         ..
 	//           ..    ..         ..
 	//           a7    b7         ..
 	//       p1  a0    b0
 	//           a1    b1
 	//
 	fmt.Printf("writing page %d\n", m.currentPage)
 	// assuming entire pages will be written
 	for x := 0; x < 8; x++ {
 		for y := 0; y < height; y++ {
 			col := data[y]
 			c := color.Black
 			if col&(1<<x) != 0 {
 				c = color.White
 			}
 			m.img.Set(x+m.currentPage*8, height-y-1, c)
 		}
 	}
 	return nil
 }
 func (m *mockBus) toImage() *image.RGBA {
 	container := image.NewRGBA(m.img.Bounds().Inset(-1))
 	draw.Draw(container, container.Bounds(), image.NewUniform(color.RGBA{G: 255, A: 255}), image.Point{}, draw.Over)
 	draw.Draw(container, m.img.Bounds(), m.img, image.Point{}, draw.Over)
 	return container
 }
 func TestDevice_Display(t *testing.T) {
 	bus := newMock()
 	dev := New(bus)
 	dev.Configure()
 	drawPlus(&dev)
 	drawHellowWorld(&dev)
 	//when
 	dev.Display()
 	//then
 	actual := bus.toImage()
 	expected, err := png.Decode(bytes.NewReader(expectedHelloWorld))
 	if err != nil {
 		panic(err)
 	}
 	assertEqualImages(t, actual, expected)
 }
 func drawPlus(d drivers.Displayer) {
 	for i := int16(0); i < 128; i++ {
 		d.SetPixel(i, 32, color.RGBA{R: 1})
 	}
 	for i := int16(0); i < 64; i++ {
 		d.SetPixel(64, i, color.RGBA{R: 1})
 	}
 }
 func drawHellowWorld(d drivers.Displayer) {
 	tinyfont.WriteLine(d, &freemono.Regular9pt7b, 0, 32, "Hello World!", color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
 }
 func assertEqualImages(t testing.TB, actual, expected image.Image) {
 	if actual.Bounds().Dx() != expected.Bounds().Dx() || actual.Bounds().Dy() != expected.Bounds().Dy() {
 		f := writeImage(actual)
 		t.Fatalf("differing size: was %v, expected %v, saved actual to %s", actual.Bounds(), expected.Bounds(), f)
 	}
 	bb := expected.Bounds()
 	for x := bb.Min.X; x < bb.Max.X; x++ {
 		for y := bb.Min.Y; y < bb.Max.Y; y++ {
 			actualBB := actual.Bounds()
 			if actual.At(x+actualBB.Min.X, y+actualBB.Min.Y) != expected.At(x, y) {
 				f := writeImage(actual)
 				t.Fatalf("different pixel at %d/%d: %v != %v, saved actual at %s", x, y, actual.At(x, y), expected.At(x, y), f)
 			}
 		}
 	}
 }
 func writeImage(img image.Image) string {
 	fn := fmt.Sprintf("%d.png", time.Now().Unix())
 	f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0644)
 	if err != nil {
 		panic(err)
 	}
 	defer f.Close()
 	err = png.Encode(f, img)
 	if err != nil {
 		panic(err)
 	}
 	return fn
 }
@@ -95,16 +95,16 @@ func (d *Device) Restart() {
 func (d *Device) ReadAcceleration() (x int32, y int32, z int32, err error) {
 	rx, ry, rz := d.ReadRawAcceleration()
-	x = int32(d.dataFormat.convertToIS(rx))
+	x = d.dataFormat.convertToIS(rx)
-	y = int32(d.dataFormat.convertToIS(ry))
+	y = d.dataFormat.convertToIS(ry)
-	z = int32(d.dataFormat.convertToIS(rz))
+	z = d.dataFormat.convertToIS(rz)
 	return
 }
 // ReadRawAcceleration reads the sensor values and returns the raw x, y and z axis
 // from the adxl345.
-func (d *Device) ReadRawAcceleration() (x int16, y int16, z int16) {
+func (d *Device) ReadRawAcceleration() (x int32, y int32, z int32) {
 	data := []byte{0, 0, 0, 0, 0, 0}
 	legacy.ReadRegister(d.bus, uint8(d.Address), REG_DATAX0, data)
@@ -140,7 +140,7 @@ func (d *Device) SetRange(sensorRange Range) bool {
 }
 // convertToIS adjusts the raw values from the adxl345 with the range configuration
-func (d *dataFormat) convertToIS(rawValue int16) int16 {
+func (d *dataFormat) convertToIS(rawValue int32) int32 {
 	switch d.sensorRange {
 	case RANGE_2G:
 		return rawValue * 4 // rawValue * 2 * 1000 / 512
@@ -190,6 +190,6 @@ func (b *bwRate) toByte() (bits uint8) {
 }
 // readInt converts two bytes to int16
-func readIntLE(msb byte, lsb byte) int16 {
+func readIntLE(msb byte, lsb byte) int32 {
-	return int16(uint16(msb) | uint16(lsb)<<8)
+	return int32(uint16(msb) | uint16(lsb)<<8)
 }
@@ -11,7 +11,7 @@ import (
 	"tinygo.org/x/drivers"
 )
-// Device wraps an I2C connection to an AT24CX device.
+// Device wraps an I2C connection to a DS3231 device.
 type Device struct {
 	bus               drivers.I2C
 	Address           uint16
@@ -49,7 +49,7 @@ func Sleep(duration time.Duration) {
 	//   * The CPU frequency is lower than 256MHz. If it is higher, long sleep
 	//     times (1-16ms) may not work correctly.
 	cycles := uint32(duration) * (machine.CPUFrequency() / 1000_000) / 1000
-	slept := C.tinygo_drivers_sleep(C.uint32_t(cycles))
+	slept := C.tinygo_drivers_sleep(cycles)
 	if !slept {
 		// Fallback for platforms without inline assembly support.
 		time.Sleep(duration)
@@ -1,34 +0,0 @@
 package encoders
 type QuadratureDevice struct {
 	cfg  QuadratureConfig
 	impl quadratureImpl
 }
 type QuadratureConfig struct {
 	Precision int
 }
 type quadratureImpl interface {
 	configure(cfg QuadratureConfig) error
 	readValue() int
 	writeValue(int)
 }
 func (enc *QuadratureDevice) Configure(cfg QuadratureConfig) error {
 	if cfg.Precision < 1 {
 		cfg.Precision = 4
 	}
 	enc.cfg = cfg
 	return enc.impl.configure(cfg)
 }
 // Position returns the stored int value for the encoder
 func (enc *QuadratureDevice) Position() int {
 	return enc.impl.readValue() / enc.cfg.Precision
 }
 // SetPosition overwrites the currently stored value with the specified int value
 func (enc *QuadratureDevice) SetPosition(v int) {
 	enc.impl.writeValue(v * enc.cfg.Precision)
 }
@@ -1,69 +0,0 @@
 //go:build tinygo && (rp2040 || stm32 || k210 || esp32c3 || nrf || sam || (avr && (atmega328p || atmega328pb)))
 // Implementation based on:
 // https://gist.github.com/aykevl/3fc1683ed77bb0a9c07559dfe857304a
 // Note: build constraints in this file list targets that define machine.PinToggle.
 // If this is supported for additional targets in the future, they can be added above.
 package encoders
 import (
 	"machine"
 	"runtime/volatile"
 )
 var (
 	states = []int8{0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0}
 )
 // NewQuadratureViaInterrupt returns a rotary encoder device that uses GPIO
 // interrupts and a lookup table to keep track of quadrature state changes.
 //
 // This constructur is only available for TinyGo targets for which machine.PinToggle
 // is defined as a valid interrupt type.
 func NewQuadratureViaInterrupt(pinA, pinB machine.Pin) *QuadratureDevice {
 	return &QuadratureDevice{impl: &quadInterruptImpl{pinA: pinA, pinB: pinB, oldAB: 0b00000011}}
 }
 type quadInterruptImpl struct {
 	pinA machine.Pin
 	pinB machine.Pin
 	// precision int
 	oldAB int
 	value volatile.Register32
 }
 func (enc *quadInterruptImpl) configure(cfg QuadratureConfig) error {
 	enc.pinA.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 	enc.pinA.SetInterrupt(machine.PinToggle, enc.interrupt)
 	enc.pinB.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 	enc.pinB.SetInterrupt(machine.PinToggle, enc.interrupt)
 	return nil
 }
 func (enc *quadInterruptImpl) interrupt(pin machine.Pin) {
 	aHigh, bHigh := enc.pinA.Get(), enc.pinB.Get()
 	enc.oldAB <<= 2
 	if aHigh {
 		enc.oldAB |= 1 << 1
 	}
 	if bHigh {
 		enc.oldAB |= 1
 	}
 	enc.writeValue(enc.readValue() + int(states[enc.oldAB&0x0f]))
 }
 // readValue gets the value using volatile operations and returns it as an int
 func (enc *quadInterruptImpl) readValue() int {
 	return int(enc.value.Get())
 }
 // writeValue set the value to the specified int using volatile operations
 func (enc *quadInterruptImpl) writeValue(v int) {
 	enc.value.Set(uint32(v))
 }
@@ -0,0 +1,20 @@
 package espat
 import (
 	"time"
 	"tinygo.org/x/drivers/net"
 )
 func (d *Device) ConnectToAccessPoint(ssid, pass string, timeout time.Duration) error {
 	if len(ssid) == 0 {
 		return net.ErrWiFiMissingSSID
 	}
 	d.SetWifiMode(WifiModeClient)
 	return d.ConnectToAP(ssid, pass, int(timeout.Seconds()))
 }
 func (d *Device) Disconnect() error {
 	return d.DisconnectFromAP()
 }
@@ -15,302 +15,41 @@
 //
 // AT command set:
 // https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf
 //
 // 02/2023    sfeldma@gmail.com    Heavily modified to use netdev interface
 package espat // import "tinygo.org/x/drivers/espat"
 import (
 	"errors"
 	"fmt"
 	"machine"
 	"net"
 	"net/netip"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
-	"tinygo.org/x/drivers/netdev"
+	"tinygo.org/x/drivers"
-	"tinygo.org/x/drivers/netlink"
+	"tinygo.org/x/drivers/net"
 )
-type Config struct {
+// Device wraps UART connection to the ESP8266/ESP32.
 	// UART config
 	Uart *machine.UART
 	Tx   machine.Pin
 	Rx   machine.Pin
 }
 type socket struct {
 	inUse    bool
 	protocol int
 	laddr    netip.AddrPort
 }
 type Device struct {
-	cfg  *Config
+	bus drivers.UART
-	uart *machine.UART
+
 	// command responses that come back from the ESP8266/ESP32
 	response []byte
 	// data received from a TCP/UDP connection forwarded by the ESP8266/ESP32
-	data   []byte
+	socketdata []byte
 	socket socket
 	mu     sync.Mutex
 }
-func NewDevice(cfg *Config) *Device {
+// ActiveDevice is the currently configured Device in use. There can only be one.
-	return &Device{
+var ActiveDevice *Device
-		cfg:      cfg,
+
-		response: make([]byte, 1500),
+// New returns a new espat driver. Pass in a fully configured UART bus.
-		data:     make([]byte, 0, 1500),
+func New(b drivers.UART) *Device {
-	}
+	return &Device{bus: b, response: make([]byte, 512), socketdata: make([]byte, 0, 1024)}
 }
-func (d *Device) NetConnect(params *netlink.ConnectParams) error {
+// Configure sets up the device for communication.
-
+func (d Device) Configure() {
-	if len(params.Ssid) == 0 {
+	ActiveDevice = &d
-		return netlink.ErrMissingSSID
+	net.ActiveDevice = ActiveDevice
 	}
 	d.uart = d.cfg.Uart
 	d.uart.Configure(machine.UARTConfig{TX: d.cfg.Tx, RX: d.cfg.Rx})
 	// Connect to ESP8266/ESP32
 	fmt.Printf("Connecting to device...")
 	for i := 0; i < 5; i++ {
 		if d.Connected() {
 			break
 		}
 		time.Sleep(1 * time.Second)
 	}
 	if !d.Connected() {
 		fmt.Printf("FAILED\r\n")
 		return netlink.ErrConnectFailed
 	}
 	fmt.Printf("CONNECTED\r\n")
 	// Connect to Wifi AP
 	fmt.Printf("Connecting to Wifi SSID '%s'...", params.Ssid)
 	d.SetWifiMode(WifiModeClient)
 	err := d.ConnectToAP(params.Ssid, params.Passphrase, 10 /* secs */)
 	if err != nil {
 		fmt.Printf("FAILED\r\n")
 		return err
 	}
 	fmt.Printf("CONNECTED\r\n")
 	ip, err := d.Addr()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("DHCP-assigned IP: %s\r\n", ip)
 	fmt.Printf("\r\n")
 	return nil
 }
 func (d *Device) NetDisconnect() {
 	d.DisconnectFromAP()
 	fmt.Printf("\r\nDisconnected from Wifi\r\n\r\n")
 }
 func (d *Device) NetNotify(cb func(netlink.Event)) {
 	fmt.Printf("\r\n%s\r\n", netlink.ErrNotSupported)
 }
 func (d *Device) GetHostByName(name string) (netip.Addr, error) {
 	ip, err := d.GetDNS(name)
 	if err != nil {
 		return netip.Addr{}, err
 	}
 	return netip.ParseAddr(ip)
 }
 func (d *Device) GetHardwareAddr() (net.HardwareAddr, error) {
 	return net.HardwareAddr{}, netlink.ErrNotSupported
 }
 func (d *Device) Addr() (netip.Addr, error) {
 	resp, err := d.GetClientIP()
 	if err != nil {
 		return netip.Addr{}, err
 	}
 	prefix := "+CIPSTA:ip:"
 	for _, line := range strings.Split(resp, "\n") {
 		if ok := strings.HasPrefix(line, prefix); ok {
 			ip := line[len(prefix)+1 : len(line)-2]
 			return netip.ParseAddr(ip)
 		}
 	}
 	return netip.Addr{}, fmt.Errorf("Error getting IP address")
 }
 func (d *Device) Socket(domain int, stype int, protocol int) (int, error) {
 	switch domain {
 	case netdev.AF_INET:
 	default:
 		return -1, netdev.ErrFamilyNotSupported
 	}
 	switch {
 	case protocol == netdev.IPPROTO_TCP && stype == netdev.SOCK_STREAM:
 	case protocol == netdev.IPPROTO_TLS && stype == netdev.SOCK_STREAM:
 	case protocol == netdev.IPPROTO_UDP && stype == netdev.SOCK_DGRAM:
 	default:
 		return -1, netdev.ErrProtocolNotSupported
 	}
 	// Only supporting single connection mode, so only one socket at a time
 	if d.socket.inUse {
 		return -1, netdev.ErrNoMoreSockets
 	}
 	d.socket.inUse = true
 	d.socket.protocol = protocol
 	return 0, nil
 }
 func (d *Device) Bind(sockfd int, ip netip.AddrPort) error {
 	d.socket.laddr = ip
 	return nil
 }
 func (d *Device) Connect(sockfd int, host string, ip netip.AddrPort) error {
 	var err error
 	var addr = ip.Addr().String()
 	var rport = strconv.Itoa(int(ip.Port()))
 	var lport = strconv.Itoa(int(d.socket.laddr.Port()))
 	switch d.socket.protocol {
 	case netdev.IPPROTO_TCP:
 		err = d.ConnectTCPSocket(addr, rport)
 	case netdev.IPPROTO_UDP:
 		err = d.ConnectUDPSocket(addr, rport, lport)
 	case netdev.IPPROTO_TLS:
 		err = d.ConnectSSLSocket(host, rport)
 	}
 	if err != nil {
 		if host == "" {
 			return fmt.Errorf("Connect to %s timed out", ip)
 		} else {
 			return fmt.Errorf("Connect to %s:%d timed out", host, ip.Port())
 		}
 	}
 	return nil
 }
 func (d *Device) Listen(sockfd int, backlog int) error {
 	switch d.socket.protocol {
 	case netdev.IPPROTO_UDP:
 	default:
 		return netdev.ErrProtocolNotSupported
 	}
 	return nil
 }
 func (d *Device) Accept(sockfd int) (int, netip.AddrPort, error) {
 	return -1, netip.AddrPort{}, netdev.ErrNotSupported
 }
 func (d *Device) sendChunk(sockfd int, buf []byte, deadline time.Time) (int, error) {
 	// Check if we've timed out
 	if !deadline.IsZero() {
 		if time.Now().After(deadline) {
 			return -1, netdev.ErrTimeout
 		}
 	}
 	err := d.StartSocketSend(len(buf))
 	if err != nil {
 		return -1, err
 	}
 	n, err := d.Write(buf)
 	if err != nil {
 		return -1, err
 	}
 	_, err = d.Response(1000)
 	if err != nil {
 		return -1, err
 	}
 	return n, err
 }
 func (d *Device) Send(sockfd int, buf []byte, flags int, deadline time.Time) (int, error) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	// Break large bufs into chunks so we don't overrun the hw queue
 	chunkSize := 1436
 	for i := 0; i < len(buf); i += chunkSize {
 		end := i + chunkSize
 		if end > len(buf) {
 			end = len(buf)
 		}
 		_, err := d.sendChunk(sockfd, buf[i:end], deadline)
 		if err != nil {
 			return -1, err
 		}
 	}
 	return len(buf), nil
 }
 func (d *Device) Recv(sockfd int, buf []byte, flags int, deadline time.Time) (int, error) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	var length = len(buf)
 	// Limit length read size to chunk large read requests
 	if length > 1436 {
 		length = 1436
 	}
 	for {
 		// Check if we've timed out
 		if !deadline.IsZero() {
 			if time.Now().After(deadline) {
 				return -1, netdev.ErrTimeout
 			}
 		}
 		n, err := d.ReadSocket(buf[:length])
 		if err != nil {
 			return -1, err
 		}
 		if n == 0 {
 			d.mu.Unlock()
 			time.Sleep(100 * time.Millisecond)
 			d.mu.Lock()
 			continue
 		}
 		return n, nil
 	}
 }
 func (d *Device) Close(sockfd int) error {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	d.socket.inUse = false
 	return d.DisconnectSocket()
 }
 func (d *Device) SetSockOpt(sockfd int, level int, opt int, value interface{}) error {
 	return netdev.ErrNotSupported
 }
 // Connected checks if there is communication with the ESP8266/ESP32.
@@ -318,7 +57,7 @@ func (d *Device) Connected() bool {
 	d.Execute(Test)
 	// handle response here, should include "OK"
-	_, err := d.Response(1000)
+	_, err := d.Response(100)
 	if err != nil {
 		return false
 	}
@@ -327,12 +66,12 @@ func (d *Device) Connected() bool {
 // Write raw bytes to the UART.
 func (d *Device) Write(b []byte) (n int, err error) {
-	return d.uart.Write(b)
+	return d.bus.Write(b)
 }
 // Read raw bytes from the UART.
 func (d *Device) Read(b []byte) (n int, err error) {
-	return d.uart.Read(b)
+	return d.bus.Read(b)
 }
 // how long in milliseconds to pause after sending AT commands
@@ -361,10 +100,9 @@ func (d Device) Set(cmd, params string) error {
 // Version returns the ESP8266/ESP32 firmware version info.
 func (d Device) Version() []byte {
 	d.Execute(Version)
-	r, err := d.Response(2000)
+	r, err := d.Response(100)
 	if err != nil {
-		//return []byte("unknown")
+		return []byte("unknown")
 		return []byte(err.Error())
 	}
 	return r
 }
@@ -394,16 +132,16 @@ func (d *Device) ReadSocket(b []byte) (n int, err error) {
 	d.Response(300)
 	count := len(b)
-	if len(b) >= len(d.data) {
+	if len(b) >= len(d.socketdata) {
 		// copy it all, then clear socket data
-		count = len(d.data)
+		count = len(d.socketdata)
-		copy(b, d.data[:count])
+		copy(b, d.socketdata[:count])
-		d.data = d.data[:0]
+		d.socketdata = d.socketdata[:0]
 	} else {
 		// copy all we can, then keep the remaining socket data around
-		copy(b, d.data[:count])
+		copy(b, d.socketdata[:count])
-		copy(d.data, d.data[count:])
+		copy(d.socketdata, d.socketdata[count:])
-		d.data = d.data[:len(d.data)-count]
+		d.socketdata = d.socketdata[:len(d.socketdata)-count]
 	}
 	return count, nil
@@ -419,11 +157,11 @@ func (d *Device) Response(timeout int) ([]byte, error) {
 	retries := timeout / pause
 	for {
-		size = d.uart.Buffered()
+		size = d.bus.Buffered()
 		if size > 0 {
 			end += size
-			d.uart.Read(d.response[start:end])
+			d.bus.Read(d.response[start:end])
 			// if "+IPD" then read socket data
 			if strings.Contains(string(d.response[:end]), "+IPD") {
@@ -466,18 +204,18 @@ func (d *Device) parseIPD(end int) error {
 	val := string(d.response[s+5 : e])
 	// TODO: verify count
-	v, err := strconv.Atoi(val)
+	_, err := strconv.Atoi(val)
 	if err != nil {
 		// not expected data here. what to do?
 		return err
 	}
 	// load up the socket data
-	d.data = append(d.data, d.response[e+1:e+1+v]...)
+	d.socketdata = append(d.socketdata, d.response[e+1:end]...)
 	return nil
 }
 // IsSocketDataAvailable returns of there is socket data available
 func (d *Device) IsSocketDataAvailable() bool {
-	return len(d.data) > 0 || d.uart.Buffered() > 0
+	return len(d.socketdata) > 0 || d.bus.Buffered() > 0
 }
@@ -51,7 +51,7 @@ func (d *Device) ConnectTCPSocket(addr, port string) error {
 // ConnectUDPSocket creates a new UDP connection for the ESP8266/ESP32.
 func (d *Device) ConnectUDPSocket(addr, sendport, listenport string) error {
 	protocol := "UDP"
-	val := "\"" + protocol + "\",\"" + addr + "\"," + sendport + "," + listenport + ",0"
+	val := "\"" + protocol + "\",\"" + addr + "\"," + sendport + "," + listenport + ",2"
 	err := d.Set(TCPConnect, val)
 	if err != nil {
 		return err
@@ -44,7 +44,10 @@ func (d *Device) ConnectToAP(ssid, pwd string, ws int) error {
 	d.Set(ConnectAP, val)
 	_, err := d.Response(ws * 1000)
-	return err
+	if err != nil {
 		return err
 	}
 	return nil
 }
 // DisconnectFromAP disconnects the ESP8266/ESP32 from the current access point.
@@ -1,42 +0,0 @@
 package main
 import (
 	"image/color"
 	"machine"
 	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/adafruit4650"
 	"tinygo.org/x/tinyfont"
 	"tinygo.org/x/tinyfont/freemono"
 )
 func main() {
 	machine.I2C0.Configure(machine.I2CConfig{})
 	dev := adafruit4650.New(machine.I2C0)
 	err := dev.Configure()
 	if err != nil {
 		panic(err)
 	}
 	drawPlus(&dev)
 	drawHelloWorld(&dev)
 	err = dev.Display()
 	if err != nil {
 		panic(err)
 	}
 }
 func drawPlus(d drivers.Displayer) {
 	for i := int16(0); i < 128; i++ {
 		d.SetPixel(i, 32, color.RGBA{R: 1})
 	}
 	for i := int16(0); i < 64; i++ {
 		d.SetPixel(64, i, color.RGBA{R: 1})
 	}
 }
 func drawHelloWorld(d drivers.Displayer) {
 	tinyfont.WriteLine(d, &freemono.Regular9pt7b, 0, 32, "Hello World!", color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
 }
@@ -1,4 +1,4 @@
-// Connects to an DS3231 I2C Real Time Clock (RTC).
+// Connects to an MAG3110 I2C magnetometer.
 package main
 import (
@@ -1,28 +0,0 @@
 //go:build macropad_rp2040
 package main
 import (
 	"machine"
 	"tinygo.org/x/drivers/encoders"
 )
 var (
 	enc = encoders.NewQuadratureViaInterrupt(machine.ROT_A, machine.ROT_B)
 )
 func main() {
 	enc.Configure(encoders.QuadratureConfig{
 		Precision: 4,
 	})
 	for oldValue := 0; ; {
 		if newValue := enc.Position(); newValue != oldValue {
 			println("value: ", newValue)
 			oldValue = newValue
 		}
 	}
 }
@@ -0,0 +1,145 @@
 // This is a console to a ESP8266/ESP32 running on the device UART1.
 // Allows you to type AT commands from your computer via the microcontroller.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> INTERNET
 //
 // More information on the Espressif AT command set at:
 // https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/espat"
 )
 // change actAsAP to true to act as an access point instead of connecting to one.
 const actAsAP = false
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	console = machine.Serial
 	adaptor *espat.Device
 )
 func main() {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	// Init esp8266
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	println("Type an AT command then press enter:")
 	prompt()
 	input := make([]byte, 64)
 	i := 0
 	for {
 		if console.Buffered() > 0 {
 			data, _ := console.ReadByte()
 			switch data {
 			case 13:
 				// return key
 				console.Write([]byte("\r\n"))
 				// send command to ESP8266
 				input[i] = byte('\r')
 				input[i+1] = byte('\n')
 				adaptor.Write(input[:i+2])
 				// display response
 				r, _ := adaptor.Response(500)
 				console.Write(r)
 				// prompt
 				prompt()
 				i = 0
 				continue
 			default:
 				// just echo the character
 				console.WriteByte(data)
 				input[i] = data
 				i++
 			}
 		}
 		time.Sleep(10 * time.Millisecond)
 	}
 }
 func prompt() {
 	print("ESPAT>")
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 // provide access point
 func provideAP() {
 	println("Starting wifi network as access point '" + ssid + "'...")
 	adaptor.SetWifiMode(espat.WifiModeAP)
 	adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
 	println("Ready.")
 	ip, _ := adaptor.GetAPIP()
 	println(ip)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,131 @@
 // This is a sensor hub that uses a ESP8266/ESP32 running on the device UART1.
 // It creates a UDP "server" you can use to get info to/from your computer via the microcontroller.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> INTERNET
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/espat"
 	"tinygo.org/x/drivers/net"
 )
 // change actAsAP to true to act as an access point instead of connecting to one.
 const actAsAP = false
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	adaptor *espat.Device
 )
 func main() {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	// Init esp8266
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	readyled := machine.LED
 	readyled.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	readyled.High()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	// now make UDP connection
 	laddr := &net.UDPAddr{Port: 2222}
 	println("Loading UDP listener...")
 	conn, _ := net.ListenUDP("UDP", laddr)
 	println("Waiting for data...")
 	data := make([]byte, 50)
 	blink := true
 	for {
 		n, _ := conn.Read(data)
 		if n > 0 {
 			println(string(data[:n]))
 			conn.Write([]byte("hello back\r\n"))
 		}
 		blink = !blink
 		if blink {
 			readyled.High()
 		} else {
 			readyled.Low()
 		}
 		time.Sleep(500 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting UDP...")
 	conn.Close()
 	println("Done.")
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 // provide access point
 func provideAP() {
 	println("Starting wifi network as access point '" + ssid + "'...")
 	adaptor.SetWifiMode(espat.WifiModeAP)
 	adaptor.SetAPConfig(ssid, pass, 7, espat.WifiAPSecurityWPA2_PSK)
 	println("Ready.")
 	ip, _ := adaptor.GetAPIP()
 	println(ip)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,110 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/espat"
 	"tinygo.org/x/drivers/net"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the listener aka "hub". Replace with your own info.
 const hubIP = "0.0.0.0"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	adaptor *espat.Device
 )
 func main() {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	// Init esp8266/esp32
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	// now make UDP connection
 	ip := net.ParseIP(hubIP)
 	raddr := &net.UDPAddr{IP: ip, Port: 2222}
 	laddr := &net.UDPAddr{Port: 2222}
 	println("Dialing UDP connection...")
 	conn, _ := net.DialUDP("udp", laddr, raddr)
 	for {
 		// send data
 		println("Sending data...")
 		conn.Write([]byte("hello\r\n"))
 		time.Sleep(1000 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting UDP...")
 	conn.Close()
 	println("Done.")
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,144 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
 //
 // You must install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 package main
 import (
 	"machine"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/espat"
 	"tinygo.org/x/drivers/net/mqtt"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the MQTT broker to use. Replace with your own info.
 const server = "tcp://test.mosquitto.org:1883"
 //const server = "ssl://test.mosquitto.org:8883"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART2
 	tx   = machine.PA22
 	rx   = machine.PA23
 	console = machine.Serial
 	adaptor *espat.Device
 	topic   = "tinygo"
 )
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	rand.Seed(time.Now().UnixNano())
 	// Init esp8266/esp32
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connecting to MQTT broker at", server)
 	cl := mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	for {
 		println("Publishing MQTT message...")
 		data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
 		token := cl.Publish(topic, 0, false, data)
 		token.Wait()
 		if token.Error() != nil {
 			println(token.Error().Error())
 		}
 		time.Sleep(1000 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,165 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
 //
 // You must also install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 package main
 import (
 	"fmt"
 	"machine"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/espat"
 	"tinygo.org/x/drivers/net/mqtt"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the MQTT broker to use. Replace with your own info.
 //const server = "tcp://test.mosquitto.org:1883"
 const server = "ssl://test.mosquitto.org:8883"
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are defaults for the Arduino Nano33 IoT.
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	console = machine.Serial
 	adaptor *espat.Device
 	cl      mqtt.Client
 	topicTx = "tinygo/tx"
 	topicRx = "tinygo/rx"
 )
 func subHandler(client mqtt.Client, msg mqtt.Message) {
 	fmt.Printf("[%s]  ", msg.Topic())
 	fmt.Printf("%s\r\n", msg.Payload())
 }
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	rand.Seed(time.Now().UnixNano())
 	// Init esp8266/esp32
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connecting to MQTT broker at", server)
 	cl = mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	// subscribe
 	token := cl.Subscribe(topicRx, 0, subHandler)
 	token.Wait()
 	if token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	go publishing()
 	select {}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 }
 func publishing() {
 	for {
 		println("Publishing MQTT message...")
 		data := []byte("{\"e\":[{ \"n\":\"hello\", \"v\":101 }]}")
 		token := cl.Publish(topicTx, 0, false, data)
 		token.Wait()
 		if token.Error() != nil {
 			println(token.Error().Error())
 		}
 		time.Sleep(1000 * time.Millisecond)
 	}
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,113 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/espat"
 	"tinygo.org/x/drivers/net"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 const serverIP = "0.0.0.0"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	adaptor *espat.Device
 )
 func main() {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	// Init esp8266/esp32
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	// first check if connected
 	if connectToESP() {
 		println("Connected to wifi adaptor.")
 		adaptor.Echo(false)
 		connectToAP()
 	} else {
 		println("")
 		failMessage("Unable to connect to wifi adaptor.")
 		return
 	}
 	// now make TCP connection
 	ip := net.ParseIP(serverIP)
 	raddr := &net.TCPAddr{IP: ip, Port: 8080}
 	laddr := &net.TCPAddr{Port: 8080}
 	println("Dialing TCP connection...")
 	conn, err := net.DialTCP("tcp", laddr, raddr)
 	if err != nil {
 		failMessage(err.Error())
 	}
 	for {
 		// send data
 		println("Sending data...")
 		conn.Write([]byte("hello\r\n"))
 		time.Sleep(1000 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting TCP...")
 	conn.Close()
 	println("Done.")
 }
 // connect to ESP8266/ESP32
 func connectToESP() bool {
 	for i := 0; i < 5; i++ {
 		println("Connecting to wifi adaptor...")
 		if adaptor.Connected() {
 			return true
 		}
 		time.Sleep(1 * time.Second)
 	}
 	return false
 }
 // connect to access point
 func connectToAP() {
 	println("Connecting to wifi network '" + ssid + "'")
 	if err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second); err != nil {
 		failMessage(err.Error())
 	}
 	println("Connected.")
 	ip, err := adaptor.GetClientIP()
 	if err != nil {
 		failMessage(err.Error())
 	}
 	println(ip)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -8,16 +8,15 @@ import (
 	"tinygo.org/x/drivers/examples/ili9341/initdisplay"
 	"tinygo.org/x/drivers/examples/ili9341/pyportal_boing/graphics"
 	"tinygo.org/x/drivers/ili9341"
 	"tinygo.org/x/drivers/pixel"
 )
 const (
-	BGCOLOR    = pixel.RGB565BE(0x75AD)
+	BGCOLOR    = 0xAD75
-	GRIDCOLOR  = pixel.RGB565BE(0x15A8)
+	GRIDCOLOR  = 0xA815
-	BGSHADOW   = pixel.RGB565BE(0x8552)
+	BGSHADOW   = 0x5285
-	GRIDSHADOW = pixel.RGB565BE(0x0C60)
+	GRIDSHADOW = 0x600C
-	RED        = pixel.RGB565BE(0x00F8)
+	RED        = 0xF800
-	WHITE      = pixel.RGB565BE(0xFFFF)
+	WHITE      = 0xFFFF
 	YBOTTOM = 123  // Ball Y coord at bottom
 	YBOUNCE = -3.5 // Upward velocity on ball bounce
@@ -26,7 +25,7 @@ const (
 )
 var (
-	frameBuffer = pixel.NewImage[pixel.RGB565BE](graphics.BALLWIDTH+8, graphics.BALLHEIGHT+8)
+	frameBuffer = [(graphics.BALLHEIGHT + 8) * (graphics.BALLWIDTH + 8) * 2]uint8{}
 	startTime int64
 	frame     int64
@@ -42,7 +41,7 @@ var (
 	balloldy  float32
 	// Color table for ball rotation effect
-	palette [16]pixel.RGB565BE
+	palette [16]uint16
 )
 var (
@@ -109,7 +108,6 @@ func main() {
 		width = maxx - minx + 1
 		height = maxy - miny + 1
 		buffer := frameBuffer.Rescale(int(width), int(height))
 		// Ball animation frame # is incremented opposite the ball's X velocity
 		ballframe -= ballvx * 0.5
@@ -130,7 +128,7 @@ func main() {
 		}
 		// Only the changed rectangle is drawn into the 'renderbuf' array...
-		var c pixel.RGB565BE      //, *destPtr;
+		var c uint16              //, *destPtr;
 		bx := minx - int16(ballx) // X relative to ball bitmap (can be negative)
 		by := miny - int16(bally) // Y relative to ball bitmap (can be negative)
 		bgx := minx               // X relative to background bitmap (>= 0)
@@ -151,20 +149,19 @@ func main() {
 					(by >= 0) && (by < graphics.BALLHEIGHT) { // inside the ball bitmap area?
 					// Yes, do ball compositing math...
 					p = graphics.Ball[int(by*(graphics.BALLWIDTH/2))+int(bx1/2)] // Get packed value (2 pixels)
 					var nibble uint8
 					if (bx1 & 1) != 0 {
-						nibble = p & 0xF
+						c = uint16(p & 0xF)
 					} else {
-						nibble = p >> 4
+						c = uint16(p >> 4)
 					} // Unpack high or low nybble
-					if nibble == 0 { // Outside ball - just draw grid
+					if c == 0 { // Outside ball - just draw grid
 						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
 							c = GRIDCOLOR
 						} else {
 							c = BGCOLOR
 						}
-					} else if nibble > 1 { // In ball area...
+					} else if c > 1 { // In ball area...
-						c = palette[nibble]
+						c = palette[c]
 					} else { // In shadow area...
 						if graphics.Background[bgidx]&(0x80>>(bgx1&7)) != 0 {
 							c = GRIDSHADOW
@@ -179,7 +176,8 @@ func main() {
 						c = BGCOLOR
 					}
 				}
-				buffer.Set(x, y, c)
+				frameBuffer[(y*int(width)+x)*2] = byte(c >> 8)
 				frameBuffer[(y*int(width)+x)*2+1] = byte(c)
 				bx1++ // Increment bitmap position counters (X axis)
 				bgx1++
 			}
@@ -190,7 +188,7 @@ func main() {
 			bgy++
 		}
-		display.DrawBitmap(minx, miny, buffer)
+		display.DrawRGBBitmap8(minx, miny, frameBuffer[:width*height*2], width, height)
 		// Show approximate frame rate
 		frame++
@@ -207,7 +205,6 @@ func DrawBackground() {
 	w, h := display.Size()
 	byteWidth := (w + 7) / 8 // Bitmap scanline pad = whole byte
 	var b uint8
 	buffer := frameBuffer.Rescale(int(w), 1)
 	for j := int16(0); j < h; j++ {
 		for k := int16(0); k < w; k++ {
 			if k&7 > 0 {
@@ -216,11 +213,13 @@ func DrawBackground() {
 				b = graphics.Background[j*byteWidth+k/8]
 			}
 			if b&0x80 == 0 {
-				buffer.Set(int(k), 0, BGCOLOR)
+				frameBuffer[2*k] = byte(BGCOLOR >> 8)
 				frameBuffer[2*k+1] = byte(BGCOLOR & 0xFF)
 			} else {
-				buffer.Set(int(k), 0, GRIDCOLOR)
+				frameBuffer[2*k] = byte(GRIDCOLOR >> 8)
 				frameBuffer[2*k+1] = byte(GRIDCOLOR & 0xFF)
 			}
 		}
-		display.DrawBitmap(0, j, buffer)
+		display.DrawRGBBitmap8(0, j, frameBuffer[0:w*2], w, 1)
 	}
 }
@@ -23,20 +23,20 @@ Builds/flashes atcmd console application with simulator instead of actual LoRa r
 tinygo flash -target pico ./examples/lora/lorawan/atcmd/
 ```
-## PyBadge with LoRa Featherwing for EU868 region
+## PyBadge with LoRa Featherwing 
 Builds/flashes atcmd console application on PyBadge using LoRa Featherwing (RFM95/SX1276).
 ```
-tinygo flash -target pybadge -tags featherwing -ldflags="-X main.reg=EU868" ./examples/lora/lorawan/atcmd/
+tinygo flash -target pybadge -tags featherwing ./examples/lora/lorawan/atcmd/
 ```
-## LoRa-E5 for US915 region
+## LoRa-E5 
 Builds/flashes atcmd console application on Lora-E5 using onboard SX126x.
 ```
-tinygo flash -target lorae5 -ldflags="-X main.reg=US915" ./examples/lora/lorawan/atcmd/
+tinygo flash -target lorae5 ./examples/lora/lorawan/atcmd/
 ```
 ## Joining a Public Lorawan Network
@@ -32,8 +32,6 @@ var (
 	defaultTimeout uint32 = 1000
 )
 var reg string
 func main() {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
@@ -47,16 +45,7 @@ func main() {
 	otaa = &lorawan.Otaa{}
 	lorawan.UseRadio(radio)
-	switch reg {
+	lorawan.UseRegionSettings(region.EU868())
 	case "AU915":
 		lorawan.UseRegionSettings(region.AU915())
 	case "EU868":
 		lorawan.UseRegionSettings(region.EU868())
 	case "US915":
 		lorawan.UseRegionSettings(region.US915())
 	default:
 		lorawan.UseRegionSettings(region.EU868())
 	}
 	for {
 		if uart.Buffered() > 0 {
@@ -21,16 +21,16 @@ loraConnect: Connected !
 tinygo flash -target pico ./examples/lora/lorawan/basic-demo
 ```
-## PyBadge with LoRa Featherwing for EU868 region
+## PyBadge with LoRa Featherwing 
 ```
-tinygo flash -target pybadge -tags featherwing -ldflags="-X main.reg=EU868" ./examples/lora/lorawan/basic-demo
+tinygo flash -target pybadge -tags featherwing ./examples/lora/lorawan/basic-demo
 ```
-## LoRa-E5 for US915 region
+## LoRa-E5 
 ```
-tinygo flash -target lorae5 -ldflags="-X main.reg=US915" ./examples/lora/lorawan/basic-demo
+tinygo flash -target lorae5 ./examples/lora/lorawan/basic-demo
 ```
@@ -12,10 +12,7 @@ import (
 	"tinygo.org/x/drivers/lora/lorawan/region"
 )
-var (
+var debug string
 	reg   string
 	debug string
 )
 const (
 	LORAWAN_JOIN_TIMEOUT_SEC    = 180
@@ -70,16 +67,8 @@ func main() {
 	// Connect the lorawan with the Lora Radio device.
 	lorawan.UseRadio(radio)
-	switch reg {
+
-	case "AU915":
+	lorawan.UseRegionSettings(region.EU868())
 		lorawan.UseRegionSettings(region.AU915())
 	case "EU868":
 		lorawan.UseRegionSettings(region.EU868())
 	case "US915":
 		lorawan.UseRegionSettings(region.US915())
 	default:
 		lorawan.UseRegionSettings(region.EU868())
 	}
 	// Configure AppEUI, DevEUI, APPKey, and public/private Lorawan Network
 	setLorawanKeys()
@@ -23,18 +23,13 @@ func (sr *SimLoraRadio) Rx(timeoutMs uint32) ([]uint8, error) {
 	return nil, nil
 }
-func (sr *SimLoraRadio) SetFrequency(freq uint32)       {}
+func (sr *SimLoraRadio) SetFrequency(freq uint32)    {}
-func (sr *SimLoraRadio) SetIqMode(mode uint8)           {}
+func (sr *SimLoraRadio) SetIqMode(mode uint8)        {}
-func (sr *SimLoraRadio) SetCodingRate(cr uint8)         {}
+func (sr *SimLoraRadio) SetCodingRate(cr uint8)      {}
-func (sr *SimLoraRadio) SetBandwidth(bw uint8)          {}
+func (sr *SimLoraRadio) SetBandwidth(bw uint8)       {}
-func (sr *SimLoraRadio) SetCrc(enable bool)             {}
+func (sr *SimLoraRadio) SetCrc(enable bool)          {}
-func (sr *SimLoraRadio) SetSpreadingFactor(sf uint8)    {}
+func (sr *SimLoraRadio) SetSpreadingFactor(sf uint8) {}
-func (sr *SimLoraRadio) SetHeaderType(headerType uint8) {}
+func (sr *SimLoraRadio) LoraConfig(cnf lora.Config)  {}
 func (sr *SimLoraRadio) SetPreambleLength(pLen uint16)  {}
 func (sr *SimLoraRadio) SetPublicNetwork(enabled bool)  {}
 func (sr *SimLoraRadio) SetSyncWord(syncWord uint16)    {}
 func (sr *SimLoraRadio) SetTxPower(txPower int8)        {}
 func (sr *SimLoraRadio) LoraConfig(cnf lora.Config)     {}
 func FirmwareVersion() string {
 	return "simulator " + CurrentVersion()
@@ -1,48 +0,0 @@
 package main
 import (
 	"fmt"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/mcp9808"
 )
 func main() {
 	//tinygo monitor
 	time.Sleep(time.Millisecond * 5000)
 	//Configure I2C (in this case, I2C0 on RPI Pico), and wire the module accordingly
 	machine.I2C0.Configure(machine.I2CConfig{
 		SCL: machine.GP1,
 		SDA: machine.GP0,
 	})
 	//Create sensor
 	sensor := mcp9808.New(machine.I2C0)
 	if !sensor.Connected() {
 		println("MCP9808 not found")
 		return
 	} else {
 		println("MCP9808 found")
 	}
 	time.Sleep(time.Millisecond * 1000)
 	//Set resolution
 	sensor.SetResolution(mcp9808.Maximum)
 	time.Sleep(time.Millisecond * 1000)
 	//Read temp.
 	temp, err := sensor.ReadTemperature()
 	if err != nil {
 		println("MCP9808 error reading temperature")
 		println(err.Error())
 		return
 	} else {
 		fmt.Printf("Temperature: %.2f \n", temp)
 	}
 	return
 }
@@ -1,88 +0,0 @@
 // This example gets an URL using http.Get().  URL scheme can be http or https.
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //
 // Some targets (Arduino Nano33 IoT) don't have enough SRAM to run http.Get().
 // Use the following for those targets:
 //
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 //go:build ninafw || wioterminal
 package main
 import (
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 )
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	name := "John Doe"
 	occupation := "gardener"
 	params := "name=" + url.QueryEscape(name) + "&" +
 		"occupation=" + url.QueryEscape(occupation)
 	path := fmt.Sprintf("https://httpbin.org/get?%s", params)
 	cnt := 0
 	for {
 		fmt.Printf("Getting %s\r\n\r\n", path)
 		resp, err := http.Get(path)
 		if err != nil {
 			fmt.Printf("%s\r\n", err.Error())
 			time.Sleep(10 * time.Second)
 			continue
 		}
 		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Printf("\r\n")
 		body, err := io.ReadAll(resp.Body)
 		println(string(body))
 		resp.Body.Close()
 		cnt++
 		fmt.Printf("-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,68 +0,0 @@
 // This example gets an URL using http.Head().  URL scheme can be http or https.
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //
 // Some targets (Arduino Nano33 IoT) don't have enough SRAM to run http.Head().
 // Use the following for those targets:
 //
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 //go:build ninafw || wioterminal
 package main
 import (
 	"bytes"
 	"fmt"
 	"log"
 	"machine"
 	"net/http"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	url  string = "https://httpbin.org"
 )
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	resp, err := http.Head(url)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer resp.Body.Close()
 	var buf bytes.Buffer
 	if err := resp.Write(&buf); err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(string(buf.Bytes()))
 	link.NetDisconnect()
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,72 +0,0 @@
 // This example posts an URL using http.Post().  URL scheme can be http or https.
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //
 // Some targets (Arduino Nano33 IoT) don't have enough SRAM to run http.Post().
 // Use the following for those targets:
 //
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 //go:build ninafw || wioterminal
 package main
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net/http"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 )
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	path := "https://httpbin.org/post"
 	data := []byte("{\"name\":\"John Doe\",\"occupation\":\"gardener\"}")
 	resp, err := http.Post(path, "application/json", bytes.NewBuffer(data))
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(string(body))
 	link.NetDisconnect()
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,73 +0,0 @@
 // This example posts an URL using http.PostForm().  URL scheme can be http or https.
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //
 // Some targets (Arduino Nano33 IoT) don't have enough SRAM to run
 // http.PostForm().  Use the following for those targets:
 //
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 //go:build ninafw || wioterminal
 package main
 import (
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net/http"
 	"net/url"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 )
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	path := "https://httpbin.org/post"
 	data := url.Values{
 		"name":       {"John Doe"},
 		"occupation": {"gardener"},
 	}
 	resp, err := http.PostForm(path, data)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(string(body))
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,146 +0,0 @@
 // This example is an MQTT client built with the natiu-mqtt package.  It sends
 // machine.CPUFrequency() readings to the broker every second for 10 seconds.
 //
 // Note: It may be necessary to increase the stack size when using
 // paho.mqtt.golang.  Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal || challenger_rp2040
 package main
 import (
 	"context"
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"math/rand"
 	"net"
 	"time"
 	mqtt "github.com/soypat/natiu-mqtt"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid   string
 	pass   string
 	broker string = "test.mosquitto.org:1883"
 	topic  string = "cpu/freq"
 )
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	clientId := "tinygo-client-" + randomString(10)
 	fmt.Printf("ClientId: %s\n", clientId)
 	// Get a transport for MQTT packets
 	fmt.Printf("Connecting to MQTT broker at %s\n", broker)
 	conn, err := net.Dial("tcp", broker)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer conn.Close()
 	// Create new client
 	client := mqtt.NewClient(mqtt.ClientConfig{
 		Decoder: mqtt.DecoderNoAlloc{make([]byte, 1500)},
 		OnPub: func(_ mqtt.Header, _ mqtt.VariablesPublish, r io.Reader) error {
 			message, _ := io.ReadAll(r)
 			fmt.Printf("Message %s received on topic %s\n", string(message), topic)
 			return nil
 		},
 	})
 	// Connect client
 	var varconn mqtt.VariablesConnect
 	varconn.SetDefaultMQTT([]byte(clientId))
 	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
 	err = client.Connect(ctx, conn, &varconn)
 	if err != nil {
 		log.Fatal("failed to connect: ", err)
 	}
 	// Subscribe to topic
 	ctx, _ = context.WithTimeout(context.Background(), 10*time.Second)
 	err = client.Subscribe(ctx, mqtt.VariablesSubscribe{
 		PacketIdentifier: 23,
 		TopicFilters: []mqtt.SubscribeRequest{
 			{TopicFilter: []byte(topic), QoS: mqtt.QoS0},
 		},
 	})
 	if err != nil {
 		log.Fatal("failed to subscribe to", topic, err)
 	}
 	fmt.Printf("Subscribed to topic %s\n", topic)
 	// Publish on topic
 	pubFlags, _ := mqtt.NewPublishFlags(mqtt.QoS0, false, false)
 	pubVar := mqtt.VariablesPublish{
 		TopicName: []byte(topic),
 	}
 	for i := 0; i < 10; i++ {
 		if !client.IsConnected() {
 			log.Fatal("client disconnected: ", client.Err())
 		}
 		freq := float32(machine.CPUFrequency()) / 1000000
 		payload := fmt.Sprintf("%.02fMhz", freq)
 		pubVar.PacketIdentifier++
 		err = client.PublishPayload(pubFlags, pubVar, []byte(payload))
 		if err != nil {
 			log.Fatal("error transmitting message: ", err)
 		}
 		time.Sleep(time.Second)
 		conn.SetReadDeadline(time.Now().Add(10 * time.Second))
 		err = client.HandleNext()
 		if err != nil {
 			log.Fatal("handle next: ", err)
 		}
 	}
 	client.Disconnect(errors.New("disconnected gracefully"))
 	for {
 		select {}
 	}
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,114 +0,0 @@
 // This example is an MQTT client built with the paho-mqtt package.  It sends
 // machine.CPUFrequency() readings to the broker every second for 10 seconds.
 //
 // Note: It may be necessary to increase the stack size when using
 // paho.mqtt.golang.  Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal || challenger_rp2040
 package main
 import (
 	"fmt"
 	"log"
 	"machine"
 	"math/rand"
 	"time"
 	mqtt "github.com/eclipse/paho.mqtt.golang"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid   string
 	pass   string
 	broker string = "tcp://test.mosquitto.org:1883"
 )
 var messagePubHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
 	fmt.Printf("Message %s received on topic %s\n", msg.Payload(), msg.Topic())
 }
 var connectHandler mqtt.OnConnectHandler = func(client mqtt.Client) {
 	fmt.Println("Connected")
 }
 var connectionLostHandler mqtt.ConnectionLostHandler = func(client mqtt.Client, err error) {
 	fmt.Printf("Connection Lost: %s\n", err.Error())
 }
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	clientId := "tinygo-client-" + randomString(10)
 	fmt.Printf("ClientId: %s\n", clientId)
 	options := mqtt.NewClientOptions()
 	options.AddBroker(broker)
 	options.SetClientID(clientId)
 	options.SetDefaultPublishHandler(messagePubHandler)
 	options.OnConnect = connectHandler
 	options.OnConnectionLost = connectionLostHandler
 	fmt.Printf("Connecting to MQTT broker at %s\n", broker)
 	client := mqtt.NewClient(options)
 	token := client.Connect()
 	if token.Wait() && token.Error() != nil {
 		panic(token.Error())
 	}
 	topic := "cpu/freq"
 	token = client.Subscribe(topic, 1, nil)
 	if token.Wait() && token.Error() != nil {
 		panic(token.Error())
 	}
 	fmt.Printf("Subscribed to topic %s\n", topic)
 	for i := 0; i < 10; i++ {
 		freq := float32(machine.CPUFrequency()) / 1000000
 		payload := fmt.Sprintf("%.02fMhz", freq)
 		token = client.Publish(topic, 0, false, payload)
 		if token.Wait() && token.Error() != nil {
 			panic(token.Error())
 		}
 		time.Sleep(time.Second)
 	}
 	client.Disconnect(100)
 	for {
 		select {}
 	}
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,115 +0,0 @@
 // This is an example of an NTP client.
 //
 // It creates a UDP connection to request the current time and parse the
 // response from a NTP server.  The system time is set to NTP time.
 //go:build ninafw || wioterminal || challenger_rp2040
 package main
 import (
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net"
 	"runtime"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	// IP address of the server aka "hub". Replace with your own info.
 	ntpHost string = "0.pool.ntp.org:123"
 )
 const NTP_PACKET_SIZE = 48
 var response = make([]byte, NTP_PACKET_SIZE)
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	conn, err := net.Dial("udp", ntpHost)
 	if err != nil {
 		log.Fatal(err)
 	}
 	println("Requesting NTP time...")
 	t, err := getCurrentTime(conn)
 	if err != nil {
 		log.Fatal(fmt.Sprintf("Error getting current time: %v", err))
 	} else {
 		message("NTP time: %v", t)
 	}
 	conn.Close()
 	link.NetDisconnect()
 	runtime.AdjustTimeOffset(-1 * int64(time.Since(t)))
 	for {
 		message("Current time: %v", time.Now())
 		time.Sleep(time.Minute)
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func getCurrentTime(conn net.Conn) (time.Time, error) {
 	if err := sendNTPpacket(conn); err != nil {
 		return time.Time{}, err
 	}
 	n, err := conn.Read(response)
 	if err != nil && err != io.EOF {
 		return time.Time{}, err
 	}
 	if n != NTP_PACKET_SIZE {
 		return time.Time{}, fmt.Errorf("expected NTP packet size of %d: %d", NTP_PACKET_SIZE, n)
 	}
 	return parseNTPpacket(response), nil
 }
 func sendNTPpacket(conn net.Conn) error {
 	var request = [48]byte{
 		0xe3,
 	}
 	_, err := conn.Write(request[:])
 	return err
 }
 func parseNTPpacket(r []byte) time.Time {
 	// the timestamp starts at byte 40 of the received packet and is four bytes,
 	// this is NTP time (seconds since Jan 1 1900):
 	t := uint32(r[40])<<24 | uint32(r[41])<<16 | uint32(r[42])<<8 | uint32(r[43])
 	const seventyYears = 2208988800
 	return time.Unix(int64(t-seventyYears), 0)
 }
 func message(format string, args ...interface{}) {
 	println(fmt.Sprintf(format, args...), "\r")
 }
@@ -1,30 +0,0 @@
 //go:build ninafw || wioterminal
 package main
 import (
 	"log"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 )
 func init() {
 	time.Sleep(2 * time.Second)
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 }
@@ -1,120 +0,0 @@
 // This example is the classic snake network test.  The snake is feed a steady
 // diet of pkts and the pkts work themselves thru the snake segments and exit
 // the tail.  Each snake segment is a TCP socket connection to a server.  The
 // server echos pkts received back to the snake, and serves each segment on a
 // different port.  (See server/main.go for server).
 //
 //                snake     |    server
 //                          |
 //            head ----->---|-->--+
 //             seg a        |     |
 //                    +---<-|--<--+
 //                    |     |
 //                    +-->--|-->--+
 //             seg b        |     |
 //                    +---<-|--<--+
 //                    |     |
 //                    +-->--|-->--+
 //             seg c        |     |
 //                    +---<-|--<--+
 //                    |     |
 //                    +-->--|-->--+
 //              ...         |     |
 //                    +---<-|--<--+
 //                    |     |
 //                    +-->--|-->--+
 //             seg n        |     |
 //            tail -------<-|--<--+
 //                          |
 // The snake segments are linked by channels and each segment is run as a go
 // func.  This forces segments to connect and run concurrently, which is a good
 // test of the underlying driver's ability to handle concurrent connections.
 //go:build ninafw || wioterminal
 package main
 import (
 	_ "embed"
 	"fmt"
 	"log"
 	"net"
 	"strings"
 	"time"
 )
 //go:embed main.go
 var code string
 var (
 	server string = "10.0.0.100:8080"
 )
 func segment(in chan []byte, out chan []byte) {
 	var buf [512]byte
 	for {
 		c, err := net.Dial("tcp", server)
 		for ; err != nil; c, err = net.Dial("tcp", server) {
 			println(err.Error())
 			time.Sleep(5 * time.Second)
 		}
 		for {
 			select {
 			case msg := <-in:
 				_, err := c.Write(msg)
 				if err != nil {
 					log.Fatal(err.Error())
 				}
 				time.Sleep(100 * time.Millisecond)
 				n, err := c.Read(buf[:])
 				if err != nil {
 					log.Fatal(err.Error())
 				}
 				out <- buf[:n]
 			}
 		}
 	}
 }
 func feedit(head chan []byte) {
 	for i := 0; i < 100; i++ {
 		head <- []byte(fmt.Sprintf("\n---%d---\n", i))
 		for _, line := range strings.Split(code, "\n") {
 			if len(line) == 0 {
 				line = " "
 			}
 			head <- []byte(line)
 		}
 	}
 }
 var head = make(chan []byte)
 var a = make(chan []byte)
 var b = make(chan []byte)
 var c = make(chan []byte)
 var d = make(chan []byte)
 var e = make(chan []byte)
 var f = make(chan []byte)
 var tail = make(chan []byte)
 func main() {
 	// The snake
 	go segment(head, a)
 	go segment(a, b)
 	go segment(b, c)
 	go segment(c, d)
 	go segment(d, e)
 	go segment(e, f)
 	go segment(f, tail)
 	go feedit(head)
 	for {
 		select {
 		case msg := <-tail:
 			println(string(msg))
 		}
 	}
 }
@@ -1,34 +0,0 @@
 package main
 import (
 	"io"
 	"log"
 	"net"
 )
 func main() {
 	// Listen for connections
 	l, err := net.Listen("tcp", ":8080")
 	if err != nil {
 		log.Fatal(err.Error())
 	}
 	defer l.Close()
 	println("Listening on port", ":8080")
 	for {
 		// Wait for a connection
 		conn, err := l.Accept()
 		if err != nil {
 			log.Fatal(err)
 		}
 		println("Accepted connection from", conn.RemoteAddr().String())
 		// Service the new connection in a goroutine.
 		// The loop then returns to accepting, so that
 		// multiple connections may be served concurrently
 		go func(c net.Conn) {
 			// Echo all incoming data
 			io.Copy(c, c)
 			// Shut down the connection
 			c.Close()
 		}(conn)
 	}
 }
@@ -1,108 +0,0 @@
 // This example opens a TCP connection and sends some data using netdev sockets.
 //
 // You can open a server to accept connections from this program using:
 //
 // nc -lk 8080
 //go:build ninafw || wioterminal || challenger_rp2040
 package main
 import (
 	"bytes"
 	"fmt"
 	"log"
 	"machine"
 	"net/netip"
 	"time"
 	"tinygo.org/x/drivers/netdev"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	addr string = "10.0.0.100:8080"
 )
 var buf = &bytes.Buffer{}
 var link netlink.Netlinker
 var dev netdev.Netdever
 func main() {
 	waitSerial()
 	link, dev = probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	for {
 		sendBatch()
 		time.Sleep(500 * time.Millisecond)
 	}
 }
 func sendBatch() {
 	addrPort, _ := netip.ParseAddrPort(addr)
 	// make TCP connection
 	message("---------------\r\nDialing TCP connection")
 	fd, _ := dev.Socket(netdev.AF_INET, netdev.SOCK_STREAM, netdev.IPPROTO_TCP)
 	err := dev.Connect(fd, "", addrPort)
 	for ; err != nil; err = dev.Connect(fd, "", addrPort) {
 		message(err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	n := 0
 	w := 0
 	start := time.Now()
 	// send data
 	message("Sending data")
 	for i := 0; i < 1000; i++ {
 		buf.Reset()
 		fmt.Fprint(buf,
 			"\r---------------------------- i == ", i, " ----------------------------"+
 				"\r---------------------------- i == ", i, " ----------------------------")
 		if w, err = dev.Send(fd, buf.Bytes(), 0, time.Time{}); err != nil {
 			println("error:", err.Error(), "\r")
 			break
 		}
 		n += w
 	}
 	buf.Reset()
 	ms := time.Now().Sub(start).Milliseconds()
 	fmt.Fprint(buf, "\nWrote ", n, " bytes in ", ms, " ms\r\n")
 	message(buf.String())
 	if _, err := dev.Send(fd, buf.Bytes(), 0, time.Time{}); err != nil {
 		println("error:", err.Error(), "\r")
 	}
 	println("Disconnecting TCP...")
 	dev.Close(fd)
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,70 +0,0 @@
 // This example listens on port :8080 for client connections.  Bytes
 // received from the client are echo'ed back to the client.  Multiple
 // clients can connect as the same time, each consuming a client socket,
 // and being serviced by it's own go func.
 //
 // Example test using nc as client to copy file:
 //
 // $ nc 10.0.0.2 8080 <file >copy ; cmp file copy
 //go:build ninafw || wioterminal
 package main
 import (
 	"io"
 	"log"
 	"net"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	port string = ":8080"
 )
 var buf [1024]byte
 func echo(conn net.Conn) {
 	println("Client", conn.RemoteAddr(), "connected")
 	defer conn.Close()
 	_, err := io.CopyBuffer(conn, conn, buf[:])
 	if err != nil && err != io.EOF {
 		log.Fatal(err.Error())
 	}
 	println("Client", conn.RemoteAddr(), "closed")
 }
 func main() {
 	time.Sleep(2 * time.Second)
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	println("Starting TCP server listening on", port)
 	l, err := net.Listen("tcp", port)
 	if err != nil {
 		log.Fatal(err.Error())
 	}
 	defer l.Close()
 	for {
 		conn, err := l.Accept()
 		if err != nil {
 			log.Fatal(err.Error())
 		}
 		go echo(conn)
 	}
 }
@@ -1,106 +0,0 @@
 // This example uses TLS to send an HTTPS request to retrieve a webpage
 //
 // You shall see "strict-transport-security" header in the response,
 // this confirms communication is indeed over HTTPS
 //
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
 //go:build ninafw || wioterminal
 package main
 import (
 	"bufio"
 	"crypto/tls"
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	// HTTPS server address to hit with a GET / request
 	address string = "httpbin.org:443"
 )
 var conn net.Conn
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func check(err error) {
 	if err != nil {
 		println("Hit an error:", err.Error())
 		panic("BYE")
 	}
 }
 func readResponse() {
 	r := bufio.NewReader(conn)
 	resp, err := io.ReadAll(r)
 	check(err)
 	println(string(resp))
 }
 func closeConnection() {
 	conn.Close()
 }
 func dialConnection() {
 	var err error
 	println("\r\n---------------\r\nDialing TLS connection")
 	conn, err = tls.Dial("tcp", address, nil)
 	for ; err != nil; conn, err = tls.Dial("tcp", address, nil) {
 		println("Connection failed:", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	println("Connected!\r")
 }
 func makeRequest() {
 	print("Sending HTTPS request...")
 	w := bufio.NewWriter(conn)
 	fmt.Fprintln(w, "GET /get HTTP/1.1")
 	fmt.Fprintln(w, "Host:", strings.Split(address, ":")[0])
 	fmt.Fprintln(w, "User-Agent: TinyGo")
 	fmt.Fprintln(w, "Connection: close")
 	fmt.Fprintln(w)
 	check(w.Flush())
 	println("Sent!\r\n\r")
 }
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	for i := 0; ; i++ {
 		dialConnection()
 		makeRequest()
 		readResponse()
 		closeConnection()
 		println("--------", i, "--------\r\n")
 		time.Sleep(10 * time.Second)
 	}
 }
@@ -1,120 +0,0 @@
 // This example runs on wioterminal.  It gets an URL using http.Get() and
 // displays the output on the wioterminal LCD screen.
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //go:build wioterminal
 package main
 import (
 	"fmt"
 	"image/color"
 	"io"
 	"log"
 	"machine"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/ili9341"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 	"tinygo.org/x/tinyfont/proggy"
 	"tinygo.org/x/tinyterm"
 )
 var (
 	ssid string
 	pass string
 )
 var (
 	display = ili9341.NewSPI(
 		machine.SPI3,
 		machine.LCD_DC,
 		machine.LCD_SS_PIN,
 		machine.LCD_RESET,
 	)
 	backlight = machine.LCD_BACKLIGHT
 	terminal = tinyterm.NewTerminal(display)
 	black = color.RGBA{0, 0, 0, 255}
 	white = color.RGBA{255, 255, 255, 255}
 	red   = color.RGBA{255, 0, 0, 255}
 	blue  = color.RGBA{0, 0, 255, 255}
 	green = color.RGBA{0, 255, 0, 255}
 	font = &proggy.TinySZ8pt7b
 )
 func main() {
 	machine.SPI3.Configure(machine.SPIConfig{
 		SCK:       machine.LCD_SCK_PIN,
 		SDO:       machine.LCD_SDO_PIN,
 		SDI:       machine.LCD_SDI_PIN,
 		Frequency: 40000000,
 	})
 	display.Configure(ili9341.Config{})
 	display.FillScreen(black)
 	backlight.Configure(machine.PinConfig{machine.PinOutput})
 	backlight.High()
 	terminal.Configure(&tinyterm.Config{
 		Font:       font,
 		FontHeight: 10,
 		FontOffset: 6,
 	})
 	fmt.Fprintf(terminal, "Connecting to %s...\r\n", ssid)
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	name := "John Doe"
 	occupation := "gardener"
 	params := "name=" + url.QueryEscape(name) + "&" +
 		"occupation=" + url.QueryEscape(occupation)
 	path := fmt.Sprintf("https://httpbin.org/get?%s", params)
 	cnt := 0
 	for {
 		fmt.Fprintf(terminal, "Getting %s\r\n\r\n", path)
 		resp, err := http.Get(path)
 		if err != nil {
 			fmt.Fprintf(terminal, "%s\r\n", err.Error())
 			time.Sleep(10 * time.Second)
 			continue
 		}
 		fmt.Fprintf(terminal, "%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Fprintf(terminal, "%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Fprintf(terminal, "\r\n")
 		body, err := io.ReadAll(resp.Body)
 		fmt.Fprintf(terminal, string(body))
 		resp.Body.Close()
 		cnt++
 		fmt.Fprintf(terminal, "-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
@@ -1,117 +0,0 @@
 // This example uses TCP to send an HTTP request to retrieve a webpage.  The
 // HTTP request is hand-rolled to avoid the overhead of using http.Get() from
 // the "net/http" package.  See example/net/http-get for the full http.Get()
 // functionality.
 //
 // Example HTTP server:
 // ---------------------------------------------------------------------------
 // package main
 //
 // import "net/http"
 //
 // func main() {
 //        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 //                w.Write([]byte("hello"))
 //        })
 //        http.ListenAndServe(":8080", nil)
 // }
 // ---------------------------------------------------------------------------
 //go:build ninafw || wioterminal
 package main
 import (
 	"bufio"
 	"fmt"
 	"io"
 	"log"
 	"machine"
 	"net"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	// HTTP server address to hit with a GET / request
 	address string = "10.0.0.100:8080"
 )
 var conn net.Conn
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func dialConnection() {
 	var err error
 	println("\r\n---------------\r\nDialing TCP connection")
 	conn, err = net.Dial("tcp", address)
 	for ; err != nil; conn, err = net.Dial("tcp", address) {
 		println("Connection failed:", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	println("Connected!\r")
 }
 func check(err error) {
 	if err != nil {
 		println("Hit an error:", err.Error())
 		panic("BYE")
 	}
 }
 func makeRequest() {
 	println("Sending HTTP request...")
 	w := bufio.NewWriter(conn)
 	fmt.Fprintln(w, "GET / HTTP/1.1")
 	fmt.Fprintln(w, "Host:", strings.Split(address, ":")[0])
 	fmt.Fprintln(w, "User-Agent: TinyGo")
 	fmt.Fprintln(w, "Connection: close")
 	fmt.Fprintln(w)
 	check(w.Flush())
 	println("Sent!\r\n\r")
 }
 func readResponse() {
 	r := bufio.NewReader(conn)
 	resp, err := io.ReadAll(r)
 	check(err)
 	println(string(resp))
 }
 func closeConnection() {
 	conn.Close()
 }
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	for i := 0; ; i++ {
 		dialConnection()
 		makeRequest()
 		readResponse()
 		closeConnection()
 		println("--------", i, "--------\r\n")
 		time.Sleep(10 * time.Second)
 	}
 }
@@ -1,64 +0,0 @@
 // This example is a websocket client.  It connects to a websocket server
 // which echos messages back to the client.  For server, see
 //
 //     https://pkg.go.dev/golang.org/x/net/websocket#example-Handler
 //
 // Note: It may be necessary to increase the stack size when using
 // "golang.org/x/net/websocket".  Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal
 package main
 import (
 	"fmt"
 	"log"
 	"machine"
 	"time"
 	"golang.org/x/net/websocket"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	url  string = "ws://10.0.0.100:8080/echo"
 )
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	origin := "http://localhost/"
 	ws, err := websocket.Dial(url, "", origin)
 	if err != nil {
 		log.Fatal(err)
 	}
 	if _, err := ws.Write([]byte("hello, world!\n")); err != nil {
 		log.Fatal(err)
 	}
 	var msg = make([]byte, 512)
 	var n int
 	if n, err = ws.Read(msg); err != nil {
 		log.Fatal(err)
 	}
 	fmt.Printf("Received: %s", msg[:n])
 }
@@ -1,62 +0,0 @@
 // This example is a websocket server.  It listens for websocket clients
 // to connect and echos messages back to the client.  For client, see
 //
 //     https://pkg.go.dev/golang.org/x/net/websocket#example-Dial
 //
 // Note: It may be necessary to increase the stack size when using
 // "golang.org/x/net/websocket".  Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal
 package main
 import (
 	"io"
 	"log"
 	"machine"
 	"net/http"
 	"time"
 	"golang.org/x/net/websocket"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	port string = ":8080"
 )
 // Echo the data received on the WebSocket.
 func EchoServer(ws *websocket.Conn) {
 	io.Copy(ws, ws)
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 // This example demonstrates a trivial echo server.
 func main() {
 	waitSerial()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	http.Handle("/echo", websocket.Handler(EchoServer))
 	err = http.ListenAndServe(port, nil)
 	if err != nil {
 		panic("ListenAndServe: " + err.Error())
 	}
 }
@@ -1,28 +0,0 @@
 <html>
 <head>
 	<title>TinyGo - A Go Compiler For Small Places</title>
 	<style>
 		body {
 			background-color: rgb(4, 111, 143);
 			text-align: center;
 			display: flex;
 			flex-direction: column;
 			align-items: center;
 		}
 		img {
 			display: block;
 			margin: 0 auto;
 			width: 299px;
 			height: 255px;
 		}
 		h1 {
 			color: white;
 			text-align: center;
 		}
 	</style>
 </head>
 <body>
 	<h1>TinyGo - A Go Compiler For Small Places</h1>
 	<img src="images/tinygo-logo.png">
 </body>
 </html>
@@ -1,49 +0,0 @@
 // This example is an HTTP server serving up a static file system
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal
 package main
 import (
 	"embed"
 	"log"
 	"net/http"
 	"time"
 	"tinygo.org/x/drivers/netlink"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	ssid string
 	pass string
 	port string = ":80"
 )
 //go:embed index.html main.go images
 var fs embed.FS
 func main() {
 	// wait a bit for console
 	time.Sleep(2 * time.Second)
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	hfs := http.FileServer(http.FS(fs))
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		hfs.ServeHTTP(w, r)
 	})
 	log.Fatal(http.ListenAndServe(port, nil))
 }
@@ -1,34 +0,0 @@
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/pcf8523"
 )
 func main() {
 	machine.I2C0.Configure(machine.I2CConfig{})
 	dev := pcf8523.New(machine.I2C0)
 	// make sure the battery takes over if power is lost
 	err := dev.SetPowerManagement(pcf8523.PowerManagement_SwitchOver_ModeStandard)
 	if err != nil {
 		panic(err)
 	}
 	// set RTC once, i.e. from `date -u +"%Y-%m-%dT%H:%M:%SZ"`
 	now, _ := time.Parse(time.RFC3339, "2023-09-18T20:31:38Z")
 	err = dev.SetTime(now)
 	if err != nil {
 		panic(err)
 	}
 	for {
 		ts, err := dev.ReadTime()
 		if err != nil {
 			panic(err)
 		}
 		println("tick-tock, it's: " + ts.String())
 		time.Sleep(2 * time.Second)
 	}
 }
@@ -0,0 +1,131 @@
 // This is a sensor station that uses a RTL8720DN running on the device UART2.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> USB-CDC <--> MCU <--> UART2 <--> RTL8720DN <--> Internet <--> MQTT broker.
 //
 // You must install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 //
 // You can check that mqttpub is running successfully with the following command.
 //
 //	mosquitto_sub -h test.mosquitto.org -t tinygo
 package main
 import (
 	"machine"
 	"fmt"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/mqtt"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    debug = true
 //    server = "tinygo.org"
 // }
 var (
 	ssid   string
 	pass   string
 	server string = "tcp://test.mosquitto.org:1883"
 	debug         = false
 )
 var buf [0x400]byte
 var lastRequestTime time.Time
 var conn net.Conn
 var adaptor *rtl8720dn.Driver
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 var (
 	topic = "tinygo"
 )
 func run() error {
 	// change the UART and pins as needed for platforms other than the WioTerminal.
 	adaptor = rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	rand.Seed(time.Now().UnixNano())
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connectng to MQTT...")
 	cl := mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	for i := 0; ; i++ {
 		println("Publishing MQTT message...")
 		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
 		token := cl.Publish(topic, 0, false, data)
 		token.Wait()
 		if err := token.Error(); err != nil {
 			return err
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 	return nil
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,154 @@
 // This is a sensor station that uses a RTL8720DN running on the device UART2.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> USB-CDC <--> MCU <--> UART2 <--> RTL8720DN <--> Internet <--> MQTT broker.
 //
 // You must also install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 //
 // You can check that mqttpub/mqttsub is running successfully with the following command.
 //
 //	mosquitto_sub -h test.mosquitto.org -t tinygo/tx
 //	mosquitto_pub -h test.mosquitto.org -t tinygo/rx -m "hello world"
 package main
 import (
 	"machine"
 	"fmt"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/mqtt"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    debug = true
 //    server = "tinygo.org"
 // }
 var (
 	ssid   string
 	pass   string
 	server string = "tcp://test.mosquitto.org:1883"
 	debug         = false
 )
 var buf [0x400]byte
 var lastRequestTime time.Time
 var conn net.Conn
 var adaptor *rtl8720dn.Driver
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	cl      mqtt.Client
 	topicTx = "tinygo/tx"
 	topicRx = "tinygo/rx"
 )
 func subHandler(client mqtt.Client, msg mqtt.Message) {
 	fmt.Printf("[%s]  ", msg.Topic())
 	fmt.Printf("%s\r\n", msg.Payload())
 }
 func run() error {
 	// change the UART and pins as needed for platforms other than the WioTerminal.
 	adaptor = rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	rand.Seed(time.Now().UnixNano())
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connecting to MQTT broker at", server)
 	cl = mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	// subscribe
 	token := cl.Subscribe(topicRx, 0, subHandler)
 	token.Wait()
 	if token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	go publishing()
 	select {}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 	return nil
 }
 func publishing() {
 	for i := 0; ; i++ {
 		println("Publishing MQTT message...")
 		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
 		token := cl.Publish(topicTx, 0, false, data)
 		token.Wait()
 		if token.Error() != nil {
 			println(token.Error().Error())
 		}
 		time.Sleep(20 * 100 * time.Millisecond)
 	}
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,143 @@
 // This is an example of using the rtl8720dn driver to implement a NTP client.
 // It creates a UDP connection to request the current time and parse the
 // response from a NTP server.
 package main
 import (
 	"machine"
 	"errors"
 	"fmt"
 	"runtime"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // IP address of the server aka "hub". Replace with your own info.
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    ntpHost = "129.6.15.29"
 //    debug = true
 // }
 var (
 	ssid    string
 	pass    string
 	ntpHost = "129.6.15.29"
 	debug   = false
 )
 const NTP_PACKET_SIZE = 48
 var b = make([]byte, NTP_PACKET_SIZE)
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	// now make UDP connection
 	hip := net.ParseIP(ntpHost)
 	raddr := &net.UDPAddr{IP: hip, Port: 123}
 	laddr := &net.UDPAddr{Port: 2390}
 	conn, err := net.DialUDP("udp", laddr, raddr)
 	if err != nil {
 		return err
 	}
 	for {
 		// send data
 		println("Requesting NTP time...")
 		t, err := getCurrentTime(conn)
 		if err != nil {
 			message("Error getting current time: %v", err)
 		} else {
 			message("NTP time: %v", t)
 		}
 		runtime.AdjustTimeOffset(-1 * int64(time.Since(t)))
 		for i := 0; i < 10; i++ {
 			message("Current time: %v", time.Now())
 			time.Sleep(1 * time.Second)
 		}
 	}
 }
 func getCurrentTime(conn *net.UDPSerialConn) (time.Time, error) {
 	if err := sendNTPpacket(conn); err != nil {
 		return time.Time{}, err
 	}
 	clearBuffer()
 	for now := time.Now(); time.Since(now) < time.Second; {
 		time.Sleep(5 * time.Millisecond)
 		if n, err := conn.Read(b); err != nil {
 			return time.Time{}, fmt.Errorf("error reading UDP packet: %w", err)
 		} else if n == 0 {
 			continue // no packet received yet
 		} else if n != NTP_PACKET_SIZE {
 			return time.Time{}, fmt.Errorf("expected NTP packet size of %d: %d", NTP_PACKET_SIZE, n)
 		}
 		return parseNTPpacket(), nil
 	}
 	return time.Time{}, errors.New("no packet received after 1 second")
 }
 func sendNTPpacket(conn *net.UDPSerialConn) error {
 	clearBuffer()
 	b[0] = 0b11100011 // LI, Version, Mode
 	b[1] = 0          // Stratum, or type of clock
 	b[2] = 6          // Polling Interval
 	b[3] = 0xEC       // Peer Clock Precision
 	// 8 bytes of zero for Root Delay & Root Dispersion
 	b[12] = 49
 	b[13] = 0x4E
 	b[14] = 49
 	b[15] = 52
 	if _, err := conn.Write(b); err != nil {
 		return err
 	}
 	return nil
 }
 func parseNTPpacket() time.Time {
 	// the timestamp starts at byte 40 of the received packet and is four bytes,
 	// this is NTP time (seconds since Jan 1 1900):
 	t := uint32(b[40])<<24 | uint32(b[41])<<16 | uint32(b[42])<<8 | uint32(b[43])
 	const seventyYears = 2208988800
 	return time.Unix(int64(t-seventyYears), 0)
 }
 func clearBuffer() {
 	for i := range b {
 		b[i] = 0
 	}
 }
 func message(format string, args ...interface{}) {
 	println(fmt.Sprintf(format, args...), "\r")
 }
@@ -0,0 +1,121 @@
 // This example opens a TCP connection using a device with RTL8720DN firmware
 // and sends some data, for the purpose of testing speed and connectivity.
 //
 // You can open a server to accept connections from this program using:
 //
 // nc -w 5 -lk 8080
 package main
 import (
 	"machine"
 	"bytes"
 	"fmt"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    serverIP = "192.168.1.119"
 //    debug = true
 // }
 var (
 	ssid     string
 	pass     string
 	serverIP = ""
 	debug    = false
 )
 var buf = &bytes.Buffer{}
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	for {
 		sendBatch()
 		time.Sleep(500 * time.Millisecond)
 	}
 	println("Done.")
 	return nil
 }
 func sendBatch() {
 	// make TCP connection
 	ip := net.ParseIP(serverIP)
 	raddr := &net.TCPAddr{IP: ip, Port: 8080}
 	laddr := &net.TCPAddr{Port: 8080}
 	message("---------------\r\nDialing TCP connection")
 	conn, err := net.DialTCP("tcp", laddr, raddr)
 	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
 		message(err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	n := 0
 	w := 0
 	start := time.Now()
 	// send data
 	message("Sending data")
 	for i := 0; i < 1000; i++ {
 		buf.Reset()
 		fmt.Fprint(buf,
 			"\r---------------------------- i == ", i, " ----------------------------"+
 				"\r---------------------------- i == ", i, " ----------------------------")
 		if w, err = conn.Write(buf.Bytes()); err != nil {
 			println("error:", err.Error(), "\r")
 			continue
 		}
 		n += w
 	}
 	buf.Reset()
 	ms := time.Now().Sub(start).Milliseconds()
 	fmt.Fprint(buf, "\nWrote ", n, " bytes in ", ms, " ms\r\n")
 	message(buf.String())
 	if _, err := conn.Write(buf.Bytes()); err != nil {
 		println("error:", err.Error(), "\r")
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting TCP...")
 	conn.Close()
 }
 func message(msg string) {
 	println(msg, "\r")
 }
@@ -0,0 +1,137 @@
 package main
 import (
 	"machine"
 	"bufio"
 	"fmt"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    debug = true
 //    url = "https://www.example.com"
 //    test_root_ca = "..."
 // }
 var (
 	ssid  string
 	pass  string
 	url   string = "https://www.example.com"
 	debug        = false
 )
 // Set the test_root_ca created by the following command
 // $ openssl s_client -showcerts -verify 5 -connect www.example.com:443 < /dev/null
 var test_root_ca = `-----BEGIN CERTIFICATE-----
 MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
 MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
 d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
 QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
 MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
 b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
 9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
 CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
 nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
 43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
 T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
 gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
 BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
 TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
 DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
 hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
 06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
 PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
 YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
 CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
 -----END CERTIFICATE-----
 `
 var buf [0x1000]byte
 var lastRequestTime time.Time
 var conn net.Conn
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	adaptor.SetRootCA(&test_root_ca)
 	http.SetBuf(buf[:])
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)
 	// 	if err != nil {
 	// 		return err
 	// 	}
 	// 	client := &http.Client{Jar: jar}
 	// 	http.DefaultClient = client
 	cnt := 0
 	for {
 		// Various examples are as follows
 		//
 		// -- Get
 		// 	resp, err := http.Get(url)
 		//
 		// -- Post
 		// 	body := `cnt=12`
 		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
 		//
 		// -- Post with JSON
 		// 	body := `{"msg": "hello"}`
 		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
 		resp, err := http.Get(url)
 		if err != nil {
 			return err
 		}
 		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Printf("\r\n")
 		scanner := bufio.NewScanner(resp.Body)
 		for scanner.Scan() {
 			fmt.Printf("%s\r\n", scanner.Text())
 		}
 		resp.Body.Close()
 		cnt++
 		fmt.Printf("-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
@@ -0,0 +1,91 @@
 package main
 import (
 	"machine"
 	"fmt"
 	"strconv"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // IP address of the server aka "hub". Replace with your own info.
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    hubIP = "192.168.1.118"
 //    debug = true
 // }
 var (
 	ssid  string
 	pass  string
 	hubIP = ""
 	debug = false
 )
 var buf [0x400]byte
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	http.SetBuf(buf[:])
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	// now make UDP connection
 	hip := net.ParseIP(hubIP)
 	raddr := &net.UDPAddr{IP: hip, Port: 2222}
 	laddr := &net.UDPAddr{Port: 2222}
 	println("Dialing UDP connection...")
 	conn, err := net.DialUDP("udp", laddr, raddr)
 	if err != nil {
 		return err
 	}
 	for {
 		// send data
 		println("Sending data...")
 		for i := 0; i < 25; i++ {
 			conn.Write([]byte("hello " + strconv.Itoa(i) + "\r\n"))
 		}
 		time.Sleep(1000 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting UDP...")
 	conn.Close()
 	println("Done.")
 	return nil
 }
 func message(msg string) {
 	println(msg, "\r")
 }
@@ -0,0 +1,40 @@
 package main
 import (
 	"machine"
 	"fmt"
 	"time"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 var (
 	debug = false
 )
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	ver, err := adaptor.Version()
 	if err != nil {
 		return nil
 	}
 	for {
 		fmt.Printf("RTL8270DN Firmware Version: %s\r\n", ver)
 		time.Sleep(10 * time.Second)
 	}
 	return nil
 }
@@ -0,0 +1,162 @@
 package main
 import (
 	"machine"
 	"bufio"
 	"fmt"
 	"image/color"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/ili9341"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 	"tinygo.org/x/tinyfont/proggy"
 	"tinygo.org/x/tinyterm"
 )
 // You can override the setting with the init() in another source code.
 // If debug is enabled, a serial connection is required.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    debug = false // true
 //    server = "tinygo.org"
 // }
 var (
 	ssid  string
 	pass  string
 	url   = "http://tinygo.org/"
 	debug = false
 )
 var (
 	display = ili9341.NewSPI(
 		machine.SPI3,
 		machine.LCD_DC,
 		machine.LCD_SS_PIN,
 		machine.LCD_RESET,
 	)
 	backlight = machine.LCD_BACKLIGHT
 	terminal = tinyterm.NewTerminal(display)
 	black = color.RGBA{0, 0, 0, 255}
 	white = color.RGBA{255, 255, 255, 255}
 	red   = color.RGBA{255, 0, 0, 255}
 	blue  = color.RGBA{0, 0, 255, 255}
 	green = color.RGBA{0, 255, 0, 255}
 	font = &proggy.TinySZ8pt7b
 )
 var buf [0x400]byte
 func main() {
 	display.FillScreen(black)
 	backlight.High()
 	terminal.Configure(&tinyterm.Config{
 		Font:       font,
 		FontHeight: 10,
 		FontOffset: 6,
 	})
 	err := run()
 	for err != nil {
 		fmt.Fprintf(terminal, "error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	fmt.Fprintf(terminal, "setupRTL8720DN()\r\n")
 	if debug {
 		fmt.Fprintf(terminal, "Running in debug mode.\r\n")
 		fmt.Fprintf(terminal, "A serial connection is required to continue execution.\r\n")
 	}
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	http.UseDriver(adaptor)
 	http.SetBuf(buf[:])
 	fmt.Fprintf(terminal, "ConnectToAP()\r\n")
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	fmt.Fprintf(terminal, "connected\r\n\r\n")
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Fprintf(terminal, "IP Address : %s\r\n", ip)
 	fmt.Fprintf(terminal, "Mask       : %s\r\n", subnet)
 	fmt.Fprintf(terminal, "Gateway    : %s\r\n", gateway)
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)
 	// 	if err != nil {
 	// 		return err
 	// 	}
 	// 	client := &http.Client{Jar: jar}
 	// 	http.DefaultClient = client
 	cnt := 0
 	for {
 		// Various examples are as follows
 		//
 		// -- Get
 		// 	resp, err := http.Get(url)
 		//
 		// -- Post
 		// 	body := `cnt=12`
 		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
 		//
 		// -- Post with JSON
 		// 	body := `{"msg": "hello"}`
 		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
 		resp, err := http.Get(url)
 		if err != nil {
 			return err
 		}
 		fmt.Fprintf(terminal, "%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Fprintf(terminal, "%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Printf("\r\n")
 		scanner := bufio.NewScanner(resp.Body)
 		for scanner.Scan() {
 			fmt.Fprintf(terminal, "%s\r\n", scanner.Text())
 		}
 		resp.Body.Close()
 		cnt++
 		fmt.Fprintf(terminal, "-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
 func init() {
 	machine.SPI3.Configure(machine.SPIConfig{
 		SCK:       machine.LCD_SCK_PIN,
 		SDO:       machine.LCD_SDO_PIN,
 		SDI:       machine.LCD_SDI_PIN,
 		Frequency: 40000000,
 	})
 	display.Configure(ili9341.Config{})
 	backlight.Configure(machine.PinConfig{machine.PinOutput})
 }
@@ -0,0 +1,106 @@
 package main
 import (
 	"machine"
 	"bufio"
 	"fmt"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    url = "http://tinygo.org/"
 //    debug = true
 // }
 var (
 	ssid  string
 	pass  string
 	url   = "http://tinygo.org/"
 	debug = false
 )
 var buf [0x400]byte
 func main() {
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	http.UseDriver(adaptor)
 	http.SetBuf(buf[:])
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)
 	// 	if err != nil {
 	// 		return err
 	// 	}
 	// 	client := &http.Client{Jar: jar}
 	// 	http.DefaultClient = client
 	cnt := 0
 	for {
 		// Various examples are as follows
 		//
 		// -- Get
 		// 	resp, err := http.Get(url)
 		//
 		// -- Post
 		// 	body := `cnt=12`
 		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
 		//
 		// -- Post with JSON
 		// 	body := `{"msg": "hello"}`
 		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
 		resp, err := http.Get(url)
 		if err != nil {
 			return err
 		}
 		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Printf("\r\n")
 		scanner := bufio.NewScanner(resp.Body)
 		for scanner.Scan() {
 			fmt.Printf("%s\r\n", scanner.Text())
 		}
 		resp.Body.Close()
 		cnt++
 		fmt.Printf("-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
@@ -1,51 +1,61 @@
 // This example listens on port :80 serving a web page.  Multiple clients
 // may connect and be serviced at the same time.  IPv4 only.  HTTP only.
 //
 // $ curl http://10.0.0.2
 //
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 //go:build ninafw || wioterminal
 package main
 import (
 	"fmt"
 	"log"
 	"machine"
 	"net/http"
 	"strconv"
 	"time"
-	"tinygo.org/x/drivers/netlink"
+	"tinygo.org/x/drivers/net/http"
-	"tinygo.org/x/drivers/netlink/probe"
+	"tinygo.org/x/drivers/rtl8720dn"
 )
 // You can override the setting with the init() in another source code.
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 //    debug = true
 // }
 var (
-	ssid string
+	ssid  string
-	pass string
+	pass  string
-	port string = ":80"
+	debug = false
 )
 var led = machine.LED
 var backlight = machine.LCD_BACKLIGHT
 func main() {
 	// wait a bit for serial
 	time.Sleep(2 * time.Second)
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	backlight.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	link, _ := probe.Probe()
+	err := run()
-
+	for err != nil {
-	err := link.NetConnect(&netlink.ConnectParams{
+		fmt.Printf("error: %s\r\n", err.Error())
-		Ssid:       ssid,
+		time.Sleep(5 * time.Second)
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func run() error {
 	adaptor := rtl8720dn.New(machine.UART3, machine.PB24, machine.PC24, machine.RTL8720D_CHIP_PU)
 	adaptor.Debug(debug)
 	adaptor.Configure()
 	http.UseDriver(adaptor)
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil {
 		return err
 	}
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		return err
 	}
 	fmt.Printf("IP Address : %s\r\n", ip)
 	fmt.Printf("Mask       : %s\r\n", subnet)
 	fmt.Printf("Gateway    : %s\r\n", gateway)
 	http.HandleFunc("/", root)
 	http.HandleFunc("/hello", hello)
@@ -53,12 +63,10 @@ func main() {
 	http.HandleFunc("/6", sixlines)
 	http.HandleFunc("/off", LED_OFF)
 	http.HandleFunc("/on", LED_ON)
-
+	if err := http.ListenAndServe(":80", nil); err != nil {
-	err = http.ListenAndServe(port, nil)
+		message(err.Error())
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	return nil
 }
 func root(w http.ResponseWriter, r *http.Request) {
@@ -93,8 +101,8 @@ func root(w http.ResponseWriter, r *http.Request) {
    <title>TinyGo HTTP Server</title>
    <script language="javascript" type="text/javascript">
        var counter = 0
-        function ledOn() { fetch("/on"); }
+        function ledOn() { fetch("/on").then(response => response.text()).then(text => { led.innerHTML = "<p>on</p>"; }); }
-        function ledOff() { fetch("/off"); }
+        function ledOff() { fetch("/off").then(response => response.text()).then(text => { led.innerHTML = "<p>off</p>"; }); }
        function fetchCnt() { fetch("/cnt").then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
        function incrCnt() { counter = counter + 1; fetch("/cnt?cnt=" + counter, { method: 'POST' }).then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
        function setCnt() { fetch("/cnt", {
@@ -133,7 +141,7 @@ func root(w http.ResponseWriter, r *http.Request) {
    </p>
 </body>
 </html>
-`, access)
+    `, access)
 }
 func sixlines(w http.ResponseWriter, r *http.Request) {
@@ -147,12 +155,14 @@ func sixlines(w http.ResponseWriter, r *http.Request) {
 func LED_ON(w http.ResponseWriter, r *http.Request) {
 	led.High()
 	backlight.High()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.High()")
 }
 func LED_OFF(w http.ResponseWriter, r *http.Request) {
 	led.Low()
 	backlight.Low()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.Low()")
 }
@@ -177,3 +187,7 @@ func cnt(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set(`Content-Type`, `application/json`)
 	fmt.Fprintf(w, `{"cnt": %d}`, counter)
 }
 func message(msg string) {
 	println(msg, "\r")
 }
@@ -1,33 +0,0 @@
 package main
 import (
 	"machine"
 	"strconv"
 	"time"
 	"tinygo.org/x/drivers/seesaw"
 )
 const readDelay = time.Microsecond * 3000
 // example reading soil moisture with an Adafruit capacitive soil-sensor (4026) powered by a seesaw
 // https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/overview
 func main() {
 	machine.I2C0.Configure(machine.I2CConfig{})
 	dev := seesaw.New(machine.I2C0)
 	dev.Address = 0x36
 	// the soil sensor is especially slow, let's give it some more time
 	dev.ReadDelay = readDelay
 	var buf [2]byte
 	err := dev.Read(seesaw.ModuleTouchBase, seesaw.FunctionTouchChannelOffset, buf[:])
 	if err != nil {
 		panic(err)
 	}
 	moisture := uint16(buf[0])<<8 | uint16(buf[1])
 	println("soil moisture: " + strconv.Itoa(int(moisture)))
 }
@@ -25,25 +25,19 @@ func main() {
 		return
 	}
 	println("setting to 0°")
 	s.SetMicroseconds(1000)
 	time.Sleep(3 * time.Second)
 	println("setting to 45°")
 	s.SetMicroseconds(1500)
 	time.Sleep(3 * time.Second)
 	println("setting to 90°")
 	s.SetMicroseconds(2000)
 	time.Sleep(3 * time.Second)
 	for {
-		println("setting to 0°")
+		time.Sleep(time.Second)
 		s.SetAngle(0)
 		time.Sleep(3 * time.Second)
 		println("setting to 45°")
 		s.SetAngle(45)
 		time.Sleep(3 * time.Second)
 		println("setting to 90°")
 		s.SetAngle(90)
 		time.Sleep(3 * time.Second)
 		println("setting to 135°")
 		s.SetAngle(135)
 		time.Sleep(3 * time.Second)
 		println("setting to 180°")
 		s.SetAngle(180)
 		time.Sleep(3 * time.Second)
 	}
 }
@@ -1,53 +0,0 @@
 package main
 // Example for the SGP30 to be used on a Raspberry Pi pico.
 // Connect the sensor I2C pins to GP26 and GP27 to test.
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/sgp30"
 )
 func main() {
 	time.Sleep(time.Second)
 	println("start")
 	// Configure the I2C bus.
 	bus := machine.I2C1
 	err := bus.Configure(machine.I2CConfig{
 		SDA:       machine.GP26,
 		SCL:       machine.GP27,
 		Frequency: 400 * machine.KHz,
 	})
 	if err != nil {
 		println("could not configure I2C:", bus)
 		return
 	}
 	// Configure the sensor.
 	sensor := sgp30.New(bus)
 	if !sensor.Connected() {
 		println("sensor not connected")
 		return
 	}
 	err = sensor.Configure(sgp30.Config{})
 	if err != nil {
 		println("sensor could not be configured:", err.Error())
 		return
 	}
 	// Measure every second, as recommended by the datasheet.
 	for {
 		time.Sleep(time.Second)
 		err := sensor.Update(0)
 		if err != nil {
 			println("could not read sensor:", err.Error())
 			continue
 		}
 		println("CO₂ equivalent:", sensor.CO2())
 		println("TVOC           ", sensor.TVOC())
 	}
 }
@@ -1,23 +0,0 @@
 package main
 import (
 	"fmt"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/sht4x"
 )
 func main() {
 	machine.I2C0.Configure(machine.I2CConfig{})
 	sensor := sht4x.New(machine.I2C0)
 	for {
 		temp, humidity, _ := sensor.ReadTemperatureHumidity()
 		t := fmt.Sprintf("%.2f", float32(temp)/1000)
 		h := fmt.Sprintf("%.2f", float32(humidity)/100)
 		println("Temperature: ", t, "°C")
 		println("Humidity:    ", h, "%")
 		time.Sleep(2 * time.Second)
 	}
 }
@@ -1,50 +0,0 @@
 // This example using the SSD1306 OLED display over SPI on the Thumby board
 // A very tiny 72x40 display.
 package main
 import (
 	"image/color"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/ssd1306"
 )
 func main() {
 	machine.SPI0.Configure(machine.SPIConfig{})
 	display := ssd1306.NewSPI(machine.SPI0, machine.THUMBY_DC_PIN, machine.THUMBY_RESET_PIN, machine.THUMBY_CS_PIN)
 	display.Configure(ssd1306.Config{
 		Width:     72,
 		Height:    40,
 		ResetCol:  ssd1306.ResetValue{28, 99},
 		ResetPage: ssd1306.ResetValue{0, 5},
 	})
 	display.ClearDisplay()
 	x := int16(36)
 	y := int16(20)
 	deltaX := int16(1)
 	deltaY := int16(1)
 	for {
 		pixel := display.GetPixel(x, y)
 		c := color.RGBA{255, 255, 255, 255}
 		if pixel {
 			c = color.RGBA{0, 0, 0, 255}
 		}
 		display.SetPixel(x, y, c)
 		display.Display()
 		x += deltaX
 		y += deltaY
 		if x == 0 || x == 71 {
 			deltaX = -deltaX
 		}
 		if y == 0 || y == 39 {
 			deltaY = -deltaY
 		}
 		time.Sleep(1 * time.Millisecond)
 	}
 }
@@ -3,9 +3,7 @@ package main
 import (
 	"image/color"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/uc8151"
 )
@@ -16,56 +14,30 @@ func main() {
 	led = machine.LED
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	machine.SPI0.Configure(machine.SPIConfig{
-		Frequency: 12 * machine.MHz,
+		Frequency: 12000000,
 		SCK:       machine.EPD_SCK_PIN,
 		SDO:       machine.EPD_SDO_PIN,
 	})
 	display = uc8151.New(machine.SPI0, machine.EPD_CS_PIN, machine.EPD_DC_PIN, machine.EPD_RESET_PIN, machine.EPD_BUSY_PIN)
 	display.Configure(uc8151.Config{
-		Rotation:    drivers.Rotation270,
+		Rotation: uc8151.ROTATION_270,
-		Speed:       uc8151.TURBO,
+		Speed:    uc8151.MEDIUM,
-		FlickerFree: true,
+		Blocking: true,
 		Blocking:    false,
 	})
 	black := color.RGBA{1, 1, 1, 255}
-	display.ClearDisplay()
+	display.ClearBuffer()
-
+	display.Display()
-	mod := int16(1)
+	for i := int16(0); i < 37; i++ {
-	for {
+		for j := int16(0); j < 16; j++ {
-		// checkerboard
+			if (i+j)%2 == 0 {
-		for i := int16(0); i < 11; i++ {
+				showRect(i*8, j*8, 8, 8, black)
 			if mod == 1 {
 				mod = 0
 			} else {
 				mod = 1
 			}
 			display.ClearBuffer()
 			for i := int16(0); i < 37; i++ {
 				for j := int16(0); j < 16; j++ {
 					if (i+j)%2 == mod {
 						showRect(i*8, j*8, 8, 8, black)
 					}
 				}
 			}
 			display.Display()
 			time.Sleep(500 * time.Millisecond)
 		}
 		// moving line
 		for i := int16(16); i < 21; i++ {
 			display.ClearBuffer()
 			for j := int16(0); j < 16; j++ {
 				if (i+j)%2 == 0 {
 					showRect(i*8, j*8, 8, 8, black)
 				}
 				display.Display()
 				time.Sleep(250 * time.Millisecond)
 			}
 		}
 	}
 	display.Display()
 }
 func showRect(x int16, y int16, w int16, h int16, c color.RGBA) {
@@ -1,84 +0,0 @@
 package main
 import (
 	"image/color"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/waveshare-epd/epd2in66b"
 	"tinygo.org/x/tinyfont"
 	"tinygo.org/x/tinyfont/freemono"
 )
 var (
 	black = color.RGBA{0, 0, 0, 0xff}
 	white = color.RGBA{0xff, 0xff, 0xff, 0xff}
 	red   = color.RGBA{0xff, 0, 0, 0xff}
 )
 func main() {
 	machine.Serial.Configure(machine.UARTConfig{})
 	time.Sleep(2 * time.Second)
 	machine.SPI1.Configure(machine.SPIConfig{
 		Frequency: epd2in66b.Baudrate,
 	})
 	println("started")
 	// in case you have a Pico module, you can directly use
 	// dev, err := epd2in66b.NewPicoModule()
 	display := epd2in66b.New(machine.SPI1)
 	cfg := epd2in66b.Config{
 		DataPin:       machine.GP8,
 		ChipSelectPin: machine.GP9,
 		ResetPin:      machine.GP12,
 		BusyPin:       machine.GP13,
 	}
 	err := display.Configure(cfg)
 	if err != nil {
 		panic(err)
 	}
 	err = display.Reset()
 	if err != nil {
 		panic(err)
 	}
 	println("draw checkerboard")
 	drawCheckerBoard(&display)
 	println("draw 'hello'")
 	tinyfont.WriteLineRotated(&display, &freemono.Bold24pt7b, 40, 10, "Hello!", white, tinyfont.ROTATION_90)
 	tinyfont.WriteLineRotated(&display, &freemono.Bold12pt7b, 10, 10, "tinygo rocks", white, tinyfont.ROTATION_90)
 	err = display.Display()
 	if err != nil {
 		panic(err)
 	}
 }
 func drawCheckerBoard(display drivers.Displayer) {
 	s := 8
 	width, height := display.Size()
 	for x := 0; x <= int(width)-s; x += s {
 		for y := 0; y <= int(height)-s; y += s {
 			c := red
 			if (x/s)%2 == (y/s)%2 {
 				c = black
 			}
 			showRect(display, x, y, s, s, c)
 		}
 	}
 }
 func showRect(display drivers.Displayer, x int, y int, w int, h int, c color.RGBA) {
 	for i := x; i < x+w; i++ {
 		for j := y; j < y+h; j++ {
 			display.SetPixel(int16(i), int16(j), c)
 		}
 	}
 }
@@ -0,0 +1,27 @@
 //go:build espat
 package main
 import (
 	"machine"
 	"tinygo.org/x/drivers/espat"
 )
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	uart = machine.UART1
 	tx   = machine.PA22
 	rx   = machine.PA23
 	adaptor *espat.Device
 )
 func initAdaptor() *espat.Device {
 	uart.Configure(machine.UARTConfig{TX: tx, RX: rx})
 	adaptor = espat.New(uart)
 	adaptor.Configure()
 	return adaptor
 }
@@ -1,60 +1,52 @@
-// This example opens a TCP connection and sends some data, for the purpose of
+// This example opens a TCP connection and sends some data,
-// testing speed and connectivity.
+// for the purpose of testing speed and connectivity.
 //
 // You can open a server to accept connections from this program using:
 //
-// nc -lk 8080
+// nc -w 5 -lk 8080
 //go:build ninafw || wioterminal || challenger_rp2040 || pico
 package main
 import (
 	"bytes"
 	"fmt"
 	"log"
 	"machine"
 	"net"
 	"time"
-	"tinygo.org/x/drivers/netlink"
+	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/netlink/probe"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 	addr string = "10.0.0.100:8080"
 )
 // IP address of the server aka "hub". Replace with your own info.
 const serverIP = ""
 var buf = &bytes.Buffer{}
 func main() {
 	initAdaptor()
-	waitSerial()
+	connectToAP()
 	link, _ := probe.Probe()
 	err := link.NetConnect(&netlink.ConnectParams{
 		Ssid:       ssid,
 		Passphrase: pass,
 	})
 	if err != nil {
 		log.Fatal(err)
 	}
 	for {
 		sendBatch()
 		time.Sleep(500 * time.Millisecond)
 	}
 	println("Done.")
 }
 func sendBatch() {
 	// make TCP connection
 	ip := net.ParseIP(serverIP)
 	raddr := &net.TCPAddr{IP: ip, Port: 8080}
 	laddr := &net.TCPAddr{Port: 8080}
 	message("---------------\r\nDialing TCP connection")
-	conn, err := net.Dial("tcp", addr)
+	conn, err := net.DialTCP("tcp", laddr, raddr)
-	for ; err != nil; conn, err = net.Dial("tcp", addr) {
+	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
 		message(err.Error())
 		time.Sleep(5 * time.Second)
 	}
@@ -73,7 +65,7 @@ func sendBatch() {
 				"\r---------------------------- i == ", i, " ----------------------------")
 		if w, err = conn.Write(buf.Bytes()); err != nil {
 			println("error:", err.Error(), "\r")
-			break
+			continue
 		}
 		n += w
 	}
@@ -87,17 +79,34 @@ func sendBatch() {
 		println("error:", err.Error(), "\r")
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting TCP...")
 	conn.Close()
 }
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	println("Connecting to " + ssid)
 	err := adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 	if err != nil { // error connecting to AP
 		for {
 			println(err)
 			time.Sleep(1 * time.Second)
 		}
 	}
 	println("Connected.")
 	time.Sleep(2 * time.Second)
 	ip, err := adaptor.GetClientIP()
 	for ; err != nil; ip, err = adaptor.GetClientIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message(ip)
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -0,0 +1,76 @@
 //go:build rtl8720dn
 package main
 import (
 	"device/sam"
 	"machine"
 	"runtime/interrupt"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/rtl8720dn"
 )
 var (
 	adaptor *rtl8720dn.RTL8720DN
 	uart UARTx
 )
 func initAdaptor() *rtl8720dn.RTL8720DN {
 	adaptor, err := setupRTL8720DN()
 	if err != nil {
 		return nil
 	}
 	net.UseDriver(adaptor)
 	return adaptor
 }
 func handleInterrupt(interrupt.Interrupt) {
 	// should reset IRQ
 	uart.Receive(byte((uart.Bus.DATA.Get() & 0xFF)))
 	uart.Bus.INTFLAG.SetBits(sam.SERCOM_USART_INT_INTFLAG_RXC)
 }
 func setupRTL8720DN() (*rtl8720dn.RTL8720DN, error) {
 	machine.RTL8720D_CHIP_PU.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	machine.RTL8720D_CHIP_PU.Low()
 	time.Sleep(100 * time.Millisecond)
 	machine.RTL8720D_CHIP_PU.High()
 	time.Sleep(1000 * time.Millisecond)
 	uart = UARTx{
 		UART: &machine.UART{
 			Buffer: machine.NewRingBuffer(),
 			Bus:    sam.SERCOM0_USART_INT,
 			SERCOM: 0,
 		},
 	}
 	uart.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, handleInterrupt)
 	uart.Configure(machine.UARTConfig{TX: machine.PB24, RX: machine.PC24, BaudRate: 614400})
 	rtl := rtl8720dn.New(uart)
 	//rtl.Debug(debug)
 	_, err := rtl.Rpc_tcpip_adapter_init()
 	if err != nil {
 		return nil, err
 	}
 	return rtl, nil
 }
 type UARTx struct {
 	*machine.UART
 }
 func (u UARTx) Read(p []byte) (n int, err error) {
 	if u.Buffered() == 0 {
 		time.Sleep(1 * time.Millisecond)
 		return 0, nil
 	}
 	return u.UART.Read(p)
 }
@@ -0,0 +1,35 @@
 //go:build wifinina
 package main
 import (
 	"machine"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// default interface for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// ESP32/ESP8266 chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 func initAdaptor() *wifinina.Device {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	return adaptor
 }
@@ -0,0 +1,156 @@
 // This example connects to Access Point and prints some info
 package main
 import (
 	"machine"
 	"strconv"
 	"time"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 }
 func main() {
 	setup()
 	waitSerial()
 	connectToAP()
 	for {
 		println("----------------------------------------")
 		printSSID()
 		printRSSI()
 		printMac()
 		printIPs()
 		printTime()
 		time.Sleep(10 * time.Second)
 	}
 }
 func printSSID() {
 	print("SSID: ")
 	ssid, err := adaptor.GetCurrentSSID()
 	if err != nil {
 		println("Unknown (error: ", err.Error(), ")")
 		return
 	}
 	println(ssid)
 }
 func printRSSI() {
 	print("RSSI: ")
 	rssi, err := adaptor.GetCurrentRSSI()
 	if err != nil {
 		println("Unknown (error: ", err.Error(), ")")
 		return
 	}
 	println(strconv.Itoa(int(rssi)))
 }
 func printIPs() {
 	ip, subnet, gateway, err := adaptor.GetIP()
 	if err != nil {
 		println("IP: Unknown (error: ", err.Error(), ")")
 		return
 	}
 	println("IP: ", ip.String())
 	println("Subnet: ", subnet.String())
 	println("Gateway: ", gateway.String())
 }
 func printTime() {
 	print("Time: ")
 	t, err := adaptor.GetTime()
 	for {
 		if err != nil {
 			println("Unknown (error: ", err.Error(), ")")
 			return
 		}
 		if t != 0 {
 			break
 		}
 		time.Sleep(time.Second)
 		t, err = adaptor.GetTime()
 	}
 	println(time.Unix(int64(t), 0).String())
 }
 func printMac() {
 	print("MAC: ")
 	mac, err := adaptor.GetMACAddress()
 	if err != nil {
 		println("Unknown (", err.Error(), ")")
 	}
 	println(mac.String())
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,173 @@
 // This example opens a TCP connection using a device with WiFiNINA firmware
 // and sends a HTTP request to retrieve a webpage, based on the following
 // Arduino example:
 //
 // https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/WiFiWebClientRepeating/
 //
 // This example will not work with samd21 or other systems with less than 32KB
 // of RAM.  Use the following if you want to run wifinina on samd21, etc.
 //
 // examples/wifinina/webclient
 // examples/wifinina/tlsclient
 package main
 import (
 	"bufio"
 	"fmt"
 	"machine"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 // Can specify a URL starting with http or https
 const url = "http://tinygo.org/"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 var buf [0x400]byte
 var lastRequestTime time.Time
 var conn net.Conn
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 }
 func main() {
 	setup()
 	http.SetBuf(buf[:])
 	waitSerial()
 	connectToAP()
 	displayIP()
 	// You can send and receive cookies in the following way
 	// 	import "tinygo.org/x/drivers/net/http/cookiejar"
 	// 	jar, err := cookiejar.New(nil)
 	// 	if err != nil {
 	// 		return err
 	// 	}
 	// 	client := &http.Client{Jar: jar}
 	// 	http.DefaultClient = client
 	cnt := 0
 	for {
 		// Various examples are as follows
 		//
 		// -- Get
 		// 	resp, err := http.Get(url)
 		//
 		// -- Post
 		// 	body := `cnt=12`
 		// 	resp, err = http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(body))
 		//
 		// -- Post with JSON
 		// 	body := `{"msg": "hello"}`
 		// 	resp, err := http.Post(url, "application/json", strings.NewReader(body))
 		resp, err := http.Get(url)
 		if err != nil {
 			fmt.Printf("%s\r\n", err.Error())
 			continue
 		}
 		fmt.Printf("%s %s\r\n", resp.Proto, resp.Status)
 		for k, v := range resp.Header {
 			fmt.Printf("%s: %s\r\n", k, strings.Join(v, " "))
 		}
 		fmt.Printf("\r\n")
 		scanner := bufio.NewScanner(resp.Body)
 		for scanner.Scan() {
 			fmt.Printf("%s\r\n", scanner.Text())
 		}
 		resp.Body.Close()
 		cnt++
 		fmt.Printf("-------- %d --------\r\n", cnt)
 		time.Sleep(10 * time.Second)
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,153 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
 //
 // You must install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 package main
 import (
 	"fmt"
 	"machine"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/net/mqtt"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the MQTT broker to use. Replace with your own info.
 const server = "tcp://test.mosquitto.org:1883"
 //const server = "ssl://test.mosquitto.org:8883"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 	topic   = "tinygo"
 )
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 	rand.Seed(time.Now().UnixNano())
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	// Init esp8266/esp32
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	connectToAP()
 	displayIP()
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connectng to MQTT...")
 	cl := mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	for i := 0; ; i++ {
 		println("Publishing MQTT message...")
 		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
 		token := cl.Publish(topic, 0, false, data)
 		token.Wait()
 		if err := token.Error(); err != nil {
 			switch t := err.(type) {
 			case wifinina.Error:
 				println(t.Error(), "attempting to reconnect")
 				if token := cl.Connect(); token.Wait() && token.Error() != nil {
 					failMessage(token.Error().Error())
 				}
 			default:
 				println(err.Error())
 			}
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		println(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	println("IP address: " + ip.String())
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,165 @@
 // This is a sensor station that uses a ESP8266 or ESP32 running on the device UART1.
 // It creates an MQTT connection that publishes a message every second
 // to an MQTT broker.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> UART1 <--> ESP8266 <--> Internet <--> MQTT broker.
 //
 // You must also install the Paho MQTT package to build this program:
 //
 //	go get -u github.com/eclipse/paho.mqtt.golang
 package main
 import (
 	"fmt"
 	"machine"
 	"math/rand"
 	"time"
 	"tinygo.org/x/drivers/net/mqtt"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the MQTT broker to use. Replace with your own info.
 const server = "tcp://test.mosquitto.org:1883"
 //const server = "ssl://test.mosquitto.org:8883"
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 	cl      mqtt.Client
 	topicTx = "tinygo/tx"
 	topicRx = "tinygo/rx"
 )
 func subHandler(client mqtt.Client, msg mqtt.Message) {
 	fmt.Printf("[%s]  ", msg.Topic())
 	fmt.Printf("%s\r\n", msg.Payload())
 }
 func main() {
 	time.Sleep(3000 * time.Millisecond)
 	rand.Seed(time.Now().UnixNano())
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	// Init esp8266/esp32
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	connectToAP()
 	displayIP()
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(server).SetClientID("tinygo-client-" + randomString(10))
 	println("Connecting to MQTT broker at", server)
 	cl = mqtt.NewClient(opts)
 	if token := cl.Connect(); token.Wait() && token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	// subscribe
 	token := cl.Subscribe(topicRx, 0, subHandler)
 	token.Wait()
 	if token.Error() != nil {
 		failMessage(token.Error().Error())
 	}
 	go publishing()
 	select {}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting MQTT...")
 	cl.Disconnect(100)
 	println("Done.")
 }
 func publishing() {
 	for i := 0; ; i++ {
 		println("Publishing MQTT message...")
 		data := []byte(fmt.Sprintf(`{"e":[{"n":"hello %d","v":101}]}`, i))
 		token := cl.Publish(topicRx, 0, false, data)
 		token.Wait()
 		if token.Error() != nil {
 			println(token.Error().Error())
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		println(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	println("IP address: " + ip.String())
 }
 // Returns an int >= min, < max
 func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 // Generate a random string of A-Z chars with len = l
 func randomString(len int) string {
 	bytes := make([]byte, len)
 	for i := 0; i < len; i++ {
 		bytes[i] = byte(randomInt(65, 90))
 	}
 	return string(bytes)
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,191 @@
 // This is an example of using the wifinina driver to implement a NTP client.
 // It creates a UDP connection to request the current time and parse the
 // response from a NTP server.
 package main
 import (
 	"errors"
 	"fmt"
 	"machine"
 	"runtime"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 const ntpHost = "129.6.15.29"
 const NTP_PACKET_SIZE = 48
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 	b       = make([]byte, NTP_PACKET_SIZE)
 )
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 }
 func main() {
 	setup()
 	waitSerial()
 	connectToAP()
 	displayIP()
 	// now make UDP connection
 	ip := net.ParseIP(ntpHost)
 	raddr := &net.UDPAddr{IP: ip, Port: 123}
 	laddr := &net.UDPAddr{Port: 2390}
 	conn, err := net.DialUDP("udp", laddr, raddr)
 	if err != nil {
 		for {
 			time.Sleep(time.Second)
 			println(err)
 		}
 	}
 	for {
 		// send data
 		println("Requesting NTP time...")
 		t, err := getCurrentTime(conn)
 		if err != nil {
 			message("Error getting current time: %v", err)
 		} else {
 			message("NTP time: %v", t)
 		}
 		runtime.AdjustTimeOffset(-1 * int64(time.Since(t)))
 		for i := 0; i < 10; i++ {
 			message("Current time: %v", time.Now())
 			time.Sleep(1 * time.Second)
 		}
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func getCurrentTime(conn *net.UDPSerialConn) (time.Time, error) {
 	if err := sendNTPpacket(conn); err != nil {
 		return time.Time{}, err
 	}
 	clearBuffer()
 	for now := time.Now(); time.Since(now) < time.Second; {
 		time.Sleep(5 * time.Millisecond)
 		if n, err := conn.Read(b); err != nil {
 			return time.Time{}, fmt.Errorf("error reading UDP packet: %w", err)
 		} else if n == 0 {
 			continue // no packet received yet
 		} else if n != NTP_PACKET_SIZE {
 			return time.Time{}, fmt.Errorf("expected NTP packet size of %d: %d", NTP_PACKET_SIZE, n)
 		}
 		return parseNTPpacket(), nil
 	}
 	return time.Time{}, errors.New("no packet received after 1 second")
 }
 func sendNTPpacket(conn *net.UDPSerialConn) error {
 	clearBuffer()
 	b[0] = 0b11100011 // LI, Version, Mode
 	b[1] = 0          // Stratum, or type of clock
 	b[2] = 6          // Polling Interval
 	b[3] = 0xEC       // Peer Clock Precision
 	// 8 bytes of zero for Root Delay & Root Dispersion
 	b[12] = 49
 	b[13] = 0x4E
 	b[14] = 49
 	b[15] = 52
 	if _, err := conn.Write(b); err != nil {
 		return err
 	}
 	return nil
 }
 func parseNTPpacket() time.Time {
 	// the timestamp starts at byte 40 of the received packet and is four bytes,
 	// this is NTP time (seconds since Jan 1 1900):
 	t := uint32(b[40])<<24 | uint32(b[41])<<16 | uint32(b[42])<<8 | uint32(b[43])
 	const seventyYears = 2208988800
 	return time.Unix(int64(t-seventyYears), 0)
 }
 func clearBuffer() {
 	for i := range b {
 		b[i] = 0
 	}
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(format string, args ...interface{}) {
 	println(fmt.Sprintf(format, args...), "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,90 @@
 //go:build nano_rp2040
 // This examples shows how to control RGB LED connected to
 // NINA-W102 chip on Arduino Nano RP2040 Connect board
 // Built-in LED code added for API comparison
 package main
 import (
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/wifinina"
 )
 const (
 	LED = machine.LED
 	// Arduino Nano RP2040 Connect board RGB LED pins
 	// See https://docs.arduino.cc/static/3525d638b5c76a2d19588d6b41cd02a0/ABX00053-full-pinout.pdf
 	LED_R wifinina.Pin = 27
 	LED_G wifinina.Pin = 25
 	LED_B wifinina.Pin = 26
 )
 var (
 	// these are the default pins for the Arduino Nano-RP2040 Connect
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	device *wifinina.Device
 )
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	device = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	device.Configure()
 	time.Sleep(time.Second)
 	LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	LED_R.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
 	LED_G.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
 	LED_B.Configure(wifinina.PinConfig{Mode: wifinina.PinOutput})
 }
 func main() {
 	setup()
 	LED.Low()    // OFF
 	LED_R.High() // OFF
 	LED_G.High() // OFF
 	LED_B.High() // OFF
 	go func() {
 		for {
 			LED.Low()
 			time.Sleep(time.Second)
 			LED.High()
 			time.Sleep(time.Second)
 		}
 	}()
 	for {
 		LED_R.Low() // ON
 		time.Sleep(time.Second)
 		LED_R.High() // OFF
 		LED_G.Low()  // ON
 		time.Sleep(time.Second)
 		LED_G.High() // OFF
 		LED_B.Low()  // ON
 		time.Sleep(time.Second)
 		LED_B.High() // OFF
 	}
 }
@@ -0,0 +1,153 @@
 // This example opens a TCP connection using a device with WiFiNINA firmware
 // and sends some data, for the purpose of testing speed and connectivity.
 //
 // You can open a server to accept connections from this program using:
 //
 // nc -w 5 -lk 8080
 package main
 import (
 	"bytes"
 	"fmt"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 const serverIP = ""
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 var buf = &bytes.Buffer{}
 func main() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	connectToAP()
 	displayIP()
 	for {
 		sendBatch()
 		time.Sleep(500 * time.Millisecond)
 	}
 	println("Done.")
 }
 func sendBatch() {
 	// make TCP connection
 	ip := net.ParseIP(serverIP)
 	raddr := &net.TCPAddr{IP: ip, Port: 8080}
 	laddr := &net.TCPAddr{Port: 8080}
 	message("---------------\r\nDialing TCP connection")
 	conn, err := net.DialTCP("tcp", laddr, raddr)
 	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
 		message(err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	n := 0
 	w := 0
 	start := time.Now()
 	// send data
 	message("Sending data")
 	for i := 0; i < 1000; i++ {
 		buf.Reset()
 		fmt.Fprint(buf,
 			"\r---------------------------- i == ", i, " ----------------------------"+
 				"\r---------------------------- i == ", i, " ----------------------------")
 		if w, err = conn.Write(buf.Bytes()); err != nil {
 			println("error:", err.Error(), "\r")
 			continue
 		}
 		n += w
 	}
 	buf.Reset()
 	ms := time.Now().Sub(start).Milliseconds()
 	fmt.Fprint(buf, "\nWrote ", n, " bytes in ", ms, " ms\r\n")
 	message(buf.String())
 	if _, err := conn.Write(buf.Bytes()); err != nil {
 		println("error:", err.Error(), "\r")
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting TCP...")
 	conn.Close()
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,163 @@
 // This example opens a TCP connection using a device with WiFiNINA firmware
 // and sends a HTTPS request to retrieve a webpage
 //
 // You shall see "strict-transport-security" header in the response,
 // this confirms communication is indeed over HTTPS
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
 package main
 import (
 	"fmt"
 	"machine"
 	"strings"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/net/tls"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 const server = "tinygo.org"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 var buf [256]byte
 var lastRequestTime time.Time
 var conn net.Conn
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 }
 func main() {
 	setup()
 	waitSerial()
 	connectToAP()
 	displayIP()
 	for {
 		readConnection()
 		if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
 			makeHTTPSRequest()
 		}
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func readConnection() {
 	if conn != nil {
 		for n, err := conn.Read(buf[:]); n > 0; n, err = conn.Read(buf[:]) {
 			if err != nil {
 				println("Read error: " + err.Error())
 			} else {
 				print(string(buf[0:n]))
 			}
 		}
 	}
 }
 func makeHTTPSRequest() {
 	var err error
 	if conn != nil {
 		conn.Close()
 	}
 	message("\r\n---------------\r\nDialing TCP connection")
 	conn, err = tls.Dial("tcp", server, nil)
 	for ; err != nil; conn, err = tls.Dial("tcp", server, nil) {
 		message("Connection failed: " + err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	println("Connected!\r")
 	print("Sending HTTPS request...")
 	fmt.Fprintln(conn, "GET / HTTP/1.1")
 	fmt.Fprintln(conn, "Host:", strings.Split(server, ":")[0])
 	fmt.Fprintln(conn, "User-Agent: TinyGo")
 	fmt.Fprintln(conn, "Connection: close")
 	fmt.Fprintln(conn)
 	println("Sent!\r\n\r")
 	lastRequestTime = time.Now()
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,119 @@
 // This is a sensor station that uses a ESP32 running nina-fw over SPI.
 // It creates a UDP connection you can use to get info to/from your computer via the microcontroller.
 //
 // In other words:
 // Your computer <--> UART0 <--> MCU <--> SPI <--> ESP32
 package main
 import (
 	"machine"
 	"strconv"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the server aka "hub". Replace with your own info.
 const hubIP = ""
 var (
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 func main() {
 	// Init esp8266/esp32
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	machine.NINA_SPI.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	// these are the default pins for the Arduino Nano33 IoT.
 	// change these to connect to a different UART or pins for the ESP8266/ESP32
 	adaptor = wifinina.New(machine.NINA_SPI,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	// connect to access point
 	connectToAP()
 	displayIP()
 	// now make UDP connection
 	ip := net.ParseIP(hubIP)
 	raddr := &net.UDPAddr{IP: ip, Port: 2222}
 	laddr := &net.UDPAddr{Port: 2222}
 	println("Dialing UDP connection...")
 	conn, err := net.DialUDP("udp", laddr, raddr)
 	if err != nil {
 		failMessage(err.Error())
 	}
 	for {
 		// send data
 		println("Sending data...")
 		for i := 0; i < 25; i++ {
 			conn.Write([]byte("hello " + strconv.Itoa(i) + "\r\n"))
 		}
 		time.Sleep(1000 * time.Millisecond)
 	}
 	// Right now this code is never reached. Need a way to trigger it...
 	println("Disconnecting UDP...")
 	conn.Close()
 	println("Done.")
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,165 @@
 // This example opens a TCP connection using a device with WiFiNINA firmware
 // and sends a HTTP request to retrieve a webpage, based on the following
 // Arduino example:
 //
 // https://github.com/arduino-libraries/WiFiNINA/blob/master/examples/WiFiWebClientRepeating/
 package main
 import (
 	"fmt"
 	"machine"
 	"time"
 	"tinygo.org/x/drivers/net"
 	"tinygo.org/x/drivers/wifinina"
 )
 var (
 	// access point info
 	ssid string
 	pass string
 )
 // IP address of the "example.com" server. Replace with your own info.
 const server = "93.184.216.34"
 // these are the default pins for the Arduino Nano33 IoT.
 // change these to connect to a different UART or pins for the ESP8266/ESP32
 var (
 	// these are the default pins for the Arduino Nano33 IoT.
 	spi = machine.NINA_SPI
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 var buf [256]byte
 var lastRequestTime time.Time
 var conn net.Conn
 func setup() {
 	// Configure SPI for 8Mhz, Mode 0, MSB First
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 }
 func main() {
 	setup()
 	waitSerial()
 	connectToAP()
 	displayIP()
 	for {
 		readConnection()
 		if time.Now().Sub(lastRequestTime).Milliseconds() >= 10000 {
 			makeHTTPRequest()
 		}
 	}
 }
 // Wait for user to open serial console
 func waitSerial() {
 	for !machine.Serial.DTR() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func readConnection() {
 	if conn != nil {
 		for n, err := conn.Read(buf[:]); n > 0; n, err = conn.Read(buf[:]) {
 			if err != nil {
 				println("Read error: " + err.Error())
 			} else {
 				print(string(buf[0:n]))
 			}
 		}
 	}
 }
 func makeHTTPRequest() {
 	var err error
 	if conn != nil {
 		conn.Close()
 	}
 	// make TCP connection
 	ip := net.ParseIP(server)
 	raddr := &net.TCPAddr{IP: ip, Port: 80}
 	laddr := &net.TCPAddr{Port: 8080}
 	message("\r\n---------------\r\nDialing TCP connection")
 	conn, err = net.DialTCP("tcp", laddr, raddr)
 	for ; err != nil; conn, err = net.DialTCP("tcp", laddr, raddr) {
 		message("Connection failed: " + err.Error())
 		time.Sleep(5 * time.Second)
 	}
 	println("Connected!\r")
 	print("Sending HTTP request...")
 	fmt.Fprintln(conn, "GET / HTTP/1.1")
 	fmt.Fprintln(conn, "Host:", server)
 	fmt.Fprintln(conn, "User-Agent: TinyGo")
 	fmt.Fprintln(conn, "Connection: close")
 	fmt.Fprintln(conn)
 	println("Sent!\r\n\r")
 	lastRequestTime = time.Now()
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -0,0 +1,234 @@
 package main
 import (
 	"fmt"
 	"machine"
 	"strconv"
 	"time"
 	"tinygo.org/x/drivers/net/http"
 	"tinygo.org/x/drivers/wifinina"
 )
 // You can override the settings with the init() in another source code:
 //
 // func init() {
 //    ssid = "your-ssid"
 //    pass = "your-password"
 // }
 //
 // Or use -ldflags option on tinygo command to set at compile-time:
 //
 // tinygo flash ... -ldflags '-X "main.ssid=xxx" -X "main.pass=xxx"' ...
 //
 var (
 	ssid string
 	pass string
 )
 var (
 	// this is the ESP chip that has the WIFININA firmware flashed on it
 	adaptor *wifinina.Device
 )
 var led = machine.LED
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	err := run()
 	for err != nil {
 		fmt.Printf("error: %s\r\n", err.Error())
 		time.Sleep(5 * time.Second)
 	}
 }
 func run() error {
 	spi := machine.NINA_SPI
 	spi.Configure(machine.SPIConfig{
 		Frequency: 8 * 1e6,
 		SDO:       machine.NINA_SDO,
 		SDI:       machine.NINA_SDI,
 		SCK:       machine.NINA_SCK,
 	})
 	adaptor = wifinina.New(spi,
 		machine.NINA_CS,
 		machine.NINA_ACK,
 		machine.NINA_GPIO0,
 		machine.NINA_RESETN)
 	adaptor.Configure()
 	connectToAP()
 	displayIP()
 	http.UseDriver(adaptor)
 	http.HandleFunc("/", root)
 	http.HandleFunc("/hello", hello)
 	http.HandleFunc("/cnt", cnt)
 	http.HandleFunc("/6", sixlines)
 	http.HandleFunc("/off", LED_OFF)
 	http.HandleFunc("/on", LED_ON)
 	return http.ListenAndServe(":80", nil)
 }
 func root(w http.ResponseWriter, r *http.Request) {
 	access := 1
 	cookie, err := r.Cookie("access")
 	if err != nil {
 		if err == http.ErrNoCookie {
 			cookie = &http.Cookie{
 				Name:  "access",
 				Value: "1",
 			}
 		} else {
 			http.Error(w, fmt.Sprintf("%s", err.Error()), http.StatusBadRequest)
 			return
 		}
 	} else {
 		v, err := strconv.ParseInt(cookie.Value, 10, 0)
 		if err != nil {
 			http.Error(w, fmt.Sprintf("invalid cookie.Value : %s", cookie.Value), http.StatusBadRequest)
 			return
 		}
 		cookie.Value = fmt.Sprintf("%d", v+1)
 		access = int(v) + 1
 	}
 	http.SetCookie(w, cookie)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprintf(w, `
 <html>
 <head>
    <title>TinyGo HTTP Server</title>
    <script language="javascript" type="text/javascript">
        var counter = 0
        function ledOn() { fetch("/on"); }
        function ledOff() { fetch("/off"); }
        function fetchCnt() { fetch("/cnt").then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
        function incrCnt() { counter = counter + 1; fetch("/cnt?cnt=" + counter, { method: 'POST' }).then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); }
        function setCnt() { fetch("/cnt", {
            method: "POST",
            body: "cnt=" + document.getElementsByName("cnt")[0].value,
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        }).then(response => response.json()).then(json => { counter = json.cnt; cnt.innerHTML = counter; }); return false; }
        function onLoad() { fetchCnt(); }
    </script>
 </head>
 <body onLoad="onLoad()">
    <h5>TinyGo HTTP Server</h5>
    <p>
        access: %d
    </p>
    <a href="/hello">/hello</a><br>
    <a href="/6">/6</a><br>
    <p>
        LED<br>
        <a href="javascript:ledOn();">/on</a><br>
        <a href="javascript:ledOff();">/off</a><br>
    </p>
    <p>
        <a href="/cnt">/cnt</a><br>
        cnt: <span id="cnt"></span><br>
        <a href="javascript:incrCnt()">incrCnt()</a><br>
        <form id="form1" style="display: inline" onSubmit="return setCnt()">
        <input type="text" name="cnt">
        <input type="button" value="set cnt", onClick="setCnt()">
        </form>
    </p>
 </body>
 </html>
    `, access)
 }
 func sixlines(w http.ResponseWriter, r *http.Request) {
 	// https://fukuno.jig.jp/3267
 	fmt.Fprint(w, `<body onload='onkeydown=e=>K=parseInt(e.key[5]||6,28)/3-8;Z=X=[B=A=12];Y=_=>`+
 		`{for(C=[q=c=i=4];f=i--*K;c-=!Z[h+(K+6?p+K:C[i]=p*A-(p/9|0)*145)])p=B[i];for(c?0:K+6?h+=K:B=C;`+
 		`i=K=q--;f+=Z[A+p])X[p=h+B[q]]=1;h+=A;if(f|B)for(Z=X,X=[l=228],B=[[-7,-20,6,h=17,-9,3,3][t=++t%7]-4,0,1,t-6?-A:2];l--;)`+
 		`for(l%A?l-=l%A*!Z[l]:(P++,c=l+=A);--c>A;)Z[c]=Z[c-A];for(S="";i<240;S+=X[i]|(X[i]=Z[i]|=++i%A<2|i>228)?i%A?"■":"■<br>":"　");`+
 		`D.innerHTML=S+P;setTimeout(Y,i-P)};Y(h=K=t=P=0)'id=D>`)
 }
 func LED_ON(w http.ResponseWriter, r *http.Request) {
 	led.High()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.High()")
 }
 func LED_OFF(w http.ResponseWriter, r *http.Request) {
 	led.Low()
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "led.Low()")
 }
 func hello(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set(`Content-Type`, `text/plain; charset=UTF-8`)
 	fmt.Fprintf(w, "hello")
 }
 var counter int
 func cnt(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
 	if r.Method == "POST" {
 		c := r.Form.Get("cnt")
 		if c != "" {
 			i64, _ := strconv.ParseInt(c, 0, 0)
 			counter = int(i64)
 		}
 	}
 	w.Header().Set(`Content-Type`, `application/json`)
 	fmt.Fprintf(w, `{"cnt": %d}`, counter)
 }
 const retriesBeforeFailure = 3
 // connect to access point
 func connectToAP() {
 	time.Sleep(2 * time.Second)
 	var err error
 	for i := 0; i < retriesBeforeFailure; i++ {
 		println("Connecting to " + ssid)
 		err = adaptor.ConnectToAccessPoint(ssid, pass, 10*time.Second)
 		if err == nil {
 			println("Connected.")
 			return
 		}
 	}
 	// error connecting to AP
 	failMessage(err.Error())
 }
 func displayIP() {
 	ip, _, _, err := adaptor.GetIP()
 	for ; err != nil; ip, _, _, err = adaptor.GetIP() {
 		message(err.Error())
 		time.Sleep(1 * time.Second)
 	}
 	message("IP address: " + ip.String())
 }
 func message(msg string) {
 	println(msg, "\r")
 }
 func failMessage(msg string) {
 	for {
 		println(msg)
 		time.Sleep(1 * time.Second)
 	}
 }
@@ -4,8 +4,7 @@ package main
 import "machine"
-func init() {
+// Replace neo and led in the code below to match the pin
-	// Replace neo in the code below to match the pin
+// that you are using if different.
-	// that you are using if different.
+var neo = machine.D2
-	neo = machine.D2
+var led = machine.LED
 }
@@ -4,9 +4,8 @@ package main
 import "machine"
-func init() {
+// This is the pin assignment for the Digispark only.
-	// This is the pin assignment for the Digispark only.
+// Replace neo and led in the code below to match the pin
-	// Replace neo and led in the code below to match the pin
+// that you are using if different.
-	// that you are using if different.
+var neo machine.Pin = 0
-	neo = machine.Pin(0)
+var led = machine.LED
 }
@@ -12,15 +12,14 @@ import (
 	"tinygo.org/x/drivers/ws2812"
 )
-var (
+var leds [10]color.RGBA
 	neo  machine.Pin
 	leds [10]color.RGBA
 )
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	neo.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	ws := ws2812.NewWS2812(neo)
+	ws := ws2812.New(neo)
 	rg := false
 	for {
@@ -36,6 +35,7 @@ func main() {
 		}
 		ws.WriteColors(leds[:])
 		led.Set(rg)
 		time.Sleep(100 * time.Millisecond)
 	}
 }
@@ -1,11 +1,10 @@
-//go:build !digispark && !arduino
+//go:build !digispark && !arduino && !qtpy && !m5stamp_c3 && !thingplus_rp2040
 package main
 import "machine"
-func init() {
+// Replace neo and led in the code below to match the pin
-	// Replace neo in the code below to match the pin
+// that you are using if different.
-	// that you are using if different.
+var neo machine.Pin = machine.WS2812
-	neo = machine.WS2812
+var led = machine.LED
 }
@@ -0,0 +1,10 @@
 //go:build qtpy || m5stamp_c3
 package main
 import "machine"
 // Replace neo and led in the code below to match the pin
 // that you are using if different.
 var neo machine.Pin = machine.WS2812
 var led = machine.NoPin
@@ -0,0 +1,12 @@
 //go:build thingplus_rp2040
 package main
 import "machine"
 // This is the pin assignment for the internal neopixel of the
 // Sparkfun thingplus rp2040.
 // Replace neo and led in the code below to match the pin
 // that you are using if different.
 var neo machine.Pin = machine.GPIO8
 var led = machine.LED
@@ -80,8 +80,7 @@ func (d *Device) Read() []byte {
 func (d *Device) ReadTouchPoint() touch.Point {
 	d.Read()
 	z := 0xFFFFF
-	switch d.buf[0] {
+	if d.buf[0] == 0 {
 	case 0, 255:
 		z = 0
 	}
@@ -1,22 +1,12 @@
 module tinygo.org/x/drivers
-go 1.18
+go 1.15
 replace tinygo.org/x/drivers/mcp9808 => /home/kasterby/Documents/drivers/mcp9808
 require (
 	github.com/eclipse/paho.mqtt.golang v1.2.0
 	github.com/frankban/quicktest v1.10.2
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/soypat/natiu-mqtt v0.5.1
 	golang.org/x/net v0.7.0
 	tinygo.org/x/tinyfont v0.3.0
 	tinygo.org/x/tinyterm v0.1.0
-)
+)
 require (
 	github.com/google/go-cmp v0.5.2 // indirect
 	github.com/kr/pretty v0.2.1 // indirect
 	github.com/kr/text v0.1.0 // indirect
 	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 // indirect
 )
@@ -7,22 +7,56 @@ github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
 github.com/hajimehoshi/go-jisx0208 v1.0.0/go.mod h1:yYxEStHL7lt9uL+AbdWgW9gBumwieDoZCiB1f/0X0as=
 github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/soypat/natiu-mqtt v0.5.1 h1:rwaDmlvjzD2+3MCOjMZc4QEkDkNwDzbct2TJbpz+TPc=
+github.com/sago35/go-bdf v0.0.0-20200313142241-6c17821c91c4/go.mod h1:rOebXGuMLsXhZAC6mF/TjxONsm45498ZyzVhel++6KM=
 github.com/soypat/natiu-mqtt v0.5.1/go.mod h1:xEta+cwop9izVCW7xOx2W+ct9PRMqr0gNVkvBPnQTc4=
 github.com/valyala/fastjson v1.6.3/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 tinygo.org/x/drivers v0.14.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.15.1/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.16.0/go.mod h1:uT2svMq3EpBZpKkGO+NQHjxjGf1f42ra4OnMMwQL2aI=
 tinygo.org/x/drivers v0.19.0/go.mod h1:uJD/l1qWzxzLx+vcxaW0eY464N5RAgFi1zTVzASFdqI=
 tinygo.org/x/tinyfont v0.2.1/go.mod h1:eLqnYSrFRjt5STxWaMeOWJTzrKhXqpWw7nU3bPfKOAM=
 tinygo.org/x/tinyfont v0.3.0 h1:HIRLQoI3oc+2CMhPcfv+Ig88EcTImE/5npjqOnMD4lM=
 tinygo.org/x/tinyfont v0.3.0/go.mod h1:+TV5q0KpwSGRWnN+ITijsIhrWYJkoUCp9MYELjKpAXk=
 tinygo.org/x/tinyfs v0.1.0/go.mod h1:ysc8Y92iHfhTXeyEM9+c7zviUQ4fN9UCFgSOFfMWv20=
 tinygo.org/x/tinyterm v0.1.0 h1:80i+j+KWoxCFa/Xfp6pWbh79x+8zUdMXC1vaKj2QhkY=
-tinygo.org/x/tinyterm v0.1.0/go.mod h1:/DDhNnGwNF2/tNgHywvyZuCGnbH3ov49Z/6e8LPLRR4=
+tinygo.org/x/tinyterm v0.1.0/go.mod h1:/DDhNnGwNF2/tNgHywvyZuCGnbH3ov49Z/6e8LPLRR4=
@@ -7,7 +7,6 @@ import (
 	"time"
 	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/pixel"
 )
 type Config struct {
@@ -32,9 +31,6 @@ type Device struct {
 	rd  machine.Pin
 }
 // Image buffer type used in the ili9341.
 type Image = pixel.Image[pixel.RGB565BE]
 var cmdBuf [6]byte
 var initCmd = []byte{
@@ -177,8 +173,6 @@ func (d *Device) EnableTEOutput(on bool) {
 }
 // DrawRGBBitmap copies an RGB bitmap to the internal buffer at given coordinates
 //
 // Deprecated: use DrawBitmap instead.
 func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
 	k, i := d.Size()
 	if x < 0 || y < 0 || w <= 0 || h <= 0 ||
@@ -193,8 +187,6 @@ func (d *Device) DrawRGBBitmap(x, y int16, data []uint16, w, h int16) error {
 }
 // DrawRGBBitmap8 copies an RGB bitmap to the internal buffer at given coordinates
 //
 // Deprecated: use DrawBitmap instead.
 func (d *Device) DrawRGBBitmap8(x, y int16, data []uint8, w, h int16) error {
 	k, i := d.Size()
 	if x < 0 || y < 0 || w <= 0 || h <= 0 ||
@@ -208,13 +200,6 @@ func (d *Device) DrawRGBBitmap8(x, y int16, data []uint8, w, h int16) error {
 	return nil
 }
 // DrawBitmap copies the bitmap to the internal buffer on the screen at the
 // given coordinates. It returns once the image data has been sent completely.
 func (d *Device) DrawBitmap(x, y int16, bitmap Image) error {
 	width, height := bitmap.Size()
 	return d.DrawRGBBitmap8(x, y, bitmap.RawBuffer(), int16(width), int16(height))
 }
 // FillRectangle fills a rectangle at given coordinates with a color
 func (d *Device) FillRectangle(x, y, width, height int16, c color.RGBA) error {
 	k, i := d.Size()
@@ -81,8 +81,6 @@ const (
 	MHz_868_1 = 868100000
 	MHz_868_5 = 868500000
 	MHz_902_3 = 902300000
 	Mhz_903_0 = 903000000
 	MHZ_915_0 = 915000000
 	MHz_916_8 = 916800000
 	MHz_923_3 = 923300000
 )
@@ -30,11 +30,11 @@ const (
 var (
 	ActiveRadio    lora.Radio
 	Retries        = 15
-	regionSettings region.Settings
+	regionSettings region.RegionSettings
 )
 // UseRegionSettings sets current Lorawan Regional parameters
-func UseRegionSettings(rs region.Settings) {
+func UseRegionSettings(rs region.RegionSettings) {
 	regionSettings = rs
 }
@@ -52,13 +52,13 @@ func SetPublicNetwork(enabled bool) {
 }
 // ApplyChannelConfig sets current Lora modulation according to current regional settings
-func applyChannelConfig(ch region.Channel) {
+func applyChannelConfig(ch *region.Channel) {
-	ActiveRadio.SetFrequency(ch.Frequency())
+	ActiveRadio.SetFrequency(ch.Frequency)
-	ActiveRadio.SetBandwidth(ch.Bandwidth())
+	ActiveRadio.SetBandwidth(ch.Bandwidth)
-	ActiveRadio.SetCodingRate(ch.CodingRate())
+	ActiveRadio.SetCodingRate(ch.CodingRate)
-	ActiveRadio.SetSpreadingFactor(ch.SpreadingFactor())
+	ActiveRadio.SetSpreadingFactor(ch.SpreadingFactor)
-	ActiveRadio.SetPreambleLength(ch.PreambleLength())
+	ActiveRadio.SetPreambleLength(ch.PreambleLength)
-	ActiveRadio.SetTxPower(ch.TxPowerDBm())
+	ActiveRadio.SetTxPower(ch.TxPowerDBm)
 	// Lorawan defaults to explicit headers
 	ActiveRadio.SetHeaderType(lora.HeaderExplicit)
 	ActiveRadio.SetCrc(true)
@@ -84,30 +84,24 @@ func Join(otaa *Otaa, session *Session) error {
 		return err
 	}
-	for {
+	// Prepare radio for Join Tx
-		joinRequestChannel := regionSettings.JoinRequestChannel()
+	applyChannelConfig(regionSettings.JoinRequestChannel())
-		joinAcceptChannel := regionSettings.JoinAcceptChannel()
+	ActiveRadio.SetIqMode(lora.IQStandard)
 	ActiveRadio.Tx(payload, LORA_TX_TIMEOUT)
 	if err != nil {
 		return err
 	}
-		// Prepare radio for Join Tx
+	// Wait for JoinAccept
-		applyChannelConfig(joinRequestChannel)
+	applyChannelConfig(regionSettings.JoinAcceptChannel())
-		ActiveRadio.SetIqMode(lora.IQStandard)
+	ActiveRadio.SetIqMode(lora.IQInverted)
-		ActiveRadio.Tx(payload, LORA_TX_TIMEOUT)
+	resp, err = ActiveRadio.Rx(LORA_RX_TIMEOUT)
-		if err != nil {
+	if err != nil {
-			return err
+		return err
-		}
+	}
-		// Wait for JoinAccept
+	if resp == nil {
-		if joinAcceptChannel.Frequency() != 0 {
+		return ErrNoJoinAcceptReceived
 			applyChannelConfig(joinAcceptChannel)
 		}
 		ActiveRadio.SetIqMode(lora.IQInverted)
 		resp, err = ActiveRadio.Rx(LORA_RX_TIMEOUT)
 		if err == nil && resp != nil {
 			break
 		}
 		if !joinAcceptChannel.Next() {
 			return ErrNoJoinAcceptReceived
 		}
 	}
 	err = otaa.DecodeJoinAccept(resp, session)
@@ -7,41 +7,43 @@ const (
 	AU915_DEFAULT_TX_POWER_DBM = 20
 )
-type ChannelAU struct {
+type RegionSettingsAU915 struct {
-	channel
+	joinRequestChannel *Channel
 	joinAcceptChannel  *Channel
 	uplinkChannel      *Channel
 }
-func (c *ChannelAU) Next() bool {
+func AU915() *RegionSettingsAU915 {
-	return false
+	return &RegionSettingsAU915{
-}
+		joinRequestChannel: &Channel{lora.MHz_916_8,
 type SettingsAU915 struct {
 	settings
 }
 func AU915() *SettingsAU915 {
 	return &SettingsAU915{settings: settings{
 		joinRequestChannel: &ChannelAU{channel: channel{lora.MHz_916_8,
 			lora.Bandwidth_125_0,
 			lora.SpreadingFactor9,
 			lora.CodingRate4_5,
 			AU915_DEFAULT_PREAMBLE_LEN,
-			AU915_DEFAULT_TX_POWER_DBM}},
+			AU915_DEFAULT_TX_POWER_DBM},
-		joinAcceptChannel: &ChannelAU{channel: channel{lora.MHz_923_3,
+		joinAcceptChannel: &Channel{lora.MHz_923_3,
 			lora.Bandwidth_500_0,
 			lora.SpreadingFactor9,
 			lora.CodingRate4_5,
 			AU915_DEFAULT_PREAMBLE_LEN,
-			AU915_DEFAULT_TX_POWER_DBM}},
+			AU915_DEFAULT_TX_POWER_DBM},
-		uplinkChannel: &ChannelAU{channel: channel{lora.MHz_916_8,
+		uplinkChannel: &Channel{lora.MHz_916_8,
 			lora.Bandwidth_125_0,
 			lora.SpreadingFactor9,
 			lora.CodingRate4_5,
 			AU915_DEFAULT_PREAMBLE_LEN,
-			AU915_DEFAULT_TX_POWER_DBM}},
+			AU915_DEFAULT_TX_POWER_DBM},
-	}}
+	}
 }
-func Next(c *ChannelAU) bool {
+func (r *RegionSettingsAU915) JoinRequestChannel() *Channel {
-	return false
+	return r.joinRequestChannel
 }
 func (r *RegionSettingsAU915) JoinAcceptChannel() *Channel {
 	return r.joinAcceptChannel
 }
 func (r *RegionSettingsAU915) UplinkChannel() *Channel {
 	return r.uplinkChannel
 }
@@ -1,42 +0,0 @@
 package region
 type Channel interface {
 	Next() bool
 	Frequency() uint32
 	Bandwidth() uint8
 	SpreadingFactor() uint8
 	CodingRate() uint8
 	PreambleLength() uint16
 	TxPowerDBm() int8
 	SetFrequency(v uint32)
 	SetBandwidth(v uint8)
 	SetSpreadingFactor(v uint8)
 	SetCodingRate(v uint8)
 	SetPreambleLength(v uint16)
 	SetTxPowerDBm(v int8)
 }
 type channel struct {
 	frequency       uint32
 	bandwidth       uint8
 	spreadingFactor uint8
 	codingRate      uint8
 	preambleLength  uint16
 	txPowerDBm      int8
 }
 // Getter functions
 func (c *channel) Frequency() uint32      { return c.frequency }
 func (c *channel) Bandwidth() uint8       { return c.bandwidth }
 func (c *channel) SpreadingFactor() uint8 { return c.spreadingFactor }
 func (c *channel) CodingRate() uint8      { return c.codingRate }
 func (c *channel) PreambleLength() uint16 { return c.preambleLength }
 func (c *channel) TxPowerDBm() int8       { return c.txPowerDBm }
 // Set functions
 func (c *channel) SetFrequency(v uint32)      { c.frequency = v }
 func (c *channel) SetBandwidth(v uint8)       { c.bandwidth = v }
 func (c *channel) SetSpreadingFactor(v uint8) { c.spreadingFactor = v }
 func (c *channel) SetCodingRate(v uint8)      { c.codingRate = v }
 func (c *channel) SetPreambleLength(v uint16) { c.preambleLength = v }
 func (c *channel) SetTxPowerDBm(v int8)       { c.txPowerDBm = v }
--- a/Show More
+++ b/Show More