In the previous chapter, we set up TinyGo and our IDE, and we now know how to build and flash our programs to the Arduino UNO. We are now going to utilize this knowledge to go one step further.

In this chapter, we are going to build a traffic lights control system. We are going to split the project into small steps, where we build and test each component. At the end, we are going to put everything together. We will be using multiple LEDs, a breadboard, GPIO ports, and a button to interrupt the normal flow to switch pedestrian lights to green. By the end of the chapter, you will know how to control external LEDs, read the state of a button, use GPIO ports, how to distinguish resistors, and how to utilize Goroutines in TinyGo.

In this chapter, we are going to cover the following topics:

• Lighting an external LED
• Lighting a single LED when a button is pressed
• Building traffic lights
• Building traffic lights with pedestrian lights

To build the traffic lights control system, we are going to need some components. We will need the following to build the complete project:

1. An Arduino UNO
2. Breadboard
3. Five LEDs
4. Multiple jumper cables
5. Multiple 220 Ohm resistors
6. One push button
7. One 10K Ohm resistor

You can find all code examples from this chapter in the following GitHub repository: https://github.com/PacktPublishing/Creative-DIY-Microcontroller-Projects-with-TinyGo-and-WebAssembly/tree/master/Chapter02

The Code in Action video for the chapter can be found here: https://bit.ly/2RpvF2a

Before we start to build a more complex circuit, let's begin with lighting up an external LED. As soon as this is working, we are going to extend the circuit step by step. We begin with a single red LED. Lighting up an external LED is a bit different compared to lighting up an onboard LED. We are going to need something on which we can place the LED, and we will need some wires as well as a basic understanding of resistors, which will help us to prevent the LED from taking damage. That is why we are going to look at each component one by one.

Using breadboards

Breadboards are used for prototyping, as they do not require you to directly solder components. We are going to build all our projects using breadboards.

A breadboard typically consists of two parts:

• The power bus
• Horizontal rows

Each side of a breadboard has a power bus. The power bus provides a + (positive) lane and a - (ground) lane. The positive lane is colored red and the ground lane is colored blue. The individual slots are connected inside the power bus.

The slots of a single horizontal row are also connected. A signal in one slot is also available in the next slot. Different horizontal rows are not connected, unless we put a cable in there to create a connection. Here's what a breadboard looks like:

Figure 2.1 – A breadboard – image taken from Fritzing

Understanding LED basics

The Arduino UNO has an operating voltage of 5V, which is too high for most LEDs. So, we need to reduce the voltage to something our LEDs can handle. For that reason, we will be using 220 Ohm resistors to draw current from the line in order to protect the LED from damage. If you do not have 220 Ohm resistors, you can also use 470 Ohm as well; anything between 220 and 1K (1K = 1,000) Ohm will be fine.

If you want to really make sure that the resistor matches the needs of the LED, you can also calculate the resistor value as follows:

R = (Vs – Vled) / Iled

Where:

• R is the resistor value.
• Vs is the source voltage.
• Vled is the voltage drop across the LED.
• Iled is the current through the LED.

  Note

  LEDs have anode (+) and cathode (-) leads. The anode lead is longer.

  Different colors need to be driven with different voltages. When using the same resistors and voltages for the different LED colors, you will notice that some colors will be brighter compared to others.

Using GPIO ports

GPIO stands for General Purpose Input Output. That means we can use these pins for input as well as output for digital signals. We can either set a GPIO pin to High or Low, or read a High or Low value from the port.

Note

We should never draw more than a maximum of 40.0 mA (milliampere) from a single GPIO port. Otherwise, we could permanently damage the hardware.

Building the circuit

Now let's build our first circuit on the breadboard:

1. Put a red LED in the G column of the horizontal rows. Put the cathode in G12 and the anode in G13.
2. Connect F12 with the ground lane on the power bus.
3. Connect F13 and E13 using a 220 Ohm resistor. (Anything between 220 and 1,000 Ohms is okay.)
4. Connect Pin 13 from the GPIO ports to A13.
5. Connect the GND port to the ground lane on the power bus.

   Note

   The descriptions on your breadboard might differ from the ones I am using. If that is the case, you'll need to build the circuit by checking the next figure.

