La scheda pico ha due porte i2c (Wire e Wire1) e diversi pin esterni su cui può essere montata la funzionalità Wire.
Il default si trova ai pin 6 e 7.
Libreria Wire (I2C) con raspberry pi pico
Tag: arduino
Programmare Raspberry PI Pico con Arduino IDE
La programmazione di Raspberry pico può essere fatta dall’IDE arduino.
Per farlo è necessario predisporre il modulo nella modalità bootloader. Infatti, di default il modulo è predisposto per funzionare con python e quindi va resettato.
Per farlo è sufficiente tenere premuto il pulsante bootloader mentre si fornisce alimentazione e così facendo si aprirà una scheda di risorse del computer con il contenuto della memoria del raspberry.
Per fare l’upload del codice è necessario selezionare la porta che incomincia con u2f. Non va scelta la porta com4.
ESP32-CAM
Per programmare questa ottima schedina sono necessarie alcune precauzioni di base.
Dato che non sono presenti connettori usb, si rende indispensabile utilizzare un convertitore USB/UART, preferibilmente con la possibilità di scelta tra tensioni a 5V oppure a 3,3v.
Infatti, il modulo ESP32 necessita di una tensione di alimentazione a 5v, però accetta i comandi sui suoi terminali con tensioni a 3,3v. Questo vuol dire che se lo alimentassimo con un convertitore a 5v, si potrebbero bruciare i pin di ingresso del chip ftdi.
L’unica possibilità è utilizzare un modulo convertitore a 3,3v e una alimentazione separata dell’ESP32 a 5v, prelevata magari da un alimentatore per telefonini.
Come convertitore io utilizzo prevalentemente l’ottimo FT232RL, visibile in figura, oppure quello scaricabile da futura elettronica, al link https://www.futurashop.it/FT232USBUARTA_USB_UART :
Il ponticello lo rende utilizzabile anche a 3,3v. Questo modulo va collegato all’ESP32-CAM unicamente con i terminali RX, TX, GND, rispettivamente ai piedini 10 (U0TXD), 11 (U0RXD), 2 (GND)
L’alimentazione va fornita al terminale 1 (5v) e 9 (GND) collegando i terminali di un piccolo alimentatore usb.
Programmazione
Per programmare il modulo è necessario scaricare le librerie che sono state indicate nell’altro articolo disponibile a questo link: https://www.fattodate.org/2019/10/30/configurare-esp32-cam/
Dopo aver compilato il codice arduino, prima di caricarlo sulla scheda è necessario ponticellare il terminale 14 (GPIO0) verso massa e poi applicare il bottone di reset.
Successivamente al caricamento, se tutto sarà andato per il verso giusto, si dovrà fornire un altro reset (prima si dovrà rimuovere il ponticello del terminale 14) e visualizzare i parametri con cui è stato programmato collegando il monitor seriale con la velocità di 115200 baud.
Il monitor fornirà l’indirizzo IP della scheda.
Configurare ESP32 cam
Per caricare lo sketch da arduino è necessario selezionare la scheda ESP32 WROOVER e come modulo nel programma selezionare AI-TINKER.
Il modulo ESP32-CAM non possedendo una porta USB richiede, come interfaccia tra se’ ed una delle porte USB del PC , un adattatore USB-UART (*) , CP2102 o FT232RL USB to TTL Serial Converter, al fine di poterlo programmare tramite i suoi 2 pins GPIO3 (U0R) e GPIO1 (U0T) (serial pins).
Si tenga presente che, a seconda della soluzione adottata ( modulo FTDI o USB-TTL cable), sara’ necessario un cavo microUSB-USB per poter collegare l’adattatore ad un computer nel caso modulo FTDI e non lo sara’ nel caso USB-TTL cable – vedasi nota(*) e foto nr1_0, nr1_1 .
Prima di caricare uno sketch, ( nel nostro caso File > Examples > ESP32 > Camera > CameraWebServer ) con l’ IDE di Arduino, sara’ necessario soddisfare le seguenti condizioni:
1 ° – Verificare ( in ambiente Windows) che la porta COMx associata all’ FTDI converter ( modulo o USB-TTL cable) sia stata riconosciuta da Windows , altrimenti si proceda con l’installazione del driver FTDI – foto nr2
2 ° – se risultano gia’ installate le librerie espressif per la board esp32 si dovra’ procedere con il loro aggiornamento all’ultima versione tramite il Board Manager, in caso contrario si dovranno installare seguendo la procedura richiesta.
3 ° – configurare l’IDE per la scheda ESP32 Wrover Module ( per tutti gli altri parametri vedasi foto allegata nr3)
4 ° – il pin GPIO0 dell’ESP32 dovra’ essere cortocircuitato (tramite jumper) con il pin GND dell’ESP32 per poter abilitare la modalità flash ( foto nr1_1)- Se non viene soddisfatta questa condizione la compilazione dello sketch. verra’ abortita dando un errore di connection time-out.
5 ° – a questo punto il pulsante di reset dell’ESP32 dovra’ essere premuto –
6 ° – leggere lo sketch di esempio e procedere con l’editing selezionando ( uncomment) la camera appropriata ( AI-THINKER), deselezionando ( comment) quella di default ed inserendo, nelle due righe successive, le credenziali del local network : SSID e password al posto degli asterischi – foto nr3. Procedere quindi con la compilazione e l’uploading.
7 ° Dopo il caricamento dello sketch , dovra’ essere rimossa la connessione tra GPIO0 e GND , aperto il Serial Monitor con baud rate 115200 ed infine eseguito un reset premendo il relativo pulsante . A questo punto, se non si sono presentati intoppi, comparira’ la scritta: Camera Ready! ( foto nr3) seguita dalla URL che dovra’ essere inserita nel campo dedicato del browser.
8.1 ° – Qualora, come nel mio caso, si opti per la connessione su smartphone con Android ( foto nr5_0,nr5_1) e’ sufficiente creare ed abilitare un hotspot WiFi avente SSID e password identici a quelli dello sketch -( vedasi foto allegate ) e digitare l’URL composta da http://<l’indirizzo IP della ESP32-CAM> ( che trovate sulla schermata Mobile Hotspot – Connected Devices – vedi foto nr5_0 e nr5_1), nel browser Chrome di Android.
.
A questo punto dovrebbe apparire sulla sinistra della pagina Web ( foto nr6_0 e nr6_1), la GUI usata per controllare vari parametri della fotocamera. E’ sufficiente premere Get Still per scattare una foto, Start Stream per ricevere un flusso video dalla videocamera o Enroll Face per avviare il riconoscimemto facciale.
Sempre da telefonino, per salvare l’immagine sul suo supporto storage di default, e’ sufficiente premere con un dito sull’area dell’immagine per far apparire una finestra con le opzioni per il suo salvataggio.
(* )Può essere utilizzato un cavo seriale USB-TTL, nel qual caso possiamo collegare direttamente i suoi 4 terminali femmina (identici ai terminali femmina di un jumper wire) ai pins dell’ ESP32-CAM come mostrato nella foto allegate.
Le uscite dai due terminali femmina , cavo colore Bianco( RX) e cavo colore Verde(Tx) sono di livello 3.3V, quindi adatte per l’interfacciamento con l’ESP32-CAM.
Connessioni USB-TTL cable to ESP32-CAM:
Dal Nero al pin GND, dal Rosso al pin 5V, dal Bianco(Rx) al pin Tx , dal Verde(Tx) al pin Rx.
E’ questa la soluzione da me adottata.
(**) note
1. Please ensure that the module input power is at least 5V 2A, otherwise the picture will have a chance of water ripple.
2. The ESP32 GPIO32 pin controls the camera power. When the camera is working, please lower the GPIO32.
3. Since IO0 is connected to the camera XCLK, please leave IO0 floating when using it, please do not connect high and low level.
(***)
On-Board vs IPEX Antenna
Default jumper set for on-board antenna.
To improve the signal with an IPEX WiFi antenna you need to change the set of jumper with a bit of very careful soldering .
const char* ssid = “WIFI_SSID”; //WIFI SSID
const char* password = “WIFI_PWD”; //WIFI password
String token = “TOKEN_TELEGRAM_BOT”;
String chat_id = “CHAT_ID”;
include
include
include
include “soc/soc.h”
include “soc/rtc_cntl_reg.h”
include “esp_camera.h”
//CAMERA_MODEL_AI_THINKER
define PWDN_GPIO_NUM 32
define RESET_GPIO_NUM -1
define XCLK_GPIO_NUM 0
define SIOD_GPIO_NUM 26
define SIOC_GPIO_NUM 27
define Y9_GPIO_NUM 35
define Y8_GPIO_NUM 34
define Y7_GPIO_NUM 39
define Y6_GPIO_NUM 36
define Y5_GPIO_NUM 21
define Y4_GPIO_NUM 19
define Y3_GPIO_NUM 18
define Y2_GPIO_NUM 5
define VSYNC_GPIO_NUM 25
define HREF_GPIO_NUM 23
define PCLK_GPIO_NUM 22
int gpioPIR = 13; //PIR Motion Sensor
boolean remoteMode = false;
void setup()
{
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
Serial.begin(115200);
delay(10);
WiFi.mode(WIFI_STA);
Serial.println(“”);
Serial.print(“Connecting to “);
Serial.println(ssid);
WiFi.begin(ssid, password);
long int StartTime=millis();
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
if ((StartTime+10000) < millis()) break;
}
Serial.println(“”);
Serial.println(“STAIP address: “);
Serial.println(WiFi.localIP());
Serial.println(“”);
if (WiFi.status() != WL_CONNECTED) {
Serial.println(“Reset”);
ledcAttachPin(4, 3);
ledcSetup(3, 5000, 8);
ledcWrite(3,10);
delay(200);
ledcWrite(3,0);
delay(200);
ledcDetachPin(3);
delay(1000);
ESP.restart();}
else
{
ledcAttachPin(4, 3);
ledcSetup(3, 5000, 8);
for (int i=0;i<5;i++) {
ledcWrite(3,10);
delay(200);
ledcWrite(3,0);
delay(200);
}
ledcDetachPin(3);
}
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;
if(psramFound())
{
config.frame_size = FRAMESIZE_VGA;
config.jpeg_quality = 10; //0-63 lower number means higher quality
config.fb_count = 2;
}
else
{
config.frame_size = FRAMESIZE_QQVGA;
config.jpeg_quality = 12; //0-63 lower number means higher quality
config.fb_count = 1;
}
// camera init
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK)
{
Serial.printf(“Camera init failed with error 0x%x”, err);
delay(1000);
ESP.restart();
}
sensor_t * s = esp_camera_sensor_get();
s->set_framesize(s, FRAMESIZE_XGA);
}
ESP32-WROOOM
Il modulo corrisponde essenzialmente a quello che Arduino chiama Esp32 Web Module.
In Arduino è necessario scegliere quella scheda, configurare eventualmente una velocità di connessione inferiore ai 921000 b/s (per esempio 115200) e lasciare la configurazione inalterata.
Per fare il test con un WebServer si può cominciare da AdvancedWebServer, della libreria degli esempi.
Per la compilazione è necessario tenere premuto il bottone BOOT, in alto, per la durata della programmazione.
Successivamente, per azionare il dispositivo offline è necessario spingere il bottone EN e il programma parte.
Per vedere l’indirizzo IP è sufficiente collegare il monitor seriale. Su questo può essere fatto il log dell’indirizzo.
Pistola in legno con elastici
Prendendo spunto dal fantastico tutorial visibile all’indirizzo Tutorial M9 Rubber Band Gun ho deciso di realizzarmi una fantastica pistola in legno con proiettili elastici.
Il tutorial è corredato anche di piani dettagliati di montaggio della pistola, scaricabili all’indirizzo pdf.
Tali piani possono essere stampati e poi ricalcati con una sega a nastro, oppure, come ho fatto io, possono essere tagliati alla cnc, essendo già disegnati a misura.
I piani si compongono di alcuni strati, da incollare tra di loro, di multistrato da 4 mm di spessore.
L’unica cosa a cui bisogna prestare molta attenzione, altrimenti si corre il rischio di dover tagliare più volte le sagome in legno, è che i percorsi nel file pdf non sono tutti chiusi. A prima vista, sembrerebbe di sì, ma se si esegue il taglio ci si accorge che i percorsi di taglio sono calcolati un po’ all’interno e un po’ all’esterno, pregiudicando il corretto allineamento dei pezzi.
Il risultato è visibile in figura
Nella figura sottostante si vede il meccanismo di caricamento degli elastici che, a seconda delle dimensioni, possono arrivare fino a 7-8 consecutivi.
Infine, un particolare del caricatore che permette di installare degli elastici di riserva in caso di emergenza:
Come ti simulo una tastiera con Arduino
Da qualche tempo mi diletto a rivivere il passato dei giochi, quelli per intenderci che spopolavano le sale giochi e/o che giravano sui vecchissimi (ma divertentissimi) commodore 64, amiga, zx spectrum, ecc.
Innanzitutto un po’ di spiegazioni, prima di arrivare al punto in cui ci servirà fare uso del nostro fidato arduino.
Cercando in giro si trova davvero di tutto. Esistono emulatori che permettono di emulare singole piattaforme, come n64, commodore 64, ecc. Ne esistono altri, invece, e di questi parlerò in questo articolo, che non emulano nessuna piattaforma in particolare, come MAME.
Dopo aver provato i vari retropie, pimame, su raspberry, con scarsi risultati, devo dire, mi sono concentrato su quello che potevo far girare sul mio Android, un Samsung s3 di oltre due anni fa.
Quello che ho trovato più interessante, tra i vari disponibili sullo store, è Mame4droid.
Di questo ne esistono due versioni, che possono essere installate entrambe contemporaneamente. La prima si chiama Mame4droid 0.37b5 e la seconda Mame4droid 0.139.
Visto che ci ho messo un po’ a capire la differenza ve la riporto: la prima permette di far girare giochi le cui rom hanno il numero di versione 0.37b5 (veramente io ho utilizzato le 0.37b11), la seconda vi obbliga a cercare qualcosa con il numero di versione 0.139.
Vi domanderete: embè ? Che me ne faccio ?
Per far girare qualcosa all’interno di un emulatore è necessario procurarsi le cosiddette roms. Sono dei piccoli (a volte) file compressi che contengono una copia binaria fedele al gioco originale, in formato leggibile dall’emulatore, che qualcuno si è preso la briga di creare per voi.
Tralasciando il discorso che, ovviamente, scaricare queste rom equivale a commettere un “piccolo” reato, in rete si trovano archivi enormi di questi giochi, alcune volte già pronti per essere solo installati. L’importante è avere un po’ di pazienza e cercare solo quello che vi serve (ricordate la versione). Oppure vi create la vostra bella copia di una rom partendo da un gioco già in vostro possesso…
Una volta che avrete il vostro nuovo archivio di roms su PC, queste vanno caricate nella flash di android.
Allora, per la versione 0.37b5, vanno caricate nella directory /sdcard/ROMS/MAME4ALL/roms, mentre per la versione 0.139 vanno caricate sotto /sdcard/ROMS/MAME/roms. Non sbagliate, altrimenti l’emulatore non le troverà mai.
Se ritenete di avere copiato il file nella posizione giusta ma l’emulatore non vi trova ancora nulla, allora vuol dire che non avete caricato la versione del file corretta, come spiegato sopra. Cercate altrove.
Quello che dovreste vedere quando avviate l’applicazione è qualcosa del genere:
A tra poco per il proseguimento… Continua a leggere Come ti simulo una tastiera con Arduino