Documentation

In the URB project, sketches are divided into 4 modules. The first module describes global variables, and, if necessary, their initial values. Adds required for this unit of the library. First part also mandatory to have the function of reloading a unit on an external command. There also overriding the Arduino pins using the #define component. In the second part, the modes of the Arduino pins are set, the used libraries are initialized and running commands are given to your layout devices so they took the default position. The third part is the loop, and it is in it that all commands are executed.

Your layout is quite complex in terms of wakeup control. The position of turnouts and signals, the order and logic of the power switching on of the lines, the state of the global settings at the power-up of the railway layout must be uniquely determined. In this project, this problem is resolved in two ways. The first, obvious, in the void setup(), you describe not only the purpose of the GPIO pins, but also their meaning. Then you, in accordance with them, bring the layout elements to the initial state. The second way is to use the RESET function. This function resets each URB by a common command. Then the same thing happens as in the first method. The reset command in the Protocol 3 has the syntax "rstz", and is executed every time the application is successfully connected via Bluetooth. You can also force the layout lines at any time by pressing the RESET button in the app. As soon as in the third part of the sketch is recognized of the reset command, control is transferred to the reset function void(* resetFunc) (void) = 0;

The fourth part of the sketch, which causes many difficulties in understanding it, is the function. The code in the ATmega microcontrollers in a void loop() is executed sequentially line by line. One wonders, therefore, how running Arduino libraries if their code is not in a loop.

Imagine the situation, you leave to the doorstep/threshold of your house and saw that it was raining. You return home, take an umbrella and again return on a threshold. That is, you are on the doorstep again, but you have an umbrella. The functions and libraries works in a similar way. Your sketch will be executed line by line with the ATmega microcontroller until it find the instruction yourfunction() (call function), after which it will go to the code block void yourfunction() {...} and then return to the main code.

You can assign any name to your function. Here is a simple example of a modified BLINK sketch code from examples Arduino IDE:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  yourfavoritname(); 
}

void yourfavoritname() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);                    
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);  
}                  

The library code is called in the same way. That is, the library is a function! That is, the principle of line-by-line code execution is always respected for Arduino NANO, UNO, MEGA.

Often in programming, there is a situation that, along with the code performed by a function, it needs to transfer data (for libraries this is the main running way). For this, parameters are put in parentheses, here is an example:

void receiveI2C(int howMany) {
  while (Wire.available() > 0) {
    dataFromI2C = Wire.read();
  }
}     

This function from the snippet for the local unit accepts commands on the I2C bus. You won’t need to write such complex function calls in the URB project, all you need to understand is a simple function call without parameters.

Function for URB is the basis of the sketch modularity. You will need to add to your sketch only the functions that are needed for your devices. For example, if you only need to control trains by one Driver, without control on turnouts, lighting, etc., you only need a void driver1() function on COMM.

The URB project uses multiple URB units (or individual Arduino boards) simultaneously, and also receives and transmits data to and from the application on an Android device. Therefore, a standard is needed for data exchange.

For Arduino there is a very large number of protocols for data exchange. For example, Firmata or NMEA 0183. But they are all complicated for this project, in addition, if you use the library implementation code of the protocol, then you cannot change anything in it, and this significantly limits the ability to connect various devices on the railway layout. In a railway model, there is not a lot of data flow and the speed of passing them is also not very important. Therefore, you can use a very simple protocol. It consists of four characters, the last character nbsp;– "z" indicates the end of the command. Combination of the first three letters or numbers gives a lot of variants the commands.

For example, for switching turnout A command are ""ja1z" and "ja0z". In the sketches of Arduino they are parsing by such a well-known block of Serial Event:

// start parsing switching turnouts command                    
if (inputString.charAt(0) =='j') {
 // select Turnout A
  if (inputString.charAt(1) =='a') { 
    if (inputString.charAt(2) =='1') { 
        // Code for switch Turnout to throw position
        Bluetooth.print("ja1z"); // feedback command
    }
    if (inputString.charAt(2) =='0') { 
        // Code for switch Turnout to branch position
        Bluetooth.print("ja0z"); // feedback command
    }
  }
}   

For testing and adjusting your layout devices you can type these commands directly into the Serial Terminal of Arduino IDE.

Ways to connect different types of point-motors

The URB Project you can connect any types point-motors for switching turnouts – servo, electromagneticm, and having a stepper or DC motor. If the servo is used as drive for switching turnouts then all you need to use is the Servo library integrated into the Arduino IDE environment. If a DC Motor or an electromagnet coils are used as drives, the situation changes as follows. Any of GPIO pins of the microcontroller can control the point-motor contacts with a simple command: digitalWrite(Number GPIO, HIGH/LOW state).

But the output voltage and current from the pins (GPIO) are too small to move the solenoid inside the coil, thereby moving switch point rails of your turnout or to rotate motor. Therefore, a booster is needed. For this you can use a simple circuit with transistors, but in my project I use only ready-made electronic components. This is the same motor driver L298, only in this case it works without PWM pins. It also allows you to manipulate the polarity at its outputs, that is, you can connect not only DC motors in reverse mode, but also KATO point motors.

If you have a very specific drive or you prefer a circuit with control of your drive via conventional buttons, then use a conventional relay instead of buttons.

LEDs and bulbs connections

The voltage on the Arduino pins is equal to the supply voltage of the MCU. ATmega328 can operate in the range from 1.5 to 5.5 V. The current for each GPIO in OUTPUT mode is no more up to 40mA. Such voltage and current are sufficient only for signal LEDs, while it is necessary to install a series-limiting resistor of near 100 Ohm.

To control a load with a different voltage and high current, I suggest repeating the trick described above. But for lighting, I suggest using the Darlington array. You do not need to shoulder to assemble this ULN2003 chip into a circuit – there is a ready-made module based on this chip. This device is called ULN2003 Stepper Motor Driver Module. When creating a circuit with this device, it is important to remember that this module must be included with a POSITIVE common wire. Using this module, you will get a maximum current at each output of about 200 mA and a maximum voltage of 52 V. If you need a current of more than 200mA, then connect the outputs in parallel.

You can also use a relay, but you will not be able to use lighting effects. I consider using a relay to control the lights to be the worst option.