LMC555 per riparare luci natalizie

[GuidoB]

...
Ho realizzato anche un video ma non so come pubblicarlo...

Purtroppo direttamente nel forum non si puo, pero' puoi caricarlo su imgur.com (massimo 60 secondi...

Si può anche caricare su Youtube e poi inserire il codice del video tra i tag "youtube" dell'editor e lo si rende fruibile direttamente dal foro.

[frankis]

…Complimenti il risultato è molto interessante.
Ciao

Grazie a te stefanopc e a coloro che mi hanno convinto e aiutato.

…Si può anche caricare su Youtube e poi inserire il codice del video tra i tag "youtube" dell'editor e lo si rende fruibile direttamente dal forum.

Grazie GuidoB ma ho già risolto con la segnalazione di Etemenanki. 60 secondi di video sono stati più che sufficienti valutare l’attività dei led. In ogni caso hai fatto bene a ricordarlo perché non sono abituato ad utilizzare youtube.

[djnz]

Partire da zero credendo di fare subito qualcosa di affidabile è illusorio

Infatti questa è l'aspettativa irreale che il mondo Arduino produce.

Ormai i progetti destinati al naufragio ancora prima di partire li riconosco al volo, perché hanno la parola "semplice" o "semplicissimo" nella prima riga della domanda Non si può materialmente costruire un ponte per i carri armati con secchiello, paletta e un filmato del tubo

[frankis]

Arduino, se lo sai utilizzare permette un enorme grado di libertà e autonomia nel realizzare soluzioni funzionanti, è come avere una marcia in più. Credo che Arduino sia uno strumento che crea dipendenza.

[Etemenanki]

Credo che Arduino sia uno strumento che crea dipendenza.

Occhio a dire cosi, che poi lo vietano per legge come le droghe ed arrestano tutti gli utenti che lo usano per "spaccio e diffusione di circuiti e programmi dannosi per la salute"

[frankis]

Ci faranno fare un programma di recupero.

Ma a parte gli scherzi, ieri pomeriggio ho lanciato il test effettivo ma è fallito, GRRRRRR. Tra l’altro dopo alcune ore dal lancio mi sono accorto che avevo modificato le ore di attività e pausa e non le ho corrette subito per non dover ripetere il lancio.
In pratica ha lampeggiato per 8 ore invece di 6 ore e si è spento regolarmente però si è riacceso dopo 9 ore anziché 16. Oltretutto si è riacceso impallato sull’effetto alternateBlinkingEffect, almeno, quello mi è sembrato essere l’effetto.
Ora, non credo si sia trattato di un problema di programma perché non dava quell’impressione. Le cause potrebbero, a mio avviso, essere più di una. O l’hardware è difettoso, o la batteria è andata sotto la soglia minima accettabile oppure c’è qualche disturbo elettromagnetico nell’ambiente che altera il funzionamento. Adesso ho corretto gli orari, ho collegato un’altra batteria e ho ripetuto il lancio. Attualmente sta lampeggiando e dovrebbe spegnersi alle ore 17 per poi riaccendersi alle ore 11 di domani. Ero così contento ieri, quando si è spento, perché ha ritardato lo spegnimento di solo 1 minuto e 40 secondi dopo un’attività di 8 ore, contro i 10 minuti e 30 secondi della precedente versione software dopo che però aveva eseguito il ciclo completo di 24 ore.
Non mi resta che attendere incrociando le dita.

[frankis]

Forse ci siamo. Questa volta ha funzionato. Ha rispettato i tempi di accensione e sospensione e ha sforato le 24 ore di 10 minuti e 8 secondi. Saprei come minimizzare il ritardo ma non m'interessa. L'importante è il servizio svolto. Non si è capito cosa sia successo con la prima prova ma non sembra essere stato un problema di programma, forse la batteria, comunque adesso va. Occorre stare attenti alla tensione di carica della batteria perché se va sotto un certo valore sembra funzionare tutto a luminosità ridotta ma in realtà il Mini riesegue il boot e riparte. Il programma è praticamente uguale all’originale fatta eccezione per la partenza automatica al momento dell’inserimento della batteria (che però si può spegnere premendo il pulsante) oltre al numero e varietà degli effetti che sono di più di quelli originali perché alcuni sono presenti per mio gradimento e possono essere anche aumentati.
I tempi degli effetti potrebbero essere da ritoccare ma qui entriamo anche nella valutazione personale e quindi non la escludo.
La funzione Millis ho cercato di utilizzarla dove sono riuscito a governarla decentemente ma in alcune parti del programma non sono riuscito a gestirla in modo da ottenere il risultato voluto e quindi ho ripiegato su soluzioni più spartane ma più semplici da gestire e comunque funzionanti.
Ho cercato di capire se esiste una utility che toglie tutti i commenti in un sol colpo in modo da mandare in compilazione solo il codice ma sembra non esistere. Ne conoscete l’esistenza?
Per provare il programma basta collegare anche solo due led in antiparallelo ad Arduino ma l’effetto è scadente però funziona.
Allego il codice completo e commentato. Se notate degli errori però ditemelo, anche se credo che in caso di errore il funzionamento del programma lo rivelerebbe.

