Archivi autore: admin

Arduino – misurare tensioni continue fino a 5V

La misurazione di una tensione con Arduino è un esercizio standard utilizzato per spiegare come funziona il convertitore Analogico Digitale sulla scheda. Nell’esempio che segue verrà mostrato come visualizzare sulla Serial Monitor la tensione di una batterie da 1,5V ma in generale di una tensione non superiore ai 5V, seguono poi una serie di esercizi per i miei studenti.
Nella prossima lezione mostreremo come misurare una tensione superiore ai 5V.

ATTENZIONE
E’ essenziale ricordare che non bisogna in alcun modo inserire tensioni superiori a 5V sui pin di Arduino, in quanto potreste distruggere irrimediabilmente la scheda.

Per la rilevazione di una tensione elettrica su un pin analogico viene utilizzata la funzione analogRead, che come più volte indicato su questo sito, è in grado di convertire una tensione tra 0V e 5V continui in un valore numerico intero con risoluzione di 10 bit tra 0 e 1023, operazione svolta dal convertitore A/D.

Ricordo che l’analogRead(pin) legge il valore di tensione (compreso tra 0 e 5V) applicato sul piedino analogico ‘pin’ con una risoluzione di 10 bit e la converte in un valore numerico compreso tra 0 e 1023, corrispondente quindi ad un intervallo di 1024 valori, pertanto il valore unitario corrisponde a:

Vu = 5V/1023 = 4,89 mV

Per conoscere il valore di tensione rilevato sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), quello che chiamiamo valore quantizzato Vq compreso tra 0 e 1024, il valore misurato Vm sarà:

Vm = Vu x Vq

e sapendo che Vu corrisponde a 4,89 mV possiamo scrivere:

Vm = 4,89 x Vq

Nota per i miei allievi: riprenderemo questo semplice calcolo qundo utilizzeremo ad esempio i sensori di temperatura.

Il semplice schema di collegamento è riportato nell’immagine che segue:

Per stampare sulla Serial Monitor la tensione ai capi della batteria, useremo valori di tipo float (in virgola mobile), che come indicato nel mio post: “Arduino: tipi di dati – ripasso” possiamo esprime valori compresi tra –3.4028235E+38 e 3.4028235E+38.
La stampa di numeri in virgola mobile sula Serial Monitor verrà rappresentata con numeri che hanno al massimo con due cifre decimali, riprenderemo questo aspetto nel secondo esempio di questa lezione.

1// Prof. Maffucci Michele
2// Esempio 01: Misura di tensioni continue non superiori a 5V
3// utilizzando variabili di tipo float
4// Data: 01.10.2021
5 
6// tensione di riferimento predefinita sulla scheda
7const float tensioneDiRiferimento = 5.0;
8 
9// batteria connessa al pin analogico 0
10const byte pinBatteria = A0;
11 
12void setup() {
13  // inizializzazione della porta seriale
14  Serial.begin(9600);
15}
16 
17void loop() {
18  // legge il valore della batteria e lo trasforma
19  // in un valore numerico tra 0 e 1023
20  int valoreLetto = analogRead(pinBatteria);
21 
22  // calcolo della proporzione
23  // volt:tensioneDiRiferimento = valoreLetto:1023.0
24  // da cui si ricava la formula che segue
25  float volt = (valoreLetto/1023.0) * tensioneDiRiferimento;
26 
27  // stampa sulla Serial Monitor la tensione misurata
28  Serial.println(volt);
29}

Per evitare spreco di memoria dovuto ai calcoli che utilizzano i tipi di dati float che occupano maggiore memoria, è possibile utilizzare al posto del tipo float il tipo long, ovvero un int lungo rappresentato da 4 byte in grado di rappresentare numeri interi tra –2147483648 a 2147483647.

Vediamo come modificare lo sketch precedente per rilevare tensioni espresse in millivolt in cui però si utilizzano variabili intere di tipo long:

1// Prof. Maffucci Michele
2// Esempio 02: Misura di tensioni continue non superiori a 5V
3// utilizzando variabili di tipo float
4// Data: 01.10.2021
5 
6// batteria connessa al pin analogico 0
7const byte pinBatteria = A0;
8 
9void setup() {
10  // inizializzazione della porta seriale
11  Serial.begin(9600);
12}
13 
14void loop() {
15  // legge il valore della batteria e lo trasforma
16  // in un valore numerico tra 0 e 1023
17  // valoreLetto è di tipo long
18  long valoreLetto = analogRead(pinBatteria);
19 
20  // stampa sulla Serial Monitor la tensione misurata
21  // in millivolt
22   
23  Serial.println((valoreLetto*(500000/1023L))/100);
24}

Quindi per evitare di effettuare calcoli con numeri di tipo float (in virgola mobile) senza perdere precisione, il trucco consiste nell’operare sui valori in millivolt invece che sui valori in volt. Ricordo che 1 volt corrisponde a 1000 millivolt.

Come detto all’inizio di questa lezione sappiamo che un valore numerico di 1023 restituito dall’analogRead, corrisponde al valore massimo di 5000 millivolt, allora ogni unità rappresenta 5000/1023 millivolt, che corrisponde a 4,89 millivolt. Come detto nell’esempio precedente, la stampa su Serial Monitor di un numero in virgola mobile mostrerà al massimo due decimali, pertanto l’eliminazione dei decimali nel secondo esempio possiamo farlo moltiplicando per 100, nel codice: 5000×100=500000, questo valore verrà poi moltiplicato per il rapporto tra il valore letto e 1023 ed il tutto ancora diviso per 100, così facendo otterremo il valore in millivolt. Questo calcolo permette di far effettuare al compilatore solamente calcoli tra interi e non tra float, rendendo quindi la computazione più veloce e riducendo la quantità di memoria utilizzata.

Si noti che al fondo del numero 1023 è stata aggiuta una L, cioè 1023L, che indicare al compilatore che il numero rappresentato è di tipo long (4 byte).

Esercizi per i miei studenti

Esercizio 1
Utilizzare un Trimmer per regolare la tensione in ingresso ad A0 tra 0 e 5V, in questo caso si prenda la tensione di 5V dal pin di Arduino.

Esercizio 2
Nel primo sketch proposto utilizzare la funzione map per convertire il valore restituito dall’ analogRead in un valore di tensione. In questo caso nascono dei problemi sulla precisione della misura, sapresti indicarmi quali?

Esercizio 3
Visualizzare il valore di tensione regolato dal Trimmer sul Plotter Seriale.

Esercizio 4
Utilizzando uno qualsiasi dei due sketch indicati sopra e visualizzare la tensione misurate sul un display 16×2

Esercizio 5
Aggiungere all’esercizio precedente l’indicazione di carica data da un grafico costituito da 5 quadrati che ne indicano il livello di carica, non appena il livello di carica raggiunge 1 volt il quadrettino inizia a lampeggiare.

Buon Making a tutti

Raspberry Pi Pico – controllare lo stato di un pin digitale

Lascia una risposta

Propongo in questa breve lezione due esempi di base sull’uso del Raspberry Pi Pico: identificare lo stato di un pulsante e realizzazione di un interruttore mediante un pulsante.

Per questo esempio utilizzeremo il pin 14 a cui connetteremo un pin del pulsante, così come rappresentato nell’immagine che segue. Come sapete molti dei pulsanti disponibili nei kit elettronici sono costituiti da 4 pin, connessi frontalmente a due a due.
Proseguiamo connettendo il secondo pin del pulsante al positivo sulla breadboard (3,3V). Ricordiamoci inoltre la connessione del 3,3V del PiPico al positivo della breadboard.

E’ molto importante ricordare che una simile connessione del pulsante con il PiPico potrebbe causare problemi di cortocircuito alla pressione del pulsante, perché non presente una resistore di PULL-UP o di PULL-DOWN fisico. Per evitare di utilizzare un resistore, attiviamo la resistenza di PULL-DOWN sul pin 14, ATTENZIONE ricordate di fare questa operazione altrimenti rischiate di distruggere irrimediabilmente il vostro microcontrollore.

Aprite l’editor Thonny e digitate il seguente programma:

