14 December 2013

Arduino DMX libraries now also available on Github

 

In the last weeks I got some very valuable feedback and some corrections for the DMXSerial2 library for Arduino from Felicitus and he asked me to put the sources into the GitHub repository.

I am used to work with Subversion and never worked with Git before but everything runs perfectly. I love the way how someone can add merge requests to an existing repository without the need to manage users and roles.

So you can find the library now on:
https://github.com/mathertel/DmxSerial2.

You can download the complete library including the samples by using the “Download ZIP” button on the right-hand side or by using the link
https://github.com/mathertel/DmxSerial2/archive/master.zip

I plan to also leave a copy of the other Arduino libraries there.

18 September 2013

Update for DMXSerial2 the DMX RDM library for Arduino

IT’s some months ago since I released the first version of DMXSerial2. Now there is an update with some fixes and some more complete functionality.

First of all thanks to Simon Newton who shared the link to a copy of the RDM standard E1.20. A download is available at http://tsp.plasa.org/freestandards. “Now there are no more excuses for not complying with the standard” – he writes and I will try to do so.

In the update you can the following additions:

  • The serial port definitions now also support Arduino MEGA 2560 (port 0 and 1) and Arduino Leonardo (port 1) boards.
  • I registered my own manufacurer id, now #0987 for mathertel.de.
  • There is a functionality that creates random device ids in the code. If a board once has started to work the device id will be stored into the eeprom and will remain there even when new software is uploaded.
  • I added the required RDM parameters SOFTWARE_VERSION_LABEL and SUPPORTED_PARAMETERS to comply with the standard.
  • Finally I removed some DMX-only specific code and did some simplifications and memory optimizations.
  • The initialization data for the library is now combined into a new structure.

It was an easy job to register a manufacturer id to myself as explained on http://tsp.plasa.org/tsp/working_groups/CP/mfctrIDs.php. Feel free to use my manufacturer id yourself if you promise only to use it for experiments and never to put a real device that leaves your hands.
If you plan for more please request your own manufacturer id and adjust the _devID definition to use it.

You can find the new version of the library now on http://www.mathertel.de/Arduino/DMXSerial2.aspx.

I will update the text of this site in the next days.

31 August 2013

DMXBridge, a wireless DMX sender and receiver

There are situations where DMX cables are unwanted or just not practical. This project implements a wireless transfer of a DMX signal in the 2.4 GHz band using the Arduino platform and the popular transceiver module nRF24L01+ from nordic semiconductor.

The DMX protocol

Receiving and sending the DMX protocol from the ATmega chip is done by using the DMXSerial library and the built-in serial port. This implementation is using interrupts and is a good base for implementing a second protocol on the same chip.

The DMX Serial library has a built-in 512 byte buffer for a DMX universe that is accessible using the functions provided by the library. After initializing the library and starting the communication the interrupts ensure the communication in the background.

You can find a lot of details in the article about the DMXSerial library.

The Wireless protocol

The 2.4GHz RF Transceiver is connected to the Arduino board or ATmega processor by using the SPI interface. The library for driving this chip I used is the library from Greg Copeland that you can find at https://github.com/gcopeland/RF24. After initializing the library it is possible to send and receive data by using the provided functions of the library. The library transfers all the commands and data to the nRF24L01+ chip will also handle all the transfer details in the background.

Implementation

Because the libraries handle most of the communication details the implementation of this project only has to close the gap between the 2 protocols. The main differences between them are

Frame size: DMX is using a max. 512 byte long frame for sending all the values of all channels at once. The Transceiver uses a much shorter protocol that can transfer up to 32 bytes in one frame. I have seen controllers that do not send all the 512 bytes when only some channels are used in the setup.

Transfer speed: DMX is constantly using a 250 kBaud serial transfer speed on the DMX wire. There may be longer gaps between the frames and also between the individual bytes of a frame but it is common to use the maximum possible transfer speed. The Transceiver is supporting 3 different transfer modes

The solution I found and implemented here is to break up the 512 channels of the DMX information into smaller packages.

The sender

There are 2 buffers of DMX values. One contains the values I have received lately from the DMX protocol. The DMXSerial library is used to listen to the DMX protocol and fill this buffer.

The second buffer contains the values that have been sent over the wireless.

The values of both buffers are compared to find the recent changes and to send them with priority. If there is no difference between the 2 buffers no priority data will be sent.

To enable the addition of new receivers and to heal dropped packages all the DMX data is sent from time to time regardless whether there are changes on not.