Codice: Seleziona tutto

#include <avr/sleep.h>    // Libreria per la gestione del sonno
#include <avr/wdt.h>      // Libreria per la gestione del watchdog
#include <avr/interrupt.h>// Libreria per la gestione degli interrupt

// =================================================
//  IMPOSTAZIONI - AREA MODIFICABILE
// =================================================
const byte pinA = 3;      // PIN LED Primo pin di controllo (catodo comune)
const byte pinB = 9;      // PIN LED Secondo pin di controllo (anodo comune)
const byte buttonPin = 2; // PIN PULSANTE (da 0 a 7)

// --------------------------------------------------------- Millisecondi per ogni secondo
const unsigned long msCoeff = 1000; // <-- Da modificare in caso di correzione dei tempi Start & Stop
// --------------------------------------------------------- Funziona con 6 e 18 ore
const unsigned long runDuration = 6 * msCoeff * 3600; 
const unsigned long sleepDuration = 18 * msCoeff * 3600;
// --------------------------------------------------------- Debug con 6 e 18 secondi
//const unsigned long runDuration = 6 * msCoeff;
//const unsigned long sleepDuration = 18 * msCoeff;

// =================================================
//  VARIABILI DI LAVORO - (AREA DEFINITIVA E DA NON MODIFICARE)
// =================================================
volatile bool systemAwake = true;               // Variabile che indica se il sistema è sveglio
volatile unsigned long lastWakeTime = 0;        // Memorizza l'ultima volta in cui il sistema si è svegliato
byte sequenceNumber = 1;                        // Numero della sequenza corrente

// =================================================
//  SETUP - (AREA DEFINITIVA E DA NON MODIFICARE)
// =================================================
void setup()
{
    pinMode(pinA, OUTPUT);                    // Configura pinA come uscita
    pinMode(pinB, OUTPUT);                    // Configura pinB come uscita
    pinMode(buttonPin, INPUT_PULLUP);         // Configura buttonPin come ingresso con pull-up
    // ------------------------------- Interrupt su variazione di pin (solo D0-D7)
    PCICR |= (1 << PCIE2);                    // Abilita l'interrupt sui cambiamenti di stato dei pin PCINT [23:16]
    PCMSK2 |= (1 << (buttonPin - 0));         // Abilita l'interrupt su buttonPin
    // ------------------------------- Imposta il tempo iniziale
    lastWakeTime = millis();                  // Memorizza il tempo corrente
}

// Interrupt service routine per il cambio di stato del pin
ISR(PCINT2_vect)
{
    if (!digitalRead(buttonPin))
    {
        systemAwake = true;                    // Imposta il sistema come sveglio
        lastWakeTime = millis();               // Aggiorna l'ultimo tempo di sveglia
        sleep_disable();                       // Disabilita il sonno
    }
}

// Interrupt service routine per il watchdog timer
ISR(WDT_vect)
{
    // Non fare nulla qui
}

// =================================================
//  LOOP - (AREA DEFINITIVA E DA NON MODIFICARE)
// =================================================
void loop()
{
  sequences();                                 // Chiama la funzione che gestisce le sequenze dei LED
}

// =================================================
//  TESTARE LO STATO DI SVEGLIA E SONNO - (AREA DEFINITIVA E DA NON MODIFICARE)
// =================================================
void testAwake()
{
    // ----------------------------------------------- test se è ora di andare a dormire
    if ((millis() - lastWakeTime) >= runDuration)
    {
        enterSleep(false);                     // Entra in modalità di sonno
        return;
    }
}