1# Prof. Maffucci Michele
2# Controllo dello stato sul pin 14 (una sola volta)
3# 18.09.2021
4 
5# libreria che permette di utilizzare MicroPython con il RaspyMicro
6import machine
7 
8# creazione dell'oggetto pulsante che include il pin 14 impostato come input
9# su cui viene attivata il resistore di PULL-DOWN
10pulsante = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
11 
12# la lettura del pulante viene fatta usando l'API machine
13# usando la funzione value
14 
15print(button.value())

Salvate il programma sulla vostra scheda, assegnate ad esempio il nome pulsante1.py
Se mandate in esecuzione il programma lo stato del pin verrà mostrato immediatamente sulla Shell una sola volta.

Se non premete il pulsante verrà mostrato sulla Shell il valore logico 0 in quanto abbiamo utilizzato una resistenza di PULL-DOWN, nel momento in cui, all’avvio premete il pulsante lo stato logico visualizzato sulla Shell sarà 1.

Per leggere lo stato del pulsante in modo continuo bisognerà aggiungere un loop all’interno del programma che segue che chiameremo pulsante2.py

1# Prof. Maffucci Michele
2# Controllo dello stato sul pin 14 (in modo continuo)
3# 18.09.2021
4 
5# libreria che permette di utilizzare MicroPython con il RaspyMicro
6import machine
7 
8# per la gestione del tempo
9import utime
10 
11# creazione dell'oggetto pulsante che include il pin 14 impostato come input
12# su cui viene attivata il resistore di PULL-DOWN
13pulsante = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
14 
15# la lettura del pulante viene fatta usando l'API machine
16# usando la funzione value
17 
18# while True definisce un loop infinito al cui interno
19# troviamo il controllo dello stato del pulsante
20while True:
21    # se la condizione è vera viene stampato
22    # il messaggio mediante la print
23    # e fermato il programma per 1 secondi
24    if pulsante.value() == 1:
25        print("Hai premuto il pulsante")
26        utime.sleep(1)

Premete sul pulsante di Run nell’IDE, vedrete che fino a quando non premete il pulsante non accade nulla. Non appena il pulsante viene premuto viene stampata sulla Shell la strina “Hai premuto il pulsante”.

Attenzione che senza la brevissima pausa di 1 secondo verrebbe stampato continuamente il messaggio “Hai premuto il pulsante”.

Vedrete quindi la stampa del messaggio ogni secondo. Se mantenete premuto il pulsante per un tempo superiore a 1 secondi verrà stampato nuovamente il messaggio e ciò si ripeterà ogni secondo fino a quando non rilasciamo il pulsante.

Vediamo ora un programma che, oltre ad inviare un messaggio sulla Shell, accende un LED esterno connesso al pin 15 ogni volta che premiamo il pulsante, chiamiamo il programma pulsante3.py.

1# Prof. Maffucci Michele
2# Controllo dello stato sul pin 14 (in modo continuo)
3# eaccensione di un led alla pressione del pulsante
4# 18.09.2021
5 
6# libreria che permette di utilizzare MicroPython con il RaspyMicro
7import machine
8 
9# per la gestione del tempo
10import utime
11 
12# creazione dell'oggetto pulsante che include il pin 14 impostato come input
13# su cui viene attivata il resistore di PULL-DOWN
14pulsante = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
15 
16#pin 15 dichiarato come OUTPUT
17ledEsterno = machine.Pin(15, machine.Pin.OUT)
18 
19# while True definisce un loop infinito al cui interno
20# troviamo il controllo dello stato del pulsante
21while True:
22    # se la condizione è vera viene stampato
23    # il messaggio mediante la print
24    # e fermato il programma per 1 secondi
25    if pulsante.value() == 1:
26        ledEsterno.value(1)    # imposta il livello logico 1 sul pin 15
27        print("Hai premuto il pulsante")
28        utime.sleep(0.5)       # imposta una pausa di mezzo secondo
29        ledEsterno.value(0)    # imposta il livello logico 0 sul pin 15

Vediamo ora come realizzare un programma che realizza la funzione di un interruttore, cioè il mantenimento dello stato al rilascio del pulsante. Chiamiamo il programma interruttore1.py. Il circuito è il medesimo dell’esempio al passo precedente.

