Hezhou Air105 Entwicklungsboard

Das Air105-Entwicklungsboard wurde auf der Grundlage der Air105-MCU (von Shanghai Hezhou Communication Technology Co., Ltd.) im Januar 2022 entwickelt, das in etwa dieselben Ausmaße wie ein Arduino Nano RP2040 Connect besitzt und laut Hersteller UART, GPIO, SPI, I2C, PWM, ADC und andere Schnittstellen unterstützen soll, die je nach Bedarf ausgewählt werden können.

Hardware/Aufbau

Es gibt einen zusätzlichen 21-Pin FPC-Anschluss für eine 0,3MP-Kamera mit GC032A-Sensor, die im Lieferumfang des Boards meistens schon enthalten ist. (Produkt-ID: WSM-032A-RD63F-C83E)

Interne LEDs

Das Air105-Board besitzt drei LEDs onboard.

Zentrale Spezifikationen des MCU Air105

Weitere Features laut Hersteller

• ARM SecurCore™ SC300™ core
  • 32-bit RISC Core (ARMv7-M)
  • MPU memory protection unit
  • Up to 204MHz main frequency (1, 2 frequency adjustable)
  • FPU unit
  • 1 controlled JTAG-DP/SW-DP debug port
• 640kB SRAM
• 1 QSPI controller, support XIP
• System control module (controls all peripheral module clocks and system-related configuration)
• Security encryption algorithm acceleration engine
  • Symmetric Algorithms: DES, TDES, AES-128/192/256
  • Asymmetric Algorithms: RSA-1024/2048, ECC
  • HASH verification algorithm: SHA-1/224/256/384/512
• 2-way SmartCard interface (supports EMV Level-1 protocol specification, ISO7816-3 standard), of which SCI0 integrates 7816 level conversion function, and can be configured to output 3V and 1.8V
• 4-way UART interface (all support 4-wire)
• 3-way SPI interface (including SPI0 master-slave can be configured, the other 2-way only support Master) * 1-way high-speed SPI Master interface SPI5
• 1 channel IIC interface
• 1-way KBD (4x5 matrix keyboard)
• 8 32-bit TIMER (with PWM function, support single-cycle output)
• 1 channel LCDI interface, support 8080, 6800 bus protocol
• 1 true random number generator
• 1 DMA controller (support 8-channel DMA transfer)
• 1 CRC module (support 16Bit/32Bit, various common polynomial calculations)
• Supports up to 87 GPIOs
• Supports up to 8 static tampers or 4 sets of dynamic tampers (4 outputs, 4 inputs), dynamic/static configurable
• 1 set of internal Sensor (support high and low voltage, high and low temperature, Mesh, clock and voltage glitch detection)
• 1 block key storage area (support hardware quick erase)
• 1 USB (OTG-FS)
  • Support USB2.0 and OTG1.0a
  • Built-in USB PHY module
  • Dedicated DMA channel and dedicated interrupt vector for faster data communication
• Integrated internal watchdog
• 1 10bit DAC interface
• One 7-channel 12bit ADC, up to 857KHz sampling rate (0 channel fixed acquisition CHARGE_VBAT voltage, other channels acquisition voltage range 0~1.8V or 0~3.6V can be matched)
• Support magnetic stripe decoding function, support ISO/ABA, AAMVA, IBM and JIS II and other standard cards
• 1 DCMI interface
• The chip integrates an LDO that can output 150mA drive capability
• The chip integrates a USB charging management module, supporting a maximum charging current of 200mA
• Chip integrated switch function
• Support 27.12M output

Anschlüsse

Hinweis: Alle GPIOs werden standardmäßig nach dem RESET des Boards auf einem internen Pull-Up-Widerstand mit 51kΩ gezogen.

Farb-Legende

Einrichtung und Programmierung

Das Board läuft mit dem LuatOS-SoC, einem real-time operating system (RTOS) mit einer Lua-Engine für IoT-Geräte, die recht niedrige Speicheranforderungen stellt (16kB RAM, 128kB Flash). Damit Programme/Lua-Scripte auf dem Board laufen können, muss zunächst das LuatOS über die serielle Schnittstelle (USB) geflasht werden:

Laden der Luatools

Zunächst wird die neueste Version von Luatools benötigt, die ca. 55MB Plattenplatz benötigt. Es wird vom Hersteller empfohlen, die Datei (hier: "Luatools_v2.exe") in einen separaten Ordner (hier: "./luatools") zu legen, bevor sie ausgeführt wird. Nun wird die Datei ausgeführt und es kommt gleich nach dem Start ein Hinweis auf Updates. Ich habe diese durchgeführt (kann einige Zeit dauern).

Nach dem Update sollte zunächste die Baudrate für die serielle Schnittstelle (zh: 通用串口波特率) auf 1500000 baud gesetzt werden (Air101/103 benutzen 921600 baud).

Firmware flashen

Nun wird das Air105-Board per USB-C an den PC (Windows 10 wird empfohlen) angeschlossen. Nach kurzer Zeit sollte im Dropdown der Luatools der COM-Port des Boards erscheinen. Dann sollte die Option 通用串口打印 ausgewählt und der COM-Port selektiert werden:

Nun lädt man sich die neueste Version der Firmware von offiziellen LuatOS-Repository herunter:
https://gitee.com/openLuat/LuatOS/releases (z.B. core_V0010.zip mit ca. 7MB). Hinweis: Bei dem vorherigen Update der Luatool sollte die neueste firmware ebenfalls mitgeladen werden, somit könnte man diesen Schritt auch einsparen.

Nun sucht man entweder im entpackten Paket der neueste Firmware oder im Ordner der Luatools nach einer Datei mit .soc-Endung. (hier: "LuatOS-SoC_V0010_AIR105" im Unterordner "resource\105_lua_lod\core_V0010")
In Luatools klickt man dann den Button "Download firmware" (zh: 下载固件).

Nun wählt man die vorher gefundene .soc-Datei aus und klickt auf download (zh: 下载). Nun wird die Firmware auf das Board geladen (~30s).

(siehe auch die offizielle Anleitung in chinesisch: https://wiki.luatos.com/boardGuide/flash.html)

Programme/Scripte laden

Zur Demostration wird das folgende einfache HelloWorld-Script in Lua benutzt, welches in der Datei "main.lua" gespeichert wird.

-- LuaTools needs two pieces of information: PROJECT and VERSION
PROJECT = "helloworld"
VERSION = "1.0.0"

-- Require necessary library files (written in Lua).
-- Internal libraries not needed to require.
sys = require("sys")

log.info("main", "Hello, World!")

print(_VERSION)

sys.timerLoopStart(function()
	print("Hi, LuatOS")
end, 3000)


-- always ends with this:
sys.run()
-- Do not add any statement after sys.run()!

Nun öffnet man den Dialog "Manage & Debug" (zh: 项目管理测试):

In der linken unteren Ecke des Dialog klick man auf "Create project" (zh: 创建项目) und gibt einen Projektnamen (hier "helloworld") ein. In der Liste auf der linken Seite sollte dieses Projekt nun erscheinen.
Nun wählt man als "Core-File" wieder die .soc-Datei aus und fügt das Lua-Script (main.lua) über den ersten Button hinzu:

Nach dem Klicken auf den Button "Download only script" wird das Lua-Script auf das Board geladen und nach dem Schließen des Dialoges sollte in der seriellen Konsole folgende Ausgabe erscheinen:

Demos

Interne LEDs ansteuern

Die drei internen LEDs in drei verschiedenen Farben sind an den Pins PD14, PD15 und PC3 erreichbar.
Basierend auf dem Demo-Script in "resource\105_lua_lod\core_V0010\demo\gpio\gpio" ist folgendes Blink-Script entstanden:

PROJECT = "rgbleds"
VERSION = "1.0.0"

_G.sys = require("sys")

-- enable watchdog to prevent programm from freezing
if wdt then
	-- Initialize watchdog set to 15s
	wdt.init(15000)
	-- Feed the watchdog every 10s
	sys.timerLoopStart(wdt.feed, 10000)
end

-- Assign GPIO pins for internal LEDs of different boards
function pinx()
	local rtos_bsp = rtos.bsp()
	rtos_bsp = rtos_bsp:lower()
	if rtos_bsp == "air101" then
		return pin.PB08, pin.PB09, pin.PB10
	elseif rtos_bsp == "air103" then
		return pin.PB26, pin.PB25, pin.PB24
	elseif rtos_bsp == "air105" then
		return pin.PD14, pin.PD15, pin.PC3
	else
		log.info("main", "Cannot define internal LED pins for unknown board.")
		return 0, 0, 0
	end
end

local P1,P2,P3 = pinx()

-- see API: https://wiki.luatos.com/api/gpio.html
local LEDA = gpio.setup(P1, 0, gpio.PULLUP)
local LEDB = gpio.setup(P2, 0, gpio.PULLUP)
local LEDC = gpio.setup(P3, 0, gpio.PULLUP)

sys.taskInit(function()
	local count = 0
	while 1 do
		sys.wait(100)
		LEDA(count % 3 == 0 and 1 or 0)
		LEDB(count % 3 == 1 and 1 or 0)
		LEDC(count % 3 == 2 and 1 or 0)
		count = count + 1
	end
end)

sys.run()

Nach den Hochladen des Script sollte folgendes Ergebnis sichtbar sein:

LED-Blink

Verwendete Bauteile

• LED (hier: 5mm grün)
• 470Ω Widerstand
• 1000µF Elektrolytkondensator (optional: zur Spannungsstabilisierung)
• 18650 Li-Ionen-Akku (optional)
• 18650 Batterie-Board (optional)
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

Als zweites Demo-Script wird der klassische Blink-Sketch programmiert, wie man ihn aus der Arduino-Umgebung kennt. Hier werden zunächst die drei internen LEDs deaktiviert und dann eine externe 5mm-LED am Pin PD13 angeschlossen.

PROJECT = "blink"
VERSION = "1.0.0"

_G.sys = require("sys")

-- turn off the internal LEDs
gpio.setup(pin.PD14, 0)
gpio.setup(pin.PD15, 0)
gpio.setup(pin.PC3, 0)

local PIN_LED = pin.PD13
gpio.setup(PIN_LED, 0)

sys.taskInit(function()
	local i = 0
	while 1 do
		sys.wait(500)

		if i % 2 == 0 then
			gpio.set(PIN_LED, gpio.LOW)
		else
			gpio.set(PIN_LED, gpio.HIGH)
		end

		i = i + 1
	end
end)

sys.run()

Weitere Demos folgen...