Archive | tronixlabs

First Look – Arduino M0 Pro with 32 bit ARM Cortex M0

Here at tronixstuff we keep an open mind with regards to new hardware, and in this spirit we have the following “first look” of the new Arduino M0 Pro (previously called the Arduino Zero) from Arduino SRL. If the term Arduino SRL is new to you – click here to learn more.

Arduino M0 Pro from Tronixlabs Australia 1

This is the second Arduino-branded board that takes the leap from 8-bit to 32-bit microcontrollers (with the Due being the first), and according to Arduino SRL offers a lot of promise:

With the new Arduino M0 pro board, the more creative individual will have the potential to create one’s most imaginative and new ideas for IoT devices, wearable technologies, high tech automation, wild robotics and other not yet thinkable adventures in the world of makers.

The Arduino M0 pro represents a simple, yet powerful, 32-bit extension of the Arduino UNO platform. The board is powered by Atmel’s SAMD21 MCU, featuring a 32-bit ARM Cortex® M0 core.

With the addition of the M0 board, the Arduino family becomes larger with a new member providing increased performance.

The power of its Atmel’s core gives this board an upgraded flexibility and boosts the scope of projects one can think of and make; moreover, it makes the M0 Pro the ideal educational tool for learning about 32-bit application development.
Atmel’s Embedded Debugger (EDBG), integrated in the board, provides a full debug interface with no need for additional hardware, making debugging much easier. EDBG additionally supports a virtual COM port for device programming and traditional Arduino boot loader functionality uses.

Lots of buzzwords in there, so let’s push that aside and first consider the specifications:

Microcontroller – ATSAMD21G18, 48pins LQFP – the “main” microcontroller
EDBG Microcontroller – AT32UC3A4256, 100pins VFBGA
Operating Voltage – 3.3 V
DC Input Voltage (recommended) – 6-15 V
DC Input Voltage (limits) – 4.5-20 V
Digital I/O Pins – 14, with 12 PWM and UART
Analogue Input Pins – 6, 12-bit ADC channels
Analogue Output Pins – 1, 10-bit DAC
DC Current per I/O Pin – 7 mA
Flash Memory – 256 KB
SRAM – 32 KB
Clock Speed – 48 MHz

Lots of good stuff there – increased clock speed, increased flash memory (sketch space) and SRAM (working memory). No EEPROM however you can emulate one.

Note that the M0 Pro is a 3.3V board – and also the DC current per I/O pin is only 7 mA. Once again the user will need to carefully consider their use of external circuitry and shields to ensure compatibility (as the “classic” Arduino boards are 5V and can happily source/sink much more current per I/O pin).

The ADC (analogue-to-digital) converters have an increased resolution – 12-bit… and the addition of a true DAC (digital-to-analogue) converter allows for a true variable voltage output. This could be useful for sound generation or other effects. You can pore over the complete details including board schematics from the arduino.org website.

Moving on, let’s have a look around the Arduino M0 Pro board itself:

Arduino M0 Pro from Tronixlabs Australia 1

You can’t miss the sticker asking you to download the IDE – as Arduino SRL have forked up the Arduino IDE and run off with it. Click here to download. Upon removing the sticker you have:

Arduino M0 Pro from Tronixlabs Australia

Note the connector for the JTAG interface which works in conjunction with Atmel Studio software for debugging. You can also use the USB connection which connects to the EDBG microcontroller (example). When Atmel offers a native MacOS version we’ll investigate that further. SPI isn’t D10~D13 as per the older boards, instead it is accessed via the six pins on the right-hand side of the board. Turning the M0 Pro over doesn’t reveal any surprises:

Arduino M0 Pro from Tronixlabs Australia 1

And like the Due there are two USB ports:

Arduino M0 Pro from Tronixlabs Australia 1

A Programming USB port for uploading sketches through the Arduino IDE and “normal” use, along with a native USB port for direct connection to the main microcontroller’s serial connection. For “regular” Arduino IDE use, you can stick with the Programming port as usual.

So let’s try out the M0 Pro. We’ve downloaded the arduino.org IDE (which can co-exist with the arduino.cc IDE). Drivers are included with the IDE for Windows users, so the board should be plug and play. Note that if you need to reflash the Arduino bootloader – Atmel Studio is required. Moving on – within the Arduino IDE you need to set the board type to “Arduino M0 Pro (Programming Port)”:

Arduino M0 Pro from Tronixlabs Australia IDE 1

… and the Programmer to “M0 Pro Programming Port”:

Arduino M0 Pro from Tronixlabs Australia port 1

… both of these options are found in the Tools menu. When using these faster boards we like to run a simple speed test that calculates Newton Approximation for pi using an infinite series, written by Steve Curd from the Arduino forum. You can download the sketch to try yourself.

In previous tests the Arduino Mega2560 completed the test in 5765 ms, and the Arduino Due crushed it in 690 ms. As you can see below the M0 Pro needed 1950 ms for the test:

Arduino M0 Pro from Tronixlabs Australia speed

Not bad at all compared to a Mega. Thus the M0 Pro offers you a neat speed bump in an Uno-compatible form-factor. At this point those of you who enjoy making your own boards and dealing with surface-mount components have an advantage – the Atmel ATSAMD21G18 is available in TQFP package for under US$6… so you could cook up your own high-performance boards. Example.

At this point I’m curious about the onboard 10-bit DAC that’s connected to pin A0, so I connected the DSO to A0 and GND, and uploaded the following sketch:

… which resulted with the following neat triangle waveform:

Arduino M0 Pro DAC fast

… and here it is with the statistics option:

Arduino M0 Pro DAC fast stats

With a frequency of 108.7 Hz there’s a lot of CPU overhead – no doubt controlling the MCU without the Arduino abstraction will result with increased performance. Finally – for some other interesting examples and “how to” guides for the M0 Pro, visit the Arduino labs page for this board.

Conclusion for now

There are many pros and cons with the Arduino M0 Pro. It is not the best “all round” or beginner’s board due to the limitations of the hardware GPIO. There’s the DAC which could be useful for creating Arduino-controlled power supplies – and plenty of PWM outputs… but don’t directly connect servos to them. However if you can live with the current limits – and need a faster clock speed with an Arduino Uno-compatible board type – then the M0 Pro is an option for you.

Furthermore the M0 Pro offers an interesting bridge into the world of 32-bit microcontrollers, and no doubt the true performance of the MCU can be unlocked by moving away from the Arduino IDE and using Atmel Studio. If you have any questions for the arduino.org team about the Arduino M0 Pro ask in their support forum.

Finally, check out tronixlabs.com – which along with being Australia’s #1 Adafruit distributor, also offers a growing range and great value for supported hobbyist electronics from Altronics, DFRobot, Freetronics, Jaycar, Seeedstudio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, Arduino SRL, M0 Pro, review, tronixlabs, tronixstuff2 Comments

Control your Arduino over the Internet using Blynk

Introduction

There are many ways of remotely-controlling your Arduino or compatible hardware over the Internet. Some are more complex than others, which can be a good thing or a bad thing depending on your level of expertise. Lately we’ve become more interested in this topic and have come across Blynk, which appeared to be a simple solution – and thus the topic of our review.

What is Blynk?

From their website: “Blynk is a Platform with iOS and Android apps to control Arduino, Raspberry Pi and the likes over the Internet. It’s a digital dashboard where you can build a graphic interface for your project by simply dragging and dropping widgets. 

It’s really simple to set everything up and you’ll start tinkering in less than 5 mins. Blynk is not tied to some specific board or shield. Instead, it’s supporting hardware of your choice. Whether your Arduino or Raspberry Pi is linked to the Internet over Wi-Fi, Ethernet or this new ESP8266 chip, Blynk will get you online and ready for the Internet Of Your Things.” Here is the original launch video:

 

Blynk started off as an idea, and raised initial funding through Kickstarter – which was successful and the system has now launched. Blynk comprises of an app on your smartphone (Android or iOS) inside which you can add widgets (controls) to send commands back to your development board (Arduino etc.).

For example, you can add a switch to turn a digital output on or off. Furthermore, data from sensors connected to the development board can be send back to the smartphone. The data passes through the Blynk Cloud server, or you can download and run your own server on your own hardware and infrastructure.

How much does it cost?

Right now (September 2015) the Blynk system is free. We downloaded the app and experimented without charge. We believe that over time there will be payment required for various functions, however you can try it out now to see if Blynk suits your needs then run with it later or experiment with other platforms.

Getting Started

Well enough talk, let’s try Blynk out. Our hardware is an Android smartphone (the awesome new Oppo R7+) for control, and a Freetronics EtherTen connected to our office modem/router:

blynk etherten tronixstuff

You can also use other Arduino+Ethernet combinations, such as an Arduino Uno with an Ethernet shield. First you need to download the app for your phone – click here for the links. Then from the same page, download the Arduino library – and install it like you would any other Arduino library.

For our first example, we’ll use an LED connected to digital pin 7 (via a 560 ohm resistor) shown above. Now it’s time to set up the Blynk app. When you run the app for the first time, you need to sign in – so enter an email address and password:

blynk tronixstuff 1

Then click the “+” at the top-right of the display to create a new project, and you should see the following screen:

blynk tronixstuff 2

You can name your project, select the target hardware (Arduino Uno) – then click “E-mail” to send that auth token to yourself – you will need it in a moment. Then click “Create” to enter the main app design screen. Next, press “+” again to get the “Widget Box” menu as shown below, then press “Button”:

blynk tronixstuff 3

This will place a simple button on your screen:

blynk tronixstuff 4

Press the button to open its’ settings menu:

blynk tronixstuff 5

From this screen you can name your button, and also determine whether it will be “momentary” (i.e., only on when you press the button) – or operate as a switch (push on… push off…). Furthermore you need to select which physical Arduino pin the button will control – so press “PIN”, which brings up the scrolling menu as shown below:

blynk tronixstuff 6

We set ours to D7 then pressed “Continue”. Now the app is complete. Now head back to your computer, open the Arduino IDE, and load the “Arduino_Ethernet” sketch included with the library:

blynk example sketch tronixstuff

Then scroll down to line 30 and enter the auth key that was sent to you via email:

blynk example sketch tronixstuff auth key

Save then upload the sketch to your Arduino. Now head back to your smartphone, and click the “Play” (looks like a triangle pointing right) button. After a moment the app will connect to the Blynk server… the Arduino will also be connected to the server – and you can press the button on the screen to control the LED.

And that’s it – remote control really is that easy. We’ve run through the process in the following short video:

Now what else can we control? How about some IKEA LED strips from our last article. Easy… that consisted of three digital outputs, with PWM. The app resembles the following:

blynk tronixstuff ikea dioder

… and watch the video below to see it in action:

Monitoring data from an Arduino via Blynk

Data can also travel in the other direction – from your Arduino over the Internet to your smartphone. At the time of writing this (September 2015) you can monitor the status of analogue and digital pins, and widgets can be added in the app to do just that. They can display the value returned from each ADC, which falls between zero and 1023 – and display the values in various forms – for example:

blynk sensors tronixstuff

The bandwidth required for this is just under 2 K/s, as you can see from the top of the image above. You can see this in action through the video below:

Conclusion

We have only scratched the surface of what is possible with Blynk – which is an impressive, approachable and usable “Internet of Things” platform. Considering that you can get an inexpensive Android smartphone or tablet for under AU$50, the overall cost of using Blynk is excellent and well worth consideration, even just to test out the “Internet of Things” buzz yourself. So to get started head over to the Blynk site.

And finally a plug for our own store – tronixlabs.com – which along with being Australia’s #1 Adafruit distributor, also offers a growing range and Australia’s best value for supported hobbyist electronics from DFRobot, Freetronics, Seeedstudio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, blynk, Ikea, iot, tronixlabs, tronixstuff, tutorial7 Comments

Experimenting with Arduino and IKEA DIODER LED Strips

Introduction

A few weeks ago I found a DIODER LED strip set from a long-ago trek to IKEA, and considered that something could be done with it.  So in this article you can see how easy it is to control the LEDs using an Arduino or compatible board with ease… opening it up to all sorts of possibilities.

This is not the most original project – however things have been pretty quiet around here, so I thought it was time to share something new with you. Furthermore the DIODER control PCB has changed, so this will be relevant to new purchases. Nevertheless, let’s get on with it.

So what is DIODER anyhow? 

As you can see in the image below, the DIODER pack includes four RGB LED units each with nine RGB LEDs per unit. A controller box allows power and colour choice, a distribution box connects between the controller box and the LED strips, and the whole thing is powered by a 12V DC plugpack:

IKEA DIODER LED strips

The following is a quick video showing the DIODER in action as devised by IKEA:

 

Thankfully the plugpack keeps us away from mains voltages, and includes a long detachable cable which connects to the LED strip distribution box. The first thought was to investigate the controller, and you can open it with a standard screwdriver. Carefully pry away the long-side, as two clips on each side hold it together…

IKEA DIODER Arduino tronixstuff
… which reveals the PCB. Nothing too exciting here – you can see the potentiometer used for changing the lighting effects, power and range buttons and so on:

ikea dioder tronixstuff arduino

Our DIODER has the updated PCB with the Chinese market microcontroller. If you have an older DIODER with a Microchip PIC – you can reprogram it yourself.

ikea dioder arduino tronixstuff

The following three MOSFETs are used to control the current to each of the red, green and blue LED circuits. These will be the key to controlling the DIODER’s strips – but are way too small for me to solder to. The original plan was to have an Arduino’s PWM outputs tap into the MOSFET’s gates – but instead I will use external MOSFETs.

ikea dioder arduino tronixstuff

So what’s a MOSFET?

In the past you may have used a transistor to switch higher current from an Arduino, however a MOSFET is a better solution for this function. The can control large voltages and high currents without any effort. We will use N-channel MOSFETs, which have three pins – Source, Drain and Gate. When the Gate is HIGH, current will flow into the Drain and out of the Source:

mosfet

A simplistic explanation is that it can be used like a button – and when wiring your own N-MOSFET a 10k resistor should be used between Gate and Drain to keep the Gate low when the Arduino output is set to LOW (just like de-bouncing a button). To learn more about MOSFETS – get yourself a copy of “The Art of Electronics“. It is worth every cent.

However being somewhat time poor (lazy?), I have instead used a Freetronics NDrive Shield for Arduino – which contains six N-MOSFETs all on one convenient shield  – with each MOSFET’s Gate pin connected to an Arduino PWM output.
freetronics ndrive shield tronixlabs

So let’s head back to the LED strips for a moment, in order to determine how the LEDs are wired in the strip. Thanks to the manufacturer – the PCB has the markings as shown below:

ikea dioder tronixstuff arduino

They’re 12V LEDs in a common-anode configuration. How much current do they draw? Depends on how many strips you have connected together…

ikea dioder arduino tronixstuff

For the curious I measured each colour at each length, with the results in the following table:

current

So all four strips turned on, with all colours on – the strips will draw around 165 mA of current at 12V. Those blue LEDs are certainly thirsty.

Moving on, the next step is to connect the strips to the MOSFET shield. This is easy thanks to the cable included in the DIODER pack, just chop the white connector off as shown below:

ikea dioder arduino tronixstuff

By connecting an LED strip to the other end of the cable you can then determine which wire is common, and which are the cathodes for red, green and blue.

The plugpack included with the DIODER pack can be used to power the entire project, so you will need cut the DC plug (the plug that connects into the DIODER’s distribution box) off the lead, and use a multimeter to determine which wire is negative, and which is positive.

Connect the negative wire to the GND terminal on the shield, and the positive wire to the Vin terminal.  Then…

  • the red LED wire to the D3 terminal,
  • the green LED wire to the D9 terminal,
  • and the blue LED wire to the D10 terminal.

Finally, connect the 12V LED wire (anode) into the Vin terminal. Now double-check your wiring. Then check it again.

ikea dioder tronixstuff arduino

Testing

Now to run a test sketch to show the LED strip can easily be controlled. We’ll turn each colour on and off using PWM (Pulse-Width Modulation) – a neat way to control the brightness of each colour. The following sketch will pulse each colour in turn, and there’s also a blink function you can use.

Success. And for the non-believers, watch the following video:

Better LED control

As always, there’s a better way of doing things and one example of LED control is the awesome FASTLED library by Daniel Garcia and others. Go and download it now – https://github.com/FastLED/FastLED. Apart from our simple LEDS, the FASTLED library is also great with WS2812B/Adafruit NeoPixels and others.

One excellent demonstration included with the library is the AnalogOutput sketch, which I have supplied below to work with our example hardware:

You can see this in action through the following video:

Control using a mobile phone?

Yes – click here to learn how.

Conclusion

So if you have some IKEA LED strips, or anything else that requires more current than an Arduino’s output pin can offer – you can use MOSFETs to take over the current control and have fun. And finally a plug for my own store – tronixlabs.com – offering a growing range and Australia’s best value for supported hobbyist electronics from adafruit, DFRobot, Freetronics, Seeed Studio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, freetronics, Ikea, MOSFET, tronixlabs, tronixstuff, tutorial3 Comments

Review – Nextion TFT Human Machine Interface

Introduction

Using a large TFT LCD with various development boards can often be a trial – from dedicating eight or more GPIO pins to working with a flaky software library or memory limitations. Personally I have thought “there must be a better way”, and thus usually results in shifting the concept over to a single-board computer such as a Raspberry Pi to get the job done.

However this is no longer necessary – thanks to the team at Itead Studio and now available from Tronixlabs. They have developed a series of TFT LCDs which include enough onboard hardware, a graphic processor unit and memory to be a self-contained display solution whose output can be created with a WYSIWYG editor and be controlled using simple serial text commands.

For a quick demonstration, check out the following video:

As you can see the display can be quite complex, and with some imagination you can create a neat interface for your project. And once the interface has been uploaded to the display, all your development board needs to do is communicate with the Nextion displays via a TTL-level USART  (serial port).

Hardware

Nextion displays are available in a wide range from 2.4″ through to 7″ at varying resolutions – with all having a resistive touch screen:

Itead Nextion displays

On the rear of an example 4.3″ unit we can see the brains behind the Nextion – an STM32F microcontroller, 16MB of flash memory and a meaty Altera MAXII FPGA. :

Itead Nextion large rear

… and the 2.4″ version which has 4MB of flash memory:

Itead Nextion small rear

And as shown above you can see from the images there is a microSD card socket on each display, and the only external connections are 5V and GND plus TX/RX for serial data to your system. For testing purposes with a Windows-based PC you can use a simple USB-TTL serial cable. This could also be used for a more permanent solution between a Raspberry Pi, or any USB-enabled PC.