The circuit should now look like the following:

Figure 2.2 – Image of the circuit – image taken from Fritzing

Writing the code

We start off by creating a new folder named Chapter02 in our project workspace. This folder will be used for all parts of this chapter. Inside the Chapter02 folder, we create a blinky-external folder and create a new main.go file inside.

The structure should look like the following:

Figure 2.3 - Project structure for writing the code

We import the machine and time packages and put the following code into the main function:

1. Declare and initialize a variable named outputConfig with a new PinConfig in output mode:

   outputConfig := machine.PinConfig{Mode: machine.
                   PinOutput}

2. Declare and initialize a variable named greenLED with a value of machine.D13:

   greenLED := machine.D13

3. Configure the LED with the outputConfig instance we created earlier, by passing it as a parameter into the Configure function:

   redLED.Configure(outputConfig)

4. We then loop endlessly:

   for {

5. Set redLED to Low (off):

     redLED.Low()

6. Sleep for half a second. Without sleeping, the LED would be turned on and off at an extremely high rate, so we sleep after each change in a state:

     time.Sleep(500 * time.Millisecond)

7. Set the redLED to High (on):

     redLED.High()

8. Sleep for half a second:

     time.Sleep(500 * time.Millisecond)
   }

9. Now flash the program using the tinygo flash command using the following command:

   tinygo flash –target=arduino Chapter02/blinky-external/main.go

When the flash progress completes and the Arduino restarts, the red LED should blink at intervals of 500 ms.

Congratulations, you have just built your first circuit and written your first program to control external hardware! As we now know how to connect and control external LEDs on a breadboard, we can continue to build a more advanced circuit. Let's do just that in the next section.

Until now, we have only used code to directly control hardware components. Let's now try to read the state of a button in order to control an LED. We will need the following components:

• At least 6 jumper wires
• One LED (the color does not matter)
• One 220 Ohm resistor
• One 4-pinned-button (push down button)
• One 10K Ohm resistor

Now let's go on to build the circuit.

Building the circuit

The following circuit extends the one we previously built. So, if you still have the previous circuit assembled, you just have to add the button part. The next circuit consists of two component groups. The first group is used to control an LED, and the second group is used to read the button state.

Adding the LED component

We start off with the LED circuit:

1. Place an LED with the cathode in G12 and the anode in G13.
2. Use a 220 Ohm resistor to connect F13 with D13.
3. Connect port D13 from the GPIO ports with A13 using a jumper wire.
4. Connect F12 with the ground lane of the power bus using a jumper wire.

Adding the button component

Now we are going to add a button:

1. Use a jumper wire to connect A31 with the positive lane of the power bus.
2. Use a 10K Ohm resistor to connect the ground lane of the power bus with B29.
3. Connect D29 with port D2.
4. Place the push button with one pin in E29, one in E31, one in F29, and the last pin in F31.

Our circuit should now look similar to the following:

Figure 2.4 – The circuit – image taken from Fritzing

Note

Before we start to write the code for this circuit, we need to learn how these buttons work.

As the button will not work if you place it incorrectly onto the breadboard, let's have a look at the button again.

The 4 pins on the button are grouped into two pins each. So, two pins are connected to each other. Looking at the back of the button, we should be able to see that two opposing pins are connected to each other. So, the button won't work as expected when you place it rotated by 90°.

Programming the logic

Before diving into the code, we will create a new folder named light-button inside the Chapter02 folder and create a main.go file in it, with an empty main function, using the following:

Figure 2.5 – The folder structure for the logic

Let's now look at the main function and the pull-up resistor.

The main function

We want to light the LED when the button is pressed. To achieve this, we need to read from a pin and check for its state using the following steps:

1. Initialize the outPutConfig variable with PinConfig in PinOutput mode. This config is going to be used to control the LED pin:

   outputConfig := machine.PinConfig{Mode: machine.
                   PinOutput}

2. Initialize the inputConfig variable with PinConfig in PinInput mode. This config is being used for the pin that reads the button state and therefore needs to be an input:

   inputConfig := machine.PinConfig{Mode: machine.PinInput}

