The SwiftIO board
MadMachine‘s SwiftIO board is an Arduino-like system, however it will possibly run Swift code natively on the {hardware}. Swift is a superb programming language for schooling functions, it’s a trendy language with a JavaScript-like syntax that’s simple to study and perceive. Swift is secure and environment friendly, this mix makes it an ideal candidate for embedded techniques. The SwiftIO board allows us common Swift / iOS builders to construct IoT initiatives utilizing our favourite programming language.
The board itself has a small footprint, it is nearly 1,57″ x 2,36″ (4cm x 6cm) huge.
It is fairly a strong microcontroller. It’s undoubtedly essentially the most inexpensive Swift language studying machine. It may be superb for STEM schooling functions for college students who wish to see how you can construct digital circuits and get some primary Swift programming expertise on the identical time.
The Maker Equipment field comprises each a 7 phase and an LCD show, a servo and a DC motor with drivers, a humiture (temperature & humidity) sensor, a buzzer module a potentiometer and a lightweight sensor and plenty of extra different issues (breadboard, resistors, LEDs, buttons and cables, and so forth.) that you should utilize to construct the starter initiatives. You should have just about all the things within the field that you simply want as a newcomer to get began and have some enjoyable time utilizing SwiftIO. 📦
Sadly you will not discover a working GPS, WiFi or Bluetooth module for the SwiftIO board but, however hopefully these sort of equipment are just some months away. There’s a new protect and a model new display module within the works. Oh by the way in which a protect is one thing that you would be able to plug into your board and join exterior equipment utilizing “particular” colourful cables. 🌈
Shields are boards that may be plugged on prime of the Arduino PCB extending its capabilities. The totally different shields comply with the identical philosophy as the unique toolkit: they’re simple to mount, and low-cost to supply. – ArduinoShields
The board initially went on sale in July, 2020 and many individuals introduced it from all world wide. New plug-ins, extensions and modules are nonetheless being developed by the makers, however it is very important emphasize that the SwiftIO board {hardware} is in a secure state. 💪
Technical specs:
- i.MX RT1052 Crossover Processor with Arm® Cortex®-M7 core @600MHz
- Micro SD card slot, supporting commonplace and excessive capability SD playing cards
- Micro USB connector for energy
- On-board USB to UART for serial communication
- 46 GPIO on left and proper edges
- On-board GRB LED
- 12x 12-bit analog to digital (ADC) converters
- 4 UART, 2 CAN, 2 IIC, and a pair of SPI
- 14 PWM pins
- Many further superior options to fulfill the wants of superior customers
Ports, communication, structure
You’ll be able to join the SwiftIO board to your laptop through a USB connector, the 2 gadgets can talk by a serial port. The USB cable will present the mandatory energy help, however alternatively you should utilize an adapter or an exterior battery by a protect.
You’ll be able to wire up further parts utilizing the Basic Objective Enter/Output pins (GPIO). You’ll be able to see the precise specification on the image above, however actually I barely perceive this diagram.
Confession time: I do not know shit about electronics (but). 💩
The board can be utilized with a protect and fortuitously the MakersKit arrives with a helpful instruction guide for absolute newcomers. I felt fortunate, as a result of I used to be in a position to method this little gadget with my programmer mindset and I might focus extra on Swift as an alternative of constructing working circuits.
So what’s truly beneath the hood? How can I construct & run functions for SwiftIO?
The grey space is the {hardware} itself, on prime of that within the pink-ish/purple containers there may be this Zephyr layer which I’ve by no means heard earlier than. I am simply scratching the floor right here, however that is fantastic, since as a Swift developer we solely care concerning the orange stuff. Lengthy story brief, there’s a customized constructed Swift toolchain for this machine that enables us to construct and run Swift functions on the board. 😅
If there’s a toolchain, then we are able to run Swift binaries, however how can we talk with the ports and stuff like that? Luckily the SwiftIO framework is right here for us. It gives an quick access to speak with exterior {hardware} equipment. You’ll be able to learn or write digital and analog alerts utilizing the communication protocol. Are you prepared for some Swift code?
The SwiftIO setting
Though the {hardware} is secure, the software program shouldn’t be completed but. There are two choices accessible, however in case you are on a Home windows machine, it’s best to seize the official MadMachine IDE and use that. The reason being that the Swift Bundle Supervisor shouldn’t be prepared for that platform but, so you will not be capable to work with the instruments that I am going to present you subsequent. Sorry Home windows, no offense. 😅
So choice A, is to go together with the IDE, it is very easy to make use of and gives an amazing DX. Choice B, study a bit extra concerning the underlying toolkit and comply with my information, it is a bit extra sophisticated, however you will know extra concerning the technical infrastructure in case you select this path. 🤔
Putting in the MadMachine SDK & CLI
As a macOS or Linux person it’s best to know that you would be able to set up the unofficial MadMachine SDK alongside a command line device referred to as mm. As you’ll be able to see this MadMachine SDK is written in Swift, however it’s best to know that I ported a python script from the unique mm-sdk challenge with the assistance of Marcus Kida. First, he made an Xcode template by invoking the unique script contained in the official MadMachine IDE, then I assumed, it might be cool to do away with the IDE for good, and now, right here we go, we now have a standalone Swift model of the mandatory construct instruments. You’ll be able to set up it like this:
git clone https://github.com/EmbeddedSwift/MadMachine.git
cd MadMachine
make set up
Now you have to be prepared to make use of the mm cli app, you’ll be able to test the accessible instructions contained in the README file on GitHub. I’ve not examined this on Linux but, so in case you discover any points, please do not hesitate to report or submit a PR. That is an experimental challenge, so maintain this in thoughts. 😅
The MadMachine toolchain
As a way to use the MadMachine SDK you’ll need a working toolchain put in in your laptop. You’ll be able to seize the most recent one by operating the next command:
mm toolchain --upgrade
This can seize the most recent launch from the unofficial MadMachine toolchain repository, and place it beneath your house folder contained in the .MadMachine listing. There may be one further factor that now you must do earlier than you could possibly begin constructing SwiftIO apps. At the moment there may be one additional python script that was not ported but, as a result of will probably be utterly eradicated sooner or later. For now you continue to need to obtain the official MadMachine SDK from the GitHub releases web page and place the complete contents of the mm-sdk/tools_[platform]/scripts/dist/gen_isr_tables folder into the ~/.MadMachine/legacy listing. You may need to create a legacy folder. 🙈
The SwiftIO framework
The SwiftIO framework goes to be linked with the applying binary, we now have to put in it (with the assistance of the mm-cli device) as a system library first. There’s an unofficial repo with a makefile for this:
git clone https://github.com/EmbeddedSwift/SwiftIO
cd SwiftIO
make set up
You will discover the library reference for the SwiftIO framework, however we’ll see you may make it work, in just some moments. Earlier than we go additional it’s best to observe that the customized MadMachine toolchain is a modified model of the Swift 5.1 toolchain. This implies that you would be able to’t use Swift 5.3 on the board but, however hopefully the creators of SwiftIO will launch new software program parts actual quickly. 🤞
Utilizing Xcode
The SwiftIO framework could be compiled in your native machine with the native Swift toolchain (utilizing Xcode), so it’s doable to construct functions with out concentrating on the board, and in a while you’ll be able to re-compile the supply recordsdata with the mm-cli command, signal the ultimate binary and deploy it to the SwiftIO board after you have pressed the obtain button. That is the present workflow in a nutshell.
There may be an current Xcode template created by @kidmar that you should utilize as a place to begin.
Utilizing SPM
These days I favor to create a Swift package deal for nearly all the things. You need to use SPM with a Makefile and your favourite editor to create SwiftIO apps. You simply need to initialize a brand new executable package deal with the mandatory dependencies, for instance:
import PackageDescription
let package deal = Bundle(
title: "myProject",
merchandise: [
.executable(name: "myProject", targets: ["myProject"]),
],
dependencies: [
.package(url: "https://github.com/EmbeddedSwift/SwiftIO", .branch("main")),
.package(url: "https://github.com/EmbeddedSwift/SHT3x", .branch("main")),
.package(url: "https://github.com/EmbeddedSwift/LCD1602", .branch("main")),
],
targets: [
.target(name: "myProject", dependencies: [
.product(name: "SwiftIO", package: "SwiftIO"),
.product(name: "SHT3x", package: "SHT3x"),
.product(name: "LCD1602", package: "LCD1602"),
]),
]
)Contained in the major.swift file now you’ll be able to write a easy Humiture sensor app that shows the present humidity & temperature on a 16×2 LCD show like this:
import SwiftIO
import SHT3x
import LCD1602
extension Float {
func format(_ f: Int) -> Float {
guard f > 0 else {return self}
var mul = 10
for _ in 1..<f {
mul *= 10
}
let information = Int(self * Float(mul))
return Float(information) / Float(mul)
}
}
let i2c = I2C(Id.I2C0)
let liquid crystal display = LCD1602(i2c)
let sht = SHT3x(i2c)
whereas true{
let temp = sht.readTemperature()
liquid crystal display.write(x: 0, y: 0, "Temperature:")
liquid crystal display.write(x: 0, y: 1, String(temp.format(1)))
liquid crystal display.write(x: 4, y: 1, " ")
liquid crystal display.write(x: 5, y: 1, "C")
sleep(ms: 1000)
}Now in case you open the Bundle.swift file utilizing Xcode you’ll be able to even construct the challenge regionally utilizing the CMD+B shortcut, however do not attempt to run it, since your Mac shouldn’t be a SwiftIO board… 😅
If you wish to construct and run this challenge you must goal the SwiftIO board. The mm-cli cannot resolve package deal dependencies (but) so you must set up the mandatory dependencies (SHT3x, LCD1602) the identical manner as we did with the SwiftIO library. It’s important to clone each repositories and use the makefile to put in them as native MadMachine system libraries. This can transfer the required recordsdata beneath the ~/.MadMachine/libraries folder, all of the accessible libraries “dwell” there. 🔨
After you have put in the libraries, you should utilize the next Makefile for the precise binary builds:
construct:
mm construct --name myProject --binary-type executable --input . --output ./myProject
run: construct
mm board --run ./myProject/swiftio.bin
clear:
rm -r ./myProject
The mm construct command invokes the swiftc compiler from the SwiftIO toolchain with the fitting search paths and library search paths. The mm board --run [binary] command will merely copy the mandatory recordsdata to the MadMachine board whether it is in obtain mode. It’s important to press the obtain button on the board earlier than you run this command. Urgent the obtain button will mount the SD card so we are able to deploy the signed binary to the machine, then eject the storage, which can restart the board and the brand new software will probably be loaded & executed straight away. 🚀
The MadMachine IDE
Should you do not wish to play with command line utilities, you’ll be able to all the time use the MadMachine IDE to construct and ship your initiatives. It makes use of a mmp file to explain dependencies, so it will possibly resolve them on the fly, however I do not like the truth that I’ve to make use of a brand new package deal supervisor and editor to work with Swift. I am in a love and hate relationship with Xcode (plus I am an old-school Chic Textual content fan). ❤️
Anyway, you’ll find actually nice examples with a devoted GitHub repository and plenty of video tutorials on the official YouTube channel. You’ll be able to entry all of the MakerKit pattern codes, they’re each on GitHub and you’ll clone a template with a click on utilizing the MadMachine IDE.
Conclusion
For me, the SwiftIO board was a pleasing shock. I all the time wished to play with embedded techniques, know a little bit extra about {hardware} and low degree stuff, however the Raspberry PI and the Arduino felt like alien planet. As soon as I’ve tried to construct an app for a Raspberry PI at a hackaton, however it was a whole catastrophe, I used to be upset, as a result of the instruments and the developer expertise was actually unhealthy.
The promise of MadMachine is that you would be able to simply use Swift on such a tool and I consider that Andy Liu created one thing that may have a brilliant future on the long run. I felt in love with SwiftIO proper after I’ve assembled my first circuit and deployed my very first Swift supply. It was a seamless (ache free) expertise and I consider that is a very vital issue for builders who by no means used such gadgets earlier than. This may be the start and the way forward for Swift on embedded techniques. 😍
You’ll be able to construct some actually enjoyable stuff with SwiftIO, it is an ideal device for studying how electrical circuits work. I can not wait to see increasingly more sensors and libraries accessible for MadMachine. If in case you have an concept or a query be at liberty to hitch the official Discord server.