1# Prof. Maffucci Michele
2# realizzazione di un interruttore 
3# mediante pulsante connesso al Pin 14 con antirimbalzo software
4# con accensione di un LED connesso al pin 15
5# 18.09.2021
6 
7# libreria che permette di utilizzare MicroPython con il RaspyMicro
8import machine
9 
10# per la gestione del tempo
11import utime
12 
13# creazione dell'oggetto pulsante che include il pin 14 impostato come input
14# su cui viene attivata il resistore di PULL-DOWN
15pulsante = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
16 
17#pin 15 dichiarato come OUTPUT
18ledEsterno = machine.Pin(15, machine.Pin.OUT)
19 
20# val usato per conservare lo stato del pulsante
21val = 0
22 
23# vecchio_val per conservare lo stato del pulsante al passo precedente
24vecchio_val = 0
25 
26# ricorda lo stato in cui si trova il LED,
27# stato = 0 led spento, stato = 1 led acceso
28stato = 0
29 
30# while True definisce un loop infinito al cui interno
31# troviamo il controllo dello stato del pulsante
32while True:
33    val = pulsante.value()                   # legge il valore del pulsante e lo conserva
34    if (val == 1) and (vecchio_val == 0):    # controlla se è accaduto qualcosa
35        stato = 1 - stato
36        utime.sleep(0.15)                # attesa di 15 millisecondi
37    vecchio_val = val;
38    if (stato == 1):
39        ledEsterno.value(1)    # imposta il livello logico 1 sul pin 15
40    else:
41        ledEsterno.value(0)    # imposta il livello logico 0 sul pin 15

Modifichiamo ora il programma precedente inviando sulla Shell il messaggio che indica lo stato del LED, chiamiamo il programma interruttire2.py. Il circuito è il medesimo dell’esempio al passo precedente.

1# Prof. Maffucci Michele
2# realizzazione di un interruttore 
3# mediante pulsante connesso al Pin 14 con antirimbalzo software
4# con accensione di un LED connesso al pin 15
5# e stampa dello stato del LED sulla Shell
6# 18.09.2021
7 
8# libreria che permette di utilizzare MicroPython con il RaspyMicro
9import machine
10 
11# per la gestione del tempo
12import utime
13 
14# creazione dell'oggetto pulsante che include il pin 14 impostato come input
15# su cui viene attivata il resistore di PULL-DOWN
16pulsante = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)
17 
18#pin 15 dichiarato come OUTPUT
19ledEsterno = machine.Pin(15, machine.Pin.OUT)
20 
21# val usato per conservare lo stato del pulsante
22val = 0
23 
24# vecchio_val per conservare lo stato del pulsante al passo precedente
25vecchio_val = 0
26 
27# ricorda lo stato in cui si trova il LED,
28# stato = 0 led spento, stato = 1 led acceso
29stato = 0
30 
31# stampare una sola volta il messaggio 'LED acceso' o 'LED spento' sulla Shell
32abilitaMessaggio = 0
33 
34# while True definisce un loop infinito al cui interno
35# troviamo il controllo dello stato del pulsante
36while True:
37    val = pulsante.value()                    # legge il valore del pulsante e lo conserva
38    if (val == 1) and (vecchio_val == 0):     # controlla se è accaduto qualcosa
39        stato = 1 - stato
40        utime.sleep(0.15)             # attesa di 15 millisecondi
41    vecchio_val = val;
42    if (stato == 1) and (abilitaMessaggio == 0):
43        ledEsterno.value(1)                   # imposta il livello logico 1 sul pin 15
44        abilitaMessaggio = 1
45        print("LED acceso")                   # stampa il messaggio
46        utime.sleep(1)
47    elif (stato == 0) and (abilitaMessaggio == 1):
48        ledEsterno.value(0)                   # imposta il livello logico 0 sul pin 15
49        abilitaMessaggio = 0
50        print("LED spento")                   # stampa il messaggio
51        utime.sleep(1)

Buon Coding a tutti

I miei corsi per Tecnica della Scuola: STEAM, idee di lezione e didattica attiva – 2′ edizione

Lascia una risposta

