I/O Device Drivers and HAL

The DCC++ EX controller has always had built-in support for turnout control, output control and input sensors attached to the Arduino pins. However, you may outgrow the built-in capabilities and want to access more output pins than the arduino has available. Or you may wish to attach servos to the controller for turnout control or for animating a layout component, such as the doors to an engine shed.

DCC++ EX, as of version 3.1.7, provides support for a wider set of input and output devices than previous versions. This is thanks to a piece of software called the HAL or Hardware Abstraction Layer. The HAL provides support for a range of different input and output modules through drivers that are supplied with DCC++ EX. In addition, its simple interface allows engineers and tinkerers to add new plug-in device support to DCC++ EX without having to change a line of the core application code.

The HAL exposes a standard set of functions which the rest of DCC++ EX code is able to call upon, and the HAL directs the calls to the appropriate device driver. The specific device end-points are given by a kind of pin number, called a Virtual pin or VPIN. Any module has one or more VPINs associated with it.

When DCC++ EX code needs to write to an Arduino digital output pin, the output is uniquely identified by a pin number. The Arduino Mega has digital I/O pin numbers ranging up to 69. For example, you may set up an Output in DCC++ EX using the <Z 1 40 0> command (id=1, pin=40). Then the command <Z 1 1> will set pin 40 HIGH and <Z 1 0> will set pin 40 LOW.

The HAL extends this model to other devices. If you want to write to a digital output pin on an external GPIO Extender Module, then you do exactly the same thing, but the pin number identifies a virtual pin number associated with an extender module. The call is passed to the driver software for that module, and a command is sent to the module to modify its pin state. DCC++ EX does not need to know what type of device it is, or what low-level commands are necessary to operate it. It just sends an instruction for the pin to be set on or off. If you want to reposition a servo, the same function is called, but with a VPIN number that identifies a pin on a servo controller module; consequently, a command is sent to the servo control module to move the servo to the appropriate position.

The same principle applies to Sensors (inputs). You can configure a sensor object on DCC++ EX by using the command <S 2 40 1> command (id=2, pin=40, pullup=enabled). When pin 40 is connected to 0V (ground), a message <Q 2> is generated, and when it is disconnected, <q 2> is generated. But if you have an MCP23017 GPIO Extender module connected up, and you replace the pin number 40 with 164 (the number of the first pin on the MCP23017), then you will get the messages when the MCP23017 pin is connected to 0V or disconnected.

So how are these ‘VPINs’ configured?

The standard DCC++ EX build for an Arduino Mega already contains support for four external modules, two GPIO Extender modules and two servo modules. The GPIO Extender modules are MCP23017 modules which each have 16 pins that can be configured as inputs or outputs. The Servo modules are PCA9685 modules which each have 16 pins that each provide a pulse-width-modulated signal that may be used to control a servo. That’s sixteen independently controlled servos on each module.

If you need more modules, then they can be added from a user-specific configuration file, as described further on.

IMPORTANT NOTE The Arduino Nano and Arduino Uno both have very limited FLASH program space and RAM memory, compared to the Arduino Mega. The rest of the DCC++ EX code takes up most of the FLASH program space, and so there is very little spare for any HAL code. Consequently, when DCC++ EX is compiled for a Nano or Uno, a reduced HAL is included in place of the full HAL. This provides limited functionality and supports only for the Arduino digital input and output functions and analogue input functions. No advanced drivers (Servos, external GPIO etc.) can be installed. It is theoretically possible to create an ‘on-line only’ version of DCC++ EX which excludes the loco programming functions and therefore frees up FLASH on the Uno and Nano to allow the full HAL to operate, but this is not currently supported.

Catching the I2C Bus

Many of the external modules are connected to the Arduino via the I2C (Inter Integrated Circuit) interface. This has four connections, usually labelled SDA (data), SCL (clock), VSS (+5V power usually) and GND (ground, or zero volts). Your motor shield may have convenient connectors for I2C devices; for example, the DeekRobot shield has two sets of four I2C pins on the top. If not, then check the Arduino’s data sheet to find the applicable I2C and power connections. For an Arduino Mega, SCL and SDA are the two connectors nearest the reset button, in the connector block running along the edge of the Arduino.

WARNING There is no standard pin order for the I2C bus connectors, so be careful that you identify which pin is which, and always connect SDA to SDA, SCL to SCL, GND to GND and VSS/+5V to VSS/+5V.

All I2C devices are connected in parallel to this bus, and when the Arduino sends commands, all attached devices receive them. However, only a device with a matching address will respond. Each device attached to the bus should have a unique address.

Pull-Ups

The I2C bus requires pull-up resistors in order for it to operate. However, most I2C modules contain 10kOhm pull-up resistors built in, and the Arduino also has built-in pull-up resistors which are sufficient for installations with short bus cables, so you don’t have to be concerned about this unless you’re really pushing the envelope!

For example, if you have 6 or more I2C modules connected to the same bus, you may need to remove the built-in pull-up resistors from one or more of them since the minimum permitted pull-up is generally 1.7kOhm (at 5V supply), to avoid too much current flowing. Also, if your I2C bus cable is long then a pull-up value closer to the minimum is desirable.

Identifying What Devices Are Connected

During the startup phase of DCC++ EX, the I2C bus is queried to identify what (if any) devices are connected. The list of active I2C addresses is shown on the serial output during startup. An example is shown below, with annotations. Note that the address does not necessarily tell you what the device is, since different modules may have the same default address.

<* License GPLv3 fsf.org (c) dcc-ex.com *>
<* I2C Device found at x20 *>    -- GPIO Extender device
<* I2C Device found at x3C *>    -- OLED display
<* I2C Device found at x40 *>    -- PWM (Servo) Control Module
<* I2C Device found at x48 *>    -- 4-pin Analogue Input Module

MCP23017 Modules

The MCP23017 GPIO Extender module has 16 input/output pins. Like the Arduino input/output pins, you can access any of these in input mode (as a sensor input) or output mode (driving a digital output and illuminating an LED or switching some external hardware). Each module has an address associated with it, which is generally either 0x20, 0x21, 0x22 or 0x23. By default, the module is usually 0x20. The address will only need to be changed if you have more than one module, in which case the second one will have to be set to address 0x21, usually by moving jumpers on the module or by soldering across pads on the circuit board. Refer to the documentation for your own board for details.

When used for inputs (sensors or switches), the sensor/switch is usually connected between the nominated pin and the GND (ground) signal. When the sensor/switch activates, it usually connects the pin to GND, and the device detects a small current flow. When the sensor/switch deactivates, the current stops flowing. This is just the same as the Arduino digital GPIO pins.

Two MCP23017 modules are pre-configured, one is address 0x20 and uses VPINs 164-179. The second is address 0x21 and uses VPINs 180-195.

An input pin may be configured using the DCC++ EX Sensor commands, as follows:

<S 201 164 1>

This command associates sensor ID 201 with VPIN 164 (MCP23017 first pin) and enables pullup.

When the sensor activates and deactivates, the following messages are sent by DCC++ EX over the serial output:

<Q 201>         -- Activation
<q 201>         -- Deactivation

PCA9685 Modules

The PCA9685 PWM (servo) controller module has 16 input/output pins. In addition, next to each PWM pin is a +5V and a GND pin, so that a servo connector may be directly plugged onto the group of three pins. Even better, the pins are usually colour-coded to match the colours of the servo cables!

Like the MCP23017 module, each PCA9685 has an address. The default address is 0x40, and may be changed to 0x41, 0x42 or 0x43 for the second, third and fourth module on the bus.

Servos contain motors, and so may draw more power than the Arduino can support. Therefore, the PCA9685 module usually has a block connector allowing connection of an external 5V power supply, to power the servo motors. If this power isn’t connected and on, then the servos won’t move.

Two PCA9685 modules are pre-configured, one is address 0x40 and uses VPINs 100-115. The second is address 0x41 and uses VPINs 116-131.

A servo turnout may be configured using the DCC++ EX Turnout commands, as follows:

<T 301 SERVO 100 410 205 2>

This command associates turnout ID 301 with VPIN 100 (PCA9685 first pin). When the turnout is ‘thrown’, the PWM position is set to 410. When the turnout is ‘closed’, the PWM position is set to 205. The movement of the turnout is Medium speed (2). The movement profile may be 0 (Immediate), 1 (Fast=0.5 sec), 2 (Medium=1 sec), 3 (Slow=2 sec), or 4 (Bounce profile for semaphore signals).

Many references quote a PWM pulse length of 1ms to 2ms, which corresponds to PWM values of 205 to 410. However, I’ve found, with SG90 servos, that 102 to 490 gives a full servo sweep of nearly 180 degrees. But use with care, as an attempt to position a servo outside of its range may cause damage to the servo gearing, or to any layout components you have connected to the servo!

<T 301 1>  -- Instructs the turnout to move to the 'thrown' position.
<T 301 0>  -- Instructs the turnout to move the the 'closed' position.

In EX-RAIL, the servo can be controlled directly via the SERVO(pin,position,profile) or SERVO2(pin,position,duration) commands.

Good to know: The PCA9685 is not only used for servos. It generates pulses of variable mark-to-space ratio, with a value of 0 being full off, and 4095 being full on. So it can be used to control an LED to different brightness levels. the EX-RAIL automation has a command FADE(pin,value,ms) which operates the PCA9685 to do exactly this.

Other Drivers

There are also drivers included with DCC++ EX for the following modules:

  • PCF8574 - 8-channel GPIO extender module, like the MCP23017 but fewer inputs/outputs (I2C).

  • MCP23008 - Another 8-channel GPIO extender module.

  • DFPlayer - MP3 Media player with microSD card holder. You can play different sounds from the player by activating or de-activating output VPINs from within DCC++ EX.

  • ADS1115 - Four-channel analogue input module (I2C). Also designed to work with the ADS1113 and ADS1114 single-channel modules.

  • VL53L0X - Laser Time-Of-Flight (TOF) range sensor (I2C). Its VPIN activates when a reflecting object is within a defined distance of the sensor.

  • HC-SR04 - Ultrasound ‘sonar’ range sensor. Its VPIN activates when a reflecting object is within a defined distance of the sensor.

Adding a New Device

If you want to add a device that is not handled by DCC++ EX ‘out-of-the-box’, then you will need to create a device configuration file, with details of the device driver and how to access the device.

DCC++ EX already has a few useful device drivers for different types of sensors, and new ones are appearing regularly. The device drivers can be installed in DCC++ EX just by adding them to the configuration file, using the steps shown below. No change is required to the DCC++ EX base code in order to do this, the device driver is configured in a user-specific configuration file.

Many device drivers are completely contained within an “#include” file, with a “.h” file extension. Some may also have one or more “.cpp” files too. You need to ensure that the driver files are present in the DCC++ EX source file folder. If you have received them from another source, then copy them to this folder.

Many of the driver “.h” files also include a description of how the driver operates, and what configuration lines are required in order to use it, together with examples. If you can’t find documentation elsewhere, then check at the top of the “.h” file.

Now you need to create a configuration file to include the device driver in the build. You can either copy the supplied file mySetup.cpp_example.txt to mySetup.cpp and then edit it, or you can create a new mySetup.cpp from scratch. In fact, the file can have any name you like. You could use AA_setup.cpp for example, then it will appear at the beginning of the list of files in the Arduino IDE.

Adding A New Device Configuration File

This will need to be done in the Arduino-IDE, so first make sure you have followed these steps to load up the Arduino IDE.

Create a new tab

First you will need to add a new file, just like the config.h file. Create a new tab using the following menu option.

Arduino IDE New Tab

Figure 1 - Creating a new tab in the Arduino IDE

Creating the mySetup.cpp file

At the bottom of the IDE window, a yellow bar will appear asking for a Name for new file, here make sure to enter mySetup.cpp (case sensitive, so upper case S in setup) and click OK to create the new file. [The screen shot shows mySetup.h, so be sure to enter mySetup.cpp.]

Arduino IDE New Tab

Figure 2 - Choosing a file name for the new file, use mySetup.cpp

Adding in the configuration commands

Within the new file that has been created, you can add in the definitions of new devices. But first you need to add the following lines:

#include "IODevice.h"

void mySetup() {
  // Insert your commands here...

}

Suppose you want to add a driver for the DFPlayer MP3 Player. This module is widely available for a few dollars and allows MP3 files to be played from a Micro-SD card (up to 32Gb). The module is connected to an Arduino serial port, for example on the Mega the pins TX1(14)/RX1(15) which is Serial 3. Connect the DFPlayer’s RX to the arduino TX3 (14) via a 1kOhm resistor, and DFPlayer’s TX direct to the Ardino RX3 (15). You also need to connect +5V power to VCC, and GND on the Arduino to GND on the DFPlayer. Connect a small speaker to the pins SPK1 and SPK2 on the DFPlayer, and that’s the hardware set up.

Copy a few MP3 files to a Micro-SD card. The order in which you copy them is important, as the first file copied is referenced as file 1, the second as file 2, etc. The names of the files are not used, but best keep them below 8 characters (excluding the .mp3 file extension). Don’t include any other files (.txt etc) on the card, including hidden files - the DFPlayer may find them and attempt to play them! When you’re done, insert the card into the DFPlayer.

Now you’re ready to set up the software.

Add the following line to the top of the mySetup.cpp file:

#include "IO_DFPlayer.h"

This makes the driver software for the DFPlayer known to the compiler. Now add the following line within the curly braces of the mySetup() { } function definition:

DFPlayer::create(1000, 5, Serial3);

This instructs the HAL to create a driver for the DFPlayer module configured to communicate on Serial3, and allocates 5 virtual pins (VPINs) to interface with it.

Upload the new version of the software

Finally, upload the code to the Arduino as you would do during the standard Arduino IDE Setup. Restart the Command Station and the new device will be configured at startup.

Checking the Driver

Start the Arduino IDE’s serial monitor program, and set its speed to 115200 baud. If you enter the following command:

<D HAL SHOW>

You will see a list of the configured devices, and among them should be the new device, as follows:

<* Arduino Vpins:2-69 *>
<* PCA9685 I2C:x40 Configured on Vpins:100-115 *>
<* PCA9685 I2C:x41 Configured on Vpins:116-131 *>
<* MCP23017 I2C:x20 Configured on Vpins:164-179 *>
<* MCP23017 I2C:x21 Configured on Vpins:180-195 *>
<* DFPlayer Configured on Vpins:1000-1004 *>           <<== New device

Using the Device

The five VPINs, 1000 to 1004, allow the first five MP3 files on the Micro-SD card to be played directly. You just need to write to the pins as if they were real digital output pins on the Arduino. For example, set up some outputs using the Arduino IDE’s serial monitor program, by entering the following commands:

<Z 1000 1000 0>
<Z 1001 1001 0>
<Z 1002 1002 0>
<Z 1003 1003 0>
<Z 1004 1004 0>

Now you can trigger any of the five MP3 files by using one of the following commands:

<Z 1000 1>
<Z 1001 1>
<Z 1002 1>
<Z 1003 1>
<Z 1004 1>

To stop the player, use <Z 1000 0> etc.

You may also control the player by writing to the VPINs as analogue output capable pins. Try the following commands:

<D ANOUT 1000 5>        // play MP3 file number 5.
<D ANOUT 1000 4 10>     // play MP3 file number 4 at low volume (10).
<D ANOUT 1001 30>       // set volume to maximum (range 0-30).
<D ANOUT 1001 10>       // set volume to low.

Note: The volume commands apply to the device, not to the specific MP3 files.