Consigli su come modificare un codice

Ciao a tutti
Come da titolo chiedo un aiuto o consigli su come posso modificare questo codice, premetto che ho iniziato a leggere i rudimenti per la programmazione cosi da avere la capacità su come poter almeno modificare un codice già compilato.
Il codice che descrivo è stato modificato rispetto all’originale solo del nome di alcune variabili e scritte sul display , dopo di che è stato verificato e caricato su un Arduino Nano, testato su bassetta sperimentale con display, pulsanti e potenziometro e funziona regolarmente.
Il codice ha le seguenti funzioni:
Attraverso un pulsante (select) su D7 e GND seleziona 3 parametri : 1° impulso , Pausa , 2° impulso, se tengo premuto più a lungo il tasto mi salva i valori.
Con un potenziometro ( pin centrale collegato su A0 e gli altri 2 su GND e 5V ) regoloo la durata in millisecondi degli impulsi e della pausa.
Un pulsante ( start) su D5 e GND, mi fa partire la sequenza di impulsi , (1°impulso –Pausa- 2°impulso ) sull’uscita D9 che mi pilota un relay.
Un display 16x2 di tipo I2C , mi indica le varie fasi , sulla seconda riga mi compaiono i 3 parametri .
Nel funzionamento io premo il tasto select, sul dispaly sulla 2° riga lui mi sposta il simbolo * prima di ogni parametro e li posso regolare la durata del parametro con il potenziometro, posso salvare i nuovi valori tenendo premuto più a lungo il tasto select oppure premere start e far partire la sequenza di impulsi, senza salvarli.
Io vorrei fargli una modifica che è la seguente :
Aggiungere alla selezione delle 3 sequenze : 1° impulso ; Pausa ; 2° impulso, una 4° selezione che è quella manuale e mi compare la scritta “manuale “ e quando premo il pulsante start, sull’uscita D9 mi resta l’impulso attivo fino a quando non rilascio il pulsante start.
Ho pensato che una soluzione potrebbe essere creando una nuova variabile , che quando è attivata nella selezione con il pulsante select mi va laggere il valore del tasto start e mi porta a valore alto l’uscita D9, i comandi di quest’ultima parte andrebbero inseriti nel blocco che gestisce l’inizio degli impulsi.
qui di seguito il codice

#define imax 300 // tempo massimo impulso
#define pts 500 // pausa  in ms
#define _SSR 9 // Pin dove è collegato il relay
#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 <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 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 (cont < time) stato = rilasciato;
    cont = 0;
  }
  if (stato != stato_old) nuovo_stato = true;
  return (stato);
}
// ************************************** Pulsante con pull up interno }



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

// ************************************ Definizione Pulsanti
pulsante_pu start_switch(5); // assegno il start 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 (start_switch.cont > 0) // aspetto che venga rilasciato lo start switch
  {
    start_switch.controlla();
    delay(100);
  }


  while (start_switch.cont == 0) // aspetto il segnale per iniziare l’avvio impulsi
  {
    select.controlla();// controllo lo stato del tasto select
    start_switch.controlla(); // controllo lo stato dello start 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("time impulse 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("time impulse 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

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

  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 un avvio e l’altro
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("* wait relase * ");


}

// **************************** inizio EEPROM
#include <avr/eeprom.h>

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

Faccio fatica a capire a prima vista cosa fa il programma, ovviamente
non è il problema di capire il linguaggio C, ma capire cosa ha pensato e voluto fare chi lo ha scritto.
Ti do un consiglio che non ti risolve il problema ma penso sia fondamentale. Se vuoi usare codice già scritto come librerie, ben venga e lo fanno tutti in misura diversa. Ma quando vuoi fare qualcosa di specifico dovresti scrivere tu il programma e non usare programmi già scritti. Per quanto ti sembra difficile se avresti scritto tu un programma aggiungere nuove funzioni ti veniva immediato.
C’è anche un discorso “filosofico” che soddisfazione c’è a fare qualcosa se in realtà non la faccio io ma è già bella e pronta. Ci sarà più soddisfazione a farsi una pizza da soli in casa piuttosto che comprarla in pizzeria, a parte che forse è più buona quella della pizzeria, fatta da me ha un valore inestimabile per me. Allora il consiglio che ti do, prova a scrivere un tuo programma e qualunque risultato è una soddisfazione.