Typically, these projects are done in a staged approach where an initial prototype is designed and built. This prototype can then be used to secure funding for additional stages of design, as well as ensure the product meets all of the requirements.

For this type of rapid design and prototyping, we often utilize the Arduino platform.

What’s Up With Arduino?

Arduino’s come in a variety of configurations targeted at various Performance, IO, and Communication Requirements, so there is usually a model that has already been tried and tested that would work for your specific application. Arduino also provides a free IDE and C style programming language that allows you to start running custom code within a matter of minutes.

However, once your program starts to stretch beyond a few hundred lines of code, or across more than a handful of files, the IDE can start to become cumbersome and difficult to work with, especially if you’re used to more advanced IDE’s or text editors. After dealing with the annoyances of the Arduino IDE for years, I’ve finally upgraded to a more user-friendly option: Visual Studio Code.

What is VSCode?

Visual Studio Code, or VSCode, is an open source, lightweight, extensible text editor, that is designed and supported by Microsoft, and runs on Linux and Mac in addition to Windows. The extensibility allows you to write extensions to customize VSCode to best suit your needs, and programming language.

With a broad user base, there are a lot of free extensions already available, including an extension to support Arduino programming without ever leaving the VSCode editor. VSCode is designed to handle multiple folders and files within the editor and utilized Microsoft’s IntelliSense auto-completion tool to help speed up your programming and reduce typos.

Using VSCode for Arduino Projects

To start using VSCode for your Arduino projects, follow the steps below.

Step 1 – Download and Install Drivers

VSCode uses the drivers that are installed with the Arduino IDE, so we need to download and install that first.

1. Download the IDE for your OS.
   
   
    
2. After the download is complete, run the installer, leaving all the default selections and options.
   
   
    
3. Be sure to install the COM port and USB drivers if prompted.
   
   

Step 2 – Download VSCode

1. While the Arduino IDE is installing, download VSCode.
    
2. After the download is complete, run the installer.
   
   

Next Steps

I recommend the following configuration for the additional tasks during the install.

1. Once installed, Launch VSCode.
    
2. Click the Extensions button on the left side of the editor, (or Ctrl+Shift+X) to display the extension marketplace.
   
   
    
3. Type Arduino in the search bar, to filter the extensions to only those related to the Arduino platform.
    
4. There are a few extensions available for Arduino, but I prefer the one supported by Microsoft.
    
5. Click the Install button and when prompted allow installation of dependencies.
    
6. Click the Reload button to relaunch VSCode with the Arduino extension enabled.
   
   
    
7. Depending on your firewall settings, you may be prompted to give VSCode firewall access.
   
   

Programming in VSCode

One more Reload and now, we’re set to start programming. To make sure everything is installed properly, we’ll start by opening up the example Blinky.

Open VSCode’s Command Palette with Ctrl+Shift+P. Once the command palette is open, you can start typing to filter all the options or to search for useful commands.

1. Open the Command Palette and type Arduino, and select Arduino:Examples in the results list.
   
   

2. In the new pane to the right, select Built-in Examples>>01.Basics>>Blink. By default, this will open a new VSCode window, with the Blink sketch and a Blink.txt help file listed in the explorer pane on the left.
    
3. Select Blink.ino from the explorer pane to open the sketch in the editor.
    
4. Connect your Arduino board to your computer, and then, in the bottom bar of VSCode, you can specify the COM port for your Arduino and the board type.
   
   
    
5. Clicking COM opens a small selection window at the top of VSCode that should display your connected Arduino.
   
   
    
6. Clicking <Select Board Type> opens a new pane on the right where you can select the board type. If various configurations are available for your board, then you need to specify those as well. I’m using the Arduino Mega with the ATMega-2560.
   
   
    
7. Open the Command Palette again (Ctrl+Shift+P) and type Arduino:Upload (Ctrl+Alt+U) to upload the Blink sketch to your Arduino. You should see LED13 start blinking about once per second.

Now you’re all set to start writing new Arduino sketches in VSCode and enjoy the features of a more advanced text editor. Learn more about DMC’s Embedded Development and Embedded Programming or Contact Us to get started on a project today.

The post Arduino Programming with VSCode appeared first on DMC, Inc..

Easy, right? Many PLCs already support RS485 and Modbus communication and only require a few functions blocks.

There is a twist, however. The devices with which the PLC is communicating are Arduinos. Lots of them.

So, how can you program an Arduino to act as a Modbus device?

Turns out the answer is easy.

In this post, I’ll talk about adding an Arduino to an RS485 network and programming it to function as a Modbus slave device.

How an Arduino can Speak over an RS485

First, let’s talk about Arduino and RS485.

Although Arduino supports serial communication through its built-in UART (Universally Asynchronous Receiver/Transmitter), it uses TTL (Transistor-Transistor Logic), not RS485. Both signaling types use serial communication. Serial communication means data is sent one bit at a time at a specified BAUD rate (bits per second). 

However, TTL is single-ended, whereas RS485 relies on a differential signal (what’s the difference?). This is far more useful in an industrial setting where signals can be influenced by electrical noise, and devices can be separated dozens or hundreds of meters.

To allow an Arduino to speak over an RS485 network, an additional device must be used to convert TTL to RS485. There are several devices on the market that do this, but I used this RS485 Transceiver Breakout Board.

Hardware Set-Up and Serial Ports

This picture shows my hardware setup.

Because I’m using an Arduino Mega, 4 serial ports available. If you are unsure how many ports you have, the Arduino website provides a description of serial ports on all board models.

Did you run out of Serial ports? Don’t forget about Software Serial!

Great! Your Arduino is now networked to the PLC (or another master device) and other non-master devices.

Installing Arduino IDE

Next is software. I’ll be using the Arduino IDE for software development.

Although Modbus was developed in 1979, it has stood the test of time and is proven to still a reliable industrial communication protocol. You may choose to write your own C++ library implementation of Modbus, but I opted to use a prewritten library.

A quick Google search yields several options. I chose this one.

Include ModbusRtu Library

The first step is to include the ModbusRtu library in your sketch.

The Modbus constructor takes three parameters:

1. Slave Address – this is the Modbus address that the master device will use to make specific queries. In other words, it’s how other devices in the network know who is talking. The address can be any number between 1 and 247; address 0 is reserved for the master. It’s important to ensure there are no duplicate addresses on the network.

2. Serial Port – this tells the library which Serial port to use. Here is the list of options, depending on the number of ports available on your Arduino model:

   0 = Serial

   1 = Serial1

   2 = Serial2

   3 = Serial3

   4 = SoftwareSerial

3. TX Enable Pin – because this is a 2-wire RS485 network, it is only half duplex. Half duplex means that a device can only receive or transmit at a time. By default, the Arduino is in receive mode. Setting the TX enable pin high allows the Arduino to transmit data.

Modbus_array Example

Below is example code that shows how we can use our newly created RS485 network and Modbus library using a very simple (and probably unrealistic) scenario.

In this scenario, our Arduino is hooked up to a toggle switch and an LED. We have an operator who wants to know the state of the switch (on or off) and the ability to remotely toggle the LED. What should we do?

First, look at how the Modbus library function that allows for reading and writing:

Modbus::poll(uint16_t *regs, uint8_t u8size)

Modbus::poll(uint16_t *regs, uint8_t u8size)

*regs is a register table used for communication exchange, and u8size is the size of the register table.

This method checks if there is an incoming query in its serial buffer. If there is, the library will validate the message (check the device address, data length, and CRC) and subsequently perform the correct function.

In other words, to use this function, we must pass it an unsigned 16-bit integer array and its length. The array will contain the data that the master device is reading or writing over.

For this simple example, I created an array called modbus_array that contains two elements.

1. The first is a status bit for the LED. If the value of the first element is 0, the LED will turn off; otherwise, it will be on.
2. The second element will be the state of the switch.

Now, let’s look at this from the perspective of the master device.

Toggling the LED

1. To toggle the LED, it must send a Modbus message to slave address 1 that writes a single holding register (Modbus function #6) to the first element with a value of 0 or 1.
2. To read the toggle switch, it must send a message that reads holding registers (Modbus function #3) starting at the second element with a length of 1. The Arduino will respond with the second element.

// Includes
#include <ModbusRtu.h>

// Defines
#define LED_PIN 5
#define SWITCH_PIN 6

// Global variables
Modbus modbus_port;

// Modbus registers:
// [0] = LED control
// [1] = Switch state
uint16_t modbus_array[] = {0, 0};

void setup()
{
    // Create Modbus slave:
    // (slave ID = 1, serial port = 1, TX enable pin = 7)
    modbus_port = Modbus(1, 1, 7);

    // Start Modbus communication
    modbus_port.begin(9600);

    pinMode(LED_PIN, OUTPUT);
    pinMode(SWITCH_PIN, INPUT);
}

void loop()
{
    // Process Modbus requests
    modbus_port.poll(
        modbus_array,
        sizeof(modbus_array) / sizeof(modbus_array[0])
    );

    // Register 0 controls the LED
    if (modbus_array[0] == 0)
    {
        digitalWrite(LED_PIN, LOW);
    }
    else
    {
        digitalWrite(LED_PIN, HIGH);
    }

    // Register 1 reports the switch state
    modbus_array[1] = digitalRead(SWITCH_PIN);
}

// Includes
#include <ModbusRtu.h>

// Defines
#define LED_PIN 5
#define SWITCH_PIN 6

// Global variables
Modbus modbus_port;

// Modbus registers:
// [0] = LED control
// [1] = Switch state
uint16_t modbus_array[] = {0, 0};

void setup()
{
    // Create Modbus slave:
    // (slave ID = 1, serial port = 1, TX enable pin = 7)
    modbus_port = Modbus(1, 1, 7);

    // Start Modbus communication
    modbus_port.begin(9600);

    pinMode(LED_PIN, OUTPUT);
    pinMode(SWITCH_PIN, INPUT);
}

void loop()
{
    // Process Modbus requests
    modbus_port.poll(
        modbus_array,
        sizeof(modbus_array) / sizeof(modbus_array[0])
    );

    // Register 0 controls the LED
    if (modbus_array[0] == 0)
    {
        digitalWrite(LED_PIN, LOW);
    }
    else
    {
        digitalWrite(LED_PIN, HIGH);
    }

    // Register 1 reports the switch state
    modbus_array[1] = digitalRead(SWITCH_PIN);
}

Conclusion

Arduinos are usually confined to hobbyist and educational markets because of their low barrier to entry, but this also makes them ideal candidates for prototyping, even in the industrial automation space.

Do you have a low fidelity project that could use some low-cost microcontrollers? Check out our Embedded Development and Programming service area to find out if DMC could be good fit for you! Or, Contact Us to get started on a solution today.

The post Turning an Arduino into a Modbus Device appeared first on DMC, Inc..