void enterSleep(bool sleepForever)
{
    // -------------------------- SPEGNE I LED
    digitalWrite(pinA, LOW);                   // Spegne pinA
    digitalWrite(pinB, LOW);                   // Spegne pinB
   
    // -------------------------- Disabilita interrupt
    cli();                                     // Disabilita gli interrupt globali
   
    // -------------------------- Watchdog 8 sec.
    MCUSR &= ~(1 << WDRF);                     // Cancella il flag di reset del watchdog
    WDTCSR |= (1 << WDCE) | (1 << WDE);        // Abilita la modifica dei registri di controllo del watchdog
    WDTCSR = (1 << WDCE) | (1 << WDP3) | (1 << WDP0); // Imposta il timer del watchdog a 8 secondi
    WDTCSR |= _BV(WDIE);                       // Abilita l'interrupt del watchdog
   
    // -------------------------- Abilita modalità di sonno
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);       // Imposta la modalità di sonno
    sleep_enable();                            // Abilita il sonno

    // -------------------------- Abilita interrupt
    sei();                                     // Abilita gli interrupt globali
   
    // -------------------------- Ciclo di sonno
    systemAwake = false;                       // Imposta il sistema come non sveglio
    unsigned long sleptTime = 0;               // Tempo di sonno accumulato
    while (sleptTime < sleepDuration)
    {
        sleep_mode();                          // Entra in modalità di sonno
        if (systemAwake) break;                // Esce se il pulsante è stato premuto
        if (!sleepForever) sleptTime += 8000;  // Aggiorna il tempo di sonno (8 sec ogni ciclo)
    }
   
    // -------------------------- Riavvia il tempo di sveglia
    sleep_disable();                           // Disabilita il sonno
    systemAwake = true;                        // Imposta il sistema come sveglio
    lastWakeTime = millis();                   // Aggiorna l'ultimo tempo di sveglia
}

// =================================================
//  PULSANTE - (AREA DEFINITIVA E DA NON MODIFICARE)
// =================================================
bool readButton()
{
    unsigned long currentTime = millis();      // Tempo corrente

    static bool buttonPressed = false;         // Stato del pulsante
    static unsigned long lastDebounceTime = 0; // Tempo dell'ultimo rimbalzo
    const unsigned long debouncewaitMsec = 50; // Tempo di attesa per il rimbalzo (50 ms)

    // -------------------------------------- HIGH quando il pulsante è premuto
    bool reading = !digitalRead(buttonPin);    // Legge lo stato del pulsante
   
    if ((currentTime - lastDebounceTime) > debouncewaitMsec)
    {
        if (reading != buttonPressed)
        {
            buttonPressed = reading;           // Aggiorna lo stato del pulsante
           
            if (buttonPressed)
            {
                // ----------------------------- Riavvia il tempo di sveglia
                lastWakeTime = millis();       // Aggiorna il tempo di sveglia
                // ----------------------------- Incrementa il numero di sequenza
                sequenceNumber++;              // Incrementa il numero di sequenza
                // ----------------------------- Restituisce true se il pulsante è premuto
                return true;
            }
        }
        lastDebounceTime = currentTime;        // Aggiorna il tempo dell'ultimo rimbalzo
    }
    return false;
}

// ===================================================
//  ATTENDERE E TESTARE LO STATO DI SVEGLIA E PULSANTE - (AREA DEFINITIVA E DA NON MODIFICARE)
// ===================================================
bool waitMsec(int milliseconds)
{
  // -------------------------------------------- test se è sveglio
  testAwake();                                // Testa se è ora di dormire
  // -------------------------------------------- test pulsante
  unsigned long currentTime = millis();       // Tempo corrente
  while (millis() - currentTime < milliseconds)
  {
    if (readButton()) return true;            // Restituisce true se il pulsante è premuto
  }
  return false;
}

