Fully Embedded

So after getting an Arduino to display a message on an LCD screen via USB serial, I moved onto transmitting from one Arduino to another over jump cables connected to the TX/RX ports. This proved that the receiver Arduino (with the LCD screen) could receive serial data over the IO pins.

Once this was completed, I moved onto transmitting the message from the Sam L21 Xplained Pro board. Unfortunately, the board I originally owned was from the first generation, which is a bit more difficult to program. After some shopping around, I managed to find a distributor in the states who could send over a second generation model (and a couple of Microchip LoRa mote boards - but more on that later!).

Using the handy new tool from Atmel - Atmel Start - I could generate a preconfigured application using their web interface which sets up all of the board and pin settings for UART communication. All that was left for me to do was create the main program loop which initialises UART and sends the message.

In the end, I managed to get the Sam L21 transmitting an alternating message every 10 seconds over jump wires to the receiver Arduino. Good so far!

My first experiment in the logger development is to set up an Arduino with an LCD shield. The Arduino takes a string from the USB Serial and displays it on the LCD screen.

This is all fairly basic stuff. The LCD shield is a standard Arduino shield, and the sketch uses the Liquid Crystal and Wire libraries to handle LCD display and serial communication, respectively.

So it looks like we’re going to get the sensors themselves manufactured elsewhere, and just develop the data loggers and on-site machines. This still means a fair amount of work for me, but at least I can concentrate on getting the basic circuits working, instead of worrying about making calibratable (not even sure if that’s a word, but hey ho...) sensors.

While I probably could knock together a logger using AVR architecture, I think in terms of the processing power to current draw ratio, it would be far better to use an ARM processor, specifically from the ARM Cortex M0+ family. I recently managed to procure a development board for the Atmel SAM L21 MCU, which is an incredibly low-powered Cortex M0+ core which can run at up to 48MHz (I assume requiring an external crystal oscillator to control it). The SAM L21 draws approximately 35µA / MHz, and as little as 200nA in sleep mode, which makes it perfect for the kind of battery life and usage we’re going for.

I’m still investigating low-power radio solutions to integrate for the logger and the on-site machine. My initial thoughts were to use Zigbee Pro, but from what I’ve read, you can only have a maximum of 10 end devices connected to either the controlling device or the routing devices. Since routing devices would have to be mains-powered, it’s a little impractical to have 40 of them installed all over the warehouse to handle the traffic. There are some other options though; I just need to do some further investigation.

My first step is to do some basic ‘blinking LED’ type tests on the L21 dev board, as I’ve never done ARM programming before, and I need to understand how it all works. From what research I have done, it seems you have to explicitly activate the pins being used in the program. This ensures that no battery is wasted on pins that aren’t in use.