# Microcontroller with Python

Presentation slides can be found here.

# Activity Goals

• Program a microcontroller in Python
• Interface electric circuits and microcontroller for input and output

# Introduction

A microcontroller is a mini-computer. A computer stores instructions in memory and executes them in sequence. A microcontroller is mini in the sense that it has smaller memory capacity, slower processor, and consumes less power. Normally microcontrollers are programmed to perform very specific tasks, such as tracking room temperature.

When we use a computer, we are actually interacting with a collection of programs that others have written and installed on the computer, known as the operating system. Similarly, to interact with a microcontroller, it needs to have a program already installed. We are going to learn how to program a microcontroller. Just as keyboards and monitors are the inputs and outputs for personal computers, sensors and LEDs are what we are going to use for our microcontrollers.

# Arduino Hardware

We will use the Arduino Nano for this activity. Typically a personal computer would use a graphical user interface to display the state of the machine. By default on a Arduino Nano, we can only tell the state from the indicator LEDs.

1. TX / RX tells us whether the board is transmitting or receiving data from the USB.
2. Pressing the reset button will clear the installed program on the board.
3. Power is supplied through the USB when it is connected. Otherwise, it can also be powered through the Vin pin by connecting it to voltage supply between 6V and 20V. Or through the 5V pin if the voltage supply is regulated.

Your Arduino Nano may look different slightly.

# Circuit Components

# LEDs

LEDs are short for light-emitting diodes. A diode can only pass electric current through in one direction; light is emitted when a current flows through the LED. Be careful that when current is forced to passed through in the opposite direction with high voltage, the diode will break and becomes ineffective. By convention, the longer terminal of a diode connects to high voltage and shorter terminal to ground.

# Motors

A motor allows current to pass through in either direction. The direction of the current determines the direction of the spin. The speed is determined by the magnitude of the current.

# Photoresistors

A photoresistor is a variable-resistance resistor, i.e. its resistance changes depending on the intensity of ambient light. The resistance ranges from 100 Ohms (bright) to 200 kOhms (dark).

# Arduino Programming

Normally you will have to use a low-level programming language like C or C++ to program an Arduino, but Arduino-Python3 allows us to directly code in Python. How does Arduino-Python3 work? explains how we are able to program an Arduino in Python.

A typical script which we will write looks as follows.

"""
 exercise1.py
 Toggle Pin13 On and Off
"""

from Arduino import Arduino
import time

# initialize
board = Arduino() 

# configure D13 as output
board.pinMode(13, "OUTPUT")

while True:
    # output 0V on D13
    board.digitalWrite(13, "LOW")
    time.sleep(1)

    # output 5V on D13
    board.digitalWrite(13, "HIGH")
    time.sleep(1)

# Exercise #1 – Blinking LED

In this exercise, we will use the Arduino to output a digital signal to toggle an on-board LED.

1. Plug Arduino to your lab computer via provided USB. You should see the power indicator light up in red on your Arduino Nano. Go back to the figure in Arduino Hardware section and locate Pin13 LED on your Arduino Nano.

2. Open a new file in Spyder. Copy and paste the code above into text editor area, and then save the file as exercise1.py.

3. Execute the code in Spyder. At this point, you should see the Pin13 LED starting to blink in one second intervals. If not, check with session or camp leaders.

4. Once you have confirmed that the LED blinks in one second intervals, stop running the Python script by pressing a red square button on the right-hand panel.

# Exercise #2 – External LED

In this exercise, we will blink an external LED with the Arduino. It will also refresh the circuit knowledge you gained from earlier this week.

1. First, disconnect USB from the Arduino. You should never connect electric components with currents running through the circuit. Although the voltage is not high enough to hurt you, it will potentially damage the components.

2. Set up your board as in the picture below. Pay attention to the long and short end of the LEDs and make sure they are connected correctly. Usually it is easier to trace from one end to the other: start from voltage source (D13) → 2.2k resistor → long end of LED → short end of LED → ground.

3. Run exercise1.py in Spyder and confirm that the newly connected LED flashes in sync with the Pin13 on-board LED. Afterwards, stop the Python script in Spyder.

4. Modify exercise1.py to output signal on D2 instead. Make sure to disconnect USB from Arduino and rewire the circuit to use the D2 pin.

# Exercise #3 – Analog Read

So far, we have only been outputting signals from the Arduino. In this exercise, we will learn to read signals from a photoresistor.

# Voltage Divider

We will put the photoresistor in a voltage divider. Using an analog pin on the Arduino to read the voltage values at the middle of the divider allows us to detect changes in ambient brightness.

First we put the photoresistor and resistor in a series (one after the other from voltage source to ground) connection. In a series connection, the resistance each component is added together $Voltage = Current \times (R_{photo} + R_{10k\Omega})$.

We can get the voltage at A6 by multiplying $Current$ and $R_{10k\Omega}$.

$V_{10k\Omega} = \frac{Voltage}{R_{photo} + R_{10k\Omega}} * R_{10k\Omega}$

Since $Voltage$ and $R_{10k\Omega}$ are constant, we will get different voltage readings when $R_{photo}$ changes resistance.

# Reading Analog Signal

To read the analog signal at A6, we just need to configure the pin as input and use the analogRead function. We will store the returned value in a variable and print its value in the next line.

"""
 exercise3.py
 Reading from photoresistor
"""
from Arduino import Arduino

board = Arduino() 

PHOTO_PIN = 6

# Using A6 as input pin
board.pinMode(PHOTO_PIN, "INPUT") 

while True:
    # value is between 0 and 1023
    photo_value = board.analogRead(PHOTO_PIN)
    print(photo_value)

1. Unpower Arduino and connect the circuit above. Again, trace from voltage source to ground to make sure everything is connected properly.

