Exploring Nano32 with MicroPython

Table of Contents#

1. Fundamental Concepts
   • What is Nano32?
   • What is MicroPython?
   • Why Use MicroPython on Nano32?
2. Getting Started
   • Prerequisites
   • Flashing MicroPython onto Nano32
3. Basic Usage
   • Blinking an LED
   • Reading Input from a Button
4. Common Practices
   • Interfacing with Sensors
   • Controlling Actuators
5. Best Practices
   • Memory Management
   • Error Handling
6. Conclusion
7. References

1. Fundamental Concepts#

What is Nano32?#

The Nano32 is a microcontroller board based on the ESP32 chip. It features a dual-core 32-bit microprocessor, built - in Wi - Fi and Bluetooth connectivity, and a rich set of input/output pins. The small form factor makes it suitable for a wide range of applications, from IoT projects to robotics.

What is MicroPython?#

MicroPython is a lightweight implementation of the Python programming language for microcontrollers and embedded systems. It allows developers to write Python code that can run directly on the hardware, eliminating the need for complex toolchains and low - level programming languages like C or C++.

Why Use MicroPython on Nano32?#

• Ease of Use: Python is a high - level programming language with a simple syntax, making it easy for beginners to learn and use.
• Rapid Prototyping: You can quickly develop and test your ideas without spending a lot of time on writing and debugging low - level code.
• Rich Library Support: MicroPython has a growing number of libraries that can be used to interface with various sensors, actuators, and communication modules.

2. Getting Started#

Prerequisites#

• A Nano32 board
• A USB cable
• A computer with a serial terminal program (e.g., PuTTY on Windows or screen on Linux)
• esptool.py (a tool for flashing the ESP32)

Flashing MicroPython onto Nano32#

1. Download the MicroPython firmware for the ESP32 from the official MicroPython website.
2. Connect the Nano32 to your computer using the USB cable.
3. Use esptool.py to erase the existing flash memory on the Nano32:

esptool.py --port /dev/ttyUSB0 erase_flash

4. Flash the MicroPython firmware onto the Nano32:

esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-xxxx.bin

Replace /dev/ttyUSB0 with the actual serial port of your Nano32 and esp32 - xxxx.bin with the name of the downloaded firmware file.

3. Basic Usage#

Blinking an LED#

import machine
import time
 
# Define the pin connected to the LED
led = machine.Pin(2, machine.Pin.OUT)
 
while True:
    led.on()
    time.sleep(1)
    led.off()
    time.sleep(1)

In this code, we first import the machine and time modules. The machine module is used to interact with the hardware, and the time module is used for delaying the execution of the code. We then define a pin object for the LED and set it as an output pin. In the infinite loop, we turn the LED on, wait for 1 second, turn it off, and wait for another 1 second.

Reading Input from a Button#

import machine
 
# Define the pin connected to the button
button = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)
 
while True:
    if button.value() == 0:
        print("Button is pressed")

Here, we define a pin object for the button and set it as an input pin with a pull - up resistor. In the infinite loop, we check the value of the button pin. If the value is 0, it means the button is pressed, and we print a message.

4. Common Practices#

Interfacing with Sensors#

Let's take a DHT11 temperature and humidity sensor as an example. First, you need to install the dht library in your MicroPython environment.

import dht
import machine
import time
 
# Define the pin connected to the DHT11 sensor
d = dht.DHT11(machine.Pin(4))
 
while True:
    try:
        d.measure()
        temp = d.temperature()
        hum = d.humidity()
        print('Temperature: {}°C, Humidity: {}%'.format(temp, hum))
    except OSError as e:
        print('Failed to read sensor.')
    time.sleep(2)

In this code, we import the dht module and create a DHT11 object connected to pin 4. In the loop, we measure the temperature and humidity, and print the values. If there is an error reading the sensor, we catch the OSError and print an error message.

Controlling Actuators#

For example, controlling a servo motor:

import machine
import time
 
# Create a PWM object for the servo
pwm = machine.PWM(machine.Pin(12), freq = 50)
 
# Function to set the servo angle
def set_angle(angle):
    duty = int((angle / 180) * 102 + 26)
    pwm.duty(duty)
 
# Move the servo to different angles
while True:
    set_angle(0)
    time.sleep(1)
    set_angle(90)
    time.sleep(1)
    set_angle(180)
    time.sleep(1)

Here, we create a PWM (Pulse Width Modulation) object on pin 12 with a frequency of 50 Hz. The set_angle function calculates the duty cycle based on the desired angle and sets the PWM duty cycle accordingly. In the loop, we move the servo to 0°, 90°, and 180° angles with a 1 - second delay between each movement.

5. Best Practices#

Memory Management#

• Use Local Variables: Local variables are stored on the stack and are automatically freed when the function returns, reducing the memory usage.
• Delete Unused Objects: Use the del keyword to delete objects that are no longer needed.

my_list = [1, 2, 3]
# Do something with my_list
del my_list

Error Handling#

• Use Try - Except Blocks: Wrap your code in try - except blocks to catch and handle exceptions gracefully. This prevents your program from crashing due to unexpected errors.

try:
    # Code that may raise an exception
    result = 1 / 0
except ZeroDivisionError:
    print("Division by zero error.")

6. Conclusion#

In this blog post, we have explored the combination of Nano32 and MicroPython. We started with the fundamental concepts of both the Nano32 board and MicroPython, then learned how to get started by flashing the MicroPython firmware onto the Nano32. We also looked at basic usage examples such as blinking an LED and reading input from a button, as well as common practices for interfacing with sensors and controlling actuators. Finally, we discussed some best practices for memory management and error handling. By using MicroPython on the Nano32, you can take advantage of the simplicity and flexibility of Python to develop a wide range of embedded system applications.

7. References#

• MicroPython official website: https://micropython.org/
• ESP32 documentation: https://docs.espressif.com/projects/esp - idf/en/latest/esp32/
• esptool.py repository: https://github.com/espressif/esptool