LMC555 per riparare luci natalizie

[Etemenanki]

Io non sono un mago, sono solo un povero metademone di quasi 63 secoli

[frankis]

Infatti non hai una bella "cera".
Comunque ho quasi finito. Adesso vado a mangiucchiare qualcosa poi torno, controllo e pubblico.

[frankis]

Il programma è il seguente.
Il codice produce un certo numero di effetti luminosi che volendo potrei cercare di implementare ulteriormente, anche se alla fine certi effetti visivi si assomigliano. Qualche effetto funziona male perché non è adatto a pilotare dei led in contropolarizzazione oppure sarebbe più adatto per led in serie ma in ogni caso qualche variazione la fa è l’ho lasciato, è comunque una differenziazione.
Quello che non mi è chiaro è per quale motivo le varianti luminose funzionino meglio se attivate singolarmente anziché nello sketch cumulativo. Non escludo che a causa delle varie duplicazioni di codice e successive modifiche per scrivere un po’ meno, abbia condiviso involontaria mente delle variabili che dovevano rimanere private. Boh. Comunque ecco il codice. Se vi va dategli un’occhiata e se potete ditemi cosa ne pensate.

Codice: Seleziona tutto

#include <LowPower.h>

// Definisci i pin di controllo dei LED
const int pinA = 3; // Primo pin di controllo (catodo comune)
const int pinB = 9; // Secondo pin di controllo (anodo comune)
const unsigned int VEL_UP = 3000; // Cambiato per migliorare la visibilità
const unsigned int VEL_DN = 3000;

// Imposta gli intervalli (in millisecondi)
const int interval = 200;
const int blinkInterval = 500;

// Funzione per calcolare il cubo di un numero ridimensionato per PWM
byte cube(byte n) {
    return (uint32_t)n * n * n / 65025;
}

// Funzione per creare un effetto di dissolvenza per il LED su un dato pin
void fade(byte pin) {
    for (int n = 30; n <= 255; n++) {
        analogWrite(pin, cube(n));
        delayMicroseconds(VEL_UP);
    }

    for (int n = 255; n >= 30; n--) {
        analogWrite(pin, cube(n));
        delayMicroseconds(VEL_DN);
    }
}

void setup() {
    // Configura i pin di controllo dei LED come output
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
   
    // Inizializza il seme del generatore di numeri casuali
    randomSeed(analogRead(0));
   
    // Spegne l'indicatore LED integrato
    digitalWrite(LED_BUILTIN, LOW);
   
    // Inizializza la comunicazione seriale per il debug
//    Serial.begin(9600);
//    Serial.println("Computer, ti ordino di iniziare a scrivere!");
}

void loop() {
    // Accende la catena LED per 6 ore
    unsigned long startTime = millis();
    while (millis() - startTime < 21600000) { // 6 ore = 21600000 millisecondi
       
        // Debug: stampa i millisecondi trascorsi su console
        // Serial.println(millis());
       
        // Applica vari effetti ai LED
        applyEffects();

        // Reset dei LED
        digitalWrite(pinA, LOW);
        fade(pinB);
        digitalWrite(pinB, LOW);
        fade(pinA);
    }

    // Spegne l'indicatore LED integrato
    digitalWrite(LED_BUILTIN, LOW);

    // Modalità sleep profonda per 18 ore
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    unsigned long sleepStartTime = millis();
    while (millis() - sleepStartTime < 64800000) { // 18 ore = 64800000 millisecondi
        LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); // Non si sa ancora se funziona; da provare per un ciclo completo se riparte il tutto
    }
}

// Funzione per applicare vari effetti di illuminazione alla catena LED
void applyEffects() {
    scrollingEffect();
    alternateBlinkingEffect();
    progressiveLightingEffect();
    waveEffect();
    randomBlinkingEffect();
    rapidSequenceEffect();
    fadeEffect();
    strobeEffect();
    breathingEffect();
    runningEffect();
    waterfallEffect();
    meteorShowerEffect();
    fireflyEffect();
    rainbowFadeEffect();
    twinkleEffect();
    heartbeatEffect();
    cometEffect();
    pulseEffect();
    flashingEffect();
    blinkSOSEffect();
    knightRiderEffect();
    sparkleEffect();
    theaterChaseEffect();
    randomSparkEffect();
}