Sono felice di comunicarvi che nel mese di ottobre prossimo, nelle date indicate di seguito, svolgerò la seconda edizione del corso: STEAM, idee di lezione e didattica attiva.
Questa seconda edizione avrà contenuti simili a quelli della prima edizione, però fornirò ulteriori suggerimenti che derivano dalle necessità espresse dai colleghi che hanno frequentato la prima edizione e dalle richieste pervenutemi via email.
La necessità impellente che molti esprimono è quella di fornire, anche se non è argomento incluso nel programma del corso, indicazioni e schede di lavoro specifiche per micro:bit e IoT, sarà quindi mia cura suggerire lavori e modalità operative in laboratorio. L’IoT con micro:bit sarà sicuramente argomento di un prossimo corso che sto realizzando e spero possa essere presentato nel breve.
Molti ancora mi chiedono indicazioni che permettono di realizzare attività in cui interagiscono più tecnologie: Ozobot Evo, micro:bit, Lego ed altri ancora desiderano realizzare attività ludiche realizzati con kit robotici.
Cercherò ovviamente di fornirvi tutto il supporto necessario in modo da soddisfare le vostre necessità didattiche.

Vi allego il programma ufficiale e ribadisco che se nascono necessità specifiche che non rientrano nel programma indicato, sarà mia cura fornivi il supporto necessario anche in momenti diversi rispetto alle date in cui si svolgerà le lezioni.

Date del corso

Il webinar si svolge 4 volte.

lun 4 ott 2021 17.00 – 19.00
gio 7 ott 2021 17.00 – 19.00
lun 11 ott 2021 17.00 – 19.00
ven 15 ott 2021 17.00 – 19.00

Programma del corso

Progettare l’attività didattica

Ricerca delle fonti
Progettazione dell’attività di laboratorio
Documentare l’attività.

Ozobot Evo

Tour introduttivo sulle possibilità didattiche
Specifiche tecniche del robot
Le applicazioni per tablet e smartphone
Usare il codice a colori come linguaggio di programmazione
Uso del codice colori: i primi programmi, ricerca degli errori, condivisione delle scoperte con il codice a colori
OzoBlockly: l’interfaccia di programmazione e connessione del robot
OzoBlockly: i primi programmi, ricerca degli errori, condivisione delle scoperte con la programmazione a blocchi
Storytelling con OzoBot
Integrare l’uso OzoBot nelle varie discipline didattiche.

Scratch 3

Conoscere l’interfaccia di programmazione
Ideazione dello storyboard
Progettazione delle meccaniche di gioco (interazione dei personaggi e degli oggetti)
Progettazione degli aspetti grafici di ogni livello di gioco
Impostazioni delle difficoltà di gioco.

Scratch Junior

Conoscere l’interfaccia di programmazione e le istruzioni di base
Realizziamo il primo programma
Attività di base:
- Creare un Collage
- Creare una Storia
- Creare un Gioco
Rinforzare il curriculum di alfabetizzazione ed informatica – esempi di attività.

Tinkercad

Cos’è Tinkercad
Registrazione e Login
L’interfacci e il piano di lavoro
I movimenti dell’inquadratura
Selezionare e ridimensionare e unire solidi
Usare il righello e allineare gli oggetti
Proposta di esercizi.
Per ogni modulo verranno proposte attività di progetto pratiche.

Obiettivi

L’obiettivo del corso è quello di fornire le competenze necessarie per realizzare in piena autonomia attività di Coding e Making mediante software gratuito e hardware di baso costo specificatamente pensato per uso didattico per il potenziamento delle discipline STEAM tracciando con esercizi ed esempi specifici, per ogni ordine di scuola, un percorso immediatamente spendibile in classe.

Mappatura delle competenze

I partecipanti al corso acquisiranno le competenze per realizzare attività laboratoriali a supporto dell’apprendimento personalizzato: verrà mostrato come inserire nei propri percorsi didattici l’apprendimento della logica e del problem solving, in generale del coding, attraverso la realizzazione di giochi didattici e dispositivi in grado di interagire con l’ambiente.

Per maggiori informazioni sul contenuto del corso e modalità di iscrizioni vi rimando al link allegato.

