ls /dev/tty* | grep usb

in my case I got

/dev/tty.usbserial-14120

Now we can connect via screen:

screen /dev/tty.usbserial-14120 115200

When you reset the board you should see something like this

configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3fff0030,len:5656
load:0x40078000,len:12696
load:0x40080400,len:4292
entry 0x400806b0

To end the session in screen, press Ctrl+a, and type :quit and press Enter.

Further Reading

Install ESP32 in ArduinoIDE

Using MicroPython on FireBeetle ESP32

Mailbox IoT ESP 32 Project

The post How to connect to your ESP32 on macos appeared first on Creatronix.

In Fire Beetle ESP 32 Project I wrote about connecting the FireBeetle ESP32 with the Arduino IDE and writing a little C-style program. Another interesting approach is to use MicroPython.

Installing MicroPython

Install esptool

To get MicroPython onto the board we use the esptool command line. Because we are in the Python ecosystem we use pip to install esptool:

pip install esptool

Download firmware

Go to https://micropython.org/download/esp32/

and download the latest release as of today is v1.19.1 (2022-06-18) .bin

Erase flash

Before we can install the firmware it is recommended to erase the flash

On my machine the port is /dev/tty.usbserial-14130. This can vary depending on your OS and setup.

esptool.py --port /dev/tty.usbserial-14130 erase_flash

Flash Firmware

Flashing the firmware looks like the following:

esptool.py --chip esp32 --baud 115200 --port /dev/tty.usbserial-14130 write_flash -z 0x1000 ./esp32-idf3-20191220-v1.12.bin

To prevent flash errors we set the transmission speed to 115200 baud

Connect via Serial

When you work with an unixoid system like linux or macos you can use screen to connect via serial port. On Windows you can download the program putty

screen /dev/tty.usbserial-14130 115200

After connecting you will get the prompt from the python command line aka REPL

Working with scripts

After fiddling around with the REPL we want to write our first program. We write a program like the Arduino blink sketch but just in Python:

Blink Program

The onboard blue led is connected to pin 2

from machine import Pin 
import time 
p2 = Pin(2, Pin.OUT) 
def blink(): 
    while True: 
        p2.value(0) 
        time.sleep(1) 
        p2.value(1) 
        time.sleep(1) 
blink()

Save this script in a file with the name blink.py

Uploading scripts

To upload scripts to the FireBeetle board we use another nice library called ampy from AdaFruit. We install it via pip as well

pip install adafruit-ampy

With ampy we can upload the file to our board.

ampy --port /dev/tty.usbserial-14130 put blink.py

If it doesn’t work right away, please close your terminal connection.

Starting scripts

When the upload is finished you can reconnect via serial console and import your script and the led should start to blink

>>>import blink

Running scripts on startup

When your script should start directly at power on, you upload it as main.py

ampy --port /dev/tty.usbserial-14130 put blink.py /main.py

If you had fun so far feel free to read my Mailbox IoT ESP 32 Project article as well

Further Reading

https://docs.micropython.org/en/latest/esp32/quickref.html#

https://blog.miguelgrinberg.com/post/micropython-and-the-internet-of-things-part-i-welcome

The post Using MicroPython on FireBeetle ESP32 appeared first on Creatronix.

Out of curiosity I bought a ESP32 board to tinker with, but for almost half a year hadn’t got an idea what to do with it… But then!

Project Idea

The idea: Every time I get mail into my physical snail mail mailbox, the mailbox shall send a message via Telegram to my smartphone:

But with many ideas the execution can become time consuming. Well, let’s see 🙂

MicroPython

As a Python afficionado I was relieved as I found out, that you can use MicroPython on the ESP32 board. I wrote a separate article as a prerequisite:

Using MicroPython on FireBeetle ESP32

From now on I assume, that You have a MicroPython version running on the ESP32.

Buttons

When the lid of the mailbox is opened, a button shall trigger the action, so we need to configure a GPIO as an input.

This is done via the machine package.

When we don’t want to have external pullups we can enable the internal pullup resistor. Beware: the logic becomes inverted, because the pin is high in idle we pull it down with the button to 0 volts, hence button pressed equals value zero