// Effetto di scorrimento
void scrollingEffect() {
    digitalWrite(pinA, HIGH);
    digitalWrite(pinB, LOW);
    delay(interval);
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, HIGH);
    delay(interval);
}

// Effetto di lampeggiamento alternato
void alternateBlinkingEffect() {
    for (int i = 0; i < 5; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(blinkInterval);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(blinkInterval);
    }
}

// Effetto di illuminazione progressiva
void progressiveLightingEffect() {
    for (int i = 0; i < 5; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(255);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(30);
    }
}

// Effetto onda
void waveEffect() {
    for (int j = 0; j < 3; j++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(interval / 2);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(interval / 2);
    }
}

// Effetto di lampeggiamento casuale
void randomBlinkingEffect() {
    for (int i = 0; i < 20; i++) {
        if (random(10) == 0) {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        } else {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        delay(interval / 2);
    }
}

// Effetto di sequenza rapida
void rapidSequenceEffect() {
    for (int i = 0; i < 40; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(50);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(50);
    }
}

// Effetto dissolvenza
void fadeEffect() {
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        delay(10);
    }

    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        delay(10);
    }
}

// Effetto stroboscopico
void strobeEffect() {
    for (int i = 0; i < 20; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, HIGH);
        delay(50);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        delay(50);
    }
}

// Effetto respirazione
void breathingEffect() {
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, brightness);
        delay(10);
    }
    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, brightness);
        delay(10);
    }
}

// Effetto di corsa
void runningEffect() {
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(100);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(100);
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(100);
    }

    for (int i = 0; i < 3; i++) {
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        delay(100);
        digitalWrite(pinB, LOW);
        digitalWrite(pinA, HIGH);
        delay(100);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        delay(100);
    }
}

// Effetto cascata
void waterfallEffect() {
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        delay(100);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(100);
        digitalWrite(pinB, LOW);
    }
}

// Effetto pioggia di meteore
void meteorShowerEffect() {
    for (int i = 0; i < 5; i++) {
        digitalWrite(pinA, HIGH);
        delay(50);
        digitalWrite(pinA, LOW);
        delay(50);
        digitalWrite(pinB, HIGH);
        delay(50);
        digitalWrite(pinB, LOW);
        delay(50);
    }
}

// Effetto lucciola
void fireflyEffect() {
    for (int i = 0; i < 10; i++) {
        int duration = random(50, 200);
        digitalWrite(pinA, HIGH);
        delay(duration);
        digitalWrite(pinA, LOW);
        delay(duration);
        digitalWrite(pinB, HIGH);
        delay(duration);
        digitalWrite(pinB, LOW);
        delay(duration);
    }
}

// Effetto dissolvenza arcobaleno
void rainbowFadeEffect() {
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, 255 - brightness);
        delay(5);
    }
    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, 255 - brightness);
        delay(5);
    }
}

// Effetto scintillio
void twinkleEffect() {
    for (int i = 0; i < 20; i++) {
        if (random(2) == 0) {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        } else {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        delay(random(100, 500));
    }
}

// Effetto battito cardiaco
void heartbeatEffect() {
    for (int i = 0; i < 3; i++) {
        analogWrite(pinA, 255);
        analogWrite(pinB, 255);
        delay(200);
        analogWrite(pinA, 0);
        analogWrite(pinB, 0);
        delay(200);
        analogWrite(pinA, 255);
        analogWrite(pinB, 255);
        delay(1000);
        analogWrite(pinA, 0);
        analogWrite(pinB, 0);
        delay(1000);
    }
}

// Effetto Cometa
void cometEffect() {
    for (int i = 0; i < 3; i++) {
        analogWrite(pinA, 255);
        analogWrite(pinB, 0);
        delay(100);
        for (int j = 255; j > 0; j -= 5) {
            analogWrite(pinA, j);
            analogWrite(pinB, 255 - j);
            delay(10);
        }
    }
}

// Effetto impulso
void pulseEffect() {
    for (int i = 0; i < 3; i++) {
        for (int brightness = 0; brightness <= 255; brightness++) {
            analogWrite(pinA, brightness);
            analogWrite(pinB, brightness);
            delay(5);
        }
        for (int brightness = 255; brightness >= 0; brightness--) {
            analogWrite(pinA, brightness);
            analogWrite(pinB, brightness);
            delay(5);
        }
    }
}

// Effetto lampeggiante
void flashingEffect() {
    for (int i = 0; i < 10; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, HIGH);
        delay(100);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        delay(100);
    }
}

// Effetto lampeggiante SOS
void blinkSOSEffect() {
    // Morse Code for SOS: ... --- ...
    int dotTime = 200;  // durata del punto
    int dashTime = dotTime * 3;  // durata della linea
    int pause = dotTime;  // pausa tra punti/linee
    int endPause = dotTime * 7;  // pausa alla fine della sequenza

    // Tre punti
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(dotTime);
        digitalWrite(pinA, LOW);
        delay(pause);
    }

    // Tre linee
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(dashTime);
        digitalWrite(pinA, LOW);
        delay(pause);
    }

    // Tre punti
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(dotTime);
        digitalWrite(pinA, LOW);
        delay(pause);
    }

    // Pausa alla fine
    delay(endPause);
}

// Effetto Supercar
void knightRiderEffect() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j <= 255; j += 5) {
            analogWrite(pinA, j);
            delay(10);
        }
        for (int j = 255; j >= 0; j -= 5) {
            analogWrite(pinA, j);
            delay(10);
        }
    }
}

// Effetto scintillio
void sparkleEffect() {
    for (int i = 0; i < 20; i++) {
        if (random(2) == 0) {
            analogWrite(pinA, random(256));
            analogWrite(pinB, random(256));
        } else {
            analogWrite(pinA, 0);
            analogWrite(pinB, 0);
        }
        delay(100);
    }
}

// Effetto inseguimento teatrale
void theaterChaseEffect() {
    for (int j = 0; j < 10; j++) {
        for (int q = 0; q < 3; q++) {
            for (int i = 0; i < 3; i++) {
                if ((i + q) % 3 == 0) {
                    digitalWrite(pinA, HIGH);
                    digitalWrite(pinB, LOW);
                } else {
                    digitalWrite(pinA, LOW);
                    digitalWrite(pinB, HIGH);
                }
                delay(50);
            }
            delay(50);
        }
    }
}

// Effetto Scintilla Casuale
void randomSparkEffect() {
    for (int i = 0; i < 20; i++) {
        int randDelay = random(50, 200);
        digitalWrite(pinA, HIGH);
        delay(randDelay);
        digitalWrite(pinA, LOW);
        delay(randDelay);
        digitalWrite(pinB, HIGH);
        delay(randDelay);
        digitalWrite(pinB, LOW);
        delay(randDelay);
    }
}

[frankis]

Il programma NON funziona benissimo. Non rispetta ancora la tempistica. Credo di avergli dato troppi effetti luminosi da gestire. Togliendone uno alla volta, partendo dal fondo del listato, migliora, ma credo che ci sia qualcos’altro.
Credo che il codice vada riesaminato e magari modificato.
Ho anche il sospetto che le variazioni dei tempi possano dipendere dal computer. Il Mini è ancora alimentato tramite seriale e non vorrei che subisse influenze per variazione di tensione o disturbi dal computer.
Cosa ne pensate?

[ThEnGi]

Il programma NON funziona benissimo. Non rispetta ancora la tempistica.

Il Mini è ancora alimentato tramite seriale e non vorrei che subisse influenze per variazione di tensione o disturbi dal computer.

Cosa significa "non rispetta", 1 secondo 10 minuti 2 ore ? Lento, veloce ?