3. Initialize the led variable with a value of machine.D13, which is the pin we have connected to led:

   led := machine.D13

4. Configure led as output by passing outputConfig as the parameter, which is the pin that is connected to the button:

   led.Configure(outputConfig)

5. Initialize the buttonInput variable with a value of machine.D2:

   buttonInput := machine.D2

6. Configure buttonInput as an input by passing inputConfig as the parameter:

   buttonInput.Configure(inputConfig)

7. As we do not want the program to be terminated after checking the button state a single time, we use an endless loop to repeat and check forever:

   for {

8. Check the current state of the button. It will be true if the button is pressed:

     if buttonInput.Get() {

9. If the button is pressed, we light up the LED:

       led.High()

10. We are calling continue here, so we do not execute the led.Low() call:

        continue
       }

11. If the button is not pressed, we turn the LED off:

        led.Low()
    }

    Note

    Do not forget to import the machine package, otherwise the code will not compile.

Now flash the program using the tinygo flash command:

tinygo flash –target=arduino Chapter02/light-button/main.go

After successfully flashing, the LED should light up when you press the button.

The pull-up resistor

You may have wondered why we need a 10K Ohm resistor in the button circuit. The 10K Ohm resistor is used to prevent the signal/pin from floating. Floating pins are bad, as an input pin in a floating state is indeterminate. When trying to read a value from a pin, we expect to get a digital value – 1 or 0, or true or false. Floating means that the value can change rapidly between 1 and 0, which happens without pull-up or pull-down resistors. Here's some further reading on floating pins: https://www.mouser.com/blog/dont-leave-your-pins-floating.

As an alternative to the 10K Ohm external resistor, an internal resistor can be used.

Configuring an input pin to use an internal resistor is done as follows:

inputConfig := machine.PinConfig{
               Mode: machine.PinInputPullup
}

We have now learned how to control an LED using an input signal, which was given by a button. The next step is to build the traffic lights flow to control three LEDs.

We know how to light up a single LED, and we also know how to light up an LED using a button input. The next step is to build a circuit using three LEDs and to write the code to light them up in the correct order.

Building the circuit

To build the circuit, we need the following components:

• Three LEDs (preferably red, yellow, and green)
• Three 220 Ohm resistors
• Seven jumper wires

We start by first setting up the components using the following steps:

1. Connect GND from the Arduino to any ground port on the power bus.
2. Place the first (red) LED with the cathode in G12 and the anode in G13.
3. Place the second (yellow) LED with the cathode in G15 and the anode in G16.
4. Place the third (green) LED with the cathode in G18 and the anode in G19.
5. Connect F13 with D13 using a 220 Ohm resistor.
6. Connect F16 with D16 using a 220 Ohm resistor.
7. Connect F19 with D19 using a 220 Ohm resistor.
8. Connect F13 to Ground on the power bus using a jumper wire.
9. Connect F16 to Ground on the power bus using a jumper wire.
10. Connect F19 to Ground on the power bus using a jumper wire.
11. Connect port D13 to A12 using a jumper wire.
12. Connect port D16 to A12 using a jumper wire.
13. Connect port D19 to A12 using a jumper wire.

Your circuit should now look similar to the following figure:

Figure 2.6 – The traffic lights circuit – image taken from Fritzing

We have now successfully set up the circuit. Now we can continue to write some code to control the LEDs.

Creating a folder structure

We start off by creating a new folder named traffic-lights-simple inside the Chapter02 folder. Also, we create a main.go file inside the new folder and start off with an empty main function. Your project structure should now look like this:

Figure 2.7 - Folder structure for the circuit

Writing the logic

We have successfully set up our project structure to continue. We are going to implement the following flow:

RED -> RED-YELLOW -> GREEN -> YELLOW -> RED

This is a typical flow for traffic lights with three bulbs.

We are going to configure three pins as output, and afterward, we want to endlessly loop and light up the LEDs in this flow.

Inside the main function, we write the following:

1. Initialize a new variable named outputConfig as PinConfig using the PinOutPut mode:

   outputConfig := machine.PinConfig{Mode: machine.
                   PinOutput}