Software

The display interface is created used an IDE (integrated development environment) which is currently available for Windows. Using the IDE, you can import images for use in the interface, determine touch areas, add  buttons, progress bars, gauges and much more.

Nextioneditor

Furthermore there is a simulator and debugger tool which allows you to test your interface on the PC or directly to the Nextion unit. The simulator also allows for sending and receiving commands with the display so you can quickly test your code.

The simulator is also a demonstration of how the Nextion can be controlled via USB-TTL serial cable from a PC, thus great for secondary displays via processing, python etc – or from any software that can communicate via the PC’s serial port. And much cheaper than a secondary display if you only want to display certain types of data.

To create an interface is easy, you first start with a background image or a solid colour. Then you can add objects such as buttons for user-input, or define an area of the screen to a “touch-zone” – which, when pressed, will send a value out to the connected device. You can also add text zones, which will display incoming text from the connected device – along with progress bars and gauges.

For an ideal example of all this together, watch the following video:

 

Conclusion

Although the units I had for test were prototype review units supplied by Itead, they worked as expected and really do solve the problem of creating a contemporary user-interface without typing up microcontroller resources. Nextion displays are now available from our Tronixlabs store.

And finally a plug for my own store – tronixlabs.com – offering a growing range and Australia’s best value for supported hobbyist electronics from adafruit, DFRobot, Freetronics, Seeed Studio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in Itead, Nextion, tronixlabs

Editorial – Arduino versus Arduino

updated 27/10/2015

Over the last few months a large split in the Arduino ecosystem has been made public with some interesting results, and possibly could be the start of the end of the project as we know it. After a few people asked me directly about my thoughts on the Arduino versus Arduino matter, I’ve decided to articulate them in this editorial.

From the beginning the Arduino team has consisted of Massimo Banzi, David Cuartielles, David Mellis, Tom Igoe, and Gianluca Martino – and over the years we have always thought of this core team as the people who brought us the Arduino world.

Furthermore the main manufacturer of the Arduino-branded boards in Italy – “Smart Projects S. r. L” belongs to team member Gianluca Martino, and this organisation paid royalties to the team for the right to manufacture the boards.

Moving on, in 2008 the five formed a company to hold the trademarks and so forth that would allow for more commercial opportunities with regards to licensing and so forth.

However as Massimo wrote in a recent Make: magazine article, Gianluca had registered the Arduino name in Italy amongst other nefarious actions.

To top this off, Massimo tells us that Smart Projects have stopped paying the royalties for over twelve months. This has been most disappointing as being the supplier to Arduino resellers across the globe, resellers thought they were doing the right thing by buying the real boards. A

And to add insult to injury, Smart Projects changed their name to Arduino S. r. L., and was sold by Gianluca Martino in 2014. This company has created their own Arduino website (ending with .org instead of .cc) – and even forked their own version of the IDE and given it a version number starting with 1.7, which is greater than the current 1.6.3. No doubt this will trap a few users into thinking that Arduino S. r. L. (which we’ll shorten to ASrL) is the legitimate supplier and site for Arduino. For more information about the later developments, read this article form Hackaday.

tronixstuff and arduino versus arduino

So from what we can tell, the manufacturing member of the original Arduino team has gone off and tried to replicate the Arduino ecosystem under their own terms, allegedly misappropriating the Arduino name and trademark and denying royalties – and is currently still the only source of what have always been “genuine Arduino boards”.

Wow, what a mess.

More keen observers will realise that there isn’t anything wrong with reproducing their own Arduino-compatible boards thanks to the open-source nature of the hardware, and there must be a google of copies, compatibles and knock-offs in the market. And it’s ok to fork the IDE for modify, improve or bork it up to your own requirements as long as yout stick to the original software licence.

However the alleged royalty issue and trademark and name theft is not ok. So where does this leave the Arduino team now? From what I can learn, the rest of the original Arduino team are moving forward and will continue to innovate with new devices and projects which is admirable – and they have agreed to work with manufacturer/retailers such as adafruit to produce new boards (such as the Arduino Gemma).

At this point how does this affect you, as a potential or current Arduino enthusiast? That’s an excellent question. If you have always believed in supporting the Arduino team by purchasing genuine boards – it would seem this option is no longer available until the original team find a new manufacturing partner.

And how does this affect Arduino resellers? As an Arduino reseller ourselves (tronixlabs.com) we made our position as clear as we could at the time. Our position at Tronixlabs is that we want to continue to sell boards that benefit the Arduino team, however we’re a business that aims to meet the needs of all of our customers – and thus we offer compatibles as well.

We have contacted the Arduino team for guidance about future Arduino-branded boards and await their reply. What we do look forward to, however, is a cheaper reseller cost. The freight charge from Europe plus the board costs at the time were quite extraordinary.

Furthermore if Arduino S. r. L introduce a compelling product that people want – hey we’ll sell that as well. The following day Nate from Sparkfun made a similar statement. Whether they make their thoughts public or not, we’re confident that all resellers will take a similar stand, as you don’t want to specifically pick a side in case the other side has a great product that you want to sell. Then again, why would a manufacturer hold back their product to a retailer if said retailer offers products from the competition?

As Kent Brockman would say “… only time will tell”.

From this juncture we look forward to what the Arduino team has for us in the future with great interest… and we’re also following Arduino S. r. L as well to see what they come up with.

However don’t panic – for day to day use nothing has changed for us as enthusiasts. However – do we owe the Arduino team our support? Absolutely – so many people have benefited from their original idea and work for everyone’s benefit. If you feel so inclined, you can directly donate funds to the Arduino project via the IDE download page.

Finally, a great lesson can be learned from these recent events. If your team comes up with a great idea, product or service – before you get serious spend the time and resources required to formalise ownership of intellectual property, naming rights, copyrighted work, and so forth.

Update 27th October 2015

Not much has changed. The first “Genuino” boards are starting to appear in the EU at 20 Euro a pop, and the Mega and Micro are now available. We believe that the Arduino trademark is lost outside of the US and thus Genuino and Arduino.cc will co-exist from the same team. This has also been reflected on the arduino.cc website.

The smartest buying decision is for you is to choose what you need. If what you need isn’t available from arduino.cc – you can always make a cash donation for their efforts via the IDE download page.

We look forward to your thoughts and notes about the situation, which can be left in our moderated comment section. And finally a plug for my own store – tronixlabs.com – offering a growing range and Australia’s best value for supported hobbyist electronics from adafruit, DFRobot, Freetronics, Seeed Studio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, Arduino SRL, tronixlabs, tronixstuff6 Comments

Tutorial – Using DS1307 and DS3231 Real-time Clock Modules with Arduino

We keep getting requests on how to use DS1307 and DS3231 real-time clock modules with Arduino from various sources – so this is the first of a two part tutorial on how to use them. For this Arduino tutorial we have  two real-time clock modules to use, one based on the Maxim DS1307:

ds1307-real-time-clock-module-from-tronixlabs-australia

and another based on the DS3231:

ds3231-real-time-clock-module-from-tronixlabs-australia

There are two main differences between the ICs on the real-time clock modules, which is the accuracy of the time-keeping. The DS1307 used in the first module works very well, however the external temperature can affect the frequency of the oscillator circuit which drives the DS1307’s internal counter.

This may sound like a problem, however will usually result with the clock being off by around five or so minutes per month. The DS3231 is much more accurate, as it has an internal oscillator which isn’t affected by external factors – and thus is accurate down to a few minutes per year at the most. If you have a DS1307 module- don’t feel bad, it’s still a great value board and will serve you well.

With both of the modules, a backup battery is installed when you receive them from Tronixlabs, however these are an inexpensive variety and shouldn’t be relied on for more than twelve months. If you’re going to install the module in a more permanent project, it’s a good idea to buy a new CR2032 battery and fit it to the module.

Along with keeping track of the time and date, these modules also have a small EEPROM, an alarm function (DS3231 only) and the ability to generate a square-wave of various frequencies – all of which will be the subject of a second tutorial.

Connecting your module to an Arduino

Both modules use the I2C bus, which makes connection very easy. If you’re not sure about the I2C bus and Arduino, check out the I2C tutorials (chapters 20 and 21), or review chapter seventeen of my book “Arduino Workshop“.

Moving on – first you will need to identify which pins on your Arduino or compatible boards are used for the I2C bus – these will be knows as SDA (or data) and SCL (or clock). On Arduino Uno or compatible boards, these pins are A4 and A5 for data and clock:

arduino-uno-i2c-pin

If you’re using an Arduino Mega the pins are D20 and D21 for data and clock:

Arduino Mega from Tronixlabs Australia

If you’re using an Pro Mini-compatible the pins are A4 and A5 for data and clock, which are parallel to the main pins, as shown below:

arduino-pro-micro-compatible-i2c-pins

DS1307 module

If you have the DS1307 module you will need to solder the wires to the board, or solder on some inline header pins so you can use jumper wires. Then connect the SCL and SDA pins to your Arduino, and the Vcc pin to the 5V pin and GND to GND.

DS3231 module

Connecting this module is easy as header pins are installed on the board at the factory. You can simply run jumper wires again from SCL and SDA to the Arduino and again from the module’s Vcc and GND pins to your board’s 5V or 3.3.V and GND. However these are duplicated on the other side for soldering your own wires.