The package transferred wirelessly contains a start-address and the actual 8 values starting at this address. The sender just sends the package without requesting any handshake from the receiver. This is called the broadcast mode of the nRF24L01+ modules that enables to use multiple receivers.

The receivers

The receiver only needs a single DMX buffer. All data from the incoming packages is directly taken into this buffer.

The DMXSerial library is used to send this information using the DMX protocol.

Setup the hardware

Both, the sender and the receivers need the DMX interface hardware attached to the serial interface and a nRF24L01+ module attached to the SPI bus. A prototype for this setup I used is the DMX Shield I published and a hand-soldered nRF24L01 adapter. The DMX shield is not forwarding the ICSP pins yet so this will only work on the Arduino UNO and older boards. (See discussion in Arduino Shield for NRF24L01+ post).

You need 2 of these at minimum.

Setup the software

Now you should be able to open and compile the provided sketches and upload them to the Arduino hardware.

The sketches I can provide for now are working in my environment and are not yet optimal for rough environments like stages. There are still some optimizations to do like sending smaller or larger packages and testing different transfer speeds. I like to get feedback from you.

Links

26 August 2013

DMXSerial Update

I just updated the Arduino Library for DMX with some improvements in memory and speed as well as some minor changes.

Thanks to Jenny for the hints.

If you use this library please download the newest version from: http://www.mathertel.de/Arduino/DMXSerial.aspx

24 August 2013

Arduino Shield for NRF24L01+

Here is the picture of a brand new Arduino Shield for the NRF24L01 on top of an Arduino UNO:

NRF24L01Shield.v01

It’s the first version and it works :-) so I finally soldered a transceiver directly onto it.

Signal layout

The signals for the SPI bus come from the ICSP connector to make it compatible to Arduino boards that do not have the classic ATmega328 (2009, UNO) but use other processor ICs like Leonardo, Mega. Here the MIIS, MOSI and SCK signals are not D12,D11 and D9. Using the ICSP connector is compatible.

The CSN and CE signals can be connected to pin D7 and D8 by using little solder drops on top of the shield that you can see on the right. Using these 2 pins because they do not conflict with other cards I use (Ethernet, SDCard). Initialize the RF24 radio class by using:

RF24 radio(7,8);

If other pins must be used, the 2 solder pads can be kept open and some wires can be used to pass the signals.

The IRQ signal is available on pin D3 the same way, but I don’t use it yet.

The rest of the shield has a permanent breadboard layout for small robust implementations.

In the back you can see another connector for I2C bus that I use to connect other hardware like LCD panels.

Prototypes:

Before I had 2 versions in place that I made. The first one was a “flying” transmitter that was perfect for finding the right pins and setup. The second one is sitting on top of an DMX shield.

NRF24L01_Proto1NRF24L01_Proto2

See also:

Hints on using NRF24L01+ with Arduino

This is a first version of a NRF24L01 shield, especially the breadboard it not perfect. I ordered more than I need so if you are working on a NRF24L01 project and like to have one – let me know. (first come first serve)

01 July 2013

Another DMXSerial example

The DMXSerial library for the Arduino that you can find at http://www.mathertel.de/Arduino/DMXSerial.aspx has only 2 small examples that show the principle functionality of the DMX library:

  • DMXSerialRecv implements a 3 channel DMX device on channel 1-3 and sends the data to the PWM output pins 9, 6 and 5.
    It also shows the usage of the DMXSerial.noDataSince method.
  • DMXSerialSend implements a 3 channel DMX Controller sending a continuously changing color schema to the channels 1 to 3.
    Here an array of color definition is used and the implementations adjusts the current color smoothly into the next color from the arrays.

Now there is a new example available:

DMXSerialFlow implements a 60 (20*3) channel DMX Controller sending a continuously changing colors schema to the channels 1 to 3.

The calculation of the colors is done by using a hue to rgb converter.

Hue is a number from 0 to 764 that represents one of the colors of a color wheel. With a simple algorithm it is possible to calculate the red,green and blue component of it.

There are some hints inside the code that allows you to make some changes for example the speed of the color changing.

This example was used for testing a wireless 2.4 GHz DMX transceiver that I am working on right now. Stay tuned :-)

19 May 2013

Update for the DMXSerial library

There is a significant update for the DMXSerial library on my web site that enables programming DMX devices on ARDUINO MEGA boards and ARDUINO Leonardo boards using the DMXSerial library.

