Ciao a tutti
come da titolo, ho recuperato un MOT di un micronde e finalmente mi volevo fare una puntatrice , mi capita di preparare dei pacchi batterie e usarla anche per lamiera sottile, ne volevo fare una di tipo ad impulsi , gestita da arduino e ho cercato in rete qualche progetto, ne ho trovato un paio e tra questi ne ho trovato uno interessante, in pratica visualizza i 3 tempi , 1 impulso -pausa- 2 impulso , la regolazione è fatta tramite un pulsante di selezione menu e un potenziometro per regolare i valori, poi c'è il pulsante "saldatura", il progetto prevede un Arduino nano , display 16x2 , un rele SSR, potenziometro e 2 pulsanti.
Il progetto lo trovato su un forum di bici elettriche , l'autore ha messo sia il codice che lo schema liberi, ho cercato di conttatare l'autore per chiedergli delle informazioni ma mai risposto, perchè volevo fare una piccola modifica e se lui mi poteva dare un aiuto.
La mia modifica è questa : in pratica voglio aggiungere un interrutore che mi selezioni una modalità manuale, magari sul display mi visualizza " manuale " e il rele SSR mi alimenta il MOT per il tutto il tempo che tengo premuto il pulsante "saldatura"
Io ho iniziato a leggere delle guide su Arduino , ma ho difficoltà a capire alcune strutture che sono all'interno dello sketch e dove poter inserire le istruzione per aggiungere l'opzione manuale.
Per ora l'unica cosa che ho fatto è verificare lo sketch su IDE arduino non presenta errori, arduino e display mi devo arrivare quindi non ho fatto nessuna prova su basetta sperimentale e caricando lo sketch.
Qualcuno mi può aiutare a fare questa modifica?
copio il codice e lo scrivo qui come listato ? oppure aggiungo il file del codice?

#define imax 300 // tempo massimo impulso
#define pts 500 // pausa tra saldature in ms
#define _SSR 9 // Pin dove è collegato il relay a stato solido
#define debug true
#define potenziometro A0
byte ci=0; // contatore array impulsi
int impulsi[3]={0,0,0}; // durata in ms del primo impulso


// ***** setupdisplay I2C {
#include
#include
LiquidCrystal_I2C lcd(0x3F,16,2);
// ****** setupdisplay I2C }

// ************************************** Pulsante con pull up interno {
#define premuto 1
#define rilasciato 2
#define trattenuto 3

struct pulsante_pu // con resistenza di pull-up interna
{
pulsante_pu(byte _pin); // numero pulsante capacitivo mpr121 (0..11)
byte cont; // contatore intervalli di tempo
byte pin; // numero pulsante capacitivo mpr121 (0..11)
byte controlla(byte _time); // controlla se viene premuto o rilasciato un tasto è memorizza le informazioni su stato (tasto premuto) e cont(tempo di pressione del tasto)
void reset(); //resetto tasto
byte stato,stato_old; //0 = nada; 1=premuto; 2=trattenuto;
boolean nuovo_stato; // se vera c'è stato un cambiamento di stato
};

void pulsante_pu::reset()
{
stato=0;
stato_old=0;
cont=0;
nuovo_stato=false;
}

pulsante_pu::pulsante_pu(byte _pin)
{
pin=_pin;
pinMode(pin, INPUT_PULLUP);
reset();
}