2. Paste the code above to a new file in Spyder and save as exercise3.py. Run the script and observe the changing values when you cover the photoresistor with your hands.

# Exercise #4 – Analog Write

In this exercise, we will learn to output analog signals using Arduino's pulse-width modulation (PWM) support. A digital signal is either 5V or 0V. But with a analog signal, we can output anything in between, such as 2.2V. By controlling the output voltage, we can control the brightness of a LED or make a motor spin faster or slower.

# Pulse-Width Modulation

The central idea of pulse-width modulation is to control signal magnitude using duty cycles, as depicted in diagram above. When the duty cycle is at 100%, then we have a constant on signal which we can think of as equivalent to a digital high signal. Similarly, duty cycle of 0% is equivalent to a digital low signal. When the duty cycle is at 50%, the signal is on and off for half the time respectively. We can consider the average voltage across a long enough time period to be 50% of the high voltage – In our case, it would be 2.5V (50% of 5V). By adjusting the duty cycle, we can control the voltage we want to output.

For most coding projects that happen in the real world, it is very unlikely that anyone will write every line of code from scratch. Therefore, one of the most important skills in programming is being able to read documentations and find answers online.

From analogWrite() documentation, we see that Arduino Nano can write analog values using Pins 3, 5, 6, 9, 10, and 11. Furthermore, the value parameter to the analogWrite function takes on integers betweeen 0 (always off) and 255 (always on).

"""
 exercise4.py
 Outputting analog signals
"""
from Arduino import Arduino
import time

board = Arduino() 

# TODO: Configure D3 to be output

while True:
    # TODO: Use `analogWrite` to output 2.5V
    # First ?? is the pin number
    # Second ?? is the PWM duty cycle value
    # board.analogWrite(??, ??)
    time.sleep(0.1)
    

1. Using information above to fill in the missing code in the given snippet and save as exercise4.py. It may help (but not necessary) to also check out the Arduino-Python3 documentation on Arduino.analogWrite() method.

2. Once you have completed the code, assemble a circuit similar to the one in Exercise #2 using an LED and a resistor. Remember to power off first!

3. Run the code with circuit connected. Try outputting different analog values.

# Challenge Problems

Come up with questions that you do not have the solutions for and answer them by conducting experiments. Think of creative ways to combine the eletronic components you have. This section contains some challenging problems to get you started.

# Problem #1 – Adaptive Lighting

(Difficulty: Medium)

In Exercise #3 and Exercise #4, we saw how to read from a photoresistor and adjust LED brightness using analog writes. Combine the two exercises to create a circuit that adjusts the intensity of a LED depending on the ambient brightness.

# Problem #2 – Controller Timing

(Difficulty: Hard)

Remember the time.sleep() function call we used in Exercise #1? It is not ideally for responsiveness purposes to have sleep() calls in the main loop of a controller.

Consider the code below. toggle_every_second() is toggles pin D13 every second as intended, but read_photoresistor() is executed only once every two seconds because of the time.sleep() calls in the previous function. How can we change it so that the LED still toggles every second, while reading photoresistor as frequently as possible?

# Some setup code omitted...

def toggle_every_second():
    board.digitalWrite(13, "LOW")
    time.sleep(1)
    board.digitalWrite(13, "HIGH")
    time.sleep(1)

def read_photoresistor():
    return board.analogRead(PHOTO_PIN)

while True:
    toggle_every_second()
    value = read_photoresistor()

# Problem #3 – State Machines

(Difficulty: Easy with Problem #2 completed, otherwise hard)

Not all controller are time-based. State machines are useful abstractions for coding all kinds of controllers. An example of a state machine is illustrated below. Each circle is a state, each state has its associated action(s) represented with arcs, and each action leads to the next state.

Code up a simple state machine with if-statements to control two LEDs. The first LED will be toggled based on time, and the second LED will mirror the state of the first LED. If first LED is on, then second LED should be off and vice versa.

# Setup code omitted...

def toggle_every_second():
    # code from Problem #2

def mirror_state():
    if <led1_on>:
        # turn led2 off
    else:
        # turn led1 on

while True:
    toggle_every_second()
    mirror_state()

# Problem #4 – Battery and Motor

(Difficulty: Easy)

In Robotics, usually there are at least two circuit boards – controller and driver board. The controller board is usually a microcontroller like the Arduino we have, or some kind of mini-computer such as Raspberry Pi. Suppose we are building an autonomous drone, the job of the controller is to process the terrain information and output commands, such as turn left, accelerate, and stop, to navigate through the terrain. Usually the controller does not support enough voltage and current to drive heavier components, such as a motor. Therefore, a driver board with a separate higher power supply is used to drive these components.

Typically the controller outputs digital signals to some kind of switch on the driver board. The switch controls whether a device, ex. motor, is on or off. For our purposes, we will use a transistor to serve as a switch.

# N-channel Transistor

A transistor is a three-terminal device, which are source, drain, and gate. In the diagram below, the source is connected to a LED then to 5V, the drain in connected to ground, and the gate is connected to D13. When the gate voltage is 0V, the transistor is off. In this case, there is no current flowing through from the source to drain, so the LED should be off. On the other hand, the transistor can be turned on by applying 5V at the gate. In this case, current will flow from 5V → LED → source → drain → ground, which will turn on the LED.

For this problem, set up a transistor switch circuit with a motor. The motor should be driven with 9V (although it will still work with 5V because the motor we have is small). Drive the motor on and off with a digital signal using the Arduino.

# More Information

Congratulations, you've made it to the end! To learn more about microcontrollers, Arduino has comprehensive tutorials and an active community sharing various projects. Make sure to also check out Arduino and Robots sections at Instructables for project inspirations.