The original library was written for Arduino 2009 and Arduino UNO boards that use the ATmega328 or ATmega168 chip. These chips only have a single Universal Synchronous and Asynchronous serial Receiver and Transmitter (USART) a.k.a. the Serial port in the Arduino environment. The DMXSerial library uses this port for sending or receiving DMX signals.

This conflicts a little bit with the usage of the programming mode the Arduino offers through then USB ports or serial interfaces but it is possible to build compatible DMX shields that don’t interfere with this usage if done right. The DMXShield is an example of this.

Arduino Leonardo

The Arduino Leonardo board uses a chip that has a USB 2.0 port available in addition to the USART. Therefore the “Serial” port is routed through the USB port that behaves like a serial port device and not the built-in USART. If you like to address the real Serial port you have to go with the Serial1.

But if you look at the hardware and the registers directly the USART0 still exists but the definitions for addressing the registers have changed (for example USART_RX_vect is now USART0_RX_vect). Therefore some adjustments had to be done.

With this board you can write debugging information to the Serial port in your sketch for debugging or data exchange purpose. So maybe a DMX diagnostic sketch can profit from that.

Arduino MEGA 2560

When using the chip on the Arduino MEGA 2560 board you have more than one USART available and maybe you wish to use port 1 instead of port 0. This can be done by enabling the definitions for port1 in the library just uncomment the line

#define DMX_USE_PORT1

ATmega8 boards

I added the definitions of boards based on the ATmega8 too for experimental purpose. If you find problems with these boards, leave me a note please.

Thanks to Bob Lynas to support me.

Available

The updated version is available on my site at: http://www.mathertel.de/Arduino/DMXSerial.aspx.

30 April 2013

RGB pixels from 1998

Last year I saw these fluorescent lamps from the Omega company that were used to display huge “bildboard” signs.

No, blue LEDs have not been evented yet.

20120609_10300820120609_10303020120609_103054

14 April 2013

Hints on using NRF24L01+ with Arduino

I like to share some liks to the ressources on the internet that I found helpful for implementing projects using the Ultra low power 2.4GHz RF Transceiver NRF24L01+ with the Arduino platform.

The chip specifications

The NRF24L01 (no + at the end) was replaced by the NRF24L01+ (or sometimes called NRF24L01P). Be sure to get the new chip when buying an breakout board.

The nRF24L01+ is drop-in compatible with nRF24L01 and on-air compatible with nRF2401A, nRF2402, nRF24E1 and nRF24E2. Intermodulation and wideband blocking values in nRF24L01+ are much improved in comparison to the nRF24L01 and the addition of internal filtering to nRF24L01+ has improved the margins for meeting RF regulatory standards.

The old chip: http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01

The new chip: http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01P

You should read the nRF24L01+DataSheet, even if it is long and with many details – but that’s what you will need: http://www.nordicsemi.com/eng/content/download/2726/34069/file/nRF24L01P_Product_Specification_1_0.pdf

About ShockBurstTM

This is a nice to read whitepaper with a description of the ShockBurstTM transfer features of the chip:

http://www.semiconductorstore.com/pdf/NewSite/nordic/WP_nRF240x_ShockBurst.pdf

Arduino compatible Libraries for NRF24L01

There is no official “Arduino” library that is maintained by the core Arduino team so you have to look for the available libraries on the internet.

The  web site http://www.tinkerer.eu/ from Stefan Engelke in 2009 provides a native NRF20L01 library, the original MiRF library (not Arduino specific) and a native SPI library See http://www.tinkerer.eu/AVRLib/nRF24L01, and http://www.tinkerer.eu/AVRLib/SPI . I mention this library because it uses interrupts that most Arduino samples don’t.

The MiRF library was ported to the Arduino platform and is using the Arduino SPI library and is described on the arduino playground article: See http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

J. Coliz (a.k.a. maniacbug) implemented a ARDUINO specific library often called the RF24 library. Its available at https://github.com/maniacbug/RF24/ and was used as the base for implementing other libraries (see below) the last commit to this projects was last on 2012/06/23.

Greg Copeland forked (copied over) the library from maniacbug and added some useful stuff including a scanner sample application. He is currently (2013.04.09) supporting his work. See https://github.com/gcopeland/RF24.

Arco van Geest (a.k.a. gnulnulf) also forked the library from maniacbug is currently adding support for the Raspberry Pi. See https://github.com/gnulnulf/RF24