Both of these modules have the required pull-up resistors, so you don’t need to add your own. Like all devices connected to the I2C bus, try and keep the length of the SDA and SCL wires to a minimum.

Reading and writing the time from your RTC Module

Once you have wired up your RTC module. enter and upload the following sketch. Although the notes and functions in the sketch refer only to the DS3231, the code also works with the DS1307.

There may be a lot of code, however it breaks down well into manageable parts.

It first includes the Wire library, which is used for I2C bus communication, followed by defining the bus address for the RTC as 0x68. These are followed by two functions that convert decimal numbers to BCD (binary-coded decimal) and vice versa. These are necessary as the RTC ICs work in BCD not decimal.

The function setDS3231time() is used to set the clock. Using it is very easy, simple insert the values from year down to second, and the RTC will start from that time. For example if you want to set the following date and time – Wednesday November 26, 2014 and 9:42 pm and 30 seconds – you would use:

Note that the time is set using 24-hour time, and the fourth paramter is the “day of week”. This falls between 1 and 7 which is Sunday to Saturday respectively. These parameters are byte values if you are subsituting your own variables.

Once you have run the function once it’s wise to prefix it with // and upload your code again, so it will not reset the time once the power has been cycled or micrcontroller reset.

Reading the time form your RTC Is just as simple, in fact the process can be followed neatly inside the function displayTime(). You will need to define seven byte variables to store the data from the RTC, and these are then inserted in the function readDS3231time().

For example if your variables are:

… you would refresh them with the current data from the RTC by using:

Then you can use the variables as you see fit, from sending the time and date to the serial monitor as the example sketch does – to converting the data into a suitable form for all sorts of output devices.

Just to check everything is working, enter the appropriate time and date into the demonstration sketch, upload it, comment out the setDS3231time() function and upload it again. Then open the serial monitor, and you should be provided with a running display of the current time and date, for example:

tronixlabs-rtc-output

From this point you now have the software tools to set data to and retrieve it from your real-time clock module, and we hope you have an understanding of how to use these inexpensive modules.

You can learn more about the particular real-time clock ICs from the manufacturer’s website – DS1307 and DS3231.

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a fourth printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, ds1307, DS3231, tronixlabs, tronixstuff, tutorial

Tutorial – L298N Dual Motor Controller Modules and Arduino

Learn how to use inexpensive L298N motor control modules to drive DC and stepper motors with Arduino. This is chapter fifty-nine of our huge Arduino tutorial series.

You don’t have to spend a lot of money to control motors with an Arduino or compatible board. After some hunting around we found a neat motor control module based on the L298N H-bridge IC that can allows you to control the speed and direction of two DC motors, or control one bipolar stepper motor with ease.

The L298N H-bridge module can be used with motors that have a voltage of between 5 and 35V DC. With the module used in this tutorial, there is also an onboard 5V regulator, so if your supply voltage is up to 12V you can also source 5V from the board.

So let’s get started!

L298N Dual Motor Controller Module 2A from Tronixlabs Australia

First we’ll run through the connections, then explain how to control DC motors then a stepper motor. At this point, review the connections on the L298N H-bridge module.

Consider the following image – match the numbers against the list below the image:

L298N Motor Controller for Arduino from Tronixlabs Australia

  1. DC motor 1 “+” or stepper motor A+
  2. DC motor 1 “-” or stepper motor A-
  3. 12V jumper – remove this if using a supply voltage greater than 12V DC. This enables power to the onboard 5V regulator
  4. Connect your motor supply voltage here, maximum of 35V DC. Remove 12V jumper if >12V DC
  5. GND
  6. 5V output if 12V jumper in place, ideal for powering your Arduino (etc)
  7. DC motor 1 enable jumper. Leave this in place when using a stepper motor. Connect to PWM output for DC motor speed control.
  8. IN1
  9. IN2
  10. IN3
  11. IN4
  12. DC motor 2 enable jumper. Leave this in place when using a stepper motor. Connect to PWM output for DC motor speed control.
  13. DC motor 2 “+” or stepper motor B+
  14. DC motor 2 “-” or stepper motor B-

Controlling DC Motors

To control one or two DC motors is quite easy with the L298N H-bridge module. First connect each motor to the A and B connections on the L298N module. If you’re using two motors for a robot (etc) ensure that the polarity of the motors is the same on both inputs. Otherwise you may need to swap them over when you set both motors to forward and one goes backwards!

Next, connect your power supply – the positive to pin 4 on the module and negative/GND to pin 5. If you supply is up to 12V you can leave in the 12V jumper (point 3 in the image above) and 5V will be available from pin 6 on the module. This can be fed to your Arduino’s 5V pin to power it from the motors’ power supply. Don’t forget to connect Arduino GND to pin 5 on the module as well to complete the circuit.

Now you will need six digital output pins on your Arduino, two of which need to be PWM (pulse-width modulation) pins. PWM pins are denoted by the tilde (“~”) next to the pin number, for example:

Arduino UNO PWM pins

Finally, connect the Arduino digital output pins to the driver module. In our example we have two DC motors, so digital pins D9, D8, D7 and D6 will be connected to pins IN1, IN2, IN3 and IN4 respectively. Then connect D10 to module pin 7 (remove the jumper first) and D5 to module pin 12 (again, remove the jumper).

The motor direction is controlled by sending a HIGH or LOW signal to the drive for each motor (or channel). For example for motor one, a HIGH to IN1 and a LOW to IN2 will cause it to turn in one direction, and  a LOW and HIGH will cause it to turn in the other direction.

However the motors will not turn until a HIGH is set to the enable pin (7 for motor one, 12 for motor two). And they can be turned off with a LOW to the same pin(s). However if you need to control the speed of the motors, the PWM signal from the digital pin connected to the enable pin can take care of it.

This is what we’ve done with the DC motor demonstration sketch. Two DC motors and an Arduino Uno are connected as described above, along with an external power supply. Then enter and upload the following sketch:

So what’s happening in that sketch? In the function demoOne() we turn the motors on and run them at a PWM value of 200. This is not a speed value, instead power is applied for 200/255 of an amount of time at once.

Then after a moment the motors operate in the reverse direction (see how we changed the HIGHs and LOWs in thedigitalWrite() functions?).

To get an idea of the range of speed possible of your hardware, we run through the entire PWM range in the function demoTwo() which turns the motors on and them runs through PWM values zero to 255 and back to zero with the two for loops.

Finally this is demonstrated in the following video – using our well-worn tank chassis with two DC motors:

Controlling a Stepper Motor

Stepper motors may appear to be complex, but nothing could be further than the truth. In this example we control a typical NEMA-17 stepper motor that has four wires:

stepper motor Tronixlabs Australia

It has 200 steps per revolution, and can operate at at 60 RPM. If you don’t already have the step and speed value for your motor, find out now and you will need it for the sketch.

The key to successful stepper motor control is identifying the wires – that is which one is which. You will need to determine the A+, A-, B+ and B- wires. With our example motor these are red, green, yellow and blue. Now let’s get the wiring done.

Connect the A+, A-, B+ and B- wires from the stepper motor to the module connections 1, 2, 13 and 14 respectively. Place the jumpers included with the L298N module over the pairs at module points 7 and 12. Then connect the power supply as required to points 4 (positive) and 5 (negative/GND).

Once again if your stepper motor’s power supply is less than 12V, fit the jumper to the module at point 3 which gives you a neat 5V power supply for your Arduino.

Next, connect L298N module pins IN1, IN2, IN3 and IN4 to Arduino digital pins D8, D9, D10 and D11 respectively. Finally, connect Arduino GND to point 5 on the module, and Arduino 5V to point 6 if sourcing 5V from the module.

Controlling the stepper motor from your sketches is very simple, thanks to the Stepper Arduino library included with the Arduino IDE as standard.

To demonstrate your motor, simply load the stepper_oneRevolution sketch that is included with the Stepper library, for example:

L298N motor controller and Arduino tutorial from Tronixlabs Australia

Finally, check the value for

in the sketch and change the 200 to the number of steps per revolution for your stepper motor, and also the speed which is preset to 60 RPM in the following line:

Now you can save and upload the sketch, which will send your stepper motor around one revolution, then back again. This is achieved with the function

Finally, a quick demonstration of our test hardware is shown in the following video:

So there you have it, an easy an inexpensive way to control motors with your Arduino or compatible board. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a fourth printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, L298, tronixlabs, tronixstuff, tutorial

Tutorial – PCF8574 backpacks for LCD modules and Arduino

Learn how to use inexpensive serial backpacks with character LCD modules with your Arduino. This is chapter fifty-eight of our huge Arduino tutorial series.

Introduction

Using LCD modules with your Arduino is popular, however the amount of wiring requires time and patience to wire it up correctly – and also uses a lot of digital output pins. That’s why we love these serial backpack modules – they’re fitted to the back of your LCD module and allows connection to your Arduino (or other development board) with only four wires – power, GND, data and clock.

You can use this with LCD modules that have a HD44780-compatible interface with various screen sizes. For example a 16 x 2 module:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

The backpack can also be used with 20 x 4 LCDs. The key is that your LCD must have the interface pads in a single row of sixteen, so it matches the pins on the backpack – for example:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

Hardware Setup

Now let’s get started. First you need to solder the backpack to your LCD module. While your soldering iron is warming up, check that the backpack pins are straight and fit in the LCD module, for example:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

Then solder in the first pin, while keeping the backpack flush with the LCD:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