Tieni conto che se il tuo codice quando entra nel "WHILE" deve eseguire tutte le istruzione e ci mette che ne so 5 minuti.
Se entra nel while 1 secondo prima delle "scadere del tempo", lo spegnimento avverà con 4 min e 59 secondi di ritardo

Salvo non avere un alimentatore pessimo, non credo ci siano problemi correlati al PC

[frankis]

Ciao ThEnGi.
Sembrava funzionare ma per provarlo ho dovuto ridurre i tempi ad 1 minuto per l’esecuzione più 1 minuto di pausa e il programma si fermava circa mezzo minuto dopo il tempo previsto e di conseguenza anche il riavvio avveniva con l’aggiunta di un ulteriore ritardo. Ho sospettato che dipendesse dalla quantità di effetti da eseguire e purtroppo si è rivelato fondato.
Adesso ho realizzato pasticciandola una versione ridotta e anche il prolungamento delle attività si è limitato 2 + 2 secondi ad ogni passaggio di accensione dei led e di pausa.
Dovrei provare a farlo funzionare per 24 ore per vedere se mantiene i 2+2 secondi di ritardo anche su 24 ore e in quel caso non sarebbe un dramma ma credo che comunque il programma abbia un problema strutturale. Quando scade il tempo non dovrebbe esserci niente che ritarda, quando scade il tempo scade e basta.
Non sono sicuro di avere spiegato in modo comprensibile come si comporta. La versione seguente è quella che va meglio.

Codice: Seleziona tutto

#include <LowPower.h>

// Definisci i pin di controllo dei LED
const int pinA = 3; // Primo pin di controllo (catodo comune)
const int pinB = 9; // Secondo pin di controllo (anodo comune)
const unsigned int VEL_UP = 3000; // Cambiato per migliorare la visibilità
const unsigned int VEL_DN = 3000;

// Imposta gli intervalli (in millisecondi)
const int interval = 200;
const int blinkInterval = 500;

byte cube(byte n) {
    return (uint32_t)n * n * n / 65025;
}

void fade(byte pin) {
    for (int n = 30; n <= 255; n++) {
        analogWrite(pin, cube(n));
        delayMicroseconds(VEL_UP);
    }

    for (int n = 255; n >= 30; n--) {
        analogWrite(pin, cube(n));
        delayMicroseconds(VEL_DN);
    }
}

void setup() {
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    randomSeed(analogRead(0));
    digitalWrite(LED_BUILTIN, LOW); // Spegne l'indicatore LED

Serial.begin(9600); //Prova console
Serial.println("Computer inizia a scrivere");//Prova console
}

void loop() {
    // Accende i LED per 6 ore
    unsigned long startTime = millis();
    while (millis() - startTime < 60000) { // 6 ore = 21600000 millisecondi
       
        Serial.println(millis());//Prova stampa millisecondi su console
       
        scrollingEffect();
        alternateBlinkingEffect();
        progressiveLightingEffect();
        waveEffect();
        randomBlinkingEffect();
        rapidSequenceEffect();
        digitalWrite(pinA, LOW);
        fade(pinB);
        digitalWrite(pinB, LOW);
        fade(pinA);
        fadeEffect();
        strobeEffect();
        breathingEffect();
        runningEffect();
        waterfallEffect();
    }

    digitalWrite(LED_BUILTIN, LOW); // Spegne l'indicatore

    // Modalità sleep profonda per 18 ore
    unsigned long sleepStartTime = millis();
    while (millis() - sleepStartTime < 60000) { // 18 ore = 64800000 millisecondi
//        LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    }
}

void scrollingEffect() {
    digitalWrite(pinA, HIGH);
    digitalWrite(pinB, LOW);
    delay(interval);
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, HIGH);
    delay(interval);
}

void alternateBlinkingEffect() {
    for (int i = 0; i < 5; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(blinkInterval);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(blinkInterval);
    }
}

void progressiveLightingEffect() {
    for (int i = 0; i < 5; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(255);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(30);
    }
}

void waveEffect() {
    for (int j = 0; j < 3; j++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(interval / 2);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(interval / 2);
    }
}