byte pulsante_pu::controlla(byte time=10) //numero intervalli da 100ms per determinare se il tasto è trattenuto di default è 10
{
nuovo_stato=false;
stato_old=stato;
stato=0;
if (!digitalRead(pin))
{
if (cont<254) cont+=1; // incremento il tempo
if (cont==1) stato=premuto;
if (cont==time) stato=trattenuto;
}
else
if (cont>0) // controllo se è stato rilasciato un tasto
{
if (contcont=0;
}
if (stato!=stato_old) nuovo_stato=true;
return(stato);
}
// ************************************** Pulsante con pull up interno }



void setup()
{
pinMode(_SSR, OUTPUT);
lcd.init(); // inizializzo il disay
lcd.clear(); // cancella schermo lcd
lcd.setBacklight(true); //Retroilluminazione -- true acceso; false spento
load_data(); // carico i dati dalla eeprom
}

// ************************************ Definizione Pulsanti
pulsante_pu foot_switch(5); // assegno il foot switch al pin 5 dell'arduino e verrà gestito come pulsante con pull_up interno
pulsante_pu select(7); // assegno il tasto select al pin 7 dell'arduino e verrà gestito come pulsante con pull_up interno
// ************************************ Definizione Pulsanti

word potval=0; // valore del potenziometro
word oldpotval=0; // vecchio valore del potenziometro

void loop()
{
byte i=0;
boolean aggiorna=true;

while (foot_switch.cont>0) // aspetto che venga rilasciato il foot switch
{
foot_switch.controlla();
delay(100);
}


while (foot_switch.cont==0) // aspetto il segnale per saldare
{
select.controlla();// controllo lo stato del tasto select
foot_switch.controlla(); // controllo lo stato del foot switch
potval = map(analogRead(potenziometro), 0, 1024, 0, 1+(imax/10))*10; // Inervalli di 10ms
//potval = map(analogRead(potenziometro), 0, 1024, 0, imax); // Inervalli di 1ms
if (oldpotval==0) oldpotval=potval;

if (select.stato==rilasciato) // Cambio parametro da modificare
{
ci++;
if (ci>2) ci=0;
aggiorna=true;
}


if (potval!=oldpotval) // Aggiorno valore letto dal potenziometro se è cambiato
{
impulsi[ci]=potval;
aggiorna=true;
}


if (select.stato==trattenuto) // salvo valori su eeprom
{
lcd.setCursor(0,0); //mi posiziono all'inizio della prima riga del display
lcd.print("** Save Data **"); //stampo riga1
save_data();
delay(2000);
aggiorna=true;
}

if ((i>=10)or aggiorna) // aggiorno dati display
{
lcd.setCursor(0,0); //mi posiziono all'inizio della prima riga del display
lcd.print("Spot Welder V1.0");


lcd.setCursor(0,1); //mi posiziono all'inizio della seconda riga del display
if (ci==0) lcd.print("*");else lcd.print(" ");
lcd.print(impulsi[0]);

if (ci==1) lcd.print("*"); else lcd.print(" ");
lcd.print("P"); //stampo riga1
lcd.print(impulsi[1]);

if (ci==2) lcd.print("*");else lcd.print(" ");
lcd.print(impulsi[2]);
lcd.print(" ");

lcd.setCursor(0,0);
lcd.print("Spot Welder V1.0");

i=0;
aggiorna=false;
}
delay(100); // pausa per gestire i tempi di lettura dei tasti
i++;
oldpotval=potval;
}


/////////////******** Questo blocco gestisce l'impulso di puntatura

lcd.setCursor(0,0);
lcd.print(" *** Saldo *** ");

lcd.setCursor(0,1);
lcd.print(impulsi[0]);

lcd.print(" P");
lcd.print(impulsi[1]);
lcd.print(" ");
lcd.print(impulsi[2]);
lcd.print(" ");


if (impulsi[0]>0) // primo impulso
{
digitalWrite(_SSR, HIGH); //Attivo l'SSR
delay(impulsi[0]); // Tengo attivo l'SSR per il tempo impostato
digitalWrite(_SSR, LOW); //disattivo l'SSR
}

if (impulsi[2]>0) // secondo impulso
{
delay(impulsi[1]); // pausa tra impulsi
digitalWrite(_SSR, HIGH); //Attivo l'SSR
delay(impulsi[2]); // Tengo attivo l'SSR per il tempo impostato
digitalWrite(_SSR, LOW); //disattivo l'SSR
}


delay(pts); // pausa minima tra una saldature
lcd.clear();
lcd.setCursor(0,0);
lcd.print("* wait relase * ");


}

// **************************** inizio EEPROM
#include

struct eeprom_data
{
int impulso1;
int pausa;
int impulso2;
};

eeprom_data ed;

void load_data() // carico l'array con i tempi degli impulsi
{
Serial.println("Carico valori da eeprom ");
eeprom_read_block((void*)&ed, (void*)0, sizeof(ed));
impulsi[0]=ed.impulso1;
impulsi[1]=ed.pausa;
impulsi[2]=ed.impulso2;
}

void save_data() // salvo l'array con i tempi degli impulsi
{
ed.impulso1=impulsi[0];
ed.pausa=impulsi[1];
ed.impulso2=impulsi[2];
eeprom_write_block((const void*)&ed, (void*)0, sizeof(ed));
}
// **************************** fine EEPROM

da quel poco che sono riuscito a capire , c'è la sruttura pulsante-pu che definisci se contato il tempo se il tasto è trattenuto o premuto
dopol definizioni dei 2 pulsanti , legge se ci sono variazioni nei valori c on il potenziometro , salva i valori in eprom e poi aggiorni la visualizazione del display , poi c'è il blocco dell'impulso e poi il blocco dell eprom.
Pensavo di inserire un istruzione di un interruttore che mi leggeva se un pin era a valore alto o basso e poi in base a questo se procedere in manuale o a impulsi, però è da mettere prima della struttura pulsante-pu o dopo .
Un altra soluzione è quella di aggiungerlo al menù , cosi una volta selezionato si passa in madolità manuale