Vi aspetto quindi al mio corso

Arduino: stampare più funzioni sulla serial plotter

Lascia una risposta

L’attività di progetto di questa mattina: progettazione di dispositivi elettronici che rispondono a diverse necessità per la salute umana: cura della persona, disabilità, sicurezza sul lavoro, strumenti medici/laboratorio, accessibilità dei luoghi pubblici, ecc…

Con mio piacere ne è nata un’intensa attività di ricerca che ha coinvolto l’intero gruppo classe. Molte le necessità e tra queste ne evidenzio uno, semplice, che riguarda la programmazione, che in più occasioni gli studenti affrontano durante le sperimentazioni e di cui mi sono reso conto di non avere documentato adeguatamente, ovvero: il plot di più funzioni su uno stesso piano cartesiano con Arduino.

Avevo mostrato in più occasioni come effettuare il plot di grandezze variabili nel tempo utilizzando la Serial Plotter dell’IDE di Arduino, uno degli ultimi articoli si riferisce alla realizzazione di uno strumento per la rilevazione di vibrazioni, un semplice sismografo realizzato con un sensore piezoelettrico.

Alcuni studenti questa mattina, si stavano cimentando nella progettazione di un guanto da utilizzare per la movimentazione di un braccio robot industriale della hyundai con l’obiettivo di simulare la movimentazione a distanza di sostanze chimiche pericolose. Nelle prime attività di ricerca si è manifestata la necessità di visualizzare su tre grafici diversi le componenti X, Y, Z dell’accelerazione fornite da un accelerometro connesso ad Arduino.

Come sicuramente saprete l’avvio della Serial Plotter avviene, così come per la Serial Monitor dal menù Tools. Ricordo che Serial Monitor e Serial Plotter non possono essere avviate contemporaneamente.

La Serial Plotter prende i valori che giungono dalla seriale (connessione USB) e li grafica su un piano cartesiano. I dati numerici vengono anche visualizzati nella parte in alto a sinistra della finestra della Serial Plotter.

I valori massimi e minimi rappresentati sull’asse Y vengono regolati automaticamente, mentre la dimensione dell’asse X è fissato a 500 punti e l’aggiornamento del grafico avviene ogni qual volta nel vostro sketch viene eseguita una Serial.println().

Ricordate inoltre di fissare il Baud Rate del Serial Plotter in modo che corrisponda a quello che avete indicato nel codice.

Per tracciare contemporaneamente forme d’onda è possibile agire in due modi:

inserendo uno spazio tra due istruzioni di stampa

1Serial.print(temperatura);
2Serial.print(" ");
3Serial.println(umidita);

oppure inserendo una tabulazione tra due istruzioni di stampa

1Serial.print(temperatura);
2Serial.print("\t");
3Serial.println(umidita);

In questo caso le due grandezze, temperatura e umidità, saranno rappresentate da due funzioni separate e tracciate contemporaneamente sullo stesso piano cartesiano.

A titolo di esempio consideriamo il mio post in cui mostravo come utilizzare un DHT11 e visualizzeremo sulla Serial Plotter le due grandezze fisiche temperatura ed umidità. Di seguito schema di collegamento, sketch e grafici.

1// Prof. Maffucci Michele
2// Visualizzazione della pressione e dell'umidità rilevata da un DHT11
3// sulla Serial Plotter
4// 16.09.2021
5 
6// Libreria DHT
7#include "DHT.h"
8 
9// Pin digitale di arduino connesso al DHT
10#define DHTPIN 2
11 
12// tipo del sensore: DHT 11
13#define DHTTYPE DHT11
14 
15DHT dht(DHTPIN, DHTTYPE);
16 
17void setup() {
18  Serial.begin(9600);
19  dht.begin();
20}
21 
22void loop() {
23  // Attesa di 1 millisecondo prima di fornire la misura.
24  delay(1);
25 
26  // Lettura dell'umidità
27  float h = dht.readHumidity();
28  // Lettura della temperatura in gradi Celsius
29  float t = dht.readTemperature();
30 
31  // Verifica se le si presenta un errore di lettura (e riprova nuovamente)
32  if (isnan(h) || isnan(t)) {
33    Serial.println(F("Impossibile leggere dal sensore DHT!"));
34    return;
35  }
36 
37  // Stampa del valore dell'umidità
38  Serial.print(h);
39  Serial.print(' ');
40  // Stampa del valore della temperatura
41  Serial.println(t);
42}