void randomBlinkingEffect() {
    for (int i = 0; i < 20; i++) {
        if (random(10) == 0) {
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, LOW);
        } else {
            digitalWrite(pinA, LOW);
            digitalWrite(pinB, HIGH);
        }
        delay(interval / 2);
    }
}

void rapidSequenceEffect() {
    for (int i = 0; i < 40; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(50);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(50);
    }
}

void fadeEffect() {
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        delay(10);
    }

    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, constrain(255 - brightness, 0, 255));
        delay(10);
    }
}

void strobeEffect() {
    for (int i = 0; i < 20; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, HIGH);
        delay(50);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
        delay(50);
    }
}

void breathingEffect() {
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, brightness);
        delay(10);
    }
    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(pinA, brightness);
        analogWrite(pinB, brightness);
        delay(10);
    }
}

void runningEffect() {
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(100);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(100);
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, LOW);
        delay(100);
    }

    for (int i = 0; i < 3; i++) {
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        delay(100);
        digitalWrite(pinB, LOW);
        digitalWrite(pinA, HIGH);
        delay(100);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinA, LOW);
        delay(100);
    }
}

void waterfallEffect() {
    for (int i = 0; i < 3; i++) {
        digitalWrite(pinA, HIGH);
        delay(100);
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, HIGH);
        delay(100);
        digitalWrite(pinB, LOW);
    }
}

[djnz]

Quando scade il tempo non dovrebbe esserci niente che ritarda, quando scade il tempo scade e basta.

Il tempo gestito con millis soffre solo dell'imprecisione dell'oscillatore. Se c'è un risuonatore ceramico siamo sui cinque secondi all'ora (che continuano ad accumularsi). Quello che può ritardare in modo macroscopico invece è il momento in cui vai a controllare se il tempo è scaduto. Ad esempio se il tempo scade adesso, ma sto eseguendo un sacco di roba che impiega cinque minuti, mi accorgerò del tempo scaduto solo tra cinque minuti, quando andrò a riverificare la condizione

Codice: Seleziona tutto

(millis() - startTime < 60000)

Ora, al di là del fatto che in generale gestire tempi lunghi con millis non è una buona cosa per l'imprecisione dell'oscillatore, si potrebbe modificare il design del codice in modo da controllare la condizione più spesso, oppure per dare semplicemente il via ogni tot ore, ma credo che non si possa temporizzare direttamente con millis in deep sleep. In un caso come questo l'uso di un RTC con il chip DS3231 mi sembra la scelta migliore: un errore nei tempi di pochissimi minuti all'anno, e un segnale interrupt wake up programmabile nell'RTC stesso all'ora voluta.

Poi, non per togliere qualcosa ai forum, ma perché ormai le IA sono ulteriori strumenti formidabili per trovare spunti, guarda quante idee su cui ragionare tira fuori perplexity alla semplice domanda: "come risvegliare un arduino in deep sleep tramite RTC ?"

[frankis]

Ciao djnz, interessante. Credo però che Millis sia sempre meglio di Delay.

Io per il risveglio sto provando la funzione Watchdog e mi sembra che il risveglio sia affidabile, sempre con 8 secondi di ritardo come da parametro di controllo ma si notano su uno start e stop di 1 minuto ma su uno start di 6 ore e un'attesa di 18 ore è uno scarto di tempo che non si apprezza. Anche perché se ogni 2 o 3 giorni dovrò sostituire la batteria Litio il conteggio dei tempi si azzererà.

[frankis]

Salve, avrei bisogno di un consiglio pratico hardware:
le file di pin fornite in dotazione con Arduino Pro Mini è meglio saldarle tutte alla PCB anche se alla fine dei test non si fa più uso di breadboard?
Grazie

[Etemenanki]

Dipende da cosa vuoi farne tu poi.

Se non le saldi, puoi riutilizzarloper collegarlo "filato" a qualcos'altro, ma e' un'eventualita' abbastanza remota.

e le saldi, lo puoi comunque usare su uno stampato disegnato da te' come componente (o su una millefori) per qualcisa di permanente, oppure tenerlo di scorta per altri test con la breadboard.