If it’s a bit crooked, you can reheat the solder and straighten it up again. Once you’re satisfied with the alignment, solder in the rest of the pins:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

Now to keep things neat, trim off the excess header pins:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

Once you’ve finished trimming the header pins, get four male to female jumper wires and connect the LCD module to your Arduino as shown in the following image and table. Then connect your Arduino to the computer via USB:

16 x 2 character LCD (white text blue background) with parallel interface from Tronixlabs Australia

Software Setup

The next step is to download and install the Arduino I2C LCD library for use with the backpack. First of all, rename the “LiquidCrystal” library folder in your Arduino libraries folder. We do this just to keep it as a backup.

If you’re not sure where your library folder can be found – it’s usually in your sketchbook folder, whose location can usually be found in the Arduino IDE preferences menu:

Next, visit https://bitbucket.org/fmalpartida/new-liquidcrysta… and download the latest file, currently we’re using v1.2.1. Expanding the downloaded .zip file will reveal a new “LiquidCrystal” folder – copy this into your Arduino libraries folder.

Now restart the Arduino IDE if it was already running – or open it now. To test the module we have a demonstration sketch prepared, simply copy and upload the following sketch:

After a few moments the LCD will be initialised and start to display our URL and the value for millis, then blink the backlight off and on – for example:

If the text isn’t clear, or you just see white blocks – try adjusting the contrast using the potentiometer on the back of the module.

How to control the backpack in your sketch

As opposed to using the LCD module without the backpack, there’s a few extra lines of code to include in your sketches. To review these, open the example sketch mentioned earlier.

You will need the libraries as shown in lines 3, 4 and 5 – and initialise the module as shown in line 7. Note that the default I2C bus address is 0x27 – and the first parameter in the LiquidCrystal_I2C function.

Finally the three lines used in void setup() are also required to initialise the LCD. If you’re using a 20×4 LCD module, change the parameters in the lcd.begin() function.

From this point you can use all the standard LiquidCrystal functions such as lcd.setCursor() to move the cursor and lcd.write() to display text or variables as normal. The backlight can also be turned on and off with lcd.setBacklight(HIGH) or lcd.setBacklight(LOW).

You can permanently turn off the backlight by removing the physical jumper on the back of the module.

Changing the I2C bus address

If you want to use more than one module, or have another device on the I2C bus with address 0x27 then you’ll need to change the address used on the module. There are eight options to choose from, and these are selected by soldering over one or more of the following spots:

There are eight possible combinations, and these are described in Table 4 of the PCF8574 data sheet which can be downloaded from the NXP website. If you’re unsure about the bus address used by the module, simply connect it to your Arduino as described earlier and run the I2C scanner sketch from the Arduino playground.

We hope you enjoyed this tutorial and you can make use of it. Finally, if you enjoyed this tutorial, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a fourth printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, LCD, PCF8574, tronixlabs, tronixstuff, tutorial

Tutorial – Arduino and TFT Color Touch Screen

Learn how to use an inexpensive TFT colour  touch LCD shield with your Arduino. This is chapter twenty-nine of our huge Arduino tutorial series.

Updated 07/02/2014

There are many colour LCDs on the market that can be used with an Arduino, and in this tutorial we’ll explain how to use a model that is easy to use, has a touch screen, doesn’t waste all your digital output pins – and won’t break the bank. It’s the 2.8″ TFT colour touch screen shield from Tronixlabs:

Arduino TFT colour touch shield front

And upside down:

Arduino TFT colour touch shield back

As you can imagine, it completely covers an Arduino Uno or compatible board, and offers a neat way to create a large display or user-interface.  The display has a resolution of 320 x 240 pixels, supports up to 65536 colours and draws around 250mA of current from the Arduino’s internal 5V supply. 

And unlike other colour LCDs, this one doesn’t eat up all your digital output pins – it uses the SPI bus for the display (D10~D13), and four analogue pins (A0~A3) if you use the touch sensor. However if you also use the onboard microSD socket more pins will be required. 

With some imagination, existing Arduino knowledge and the explanation within you’ll be creating all sorts of displays and interfaces in a short period of time. Don’t be afraid to experiment!

Getting started

Setting up the hardware is easy – just plug the shield on your Arduino. Next, download the library bundle from here. Inside the .zip file is two folders – both which need to be copied into your …\Arduino-1.0.x\libraries folder. Then you will need to rename the folder “TFT_Touch” to “TFT”. You will notice that the Arduino IDE already contains a library folder called TFT, so rename or move it.

Now let’s test the shield so you know it works, and also to have some quick fun. Upload the paint example included in the TFT library – then with a stylus or non-destructive pointer, you can select colour and draw on the LCD – as shown in this video. At this point we’d like to note that you should be careful with the screen – it doesn’t have a protective layer.

Afraid the quality of our camera doesn’t do the screen any justice, however the still image looks better:

Arduino TFT colour touch shield paint demonstration

Using the LCD 

Moving on, let’s start with using the display. In your sketches the following libraries need to be included using the following lines before void setup():

… and then the TFT library is initialised in void setup()

Now you can use the various functions to display text and graphics. However you first need to understand how to define colours.

Defining colours

Functions with a colour parameter can accept one of the ten ten predefined colours – RED, GREEN, BLUE, BLACK, YELLOW, WHITE, CYAN, BRIGHT_RED, GRAY1 and GRAY2, or you can create your own colour value. Colours are defined with 16-but numbers in hexadecimal form, with 5 bits for red, 6 for green and 5 for blue – all packed together. For example – in binary:

These are called RGB565-formatted numbers – and we use these in hexadecimal format with our display. So black will be all zeros, then converted to hexadecimal; white all ones, etc. The process of converting normal RGB values to RGB565 would give an aspirin a headache, but instead thanks to Henning Karlsen you can use his conversion tool to do the work for you. Consider giving Henning a donation for his efforts.

Displaying text

There are functions to display characters, strings of text, integers and float variables:

In each of the functions, the first parameter is the variable or data to display; x and y are the coordinates of the top-left of the first character being displayed; and colour is either the predefined colour as explained previously, or the hexadecimal value for the colour you would like the text to be displayed in – e.g. 0xFFE0 is yellow.

The drawFloat() function is limited to two decimal places, however you can increase this if necessary. To do so, close the Arduino IDE if running, open the file TFTv2.cpp located in the TFT library folder – and search for the line:

… then change the value to the number of decimal places you require. We have set ours to four with success, and the library will round out any more decimal places. To see these text display functions in action,  upload the following sketch:

… which should result in the following:

Arduino TFT colour touch shield text

To clear the screen

To set the screen back to all black, use:

Graphics functions

There are functions to draw individual pixels, circles, filled circles, lines, rectangles and filled rectangles. With these and a little planning you can create all sorts of images and diagrams. The functions are:

The following sketch demonstrates the functions listed above:

… with the results shown in this video.

Using the touch screen

The touch screen operates in a similar manner to the other version documented earlier, in that it is a resistive touch screen and we very quickly apply voltage to one axis then measure the value with an analogue pin, then repeat the process for the other axis.

You can use the method in that chapter, however with our model you can use a touch screen library, and this is included with the library .zip file you downloaded at the start of this tutorial.

The library does simplify things somewhat, so without further ado upload the touchScreen example sketch included with the library. Open the serial monitor then start touching the screen. The coordinates of the area over a pixel being touch will be returned, along with the pressure – as shown in this video.

Take note of the pressure values, as these need to be considered when creating projects. If you don’t take pressure into account, there could be false positive touches detected which could cause mayhem in your project.

Now that you have a very simple method to determine the results of which part of the screen is being touched – you can create sketches to take action depending on the touch area. Recall from the example touch sketch that the x and y coordinates were mapped into the variables p.x and p.y, with the pressure mapped to p.z. You should experiment with your screen to determine which pressure values work for you.

In the following example, we don’t trigger a touch unless the pressure value p.z is greater than 300. Let’s create a simple touch-switch, with one half of the screen for ON and the other half for OFF. Here is the sketch:

What’s happening here? We divided the screen into two halves (well not physically…) and consider any touch with a y-value of less than 160 to be the off area, and the rest of the screen to be the on area. This is tested in the two if functions – which also use an and (“&&”) to check the pressure. If the pressure is over 300 (remember, this could be different for you) – the touch is real and the switch is turned on or off.

… and a quick demonstration video of this in action.

Displaying images from a memory card

We feel this warrants a separate tutorial, however if you can’t wait – check out the demo sketch which includes some example image files to use.

Conclusion

By now I hope you have the answer to “how do you use a touch screen LCD with Arduino?” and had some fun learning with us. You can get your LCD from Tronixlabs. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, LCD, TFT, touch screen, tronixlabs, tronixstuff, tutorial

Tutorial – Arduino Mega and SM5100B GSM Cellular

Shield is now out of date so tutorial has been removed. Contact your hardware supplier for support.

Posted in arduino, GSM, shield, tronixlabs, tronixstuff, tutorial

Tutorial – Arduino and MediaTek 3329 GPS

Learn how to use MediaTek 3329-based GPS shields with Arduino in Chapter 19 of our Arduino Tutorials. The first chapter is here, the complete series is detailed here. If you have an EM406A GPS module, please visit the separate tutorial. Updated 15/01/2014

Introduction

In this instalment we will introduce and examine the use of the Global Positioning System receivers with Arduino systems. What is the GPS? In very simple terms, a fleet of satellites orbit the earth, transmitting signals from space. Your GPS receiver uses signals from these satellites to triangulate position, altitude, compass headings, etc.; and also receives a time and date signal from these satellites.

The most popular GPS belongs to the USA, and was originally for military use – however it is now available for users in the free world.

Interestingly, the US can switch off or reduce accuracy of their GPS in various regions if necessary, however many people tell me this is not an issue unless you’re in a combat zone against the US forces. For more information, have a look at Wikipedia or the USAF Space Command GPS Ops Centre site. As expected,  other countries have their own GPS as well – such as Russia, China, and the EU is working on one as well.

So – how can us mere mortals take advantage of a multi-billion dollar space navigation system just with our simple Arduino? Easy – with an inexpensive GPS receiver and shield. In this tutorial we’ll use a GPS shield based on the MediaTek3329 GPS receiver from Tronixlabs.

Unlike the EM406A used in the other tutorial, the whole lot is all on one shield – and after some experimenting has better reception. Plus there’s an onboard SD card socket which we’ll use for a GPS logging device. The only catch is that you need to solder the stacking headers yourself. (update – if purchased from Tronixlabs these will be fully assembled):

Linksprite Arduino GPS SD card shield

Apart from the GPS shield we’ll also be using a typical Arduino-compatible LCD shield and of course an Arduino Uno or compatible. Finally before getting started, you need to set the two jumpers on the GPS shield as shown in the following image:

Linksprite GPS Arduino shield jumpers

By doing this the serial data lines from the GPS receiver can be connected to Arduino D2 and D3 – which we will use with SoftwareSerial. The benefit of doing it this way is that you can then upload sketches without any hardware changes and also use the serial monitor and GPS at the same time. So let’s get started.

Testing your GPS shield

Simply connect your GPS shield as described above to your Arduino Uno or compatible, and upload the following sketch:

Note the use of SoftwareSerial in the sketch. As mentioned earlier, the GPS data is transferred to the Arduino via D2/D2 – which we set up as a software serial port.

If possible try to get your hardware close to a window, then open the serial monitor window. The first time you power up your receiver, it may take a  minute or so to lock onto the available satellites, this period of time is the cold start time.

The subsequent times you power it up, the searching time is reduced somewhat as our receiver stores some energy in a supercap (very high-value capacitor) to remember the satellite data, which it will use the next time to reduce the search time (as it already has a “fair idea” where the satellites are).

Moving on, after a few moments you should be presented with a scrolling wall of text, for example:

Arduino GPS raw NMEA data

What on Earth does all that mean? For one thing the hardware is working correctly. Excellent! Now how do we decode these space-signals… They are called NMEA codes. Let’s break down one and see what it means. For example, the line:

  • $GPRMC tells us the following data is essential point-velocity-time data;
  • 100748.000 is the universal time constant (Greenwich Mean Time) – 10:07:48 (hours, minutes, seconds). So you now have a clock as well.
  • A is status – A for active and data is valid, V for void and data is not valid.
  • 3754.9976  is degrees latitude position data = 37 degrees, 54.9976′
  • S for south (south is negative, north is positive)
  • 14507.0283 is degrees longitude position data = 145 degrees, 07.0283′
  • E for east (east is positive, west is negative)
  • 0.00 is my speed in knots over ground. This shows the inaccuracy  that can be caused by not having a clear view of the sky
  • 263.36 – course over ground (0 is north, 180 is south, 270 is west, 90 is east)
  • 140114 is the date – 14th January 2014
  • the next is magnetic variation for which we don’t have a value
  • checksum number

Thankfully the data is separated by commas. This will be useful later when you log the data to a text file using the SD card, as you will then be able to use the data in a spreadsheet very easily. For more explanation about the data, here is the NMEA Reference Manual that explains them all.

Extracting the GPS data

You can’t decode all that NMEA on the fly, so thankfully there is an Arduino library to do this for us – TinyGPS. So head over to the library website, download and install the library before continuing.

Now with the same hardware from the previous example, upload the following sketch:

How this works is quite simple. In void loop() the sketch waits for data to come from the GPS receiver, and then checks if it’s valid GPS data. Then it passes over to the function getgps() which uses the function:

to extract the location data and place it in two variables. Next, another function:

will extract the date and time data, and place them in the pre-determined variables. Finally the use of

and

can be assigned to variables as they store the altitude and speed respectively. These functions will be commonly used across all the examples, so you can see how they can be used.

To test the sketch, position the hardware and open the serial monitor. After a moment you should be presented with the GPS data in a much more useful form, for example:

Arduino GPS data

At this point you should be able to form ideas of how to harness that data and display or work with it in a more useful way. Useful hint – you can enter coordinates directly into Google Maps to see where it is, for example:

GPS data in Google Maps

 A portable GPS display

Now that you can extract the GPS data, it’s a simple matter of sending it to an LCD shield for display. Just add the LCD shield to your hardware and upload the next sketch. Be sure to change the values in the LiquidCrysal LCD… line if your shield uses different digital pins.

Again, position the hardware and your current position should be shown on the LCD, for example:

Arduino GPS LCD

A GPS Clock

Armed with the same hardware you can also create a GPS clock. With this you can finally have a reference clock and end all arguments about the correct time without calling the speaking clock. Just use the same hardware from the previous example and upload the following sketch:

Now position the hardware again, and after a moment the time will appear – as shown in this video.

Unless you live in the UK or really need to know what GMT/UTC is, a little extra work is required to display your local time. First you will need to know in which time zone you are located – find it in this map.

If your time zone is positive (e.g. GMT +10) – you need to add 10 to your hour value, and if it’s over 23 you then subtract 24 to get the correct hours.

If your time zone is negative (e.g. GMT – 5) – you need to subtract 5 from your hour value, and if it’s under zero  you then add 24 to get the correct hours.

GPS Speedometer

Just as with the clock, it’s easy to display the speed readings with the LCD. Using the same hardware as above, enter and upload the following sketch:

Now position the hardware again, and after a moment your speed should appear. You might get some odd readings if indoors, as the receiver needs data from several satellites to accurately determine your speed. The sketch is written for km/h, however you can replace the display lines with the section that is commented out to display miles per hour.

So at this point find a car and driver, an external power supply and go for a drive. You may find the GPS speed is quite different to the vehicle’s speedometer.

Build a GPS logging device

And for our final example, let’s make a device that captures the position, speed and time data to SD card for later analysis. The required hardware is just the GPS shield and Arduino Uno or compatible board – plus an SD memory card that is formatted to FAT16. SDXC cards may or may not work, they’re quite finicky – so try and get an older standard card.

Now enter and upload the following sketch:

This will append the data to a text file whose name is determine in line 34 of the sketch. If you are using a different GPS shield or a separate SD card shield you may need to change the digital pin value for the chip select line, which is found in lines 14 and 18. The data in our example is logged every ten seconds, however you can change the frequency using the delay() function in line 73.

When you’re ready to start capturing data, simply insert the card and power up the hardware. It will carry on until you turn it off, at which point the data file can be examined on a PC. As an example capture, I took the hardware for a drive, and ended with a file containing much data – for example:

Arduino GPS logging example data

For a more graphical result, you can import the data using a third-party service into Google Maps to get a better idea of the journey. But first, the text file requires a little work. Open it as a text file using a typical spreadsheet, which will then ask how to organise the columns. Delimit them with a space, for example:

delimit Arduino GPS data

Which will give you a spreadsheet of the data. Now delete all the columns except for the latitude and longitude data, and add a header row as such:

GPS data in spreadsheet

Now save that file as an .xls spreadsheet. Next, visit the GPS Visuliser website, and upload the file using the box in the centre of the page. Select “Google Maps” as the output format, and your trip will be presented – for example:

GPS trip map

There are many options on the visualiser site, so if you end up using it a lot – consider giving them a donation.

Conclusion

Now you have some easy example sketches that demonstrate how to extract and work with data from your GPS shield. For the curious, the static GPS locations displayed in this tutorial are not our current location. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, GPS, Mediatek 3329, shield, SKM58, tronixlabs, tronixstuff, tutorial0 Comments

Project – Arduino “Book Monster”

Introduction

Recently we saw a neat project by the people from Evil Mad Scientist – their “Peek-O-Book“, a neat take on a book with a shy monster inside, based on hardware from their Snap-O-Lantern kit. Not wanting to fork out for the postage to Australia we decided to make our own version, of which you can follow along.

This is a fun project that doesn’t require too much effort and has a lot of scope for customisation. There’s no right or wrong when making your own (or this one!) so just have fun with it.

Construction

First, you’ll need a book of some sort, something large enough to hide the electronics yet not too large to look “suspicious” – then cut the guts out to make enough space for the electronics. Then again it’s subjective, so get whatever works for you. Coincidentally we found some “dummy books” (not books for dummies) that were perfect for the job:

dummy book

After spraying the inside with matt black paint, the inside is better suited for the “eyes in the dark” effect required for the project:

dummy book internal

The “book” had a magnet and matching metal disk on the flap to aid with keep the cover shut, however this was removed as it will not allow for smooth opening with the servo.

The electronics are quite simple if you have some Arduino or other development board experience. Not sure about Arduino? You can use any microcontroller that can control a servo and some LEDs. We’re using a Freetronics LeoStick as it’s really small yet offers a full Arduino Leonardo-compatible experience, and a matching Protostick to run the wires and power from:

Freetronics Leostick and Protostick

By fitting all the external wiring to the Protostick you can still use the main LeoStick for other projects if required. The power is from 4 x AA cells, with the voltage reduced with a 1n4004 diode:

battery power and diode

And for the “eyes” of our monster – you can always add more if it isn’t too crowded in the book:

Arduino LEDs

We’ll need a resistor as well for the LEDs. As LEDs are current driven you can connect two in series with a suitable dropping resistor which allows you to control both if required with one digital output pin. You can use the calculator here to help determine the right value for the resistor.

Finally a servo is required to push the lid of the book up and down. We used an inexpensive micro servo that’s available from Tronixlabs:

Arduino servo

The chopsticks are cut down and used as an extension to the servo horn to give it more length:

Arduino servo mounted

Don’t forget to paint the arm black so it doesn’t stand out when in use. We had a lazy attack and mounted the servo on some LEGO bricks held in with super glue, but it works. Finally, here is the circuit schematic for our final example – we also added a power switch after the battery pack:

book monster schematic small

To recap  – this is a list of parts used:

After some delicate soldering the whole lot fits neatly in the box:

Arduino book monster final

Arduino Sketch

The behaviour of your “book monster” comes down to your imagination. Experiment with the servo angles and speed to simulate the lid opening as if the monster is creeping up, or quickly for a “pop-up” surprise. And again with the LED eyes you can blink them and alter the brightness with PWM. Here’s a quick sketch to give you an idea:

You can watch our example unit in this video.

Frankly the entire project is subjective, so just do what you want.

Conclusion

Well that was fun, and I am sure this will entertain many people. A relative is a librarian so this will adorn a shelf and hopefully give the children a laugh. Once again, thanks to the people from Evil Mad Science for the inspiration for this project – so go and buy something from their interesting range of kits and so on.

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, evil mad science, freetronics, leostick, projects, tronixlabs, tronixstuff, tutorial0 Comments

Kit Review – “Short Circuits” 3 Digit Counter

Introduction

Time for another kit review and in this instalment we have a look at the “3 digit counter” kit from Tronixlabs. This is part of a much larger series of kits that are described in a three volume set of educational books titled “Short Circuits”.

Aimed at the younger readers or anyone who has an interest in learning electronics, these books (available from Tronixlabs) are well written and with some study and practice the reader will make a large variety of projects and learn quite a bit. They could be considered as a worthy 21st-century replacement to the old Dick Smith “Funway…” guides.

The purpose of this kit is to give you a device which can count upwards between zero and 999 – which can be used for various purposes and also of course to learn about digital electronics.

Assembly

The kit arrives in typical retail fashion:

Jaycar Short Circuits Counter Kit packaging

Everything you need to make the counter is included except for the instructions – which are found in the “Short Circuits” volume two book – and IC sockets. Kits for beginners with should come with IC sockets.

Jaycar Short Circuits Counter Kit contents

The components are separated neatly in the bag above, and it was interesting to see the use of zero ohm resistors for the two links on the board:

KJ8234 Jaycar Short Circuits Counter Kit components

The PCB is excellent. The silk screening and solder-mask is very well done.

KJ8234 Jaycar Short Circuits Counter Kit PCB top

Jaycar Short Circuits Counter Kit PCB bottom KJ8234

Furthermore I was really, really impressed with the level of detail with the drilling. The designer has allowed for components with different pin spacing – for example the 100 nF capacitor and transistors as shown below:

Jaycar Short Circuits Counter Kit PCB detail KJ8234

The instructions in the book are very clear and are written in an approachable fashion:

Jaycar Short Circuits Counter Kit instructions KJ8234

Jaycar Short Circuits Counter Kit instructions two KJ8234

There’s also a detailed explanation on how the circuit works, some interesting BCD to decimal notes, examples of use (slot cars!) and a neat diagram showing how to mount the kit in a box using various parts from Jaycar – so you’re not left on your own.

Construction went well, starting with the low-profile parts:

Jaycar Short Circuits Counter Kit assembly 1 KJ8234

… then the semiconductors:

Jaycar Short Circuits Counter Kit assembly 2 KJ8234

… then the higher-profile parts and we’re finished:

Jaycar Short Circuits Counter Kit assembly finished KJ8234

There wasn’t any difficulty at all, and the counter worked first time. Although I’m not a new user, the quality of PCB and instructions would have been a contributing factor to the success of the kit.

How it works

The input signal for the counter (in this case a button controlling current from the supply rail) is “squared-up” by an MC14093 schmitt-trigger IC, which then feeds a MC14553 BCD counter IC, which counts and then feeds the results to a 4511 BCD to 7-segment converter to drive the LED digits which are multiplexed by the MC14553. For the schematic and details please refer to the book. Operation is simple, and demonstrated in the following video:

However you can feed the counter an external signal, by simply applying it to the input section of the circuit. After a quick modification:

Jaycar Short Circuits Counter Kit counter input KJ8234

… it was ready to be connected to a function generator. In the following video we send pulses with a varying frequency up to 2 kHz:

Conclusion

This is a neat kit, works well and with the accompanying book makes a good explanation of a popular digital electronics subject. There aren’t many good “electronics for beginners” books on the market any more, however the “Short Circuits” range fit the bill.

And finally a plug for our own store – tronixlabs.com – which along with being Australia’s #1 Adafruit distributor, also offers a growing range and Australia’s best value for supported hobbyist electronics from Altronics, Jaycar, DFRobot, Freetronics, Seeedstudio and much much more.

visit tronixlabs.com

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in education, electronics, kit, kit review, KJ8234, tronixlabs, tronixstuff6 Comments

Kit Review – Altronics 3 Digit Counter Module

Introduction

In this review we examine the three digit counter module kit from Tronixlabs. The purpose of this kit is to allow you to … count things. You feed it a pulse, which it counts on the rising edge of the signal. You can have it count up or down, and each kit includes three digits.

You can add more digits, in groups of three with a maximum of thirty digits. Plus it’s based on simple digital electronics (no microcontrollers here) so there’s some learning afoot as well. Designed by Graham Cattley the kit was first described in the now-defunct (thanks Graham) January 1998 issue of Electronics Australia magazine.

Assembly

The kit arrives in the typical retail fashion:

Altronics K2505 Counter Module Kit

And includes the magazine article reprint along with an “electronics reference sheet” which covers many useful topics such as resistor colour codes, various formulae, PCB track widths, pinouts and more. There is also a small addendum which uses two extra (and included) diodes for input protection on the clock signal:

Altronics K2505 Counter Module Kit instructions

The counter is ideally designed to be mounted inside an enclosure of your own choosing, so everything required to build a working counter is included however that’s it:

Altronics K2505 Counter Module Kit parts

No IC sockets, however I decided to live dangerously and not use them – the ICs are common and easily found. The PCBs have a good solder mask and silk screen:

Altronics K2505 Counter Module Kit PCBs

Altronics K2505 Counter Module Kit PCBs rear

With four PCBs (one each for a digit control and one for the displays) the best way to start was to get the common parts out of the way and fitted, such as the current-limiting resistors, links, ICs, capacitors and the display module. The supplied current-limiting resistors are for use with a 9V DC supply, however details for other values are provided in the instructions:

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

At this point you put one of the control boards aside, and then start fitting the other two to the display board. This involves holding the two at ninety degrees then soldering the PCB pads to the SIL pins on the back of the display board. Starting with the control board for the hundreds digit first:

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

… at this stage you can power the board for a quick test:

Altronics K2505 Counter Module Kit

… then fit the other control board for the tens digit and repeat:

Altronics K2505 Counter Module Kit

Now it’s time to work with the third control board. This one looks after the one’s column and also a few features of the board. Several functions such as display blanking, latch (freeze the display while still counting) and gate (start or stop counting) can be controlled and require resistors fitted to this board which are detailed in the instructions.

Finally, several lengths of wire (included) are soldered to this board so that they can run through the other two to carry signals such as 5V, GND, latch, reset, gate and so on:

Altronics K2505 Counter Module Kit

These wires can then be pulled through and soldered to the matching pads once the last board has been soldered to the display board:

Altronics K2505 Counter Module Kit

 You also need to run separate wires between the carry-out and clock-in pins between the digit control boards (the curved ones between the PCBs):

Altronics K2505 Counter Module Kit

For real-life use you also need some robust connections for the power, clock, reset lines, etc., however for demonstration use I just used alligator clips. Once completed a quick power-up showed the LEDs all working:

Altronics K2505 Counter Module Kit

How it works

Each digit is driven by a common IC pairing – the  4029 (data sheet) is a presettable up/down counter with a BCD (binary-coded decimal) output which feeds a 4511 (data sheet) that converts the BCD signal into outputs for a 7-segment LED display. You can count at any readable speed, and I threw a 2 kHz square-wave at the counter and it didn’t miss a beat. By default the units count upwards, however by setting one pin on the board LOW you can count downwards.

Operation

Using the counters is a simple matter of connecting power, the signal to count and deciding upon display blanking and the direction of counting. Here’s a quick video of counting up, and here it is counting back down.

Conclusion

This is a neat kit that can be used to count pulses from almost anything. Although some care needs to be taken when soldering, this isn’t anything that cannot be overcome without a little patience and diligence. So if you need to count something, get one or more of these kits from Tronixlabs Australia. Full-sized images are available on flickr. And while you’re here – are you interested in Arduino? Check out my book “Arduino Workshop” from No Starch Press – also available from Tronixlabs.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in altronics, cmos, counter, K2505, kit, kit review, LED, tronixlabs, tronixstuff1 Comment