Il plot delle due grandezze è:

Per completezza realizziamo un semplice sketch che permette di rappresentare 3 funzioni sinusoidali sfasate di 90 gradi una rispetto all’altra con ampiezze diverse:

1// Prof. Maffucci Michele
2// Visualizzazione di tre funzioni siusoidali
3// di ampiezza diversa e sfasate di 90 gradi
4// 16.09.2021
5 
6void setup() {
7  Serial.begin(9600);
8}
9 
10void loop() {
11 
12  // M_PI è la macro definita nell'header math.h
13  // che definisce il pi greco che ha il valore di:
14  // 3.14159265358979323846
15  for(int i = 0; i < 360; i += 2) {
16    float ValoreY1 = 1 * sin(i * M_PI / 180);
17    float ValoreY2 = 2 * sin((i + 90)* M_PI / 180);
18    float ValoreY3 = 4 * sin((i + 180)* M_PI / 180);
19 
20    Serial.print(ValoreY1);
21    Serial.print(' ');         // deve essere stampato spazio ' ' o  tab '\t' tra due valori.
22    Serial.print(ValoreY2);
23    Serial.print(' ');         // deve essere stampato spazio ' ' o  tab '\t' tra due valori.
24    Serial.println(ValoreY3);  // l'ultimo valore deve avere un ritorno a capo
25 
26    delay(1);
27  }
28}

Buon Coding a tutti

Raspberry Pi Pico – come cancellare un file dalla memoria del microcontrollore

Lascia una risposta

Come avrete notato durante le prime sperimentazioni con il PiPico, possiamo depositare all’interno della memoria del microcontrollore più programmi in MicroPython e decidere quali di questi mandare in esecuzione. Nel caso in cui si desideri rendere l’avvio automatico e continuo uno programma non appena il PiPico viene connesso ad una fonte di alimentazione, è sufficiente rinominate il file in main.py.
Può accadere quindi che le nostre sperimentazioni ci portino a memorizzare più programmi all’interno della memoria del PiPico pertanto si potrebbe avere la necessità di dover cancellare o rinominare alcuni di questi.
In questo breve tutorial vedremo come cancellare un file usando i comandi che inseriremo nella shell di Thonny.

Come aprire un programma memorizzato nel PiPico

Per poter consultare la lista di file memorizzati all’interno del microcontrollore con l’IDE Thonny, fate clic su “Apri” (seconda icona)

Si aprirà un pannello che richiede la selezione dell’unità da aprire: sul computer o sul PiPico, selezionare il Raspberry Pi Pico

Ciò aprirà la finestra di seguito indicata da cui poter visionare la lista dei file e con cui potrete aprire uno dei file per poi modificarlo o eseguirlo.

Cancellare un file memorizzato nel PiPico

Posizionate il cursore nella prima riga della Shell e digitate il comando. Inseriremo una serie di comandi terminali in Python:

`1`	`import` `os`

in Python “import os” consente di importare i moduli necessari per interfacciarsi con il sistema operativo sottostante su cui Python è in esecuzione ed eseguire una serie di operazioni sui file, come ad esempio la cancellazione, lo spostamento dei file, rinominare file, creare directory e molto altro. Poichè con MicroPython non si ha nessun sistema operativo il modulo os fornisce tutte quelle funzioni relative alla gestione del semplice del file system e le informazioni relativo al sistema.

Continua a leggere→

Michele Maffucci

… my stories, life and work

Archivi autore: admin

Arduino – misurare tensioni continue fino a 5V

Raspberry Pi Pico – controllare lo stato di un pin digitale

I miei corsi per Tecnica della Scuola: STEAM, idee di lezione e didattica attiva – 2′ edizione

Arduino: stampare più funzioni sulla serial plotter

Raspberry Pi Pico – come cancellare un file dalla memoria del microcontrollore

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: