Getting began with SwiftIO – The.Swift.Dev.

The SwiftIO board

MadMachine‘s SwiftIO board is an Arduino-like system, however it might probably run Swift code natively on the {hardware}. Swift is a good programming language for schooling functions, it’s a trendy language with a JavaScript-like syntax that’s simple to be taught and perceive. Swift is protected and environment friendly, this mixture makes it an ideal candidate for embedded programs. The SwiftIO board permits 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 positively essentially the most reasonably priced Swift language studying system. It may be splendid for STEM schooling functions for college students who need to see the right way to construct digital circuits and get some fundamental Swift programming abilities on the identical time.

The Maker Equipment field comprises each a 7 section and an LCD show, a servo and a DC motor with drivers, a humiture (tempearture & humidity) sensor, a buzzer module a potentiometer and a light-weight sensor and plenty of extra different issues (breadboard, resistors, LEDs, buttons and cables, and so on.) that you should use to construct the starter initiatives. You should have just about every part within the field that you just 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 type of equipment are only a few months away. There’s a new defend and a model new display screen module within the works. Oh by the way in which a sheild is someting which you can 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 all over the world. New plug-ins, extensions and modules are nonetheless being developed by the makers, however you will need to emphasize that the SwiftIO board {hardware} is in a steady state. 💪

Technical specs:

• i.MX RT1052 Crossover Processor with Arm® Cortex®-M7 core @600MHz
• Micro SD card slot, supporting customary 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 couple of SPI
• 14 PWM pins
• Many further superior options to satisfy 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 units can talk by means of a serial port. The USB cable will present the required energy help, however alternatively you should use an adapter or an exterior battery by means of a defend.

You’ll be able to wire up further elements utilizing the Common Goal 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 defend and thankfully the MakersKit arrives with a useful instruction guide for absolute rookies. I felt fortunate, as a result of I used to be capable of method this little gadget with my programmer mindset and I may focus extra on Swift as a substitute of constructing working circuits.

So what’s truly below the hood? How can I construct & run purposes for SwiftIO?

The grey space is the {hardware} itself, on prime of that within the pink-ish/purple packing 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 tremendous, since as a Swift developer we solely care in regards to the orange stuff. Lengthy story brief, there’s a customized constructed Swift toolchain for this system that permits us to construct and run Swift purposes on the board. 😅

If there’s a toolchain, then we are able to run Swift binaries, however how will we talk with the ports and stuff like that? Fortuitously the SwiftIO framework is right here for us. It offers 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 surroundings

Though the {hardware} is steady, the software program is just not completed but. There are two choices out there, however in case you are on a Home windows machine, you must seize the official MadMachine IDE and use that. The reason being that the Swift Bundle Supervisor is just not 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 possibility A, is to go together with the IDE, it is very easy to make use of and offers an incredible DX. Possibility B, be taught a bit extra in regards to the underlying toolkit and comply with my information, it is a bit extra difficult, however you will know extra in regards to the technical infrastructure when you select this path. 🤔

Putting in the MadMachine SDK & CLI

As a macOS or Linux consumer you must know which you can set up the unofficial MadMachine SDK alongside a command line device referred to as mm. As you possibly can see this MadMachine SDK is written in Swift, however you must know that I ported a python script from the unique mm-sdk mission 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 eliminate the IDE for good, and now, right here we go, we’ve got a standalone Swift model of the required 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 ought to be prepared to make use of the mm cli app, you possibly can test the out there instructions contained in the README file on GitHub. I’ve not examined this on Linux but, so when you discover any points, please do not hesitate to report or submit a PR. That is an experimental mission, so maintain this in thoughts. 😅

The MadMachine toolchain

In an effort to use the MadMachine SDK you have to a working toolchain put in in your laptop. You’ll be able to seize the newest one by working the next command:

mm toolchain --upgrade

It will seize the newest launch from the unofficial MadMachine toolchain repository, and place it below your house folder contained in the .MadMachine listing. There may be one further factor that now you need to do earlier than you may begin constructing SwiftIO apps. At present there may be one additional python script that was not ported but, as a result of it is going to be fully eradicated sooner or later. For now you continue to should obtain the official MadMachine SDK from the GitHub releases web page and place the whole contents of the mm-sdk/tools_[platform]/scripts/dist/gen_isr_tables folder into the ~/.MadMachine/legacy listing. You might need to create a legacy folder. 🙈

The SwiftIO framework

The SwiftIO framework goes to be linked with the appliance binary, we’ve got 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 can also make it work, in only a few moments. Earlier than we go additional you must word that the customized MadMachine toolchain is a modified model of the Swift 5.1 toolchain. This implies which you can’t use Swift 5.3 on the board but, however hopefully the creators of SwiftIO will launch new software program elements actual quickly. 🤞

Utilizing Xcode

The SwiftIO framework may be compiled in your native machine with the native Swift toolchain (utilizing Xcode), so it’s attainable to construct purposes with out focusing on the board, and in a while you possibly can 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 use as a place to begin.

Utilizing SPM

These days I favor to create a Swift package deal for nearly every part. You should utilize SPM with a Makefile and your favourite editor to create SwiftIO apps. You simply should initialize a brand new executable package deal with the required 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 principal.swift file now you possibly can 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 when you open the Bundle.swift file utilizing Xcode you possibly can even construct the mission regionally utilizing the CMD+B shortcut, however do not attempt to run it, since your Mac is just not a SwiftIO board… 😅

If you wish to construct and run this mission you need to goal the SwiftIO board. The mm-cli cannot resolve package deal dependencies (but) so you need to set up the required dependencies (SHT3x, LCD1602) the identical manner as we did with the SwiftIO library. You need to clone each repositories and use the makefile to put in them as native MadMachine system libraries. It will transfer the required recordsdata below the ~/.MadMachine/libraries folder, all of the out there libraries “stay” there. 🔨

After you have put in the libraries, you should use 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 suitable search paths and library search paths. The mm board --run [binary] command will merely copy the required recordsdata to the MadMachine board whether it is in obtain mode. You need 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 system, then eject the storage, which is able to restart the board and the brand new utility will likely be loaded & executed straight away. 🚀

The MadMachine IDE

If you happen to do not prefer to play with command line utilities, you possibly can 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 might probably 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, yow will discover 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 may clone a template with a click on utilizing the MadMachine IDE.

Conclusion

For me, the SwiftIO board was a nice shock. I all the time wished to play with embedded programs, know a bit of extra about hardwares 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, nevertheless it was a whole catastrophe, I used to be disillusioned, as a result of the instruments and the developer expertise was actually dangerous.

The promise of MadMachine is which you can simply use Swift on such a tool and I consider that Andy Liu created one thing that may have a shiny 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 units earlier than. This may be the start and the way forward for Swift on embedded programs. 😍

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 out there for MadMachine. You probably have an thought or a query be happy to hitch the official discord server.

You can too preorder the subsequent spherical of SwiftIO boards from the MadMachine Retailer. Andy simply instructed me that when you order now, they will ship your package deal in 1-3 days as soon as they get a brand new order. This may change quick, however you possibly can all the time test the order particulars on the MadMachine web site. 🤖