// =================================================
//  SEQUENZE - AREA MODIFICABILE
// =================================================
void sequences()
{
    switch (sequenceNumber)
    {
        case 1:
            if(scrollingEffect()) break;      // Effetto scorrimento
            if(alternateBlinkingEffect()) break; // Effetto lampeggiante alternato
            if(progressiveLightingEffect()) break; // Effetto illuminazione progressiva
            if(waveEffect()) break;           // Effetto onda
            if(randomBlinkingEffect()) break; // Effetto lampeggiante casuale
            if(rapidSequenceEffect()) break;  // Effetto sequenza rapida
            if(fadePinA()) break;             // Effetto dissolvenza pinA
            if(fadePinB()) break;             // Effetto dissolvenza pinB
            if(fadeEffect()) break;           // Effetto dissolvenza
            if(strobeEffect()) break;         // Effetto stroboscopico
            if(breathingEffect()) break;      // Effetto respirazione
            if(runningEffect()) break;        // Effetto corsa
            if(waterfallEffect()) break;      // Effetto cascata
            if(meteorShowerEffect()) break;   // Effetto pioggia di meteore
            if(fireflyEffect()) break;        // Effetto lucciola
            if(rainbowFadeEffect()) break;    // Effetto dissolvenza arcobaleno
            if(twinkleEffect()) break;        // Effetto scintillio
            break;

                case 2:
            if(waveEffect()) break;           // Effetto onda
            if(rainbowFadeEffect()) break;    // Effetto dissolvenza arcobaleno
            break;

        case 3:
            if(randomBlinkingEffect()) break; // Effetto lampeggiante casuale
            if(twinkleEffect()) break;        // Effetto scintillio
            break;

        case 4:
            if(rapidSequenceEffect()) break;  // Effetto sequenza rapida
            break;

        case 5:
            if(fadeEffect()) break;           // Effetto dissolvenza
            break;

        case 6:
            if(strobeEffect()) break;         // Effetto stroboscopico
            break;

        case 7:
            if(breathingEffect()) break;      // Effetto respirazione
            break;

        case 8:
            if(alternateBlinkingEffect()) break; // Effetto lampeggiante alternato
            break;

        case 9:
            digitalWrite(pinA, LOW);          // Spegne il LED su pinA
            digitalWrite(pinB, LOW);          // Spegne il LED su pinB
            while (!digitalRead(buttonPin));  // Attende che il pulsante venga premuto
            enterSleep(true);                 // Entra in modalità di sonno permanente
            sequenceNumber = 1;               // Reimposta il numero di sequenza
            break;

        default:
            sequenceNumber = 1;               // Imposta il numero di sequenza a 1 di default
    }
}


// =================================================
//  EFFETTI - AREA MODIFICABILE
// =================================================

bool scrollingEffect() // Accende pinA e spegne pinB
{
    digitalWrite(pinA, HIGH);
    digitalWrite(pinB, LOW);
    if (waitMsec(300)) return true;
   
    // Spegne pinA e accende pinB
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, HIGH);
    if (waitMsec(300)) return true;
   
    return false; // Effetto completato
}

bool alternateBlinkingEffect()
{
    // Ciclo di lampeggio alternato per 5 volte
    for (byte i = 0; i < 5; i++)
    {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(500)) return true; // Attendi 500 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(500)) return true; // Attendi 500 ms
    }
    return false; // Effetto completato
}

bool progressiveLightingEffect()
{
    // Accende e spegne progressivamente pinA e pinB 20 volte
    for (byte i = 0; i < 20; i++)
    {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(255)) return true; // Attendi 255 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(30)) return true; // Attendi 30 ms
    }
    return false; // Effetto completato
}

bool waveEffect()
{
    // Effetto onda per 20 cicli
    for (byte j = 0; j < 20; j++)
    {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(100)) return true; // Attendi 100 ms
    }
    return false; // Effetto completato
}

bool randomBlinkingEffect()
{
    // Lampeggio casuale per 30 volte
    for (byte i = 0; i < 30; i++)
    {
        if (random(10) == 0)
        {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        }
        else
        {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        if (waitMsec(100)) return true; // Attendi 100 ms
    }
    return false; // Effetto completato
}

bool rapidSequenceEffect()
{
    // Sequenza rapida di accensione e spegnimento per 40 volte
    for (byte i = 0; i < 40; i++)
    {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(50)) return true; // Attendi 50 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(50)) return true; // Attendi 50 ms
    }
    return false; // Effetto completato
}