Project – LED Cube Spectrum Analyzer

Introduction

A few weeks ago I was asked about creating a musical-effect display with an RGB LED cube kit from Freetronics, and with a little work this was certainly possible using the MSGEQ7 spectrum analyser IC. In this project we’ll create a small add-on PCB containing the spectrum analyser circuit and show how it can drive the RGB LED cube kit.

Freetronics CUBE4 RGB LED cube kit

Assumed knowledge

To save repeating myself, please familiarise yourself with the MSGEQ7 spectrum aanalyserIC in Chapter 48 of our Arduino tutorials. And learn more about the LED cube from our review and the product page.

You can get MSGEQ7 ICs from various sources, however they had varying results. We now recommend using the neat module from Tronixlabs.

The circuit

The LED cube already has an Arduino Leonardo-compatible built in to the main PCB, so all you need to do is build a small circuit that contains the spectrum analyzer which connects to the I/O pins on the cube PCB and also has audio input and output connections. First, consider the schematic:

MSGEQ7 CUBE4 spectrum analyser schematic

For the purposes of this project our spectrum analyser will only display the results from one channel of audio – if you want stereo, you’ll need two! And note that the strobe, reset and DCOUT pins on the MSGEQ7 are labelled with the connections to the cube PCB. Furthermore the pinouts for the MSGEQ7 don’t match the physical reality – here are the pinouts from the MSGEQ7 data sheet (.pdf):

MSGEQ7 pinouts

The circuit itself will be quite small and fit on a small amount of stripboard or veroboard. There is plenty of room underneath the cube to fit the circuit if so desired:

MSGEQ7 LED cube

With a few moments you should be able to trace out your circuit to match the board type you have, remember to double-check before soldering. You will also need to connect the audio in point after the 1000 pF capacitor to a source of audio, and also pass it through so you can connect powered speakers, headphones, etc.

One method of doing so would be to cut up a male-female audio extension lead, and connect the shield to the GND of the circuit, and the signal line to the audio input on the circuit. Or if you have the parts handy and some shielded cable, just make your own input and output leads:

MSGEQ7 input output leads

Be sure to test for shorts between the signal and shield before soldering to the circuit board. When finished, you should have something neat that you can hide under the cube or elsewhere:

MSGEQ7 RGB cube LED spectrum analyzer board

Double-check your soldering for shorts and your board plan, then fit to the cube along with the audio source and speakers (etc).

Arduino Sketch

The sketch has two main functions – the first is to capture the levels from the MSGEQ7 and put the values for each frequency band into an array, and the second function is to turn on LEDs that represent the level for each band. If you’ve been paying attention you may be wondering how we can represent seven frequency bands with a 4x4x4 LED cube. Simple – by rotating the cube 45 degrees you can see seven vertical columns of LEDs:

MSGEQ7 LED cube spectrum analyzer columns

So when looking from the angle as shown above, you have seven vertical columns, each with four levels of LEDs. Thus the strength of each frequency can be broken down into four levels, and then the appropriate LEDs turned on.

After this is done for each band, all the LEDs are turned off and the process repeats. For the sake of simplicity I’ve used the cube’s Arduino library to activate the LEDs, which also makes the sketch easier to fathom. The first example sketch only uses one colour:

… and a quick video demonstration:

For a second example, we’ve used various colours:

… and the second video demonstration:

A little bit of noise comes through into the spectrum analyser, most likely due to the fact that the entire thing is unshielded. The previous prototype used the Arduino shield from the tutorial which didn’t have this problem, so if you’re keen perhaps make your own custom PCB for this project.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in analyzer, arduino, com-10468, cube, freetronics, LED, MSGEQ7, projects, rgb, RGB LED, spectrum, tronixlabs, tronixstuff, tutorial

Tutorial – Arduino and the MAX7219 LED Display Driver IC

Use the Maxim MAX7219 LED display driver with Arduino in Chapter 56 of our Arduino Tutorials. The first chapter is here, the complete series is detailed here.

Introduction

Sooner or later Arduino enthusiasts and beginners alike will come across the MAX7219 IC. And for good reason, it’s a simple and somewhat inexpensive method of controlling 64 LEDs in either matrix or numeric display form. Furthermore they can be chained together to control two or more units for even more LEDs. Overall – they’re a lot of fun and can also be quite useful, so let’s get started.

Here’s an example of a MAX7219 and another IC which is a functional equivalent, the AS1107 from Austria Microsystems. You might not see the AS1107 around much, but it can be cheaper – so don’t be afraid to use that instead:

MAX7219 AS1107

 At first glance you may think that it takes a lot of real estate, but it saves some as well. As mentioned earlier, the MAX7219 can completely control 64 individual LEDs – including maintaining equal brightness, and allowing you to adjust the brightness of the LEDs either with hardware or software (or both). It can refresh the LEDs at around 800 Hz, so no more flickering, uneven LED displays.

You can even switch the display off for power saving mode, and still send it data while it is off. And another good thing – when powered up, it keeps the LEDs off, so no wacky displays for the first seconds of operation. For more technical information, here is the data sheet: MAX7219.pdf. Now to put it to work for us – we’ll demonstrate using one or more 8 x 8 LED matrix displays, as well as 8 digits of 7-segment LED numbers.

Before continuing, download and install the LedControl Arduino library as it is essential for using the MAX7219.

Controlling LED matrix displays with the MAX7219

First of all, let’s examine the hardware side of things. Here is the pinout diagram for the MAX7219:

MAX7219 pinout

The MAX7219 drives eight LEDs at a time, and by rapidly switching banks of eight your eyes don’t see the changes. Wiring up a matrix is very simple – if you have a common matrix with the following schematic:

LED matrix pinoutsconnect the MAX7219 pins labelled DP, A~F to the row pins respectively, and the MAX7219 pins labelled DIG0~7 to the column pins respectively. A total example circuit with the above matrix  is as follows:

MAX7219 example LED matrix circuit

The circuit is quite straight forward, except we have a resistor between 5V and MAX7219 pin 18. The MAX7219 is a constant-current LED driver, and the value of the resistor is used to set the current flow to the LEDs. Have a look at table eleven on page eleven of the data sheet:

MAX7219 resistor tableYou’ll need to know the voltage and forward current for your LED matrix or numeric display, then match the value on the table. E.g. if you have a 2V 20 mA LED, your resistor value will be 28kΩ (the values are in kΩ). Finally, the MAX7219 serial in, load and clock pins will go to Arduino digital pins which are specified in the sketch. We’ll get to that in the moment, but before that let’s return to the matrix modules.

In the last few months there has been a proliferation of inexpensive kits that contain a MAX7219 or equivalent, and an LED matrix. These are great for experimenting with and can save you a lot of work – some examples of which are shown below:

MAX7219 LED matrix modules

At the top is an example from tronixlabs.com, and the pair on the bottom are the units from a recent kit review. We’ll use these for our demonstrations as well.

Now for the sketch. You need the following two lines at the beginning of the sketch:

The first pulls in the library, and the second line sets up an instance to control. The four parameters are as follows:

  1. the digital pin connected to pin 1 of the MAX7219 (“data in”)
  2. the digital pin connected to pin 13 of the MAX7219 (“CLK or clock”)
  3. the digital pin connected to pin 12 of the MAX7219 (“LOAD”)
  4. The number of MAX7219s connected.

If you have more than one MAX7219, connect the DOUT (“data out”) pin of the first MAX7219 to pin 1 of the second, and so on. However the CLK and LOAD pins are all connected in parallel and then back to the Arduino.

Next, two more vital functions that you’d normally put in void setup():

The first line above turns the LEDs connected to the MAX7219 on. If you set TRUE, you can send data to the MAX7219 but the LEDs will stay off. The second line adjusts the brightness of the LEDs in sixteen stages. For both of those functions (and all others from the LedControl) the first parameter is the number of the MAX7219 connected. If you have one, the parameter is zero… for two MAX7219s, it’s 1 and so on.

Finally, to turn an individual LED in the matrix on or off, use:

which turns on an LED positioned at col, row connected to MAX7219 #1. Change TRUE to FALSE to turn it off. These functions are demonstrated in the following sketch:

And a quick video of the results:

How about controlling two MAX7219s? Or more? The hardware modifications are easy – connect the serial data out pin from your first MAX7219 to the data in pin on the second (and so on), and the LOAD and CLOCK pins from the first MAX7219 connect to the second (and so on). You will of course still need the 5V, GND, resistor, capacitors etc. for the second and subsequent MAX7219.

You will also need to make a few changes in your sketch. The first is to tell it how many MAX7219s you’re using in the following line:

by replacing X with the quantity. Then whenever you’re using  a MAX7219 function, replace the (previously used) zero with the number of the MAX7219 you wish to address. They are numbered from zero upwards, with the MAX7219 directly connected to the Arduino as unit zero, then one etc. To demonstrate this, we replicate the previous example but with two MAX7219s:

And again, a quick demonstration:

Another fun use of the MAX7219 and LED matrices is to display scrolling text. For the case of simplicity we’ll use the LedControl library and the two LED matrix modules from the previous examples.

First our example sketch – it is quite long however most of this is due to defining the characters for each letter of the alphabet and so on. We’ll explain it at the other end!