2. Initialize a new variable named redLED with the value machine.D13 and configure it as output:

   redLED := machine.D13
   redLED.Configure(outputConfig)

3. Initialize a new variable named yellowLED with the value machine.D12 and configure it as output:

   yellowLED := machine.D12
   yellowLED.Configure(outputConfig)

4. Initialize a new variable named greenLED with the value machine.D11 and configure it as output:

   greenLED := machine.D11
   greenLED.Configure(outputConfig)

We have now initialized our variables to act as output pins. The next step is to light up the LEDs in the correct order. We basically have four phases, which just need to repeat in order to simulate a real traffic light. Let's go through these one by one:

1. We are going to handle the phases in an endless loop:

   for {

2. For RED-Phase, turn on the red LED and wait for a second:

       redLED.High()
       time.Sleep(time.Second)

3. For RED-YELLOW-Phase, turn on the yellow LED and wait for a second:

       yellowLED.High()
       time.Sleep(time.Second)

4. For GREEN-PHASE, turn off the yellow and red LEDs and turn on the green LED and wait for a second:

       redLED.Low()
       yellowLED.Low()
       greenLED.High()
       time.Sleep(time.Second)

5. For YELLOW-Phase, turn off the green LED and turn on the yellow LED, then wait for a second and turn off yellow again, so we can start cleanly with RED-Phase again:

       greenLED.Low()
       yellowLED.High()
       time.Sleep(time.Second)
       yellowLED.Low()
   }

The complete content of the function is available at the following URL:

https://github.com/PacktPublishing/Programming-Microcontrollers-and-WebAssembly-with-TinyGo/blob/master/Chapter02/traffic-lights-simple/main.go

Note

Don't forget to import the time and machine packages.

We have now assembled and programmed a complete traffic lights flow. The next step is to combine everything we have built to complete our project.

We will now combine everything we have learned and done in this chapter to create an even more realistic traffic lights system. We will do so by assembling a circuit that contains the three-bulb traffic lights from the previous step and adding pedestrian lights with two bulbs that are controlled by a button.

Assembling the circuit

For our final project in this chapter, we need the following:

• Five LEDs: preferably two red, one yellow, and two green
• Five 220 Ohm resistors, one for each LED
• One 10K Ohm resistor as a pull-up resistor for our push button
• One 4-pin push button
• 14 jumper wires

We start by setting up the three-bulb traffic lights using the following steps:

1. Place the first LED (red) with the cathode on G12 and the anode on G13.
2. Place the second LED (yellow) with the cathode on G15 and the anode on G16.
3. Place the third LED (green) with the cathode on G18 and the anode on G19.
4. Use a 220 Ohm resistor to connect F13 with D13.
5. Use a 220 Ohm resistor to connect F16 with D16.
6. Use a 220 Ohm resistor to connect F19 with D19.
7. Connect pin D13 with A13 using a jumper wire.
8. Connect pin D12 with A16 using a jumper wire.
9. Connect pin D11 with A10 using a jumper wire.
10. Connect F12 with Ground on the power bus using a jumper wire.
11. Connect F15 with Ground on the power bus using a jumper wire.
12. Connect F18 with Ground on the power bus using a jumper wire.

Now assemble the pedestrian lights using the following steps:

1. Place the fourth LED (red) with the cathode on G22 and the anode on G23.
2. Place the fifth LED (green) with the cathode on G25 and the anode on G26.
3. Use a 220 Ohm resistor to connect F23 with D23.
4. Use a 220 Ohm resistor to connect F26 with D26.
5. Connect pin D5 with A23 using a jumper wire.
6. Connect pin D4 with A26 using a jumper wire.
7. Connect F22 with Ground on the power bus using a jumper wire.
8. Connect F24 with Ground on the power bus using a jumper wire.

Now we only need to assemble the button and connect the power bus:

1. Place a push button with the left pins in E29 and F29 and the right pins on E31 and F31.
2. Use a 10K Ohm resistor to connect the Ground from the power bus with B29.
3. Connect pin D2 with C29 using a jumper wire.
4. Connect A31 with the positive lane on the power bus using a jumper wire.
5. Connect the positive lane on the power bus with the 5V port on the Arduino UNO using a jumper wire.
6. Connect the ground lane on the power bus with a ground port on the Arduino UNO using a jumper wire.

When you've finished assembling, your circuit should look like this:

Figure 2.8 – Circuit for the traffic lights with pedestrian lights controlled by a button – image taken from Fritzing

Great, we have now completely assembled our final project for this chapter. We can now write some code to bring this project to life.

Setting up the project structure

We start off by creating a new folder named traffic-lights-pedestrian inside the Chapter02 folder. Inside the new folder, we create a new main.go file with an empty main function.

Our project structure should now look like the following:

Figure 2.9 - Project structure for the project

Writing the logic

We are going to split the program into three parts:

• Initialization logic
• Main logic
• trafficLights logic

Initializing the logic

We need to initialize a stopTraffic variable and configure the pins for the LEDs as output pins using the following steps:

1. We start off by declaring a bool variable named stopTraffic at the package level. This variable is going to be used as a communication channel between our two logic parts:

   var stopTraffic bool

2. The first thing we do in the main method is set the value of stopTraffic to false:

   stopTraffic = false

3. We declare and initialize a new variable named outputConfig with PinConfig in PinOutput mode. We are going to pass this config to all LED pins:

   outputConfig := machine.PinConfig{Mode: machine.
                   PinOutput}

4. We initialize some new variables: greenLED with the value machine.D11, yellowLED with the value machine.D12, and redLED with the value machine.D13. Then, we configure each LED variable as output pins:

   greenLED := machine.D11
   greenLED.Configure(outputConfig)
   yellowLED := machine.D12
   yellowLED.Configure(outputConfig)
   redLED := machine.D13
   redLED.Configure(outputConfig)

5. We initialize some new variables: pedestrianGreen with the value machine.D4 and pedestrianRed with the value machine.D5. Then, we configure each LED variable as output pins:

   pedestrianGreen := machine.D4
   pedestrianGreen.Configure(outputConfig)
   pedestrianRed := machine.D5
   pedestrianRed.Configure(outputConfig)

6. We declare and initialize a new variable named inputConfig with PinConfig in PinInput mode. Then, we declare and initialize a new variable named buttonInput with the value machine.D2 and configure buttonInput as the input pin:

   inputConfig := machine.PinConfig{Mode: machine.PinInput}
   buttonInput := machine.D2
   buttonInput.Configure(inputConfig)

That's it for the initialization. We have set up all pins and a Boolean variable at the package level.

Note

The pin constants, such as machine.D13, are of the machine.Pin type.

Writing the trafficLights logic

We will now write the complete logic to control all the LEDs in our circuit. This is going to be the first time that we have to move some parts of the code into other functions.

To do that, we start by writing a new function named trafficLights that takes all five LED pins as parameters and has no return value. Inside the function, we start off with an empty, endless loop. Our function should now look like the following:

func trafficLights(redLED, greenLED, yellowLED, pedestrianRED, 
    pedestrianGreen machine.Pin) {
      for {
      }
}

All the logic will be placed inside the for loop. The actual logic in the loop consists of two parts:

• Handling signals from the button to stop the traffic and control the pedestrian lights
• Controlling the normal traffic lights flow

We start off with handling the signals from the button. To do that, we check for stopTraffic in the if, and also have an empty else branch. It looks like the following:

        if stopTraffic {
    } else {
}

So, when stopTraffic is true, we want to set our traffic lights phase to be red. Also, we want to set the pedestrian lights phase to green for 3 seconds and then back to red and set stopTraffic to false afterward, as we handled the signal one time.

Let's implement this logic using the following steps:

1. Set traffic lights phase to red:

   redLED.High()
   yellowLED.Low()
   greenLED.Low()

2. Set the pedestrian lights phase to green for 3 seconds:

   pedestrianGreen.High()
   pedestrianRED.Low()
   time.Sleep(3 * time.Second)

3. Set the pedestrian lights phase to red:

   pedestrianGreen.Low()
   pedestrianRED.High()

4. Set stopTraffic to false, as we have handled the signal:

   stopTraffic = false

5. In the else block, we just reset the pedestrian lights state to red:

   pedestrianGreen.Low()
   pedestrianRED.High()

Okay, that is the part that reacts to stopTraffic signals. Underneath that if-else block, we are going to implement the actual logic to control the traffic lights flow, which is the same as done earlier. So, we start with the red phase, transit to the red-yellow phase, then to green, then to yellow, and then reset yellow to be able to start clean again, as follows:

redLED.High()
time.Sleep(time.Second)
yellowLED.High()
time.Sleep(time.Second)
redLED.Low()
yellowLED.Low()
greenLED.High()
time.Sleep(time.Second)
greenLED.Low()
yellowLED.High()
time.Sleep(time.Second)
yellowLED.Low()

That is all that we have to do in the trafficLights function.

Implementing the main logic

Now we only need to run the trafficLights function and handle the button input at the same time. This is where goroutines come in. As microcontrollers only have one processor core, which works with a single thread, we cannot have real parallel execution of tasks. As we use goroutines on an Arduino UNO, we will need some additional build parameters. We are going to learn about these parameters later, when we flash the program. In our case, we want to have a listener on the button, while still being able to step through the traffic lights process. The logic consists of three steps:

1. Initialize the pedestrian lights with the red phase.
2. Run the trafficLights function in a goroutine.
3. Handle the button input.

For the first part, we only have to set the pedestrianRED LED to High and the pedestrianGreen LED to Low:

pedestrianRed.High()
pedestrianGreen.Low()

Now we just call trafficLights and pass all necessary parameters using a goroutine:

go trafficLights(redLED, greenLED, yellowLED, pedestrianRed, pedestrianGreen)

For the last step, we need an endless loop that checks for buttonInput and to set stopTraffic to true if the button is pressed. We also need it to sleep for 50 milliseconds afterward:

for {
  if buttonInput.Get() {
    stopTraffic = true
  }
  time.Sleep(50 * time.Millisecond)
}

Note

It is necessary to add a sleep time to the loop that handles the button input because the scheduler needs time to run the goroutine. The goroutine is being handled in the time that the main function is sleeping. Also, other blocking functions, such as reading from a channel, can be used to give the scheduler time to work on other tasks.

As we now have completed our logic, it is time to flash the program onto the controller. As we are using goroutines in this project, we need to pass additional parameters to the tinygo flash command:

tinygo flash -scheduler tasks -target=arduino Chapter02/traffic-lights-pedestrian/main.go

As the ATmega328p has very limited resources, the scheduler is deactivated by default on boards that use this microcontroller. The Arduino UNO is such a board. When using other microcontrollers, we would normally not need to override the default scheduler by setting this parameter.

We have now successfully flashed our program to the Arduino Uno. The traffic lights should start looping all phases and the pedestrian lights should remain in the red phase. When clicking the button, the traffic lights should end their loop and then the pedestrian lights should switch to the green phase, while the traffic lights remain on the red phase for 3 seconds.

Note

Due to the very limited memory on the Arduino Uno, working with goroutines might only work in projects that are not very complex, such as this one.

We have learned how to build a fully functional traffic lights system with pedestrian lights controlled by a button. We achieved this by building each part of the project separately and assembling it all together at the end.

We learned how to use breadboards, how the color codes on resistors work, why we use resistors when controlling LEDs, and how external LEDs are assembled. Also, we learned how to use push buttons, how to prevent floating signals using pullup resistors, and how to utilize goroutines in TinyGo.

In the next chapter, we are going to learn how to read input from a 4x4 keypad and how to control a servo motor. We are going to utilize this knowledge to build a safety lock that opens when the correct passcode is entered.

1. Why do we place a resistor between an LED anode and the GPIO port?
2. How do we stop a signal from floating?
3. Why do we sleep after checking a button's state?
4. How would you modify the code to achieve the following behavior?

   a. When the button is pressed, turn off the red and green LEDs of the traffic lights and let the yellow LED blink.

   b. When the button is pressed again: go back to the normal phase rotation.

• Resistor Color Conversion Calculator: https://www.digikey.com/en/resources/conversion-calculators/conversion-calculator-resistor-color-code
• Goroutines in TinyGo: https://aykevl.nl/2019/02/tinygo-goroutines