Stanley Seow forked the version gnulnulf https://github.com/stanleyseow/RF24 also working on upport for the Raspberry Pi.

Critics

There are too much libraries out there for my opinion and those starting from J. Coliz are using the GNU General Public License (not LGPL) and therefore are not compatible with the Arduino license policy.

J. Coliz also used the stdio.h printf() functionality ??? causing more usage of the program memory

For my personal projects I used the library from Greg Copeland for my first steps to discover the functionality of the chip.

 

 

 

Samples and Projects

Poor Man's 2.4 GHz Scanner:
http://arduino.cc/forum/index.php/topic,54795.0.html

Home Automation – Designing a remote module:
http://geekboy.it/projects/home_automation/home-automation-design

Sample without using a library:
http://blog.iteadstudio.com/nrf24l01-wireless-module-with-arduino/

A sample using the MiRF library:
http://www.bajdi.com/playing-with-nrf24l01-modules/

Step-by-Step introduction using the RF24 library:
http://arduino-info.wikispaces.com/Nrf24L01-2.4GHz-HowTo

Network Layer for RF24 Radios:
http://maniacbug.github.io/RF24Network/index.html

A very detailed tutorial in German:
http://www.mikrocontroller.net/articles/NRF24L01_Tutorial

Other Stuff

These links are not related to Arduino itself but when reading you may also find some interesting information.

...

07 April 2013

Update to the OneButton Arduino library

I wrote this small Arduino library more than 2 years ago for some of my projects to use a single input button for multiple purposes. This library detects clicks, doubleclicks and long press situations without a lot of coding on the sketch side.

This enables you to reuse the same hardware button and input pin for several functions and lowers the hardware invests.

I just updated it including a new sample that shows how to setup the library and bind a "machine" that can blink the LED slow or fast.

See Arduino OneButton Library on my side.

06 April 2013

Using the SPI bus with Ethernet, SD-card and NRF24L01 and other slave devices together

I currently work on an project using the popular NRF24L01 module where I came across the question how to avoid conflicts of new designs and existing Arduino boards.
The problem when using the W5100 based Ethernet shield including the  SD Card adapter and the NRF24L01 Modules together with a Arduino UNO board is that all of them are using the same SPI bus for the data transfer to the chips. Here is an overview of how to make them work all together.
Here the master is always the same ATMEGA328 chip on the Arduino board and the 3 chips are slave devices.

The SPI bus concept

A brief explanation of the SPI bus can be found on wikipedia. See http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
The SPI bus needs 4 signals to work:
SCK or SCLK (serial clock) The clock signal that sets the tempo for any data transfer. This signal is generated by the master chip.
On the Arduino Uno this signal is available on pin 13 and ICSP 3.
MISO (master input, slave output) This signal line transfers the data from a slave device to the master chip.
On the Arduino Uno this signal is available on pin 12 and ICSP 1.
MOSI (master output, slave input) This signal line transfers the data from the master to the slave devices.
On the Arduino Uno this signal is available on pin 11 and ICSP 4.
SS or CSN (Slave Select) This signal makes a slave active by selecting it with a low signal.
On the Arduino Uno this signal has to be discussed…
Remark: The signal lines SCK, MOSI and MISO are also available on the ICSP header, see below.
The signal lines SCK, MOSI and MISO can permanently remain connected to all participating chips. However the Slave Select signal has to be different for every device.

Advantages in using the ICSP header

The SPI signals on an Arduino Mega board are not available on the pins 10, 11, 12 and 13 because this board uses another processor. But because programming an ATMEGA chip through the ICSP is internally also using the SPI interface, the signals are available on the ICSP header too. With the Arduino Ethernet Shield Version 06 the design has changed so that the SPI signals are not taken from the pins 11, 12 and 13 but from the pins ISP 4, 1 and 3. If you use an Arduino UNO or 2009 however these pins are connected on the main board.  When designing new shields for Standard and MEGA boards with SPI usage I recommended using the ICSP header like the Ethernet Shield does.

Pin 10

The Arduino pin 10, also labeled SS, also known as PB2 for ATMEGA328, is used by ATMEL to indicate whether the processor is used as an SPI master or slaver device. That pin 10 must remain an output or the SPI hardware will go into 'slave' mode.
Using this pin 10 for example on the Ethernet Shield is fine, but if you use other SPI slave devices, keep in mind to no use this pin for input purpose – better don’t use it to avoid conflicts.

Using multiple SPI bus slave devices