bool fadePinA()
{
    // Fade in e fade out per pinA
    for (int brightness = 0; brightness <= 255; brightness++)
    {
        analogWrite(pinA, brightness);
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    for (int brightness = 255; brightness >= 0; brightness--)
    {
        analogWrite(pinA, brightness);
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    return false; // Effetto completato
}

bool fadePinB()
{
    // Fade in e fade out per pinB
    for (int brightness = 0; brightness <= 255; brightness++)
    {
        analogWrite(pinB, brightness);
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    for (int brightness = 255; brightness >= 0; brightness--)
    {
        analogWrite(pinB, brightness);
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    return false; // Effetto completato
}

bool fadeEffect()
{
    // Effetto di dissolvenza tra pinA e pinB
    for (int brightness = 0; brightness <= 255; brightness++)
    {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    for (int brightness = 255; brightness >= 0; brightness--)
    {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    return false; // Effetto completato
}

bool strobeEffect()
{
    // Effetto strobe per 40 cicli
    for (byte i = 0; i < 40; i++)
    {
        if (i % 2 == 0)
        {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        }
        else
        {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        if (waitMsec(100)) return true; // Attendi 100 ms
    }
    return false; // Effetto completato
}

bool breathingEffect()
{
    // Effetto respiro, il pinA e il pinB si accendono e si spengono lentamente
    static int brightness = 0;
    static int fadeAmount = 1;

    for (int i = 0; i < 512; i++)
    {
        analogWrite(pinA, brightness);
        analogWrite(pinB, 255 - brightness);
        brightness += fadeAmount;
        if (brightness <= 0 || brightness >= 255)
        {
            fadeAmount = -fadeAmount;
        }
        if (waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    return false; // Effetto completato
}

bool runningEffect()
{
    // Effetto corsa per 3 cicli
    for (byte i = 0; i < 3; i++)
    {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        if (waitMsec(100)) return true; // Attendi 100 ms
    }
    for (byte i = 0; i < 3; i++)
    {
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        if (waitMsec(100)) break; // Attendi 100 ms
       
        digitalWrite(pinB, LOW);
        digitalWrite(pinA, HIGH);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        if (waitMsec(100)) return true; // Attendi 100 ms
    }
    return false; // Effetto completato
}

bool waterfallEffect()
{
    // Effetto cascata per 3 cicli
    for (byte i = 0; i < 3; i++)
    {
        digitalWrite(pinA, HIGH);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        if (waitMsec(100)) return true; // Attendi 100 ms
       
        digitalWrite(pinB, LOW);
    }
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
    return false; // Effetto completato
}

bool meteorShowerEffect()
{
    // Effetto pioggia di meteore per 5 cicli
    for (int i = 0; i < 5; i++)
    {
        digitalWrite(pinA, HIGH);
        if (waitMsec(50)) return true; // Attendi 50 ms
       
        digitalWrite(pinA, LOW);
        if (waitMsec(50)) return true; // Attendi 50 ms
       
        digitalWrite(pinB, HIGH);
        if (waitMsec(50)) return true; // Attendi 50 ms
       
        digitalWrite(pinB, LOW);
        if (waitMsec(50)) return true; // Attendi 50 ms
    }
    return false; // Effetto completato
}

bool fireflyEffect()
{
    // Effetto lucciole per 10 cicli
    for (int i = 0; i < 10; i++)
    {
        int duration = random(50, 200);
        digitalWrite(pinA, HIGH);
        if(waitMsec(duration)) return true; // Attendi una durata casuale tra 50 e 200 ms
       
        digitalWrite(pinA, LOW);
        if(waitMsec(duration)) return true; // Attendi una durata casuale tra 50 e 200 ms
       
        digitalWrite(pinB, HIGH);
        if(waitMsec(duration)) return true; // Attendi una durata casuale tra 50 e 200 ms
       
        digitalWrite(pinB, LOW);
        if(waitMsec(duration)) return true; // Attendi una durata casuale tra 50 e 200 ms
    }
    return false; // Effetto completato
}

bool rainbowFadeEffect()
{
    // Effetto dissolvenza arcobaleno tra pinA e pinB
    for (int brightness = 0; brightness <= 255; brightness++)
    {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    for (int brightness = 255; brightness >= 0; brightness--)
    {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        if(waitMsec(10)) return true; // Attendi 10 ms per ogni step di luminosità
    }
    return false; // Effetto completato
}

bool twinkleEffect()
{
    // Effetto scintillio per 20 cicli
    for (int i = 0; i < 20; i++)
    {
        if (random(2) == 0)
        {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        }
        else
        {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        if (waitMsec(random(100, 500))) return true; // Attendi una durata casuale tra 100 e 500 ms
    }
    return false; // Effetto completato
}

[vince59]

Arduino, se lo sai utilizzare permette un enorme grado di libertà e autonomia nel realizzare soluzioni funzionanti, è come avere una marcia in più. Credo che Arduino sia uno strumento che crea dipendenza.

...azz se non lo avessi detto tu, oggi 10 febbraio 2025, come avremmo potuto fare, è appena maggiorenne!!
(prendila simpaticamente )
un po' di storia e ricnoscimento per chi lo dato alla luce.
https://it.wikipedia.org/wiki/Arduino_(hardware)

[frankis]

Io non trovo niente da leggere in quella pagina. E' vuota.

[vince59]

meglio questa...

https://poseidone75.altervista.org/la-s ... 1757812500