ARDUINO IDE Set Up for DCC Controller

Arduino IDE set-up for DCC controller

Step 1. IDE environment set-up. Load the ESP boards.

When you first instal the Arduino IDE, it only supports ARM based boards. We need to add support for ESP based boards. Navigate to File… Preferences

Type this line below into the Additional Boards Manager URLS box. Note there are underscores in it, no spaces. http://arduino.esp8266.com/stable/package_esp8266com_index.json,https://dl.espressif.com/dl/package_esp32_index.json
Also check the box that says Show Verbose during compilation. This gives us more information if something fails during the compilation.

Note that the line above adds support for both esp8266 devices and the newer esp32. The two json strings are separated by a comma.
Now select board version 2.7.4 from boards manager

Install version 2.7.4. This works. Version 3.0.0 and higher does not work for this project. Now, back in the Tools menu, select the board you will be using. For this project it will be either a nodeMCU 1.0 or a WeMos D1R1

Here we select the WeMos D1R1. (changing this from the Nano)

Step 2. IDE environment set-up. Load ESP8266 Sketch Data Upload add-in.

We need to load this add-in to allow us to publish (put) HTML pages and other files on the ESP device. These live in the data folder inside your project folder https://github.com/esp8266/arduino-esp8266fs-plugin/releases
Go to the URL above and download ESP8266FS-0.5.0.zip.
Create a Tools folder inside your Arduino folder. Unzip the contents of the zip file to this Tools folder. You should end up with this;

And a new menu option will appear under Tools…

If you invoke that menu option, the IDE will upload the contents of the data folder to the board. Ok so that’s the IDE environment set up for general ESP8266 use, now we need to add some libraries to the Arduino/Libraries folder for this specific project.

Step 3. Download libraries and manually instal.

We need to download these libraries from Github; https://github.com/me-no- dev/ESPAsyncTCP

Click on code, and then download zip. It will go to your downloads folder. Go into downloads, find the zip, open it and drag the content folder “ESPAsyncTCP” to Arduino/libraries.
If the folder name ends with “-master”, then rename it to remove “-master” from the end.
i.e. from downloads

Open the .zip for ESPAsyncTCP-master, and drag ESPAsyncTCP-master folder from inside this to Arduino/Libraries

Note: Arduino/libraries cannot use the .zip version, you need to unzip (drag) the desired folder over. We also need https://github.com/fmalpartida /New-LiquidCrystal
Download the zip then drag its content to Arduino/libraries and remove -master ending.

And finally, we need ArduinoJson-5.13.5.zip from the link below https://www.arduinolibraries.info/libraries/arduino-json

download and then drag the zip contents to Arduino/libraries

Step 4. Instal a couple more libraries using Arduino Library Manager.

We need two more libraries, and these come from the Arduino Library Manager which holds a selection of built-in libraries. Go to Tools… Manage Libraries…

Use version 1.0.3 of Adafruit INA219. This works.

And also

Use version 2.1.0 of WebSockets from Markus Sattler, this is tested and working. I have not tested later versions.
OK so that’s all the libraries (aka references) that the IDE needs to compile this project.

Step 5. Download the ESP_DCC_Controller project from GitHub and open in

IDE.

Go to GitHub and download https://github.com/computski/ESP_DCC_controller

Click on the green “Code” button, and download the zip. Then open the zip file and move its contents to the Arduino folder. Rename the folder to remove the “-main” ending on the folder name. You should end up with a folder ESP DCC controller in your Arduino folder. It will contain an .INO file, various .H and .CPP files and a data folder.

Double click on the .INO file to open the project in the Arduino IDE.
Before we hit compile, we need to configure to your requirements…

Step 6. Set your requirements in Global. h

This project can support the nodeMCU or WeMo’s D1R1 and it also can support a number of  different power board (motor shield) options, plus it can support devices on an I2C bus such as current monitor, LCD display and keypad. And finally it can also support a jogwheel (rotary encoder). The most basic build you can do is a WeMo’s D1R1 and L298 motor shield.
Note the easiest way to disable an option is add a lowercase n in front of its name in the #define statement.

define nNODEMCU_OPTION3

define nBOARD_ESP12_SHIELD

define WEMOS_D1R1_AND_L298_SHIELD

For example, above NODEMCU_OPTION3 has been disabled with n, the same for nBOARD_ESP12_SHIELD. WEMOS_D1R1_AND_L298_SHIELD is the active option, and this will cause the compiler to use the configuration for this as listed lower down.

To walk through this config:

elif defined(WEMOS_D1R1_AND_L298_SHIELD)

/Wemos D1-R1 stacked with L298 shield, note that the D1-R2 is a newer model with different pinouts/
/*Cut the BRAKE jumpers on the L298 shield. These are not required and we don’t want them driven by the I2C pins as it will corrupt the DCC signal.

The board has an Arduino form factor, the pins are as follows
D0 GPIO3 RX
D1 GPIO1 TX
D2 GPIO16 heartbeat and jogwheel pushbutton (active hi)
D3 GPIO5 DCC enable (pwm)
D4 GPIO4 Jog1
D5 GPIO14 DCC signal (dir)
D6 GPIO12 DCC signal (dir)
D7 GPIO13 DCC enable (pwm)
D8 GPIO0 SDA, with 12k pullup
D9 GPIO2 SCL, with 12k pullup
D10 GPIO15 Jog2
the above are notes for humans, lets you know which ESP GPIOs will perform which functions. Note that the Arduino D1-D10 to GPIO mappings are different to the node MCU D1-D10 to GPIO mappings */

define USE_ANALOG_MEASUREMENT

define ANALOG_SCALING 3.9 //when using A and B in parallel (2.36 to match

multimeter RMS)
We will use the AD on the ESP and not an external I2C current monitoring device such as the INA219 disable
this with n USE ANALOG MEASUREMENT if you do wish to use an INA219

define PIN_HEARTBEAT 16 //and jogwheel pushbutton

define DCC_PINS \

uint32 dcc_info[4] = { PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12, 12 , 0 }; \
uint32 enable_info[4] = { PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO5, 5 , 0 }; \
uint32 dcc_infoA[4] = { PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO14, 14 , 0 }; \
uint32 enable_infoA[4] = { PERIPHS_IO_MUX_MTDI_U, FUNCGPIO13,13 , 0 };
Defines which pins will drive the DCC signals, we have two channels, running in-phase so we can common them together. A-channel is dcc info [] and B-channel is dcc_ info A []. These are defined as macros and the backslash is a line-continuation marker.

define PIN_SCL 2 //12k pullup

define PIN_SDA 0 //12k pullup

define PIN_JOG1 4

define PIN_JOG2 15 //12k pulldown

Define the pins (GPIOs) which drive the I2C SCL/SDA and then also the jogwheel inputs 1 and 2

define KEYPAD_ADDRESS 0x21 //pcf8574

Used for the optional 4 x 4 matrix keypad, which is scanned using a pcf8574 chip

//addr, en,rw,rs,d4,d5,d6,d7,backlight, polarity. we are using this as a 4 bit device //my display pinout is rs,rw,e,d0-d7. only d<4-7> are used. <210> appears because bits <012> are //mapped as EN,RW,RS and we need to reorder them per actual order on the hardware, 3 is mapped //to the backlight. <4-7> appear in that order on the backpack and on the display.

define BOOTUP_LCD LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3,

POSITIVE); //YwRobot backpack

Used to define and configure the I2C backpack that drives the 1602 LCD display (optional), this is softconfigurable and there are several backpacks available whose pin configurations vary.

endif

Step 7. Compile and upload to the board.

Now you have configured the board combo you intend using, you can compile the project. If you don’t intend to use the 4×4 matrix keypad, and LCD, no problem, leave in their definitions as the software expects to configure them. The system will work fine over WiFi without them.
On the IDE, the tick symbol (verify) is actually “Compile”. Click this and you will see various messages appear (provided you enabled Verbose compilation) as the system compiles the various libraries and links it all together. If all works well, and it should if you followed all steps above  exactly, then you should see a success message appear. You are now ready to hit the right-arrow (upload) button, but before you do this, check you have selected the correct COM port for the board under the Tools menu.
After a successful upload (use a good quality USB cable) you also need to invoke the Load ESP8266 Sketch Data menu option under Tools. This will put the contents of the data folder onto the device (all the HTML pages).
You are done. Open the serial monitor, click the reset button and you should see the device boot and scan for I2C devices. You can now connect to it over Wifi, and its ready to wire up to its power board (motor shield).

References

• GitHub - computski/ESP_DCC_Controller: DCC controller based on nodeMCU ESP12-E device
• Releases · esp8266/arduino-esp8266fs-plugin · GitHub
• GitHub - fmalpartida/New-LiquidCrystal: Clone of the new liquid crystal library from: https://bitbucket.org/fmalpartida/new-liquidcrystal
• GitHub - me-no-dev/ESPAsyncTCP: Async TCP Library for ESP8266
• ArduinoJson - Arduino Libraries

Read User Manual Online (PDF format)

Read User Manual Online (PDF format)  >>

Download This Manual (PDF format)

Download this manual  >>