When using multiple slave devices on the same SPI bus there is no principle problem with the lines SCK, MOSI and MISO. Because every slave device needs its own slave select signal there are conflicts using the available Arduino pins. When you stack multiple ARDUINO shields on a single Arduino board you may also have conflicts with other pins the shield uses so you have to take care of other conflicts too. Here are some common pin usages:

Arduino Shield Salve device Arduino Pin
Ethernet version 01 W5100 chip Slave Select 10
Ethernet version 06 W5100 chip Slave Select 10
Ethernet version 06 SD card Slave Select 4

Using a NRF24L01 radio module

In different samples where the NRF24L01 radio is using the Arduino pin 9 for SS and using pin 8 for the Chip Enable signal but also 8 and 7 is used in same samples. There is no standard definition right now and therefore you have to tell the NRF24L01 library what signals to use for Slave Select and Chip Enable.
I personally recommend using 7 for Chip Enable and 8 for Slave Select because the pin 9 is one of the possible PWM output pins. When designing new Shields these pins assignments should be changeable in any way, just to be friendly to other shields… and having the chance to settle conflicts.

More Readings:

Design of the Arduino Ethernet Shield: http://arduino.cc/en/Main/ArduinoEthernetShield

Using the SD-Slot on the EthernetShield with Hardware SPI: http://playground.arduino.cc//Main/EthernetShieldSDHardwareSPIMod General tutorial: http://tronixstuff.wordpress.com/  About the NRF24L01: http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

08 March 2013

DMX RDM library DMXSerial2 Version 1.0 released

I just published the version 1.0 of the DMX RDM library as an Arduino library with sample code.

Download the file from http://www.mathertel.de/Arduino/DMXSerial.aspx, unzip the file to your Sketches\libraries and try the example in libraries\DMXSerial2\examples\RDMSerialRecv.

The hardware requirements for that sample is a DMX line attached to the serial port, the data direction switch at pin 2 and some led to the ports 5, 6 and 9.

The schema of the DMX shield documented in http://www.mathertel.de/Arduino/DMXShield.aspx can be used as well.

Any feedback is welcome.

01 March 2013

DMXSerial2 Update

The first versions (up to version from 22.01.2013) of DMXSerial2 was not stable during several tests I did and often a response package did not reach the controller as expected.

After some testing with inserted delayMicroseconds() functions and time probes in several places I found that the implementation with the Arduino processor and the DMX Shield was sometimes too fast for the used controllers and the DMX line.

In several publications for example in http://www.soundlight.de/techtips/dmx512/dmx_rdm.htm you can find the timing requirements defined by the RDM standard and it seems that it is very important to follow them strictly.

The one timing condition that is indeed implemented by the RDM client is the time between the end of a RDM command that is sent by the controller and the start of the RDM response that is sent by the client.

Because the answer to a command is created asynchronously in the tick() function this time was varying and was often shorter than the expected minimal 176 µsec .

The version from 01.03.2013 and later now saves the time when the last byte of a command was sent into a global variable and delays the start of the answer when appropriate. After implementing this delay mechanism the RDM communication was much more stable then before.

And there is the RDM-BREAK that is longer than the DMX-BREAK: min. 176 µsec instead of 88 µsec.

I published the updated Arduino project today. It’s still work in progress and a library format will be available soon.

See http://www.mathertel.de/Arduino/DMXSerial2.aspx

22 January 2013

New DMX RDM Library for Arduino available

I just published an new Arduino project on my web site that implements an DMX RDM Device using the DMXShield.

From the beginning the DMXSerial library was designed to send and receive DMX data packets. Now it is extended to support RDM packets as well. I had to overcome several pitfalls and stumbling blocks while extending the DMXSerial implementation and I will keep the current version because it needs only a very small amount of program data. The RDM extended version will be DMXSerial2.

What you can find in the attached zip file right now is an ARDUINO project including all the files you need to compile. Because it is still in WIP (work in progress) I did not extract the DMXSerial2 files into a library format yet.

see: RDM Library for Arduino (DMXSerial2)

10 January 2013

DMX Shield for Arduino is also working with RDM

DMX Shield for Arduino

The last weeks I spent some time in extending the DMXSerial library for Arduino to support the DMX - RDM protocol by using the DMX Shield for Arduino.

A prototype version (proof of concept state) is already working. So now I know that the layout of the shield is RDM compatible.

But there is still some work to do for the library. I’ll try to publish a new version of the DMX library in some weeks.

If you are interested in co-working please let me know.