import machine 
button = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP) 
while True: 
    if not button.value(): 
        print('Button pressed!')

Deep Sleep

Due to the fact that the device will be battery powered and will just need to send a message once or twice a day, we will need the deepsleep capability.

The machine package gives you access to the deepsleep function as well.

A bit counterintuitive but you also need the esp32 package for defining a wake up cause. One caveat: not every GPIO is able to wake up the ESP32 from deepsleep but GPIO 4 will do it.

import machine 
import esp32 
from time import sleep 

wake1 = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP) 
esp32.wake_on_ext0(pin=wake1, level=esp32.WAKEUP_ALL_LOW) 
print('Im awake. Going to sleep in 10 seconds') 
sleep(10) 
print('Going to sleep now') 

machine.deepsleep()

Setting up Wifi in MicroPython

To be able to send messages we need a WiFi connection. In MicroPython this is handled by the network package.

import network

The ESP32 can either work as a station or as an access point. We need the first option so we use the STA_IF configuration.
sta_if = network.WLAN(network.STA_IF)
the interface has to be activated via

sta_if.active(True)

Now we can connect to our Wi-Fi

sta_if.connect(ssid,  password)

You can check the status of the connection via:

sta_if.isconnected()

Writing a Telegram Bot

Create TG bot

1. Open Telegram app on your phone
2. Search for @botfather
3. Start chat
4. Send /newbot
5. Pick a name
6. Pick a username (must be unique)
7. Receive credentials

Chat with your bot

Now you can search for your bot’s name and send a message

Python test Program

Telegram has a nice python package which you can pip install

pip install python-telegram-bot --upgrade

import telegram 

bot = telegram.Bot(token='<your_token>') 

if __name__ == '__main__': 
    print(bot.get_me()) 
    bot.send_message(chat_id="<your_chat_id>", text="Post ist da")

This program is just used to test the connectivity of your bot.

urequests

Because we don’t have access to the telegram package inside the ESP / MicroPython environment we use urequests.

urequests is similar to the requests package and lets you send http messages.

Sending messages looks like the following

import urequests 

requests.get("https://api.telegram.org/bot<your_token>/sendMessage?text=hallo&chat_id=<your_chat_id>")

The complete Code

import network
import urequests
import machine
import esp32
from time import sleep

SSID = <your_ssid>
WIFI_PW = <your_wifi_pw>
TOKEN = <your_tg_token>
URL = "https://api.telegram.org/bot{}/".format(TOKEN)
CHAT_ID = <your_chat_id>


def connect_to_wifi(ssid, password):
    print("MBB: connect_to_wifi")
    sta_if = network.WLAN(network.STA_IF)

    if sta_if.isconnected():
        print("MBB: already connected")
        return

    if not sta_if.active():
        print("MBB: activate network adapter")
        sta_if.active(True)
        print("MBB: network adapter activated")

    if not sta_if.isconnected():
        print("MBB: trying to connect")
        sta_if.connect('%s' % ssid, '%s' % password)

        while not sta_if.isconnected():
            pass
        print("MBB: connected successfully")
    print(sta_if.ifconfig())


def get_url(url):
    response = urequests.get(url)
    content = response.text
    return content


def send_message(text, chat_id):
    url = URL + "sendMessage?text={}&chat_id={}".format(text, chat_id)
    get_url(url)


if __name__ == '__main__':
    print("MBB: start")
    #disable LED on firebeetle board
    p2 = machine.Pin(2, machine.Pin.OUT)
    p2.value(0)
    wake1 = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP) # pin 4 is able to wake
    esp32.wake_on_ext0(pin=wake1, level=esp32.WAKEUP_ALL_LOW)
    print('MBB: Im awake. Going to sleep in 10 seconds')
    connect_to_wifi(SSID, WIFI_PW)
    print("MBB: sending message")
    send_message("Post ist endlich da", CHAT_ID)
    print("MBB: finished")
    sleep(10)
    print('MBB: Going to sleep now')
    machine.deepsleep()

Testing

After charging the battery we can use the board independently from the computer

Sources

https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf

The post Mailbox IoT ESP 32 Project appeared first on Creatronix.