Start programma, stop e memoria posizione

International Italiano Software
1

Ciao a tutti , essendo alle prime armi sono pò incasinato con la programmazione, sono ancora molto acerbo per un simile progetto a mio parere, mi sembrava semplice ma semplice per me non è :

Spiego brevemente il mio progettino
componenti :
pulsante 1 start programma 1
pulsante 2 start programma 2
led 1
led 2
rele 4 uscite :
elettrovalvola 1 filling
elettrovalvola. 2 airout
elettrovalvola 3 portvac
pompa per il vuoto. 4 vacuum

`int progr1 = 9;
int progr2 = 10;

int ledp1  = 11
inte ledp2 = 12

int filling = 13 ;
int airout = 14 ;
int portvac = 15 ;
int vacuum = 16 ;

Arduino sarà collegato ad un pulsante esterno sull alimentatore, una volta collegato tutto dovrà rimanere fermo fino alla pressione di uno dei due pulsanti.

Al premere del pulsante 1 partirà il programma 1 e relativo led fisso che indica il programma attivo in funzione e dovrà ripetere il ciclo 7 volte poi stopparsi
stessa cosa per il pulsante 2 abbinato al programma 2 (qui 10 cicli e diverse lunghezze di pause )

entrambi i pulsanti dovranno essere start and stop , nel caso dovessi stoppare vorrei che mantenesse memoria del passaggio per ripartire da dove si è fermato.
Il led allo stop dovrà lampeggiante

Non è importante riprendere una pausa o roba simile , l importante è che riparta dalla sequenza interrotta lasciando i rele sempre tutti chiusi, è un impianto ad aria compressa collegata con olio idrauilico, in caso di stop i 3 rubinetti e la pompa devono rimanere in posizione di riposo assolutamente per questioni di sicurezza

Esempio se STOPPO durante il passaggio // scarico aria la sua elettrovalvola dovrà essere chiusa per questioni di sicurezza.
allo START dovrà ripartire sempre da // scarico valvola .

Sicuramente un display con menu, una percentuale di avanzamento e con vari pulsanti sarebbe meglio, ma io non sono proprio in grado di gestire una tale programmazione, già così sarei molto contento per partire non voglio nemmeno scocciarvi troppo.

Quoto il programma 1 ( il programma 2 sarà simile cambieranno solo i secondi delle pause )

digitalWrite(filling, HIGH);    // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
delay(4000);
digitalWrite(filling, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
delay(1000);

//scarico aria

digitalWrite(airout, HIGH);   // APERTURA ELETTROVALVOLA SCARICO ARIA
delay(3000);
digitalWrite(airout, LOW);
delay(1000);   // CHIUSURA ELETTROVALVOLA SCARICO ARIA

//APERTURA VALVOLA


digitalWrite(portvac, HIGH); // APERTURA ELETTROVALVOLA ASPIRAZIONE
delay(1000);

  //INIZIO ASPIRAZIONE 


digitalWrite(vacuum, HIGH); // ACCENSIONE POMPA VUOTO 
delay(10000);

//CHIUSURA VALVOLA E SPEGNIMENTO POMPA

digitalWrite(portvac, LOW);  //CHIUSURA  ELETTROVALVOLA ASPIRAZIONE
delay(1000);

digitalWrite(vacuum, LOW); // SPEGNIMENTO POMPA VUOTO 
delay(1000);



//scarico aria

digitalWrite(airout, HIGH);  // APERTURA ELETTROVALVOLA SCARICO ARIA
delay(3000);
digitalWrite(airout, LOW);  // CHIUSURA  ELETTROVALVOLA SCARICO ARIA
delay(1000);

Spero si capisca e che non sia una cosa troppo complicata

2

.. fosse anche per una sola riga, come richiesto al punto 7 del REGOLAMENTO, il codice va racchiuso tra i tag CODE, per cui, cortesemente edita il tuo post qui sopra (quindi NON scrivendo un nuovo post, ma utilizzando il bottone a forma di piccola matita :pencil2: che si trova in basso del tuo post), seleziona la parte di codice e premi l'icona <code/> nella barra degli strumenti per contrassegnarla come codice. Inoltre, così com'è, non è molto leggibile ... assicurati di averlo correttamente indentato nell'IDE prima di inserirlo (questo lo si fa premendo ctrlT su un PC o cmd T su un Mac, sempre all'interno del IDE).

Grazie,

Guglielmo

P.S.: Ti ricordo che, purtroppo, fino a quando non sarà sistemato il codice come indicato, nel rispetto del regolamento nessuno ti risponderà (eventuali risposte o tuoi ulteriori post, verrebbero temporaneamente nascosti), quindi ti consiglio di farlo al più presto. :wink:

3

Ciao. Modifica il tuo post, cliccando sulla matita.

Seleziona tutte le istruzioni inclusi i commenti // e premi il pulsante <code>

Non è facile, ma il problema non è l'algoritmo in se, ma come lo hai pensato (tutti lo pensano come hai fatto tu). Il problema principale è il delay() che si dice essere "bloccante", cioè durante il delay la lettura dei pulsanti non può essere eseguita. In genere si consiglia di usare la funzione millis() per eseguire codice temporizzato, ma purtroppo ho costato che nonostante il consiglio sia corretto, il principiante non è capace di pensare l'algoritmo usando millis(). Documentati su millis anche superficialmente, mentre studia e applica il comando switch(), perché ti servirà per tenere traccia di cosa stava eseguendo il programma1.

Il motto è "Dividi et impera".

In questo caso, dividi programma1 in n fasi, esempio:

byte fase;  // vale 0
void loop() {
    switch(fase) {
        case 0:
            digitalWrite(filling, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 1; // dopo il delay verrà eseguito il case 1 
            delay(4000);
            break;
        case 1:
            digitalWrite(filling, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 2; // dopo  il delay verrà eseguito il case 2
            delay(1000);
            break;
    }
}

Quando arrivi alla ultima fase, ad esempio fase = 8 se il case 8: non esiste non verrà eseguito nulla della switch.

Per adesso prova a creare questo switch e poi vediamo dove andiamo a parare. Durante l'esecuzione di programma1 nei delay non potrai leggere i pulsanti, ma a questo c'è una soluzione, ma facciamo un passo per volta.

Ok, ciao.

5

Ciao Mauro è un piacere, intanto grazie per l interessamento, scusate per il code ho visto che è un errore che fanno tutti, non potevo essere brillante da riuscirci al primo colpo :smiley:
Torniamo alle cose piacevoli e serie :smiley: diciamo il mio codice di avviamento con 1 ciclo di spurgo

int buttonPin = 13;
int filling = 5 ;
int airout = 7 ;
int portvac = 8 ;
int vacuum = 10 ;



void setup() {


 pinMode(buttonPin, INPUT);
 pinMode( filling,OUTPUT);
 pinMode( airout,OUTPUT);
 pinMode( portvac,OUTPUT);
 pinMode( vacuum,OUTPUT);
}




byte fase;  // vale 0
void loop() {
    switch(fase) {
        case 0:
            digitalWrite(filling, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 1; // dopo il delay verrà eseguito il case 1 
            delay(2000);
            break;
        case 1:
            digitalWrite(filling, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 2; // dopo  il delay verrà eseguito il case 2
            delay(1000);
            break;
      
    
  
   
        case 2:
            digitalWrite(airout, HIGH); // APERTURA SCARICO ARIA 
            fase = 3; // dopo il delay verrà eseguito il case 3
            delay(2000);
            break;
        case 3:
            digitalWrite(airout, LOW); // CHIUSURA  SCARICO ARIA
            fase = 4; // dopo  il delay verrà eseguito il case 4
            delay(1000);
            break;
      
       case 4:
            digitalWrite(portvac, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 5; // dopo il delay verrà eseguito il case 5 
            delay(2000);
            break;

      case 5:
            digitalWrite(vacuum, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 6; // dopo il delay verrà eseguito il case 7 
            delay(2000);
            break;
        case 6:
            digitalWrite(portvac, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 7; // dopo  il delay verrà eseguito il case 7
            delay(1000);
            break;
      
  
        case 7:
            digitalWrite(vacuum, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 8; // dopo  il delay verrà eseguito il case 8
            delay(1000);
            break;

        case 8:
            digitalWrite(airout, HIGH); // APERTURA SCARICO ARIA 
            fase = 9; // dopo il delay verrà eseguito il case 3
            delay(2000);
            break;
        case 9:
            digitalWrite(airout, LOW); // CHIUSURA  SCARICO ARIA
            fase = 10; // dopo  il delay verrà eseguito il case 4
            delay(1000);
            break;
                  
 }
 
}

Ora vorrei ripetere questi 9 casi e ripeterli ad esempio 10 volte. Per il discorso di stoppare dove vorrei io immagino dovro fare un copia incolla, se saranno 90 casi e si ferma a 60 ovviamente da li dovrà ripartire, è corretto ?
Altra cosa per far si che il ciclo non parta da solo in automatico come fare per a mettere uno start / pausa su pulsante 1 ?

6

Rivedi il tuo primo post, solo il codice sorgente deve essere evidenziato
Puoi anche premere il pulsante <code> e ti compaiono
```
type or paste code here
```

Ok, copia il tuo switch all'interno di questa funzione:

void programma1() {
    // qui il tuo switch
}

byte ripetizioni;  // vale 0
void loop() {
   if (ripetizioni < 10) {
       Serial.println(ripetizioni); // solo per test
       programma1();  // chiama la funzione di nome programma1
       ripetizioni++; // incrementa di una unità
       fase = 0;  // riparte dalla fase 0
   }
}

PS: le variabili le metto poco prima del loop per brevità del post, ma tu poi le metti tutti in testa allo sketch.

No, ne verrebbe fuori una confusione di codice, come vedi il codice sopra fa queste ripetizioni. Metabolizzalo, perché qui siamo sul semplice.

Ecco qui andiamo sul difficile, serve prepararti alla complessità senza traumi, per cui per adesso non ci pensare.

Testa le n ripetizioni, non creare programma2, non aggiungere funzionalità prima ancora di avere quel poco di codice da testare e verificare che funziona.

PS: impara le funzioni, almeno quelle che non prendono argomenti e non ne restituiscono come appunto programma1()

Ciao.

7

Così funziona solo un led ( int filling = 5 ; ) e rimane acceso, ti posto il codice magari ho sbagliato qualcosa io

int buttonPin = 13;
int filling = 5 ;
int airout = 7 ;
int portvac = 8 ;
int vacuum = 10 ;
byte ripetizioni;  // vale 0
byte fase;  // vale 0

void setup() {


 pinMode(buttonPin, INPUT);
 pinMode( filling,OUTPUT);
 pinMode( airout,OUTPUT);
 pinMode( portvac,OUTPUT);
 pinMode( vacuum,OUTPUT);
}


void programma1() {
    switch(fase) {
        case 0:
            digitalWrite(filling, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 1; // dopo il delay verrà eseguito il case 1 
            delay(2000);
            break;
        case 1:
            digitalWrite(filling, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 2; // dopo  il delay verrà eseguito il case 2
            delay(1000);
            break;
      
   
        case 2:
            digitalWrite(airout, HIGH); // APERTURA SCARICO ARIA 
            fase = 3; // dopo il delay verrà eseguito il case 3
            delay(2000);
            break;
        case 3:
            digitalWrite(airout, LOW); // CHIUSURA  SCARICO ARIA
            fase = 4; // dopo  il delay verrà eseguito il case 4
            delay(1000);
            break;
      
       case 4:
            digitalWrite(portvac, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 5; // dopo il delay verrà eseguito il case 5 
            delay(2000);
            break;

      case 5:
            digitalWrite(vacuum, HIGH); // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 6; // dopo il delay verrà eseguito il case 6 
            delay(2000);
            break;
        case 6:
            digitalWrite(portvac, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 7; // dopo  il delay verrà eseguito il case 7
            delay(1000);
            break;
      
  
        case 7:
            digitalWrite(vacuum, LOW); // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
            fase = 8; // dopo  il delay verrà eseguito il case 8
            delay(1000);
            break;

        case 8:
            digitalWrite(airout, HIGH); // APERTURA SCARICO ARIA 
            fase = 9; // dopo il delay verrà eseguito il case 9
            delay(2000);
            break;
        case 9:
            digitalWrite(airout, LOW); // CHIUSURA  SCARICO ARIA
            fase = 10; // dopo  il delay verrà eseguito il case 10
            delay(1000);
            break;
}
}

void loop() {
   if (ripetizioni < 10) {
       Serial.println(ripetizioni); // solo per test
       programma1();  // chiama la funzione di nome programma1
       ripetizioni++; // incrementa di una unità
       fase = 0;  // riparte dalla fase 0
       
   }
}
8

C'è un errore ho introdotto io. Metabolizzalo e prova trovare l'errore.
Non lo voglio più ripetere, sistema i tuo primo post.

Prima di postare premi nell'ide di arduino la combinazione di tasti CTRL+T
questo formatterà il codice in modo che sia più leggibile.

Ciao.

10

La fase 0 non esiste....

fase = 0;                     // riparte dalla fase 0

Ho modificato in


fase = 1;                     // riparte dalla fase 1

così però si accende il primo led e si spegne poi non accade piu nulla...

11

Passo e chiudo per sta notte.
Ciao.

12

Il primo istinto era quasi giusto. La fase 0 esiste (è gestita dal case 0). Per il fatto che poi "non accade più nulla", come indicazione è sempre importante cercare di eseguire/simulare mentalmente l'ordine in cui le istruzioni vengono eseguite, tenendosi nota momento per momento del valore delle variabili.

Per partire avrei strutturato la logica (descritta a parole nel primo post) con un diagramma delle fasi simile a questo (ma non vorrei aggiungere confusione alla strada già iniziata per cui mi fermo qua).

87623547653
87623547653608×545 14.7 KB

13

Eh essendo all inzio faccio fatica a capire perchè rimane acceso
fase = 0

Il fatto che si blocchi nonostante venga detto di incrementare per quel poco che capisco mi lascia perplesso.

Se modifico così

void loop() {
  if (ripetizioni < 10) {
    Serial.println(ripetizioni);  // solo per test
    programma1();                 // chiama la funzione di nome programma1
    ripetizioni ++;                // incrementa di una unità
    fase = 0;                     // riparte dalla fase 0
    fase = 1;

il led 1 fase si accende e si spegne come da programma ma non succede altro

In alternativa ho eliminato i break per fare una prova e funziona

int buttonPin = 13;
int filling = 5;
int airout = 7;
int portvac = 8;
int vacuum = 10;
byte ripetizioni;  // vale 0
byte fase;         // vale 0

void setup() {


  pinMode(buttonPin, INPUT);
  pinMode(filling, OUTPUT);
  pinMode(airout, OUTPUT);
  pinMode(portvac, OUTPUT);
  pinMode(vacuum, OUTPUT);
}


void programma1() {
  switch (fase) {
    case 0:
      digitalWrite(filling, HIGH);  // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 1;                     // dopo il delay verrà eseguito il case 1
      delay(2000);
      
    case 1:
      digitalWrite(filling, LOW);  // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 2;                    // dopo  il delay verrà eseguito il case 2
      delay(1000);
      


    case 2:
      digitalWrite(airout, HIGH);  // APERTURA SCARICO ARIA
      fase = 3;                    // dopo il delay verrà eseguito il case 3
      delay(2000);
      
    case 3:
      digitalWrite(airout, LOW);  // CHIUSURA  SCARICO ARIA
      fase = 4;                   // dopo  il delay verrà eseguito il case 4
      delay(1000);
      

    case 4:
      digitalWrite(portvac, HIGH);  // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 5;                     // dopo il delay verrà eseguito il case 5
      delay(2000);
      

    case 5:
      digitalWrite(vacuum, HIGH);  // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 6;                    // dopo il delay verrà eseguito il case 6
      delay(2000);
      
    case 6:
      digitalWrite(portvac, LOW);  // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 7;                    // dopo  il delay verrà eseguito il case 7
      delay(1000);
      


    case 7:
      digitalWrite(vacuum, LOW);  // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
      fase = 8;                   // dopo  il delay verrà eseguito il case 8
      delay(1000);
      
    case 8:
      digitalWrite(airout, HIGH);  // APERTURA SCARICO ARIA
      fase = 9;                    // dopo il delay verrà eseguito il case 9
      delay(2000);
      
    
    case 9:
      digitalWrite(airout, LOW);  // CHIUSURA  SCARICO ARIA
      fase = 10;                  // dopo  il delay verrà eseguito il case 10
      delay(1000);
      
  }
}

void loop() {
  if (ripetizioni < 10) {
    Serial.println(ripetizioni);  // solo per test
    programma1();                 // chiama la funzione di nome programma1
    ripetizioni ++;                // incrementa di una unità
    fase = 0;                     // riparte dalla fase 0
    
  
}
  }
14 
void programma1() {
    // esegue il case selezionato e restituisce il controllo al chiamante
    
}

void loop() {
     programma1(); 
     // quando si trova qui ha appena eseguito il case 0
     // quando il loop ricomincia e si trova qui ha eseguito il case 1
     // quando il loop .... ha eseguito il case 2
     // quando fase == 10 il programma1 è stato eseguito tutto dal case 0 al 
     // case 9
}

Quindi dobbiamo incrementare la variabile ripetizioni solo se la variabile
fase vale 10.

void loop () {
    if (ripetizioni < 10) {
        Serial.println(ripetizioni);
        programma1();
        if (fase == 10) {
            ripetizioni++;
            fase = 0;
        }
    }
}

Lascio stagionare questo post, perché è importante prendere familiarità con il codice attuale al fine di capire come funziona. Considera che questa è la parte semplice ed è impensabile introdurre la parte complicata in questa fase.

Ciao.

15

Grazie Mauro per l' aiuto, vedrò di studiarmelo a modo poi magari ci torneremo sopra. Grazie ancora

16

Appunto per questo è importante seguire passo passo, una per una, le istruzioni nell'ordine in cui sono eseguite, annotandosi il valore delle variabili.
Nel case0 dello switch della funzione programma1, la variabile fase viene impostata a 1, ma nella funzione loop, dopo la chiamata di programma1, la variabile fase viene rimessa a zero, per cui al successivo ciclo di elaborazione viene di nuovo eseguito il case 0, e allora sembra che tutto sia bloccato.
Con la tua modifica sposti solo il "problema" un case più avanti, perché dal momento che la variabile fase diventa 1, poi rimane sempre 1, e di nuovo sembra tutto bloccato... mentre in realtà il programma sta facendo esattamente quello che gli hai detto di fare, cioè di rimanere fermo a quella fase :wink:

17

mmmm...allora con la implementazione attuale abbiamo due programmi e il loro stato memorizzato nelle variabili. Inizialmente nessuno dei programmi è in stato in esecuzione. La pressione di button1 avvia programma1 e la pressione di button2 avvia programma2, ma a patto che non ci sia già avviato un programma. Cioè se il programma2 è in esecuzione (RUN) il programma1 non può essere avviato e viceversa. Il programma che risulta in esecuzione può essere messo in pausa e fintantoché non viene riavviato e termina tutte le ripetizioni non si può fare altro (come ad esempio selezionare l'altro programma)

Ok quando il programma viene messo in pausa tutte le uscite devono essere LOW. Ma quando il programma viene riavviato da quale case deve iniziare, da quello in cui è stato messo in pausa? Oppure da quello seguente alla pausa. Cioè se metto in pausa quando fase == 2, quando riavvio deve partire da 2 o da 3?
Per adesso riparte da 3, se è stato messo in pausa quando fase == 2.

Non è facile per niente, non lo è neanche descrivere cosa deve fare ad uno che di impianti di aria non ne capisce nulla e non ne vuole capire nulla (io ad esempio).

@Claudio_FF
Andrò a parare su una delay custom di nome es. dly che è la copia della delay() del core, che però chiama la funzione process() anziché la YELD();
In questo modo vado incontro al modo di ragionare del principiante che va di delay(), ma durante l'attesa process() legge gli input. Non ho mai consigliato questa strada perché non la ho mai studiata per verificarne i limiti, vedremo come si evolve.

Ciao.

18

Ma c'è una descrizione di quello che deve fare sta' roba oppure no?
Magari un diagrammino di Gannt?

Inoltre cosa deve succedere se il pulsante P1 viene premuto durante la sequenza due?
E viceversa?
O durante la pausa?

Senza sapere queste cose si brancola solo nel buio

19

@Claudio_FF grazie per la spiegazione ho capito il concetto alla perfezione, sei stato molto chiaro.

@Maurotec si è corretto quello che hai scritto, sotto descrivo meglio il tutto e il video sicuramente spiega meglio il tutto.

@Ducembarr hai pienamente ragione forse non si capisce bene il tipo di progetto, io il diagrammino non lo so fare ma posso postare un video se si può inerente al funzionamento dove si vede la funzione totalmente in manuale usando i classici rubinetti al posto dell elettrovalvole ,posto un video spero non sia contro il regolamento

Video vuoto ammortizzatore

Qui parte col ciclo di aspirazione,la sequeza è inversa alla mia ma non è importante per la programmazione, adesso vi spiego quello che sta facendo lui nel video ;

vedete 2 maniglie rosse dei rubinetti, poi c ' è uno sfiato aria che si vede poco, la pompa sotto di colore blu.
il contenitore trasparente contiene olio ed è a tenuta di pressione.

l' ammortizzatore è vuoto,senza olio quindi lui parte aspirando l' aria che c' è dentro finchè l' ammortizzatore si ritrae del tutto, poi sfiata l' aria in eccesso dentro il contenitore e rimanda dentro l olio dando di nuovo pressione al suo interno.

Avanti così circa 5-10 volte fino a quando non ci sarà più aria all' interno dell' ammortizzatore, il numero di cicli dipende dai vari ammortizzatori, per questo volevo almeno 2 programmi, ma per il momento dimentichiamoci di questo per non fare troppa confusione.

ricapitolando quello che fa nel video è :

//ASPIRAZIONE

1 apertura maniglia di aspirazione    // PORTVAC
2  accensione pompa del vuoto          // VACUUM
3 chiusura maniglia di aspirazione 
4 spegnimento pompa 

//SCARICO ARIA

5 apertura maniglia scarico aria     //AIROUT
6 chiusura maniglia scarico aria

//RIEMPIMENTO

7 apertura maniglia riempimento olio   // FILLING
8 chiusura maniglia riempimento olio

//SCARICO ARIA

5 apertura maniglia scarico aria     //AIROUT
6 chiusura maniglia scarico aria

//FINE 

RIPETIZIONE CICLO PER  " x"  VOLTE

Ora io vorrei alimentare arduino e non deve fare assolutamente nulla, FERMO.
1 pulsante START programma 1

il programma 1 fa 10 cicli e si ferma.

Durante questo programma se capita un emergenza l olio schizza ovunque e prima chiudo le valvole e meglio è, se è in pressione mi faccio la doccia di olio , finchè non è vuoto il contenitore è una fontana, quindi mi serve qualcosa che faccia da PAUSA, che sia un' altro pulsante poco importa basta che funzioni insomma.

(La mia idea iniziale era 1 pulsante START programma1 , un RESET e uno di PAUSA ma non l ho specificato perchè non volevo creare troppo casino.)

La PAUSA dovrebbe agire così :

Riempimento. // FILLING  CHIUSA
aspirazione  // PORTVAC CHIUSA
pompa  vuoto    //VACUUM  CHIUSA

Valvola scarco aria      APERTA
tempo 3 secondi
Valvola  scarico aria.  CHIUSA

Ora poniamo d' esempio che ho avviato il mio programma e metà del 5 ciclo io debba mettere in PAUSA.
Ripristino i miei problemi meccanici , poi vorrei ripartire dall' inzio del 5 ciclo e proseguire fino al 10 come prestabilito.

Il tutto serve ad ottimizzare i tempi, dover rifare un ciclo da 10 minuti è tecnicamente inutile.

Spero sia chiaro e di aver postato bene tutto.

Grazie a tutti per l' aiuto

20

Ma allora tu vuoi mettere in pausa per abbassare tutte le uscite low, ma poi quando riprendi l'esecuzione non deve ripartire da case che è stato messo in pausa, ma dal case 0.

Cioè se alla 5 ripetizione al case 7 devi premere il pulsante per fare la pausa. Quando premi nuovamente per ripartire vuoi che la ripetizione 5 venga ripetuta da capo, cioè dal case 0.

Io avevo capito che volevi fermare e riprendere i singoli case.

21

Esatto così sarebbe la cosa migliore, tutte le uscite in low a parte lo scarico aria che prima si apre poi dopo 3 secondi si chiude tutto si ferma.

Si puo fare ?

Poi per chi chiedeva del programma2 era una copia di quello attuale con cicli magari da 15 invece che da 10 tutto qua.

Io tempo fa me l ero immaginato con un display e i pilsanti tipo freccette su e giu,che visualizzava il numero dei cicli da fargli fare prima dello start,impostavo il numero di cicli desiderato e poi una volta partito il programma visualizzava il numero del ciclo attuale, tutto questo quando pensavo fosse una cosa non troppo complicata, quindi va bene anche senza display, magari piu avanti :smile:

22

Quello che vuoi fare non è "non troppo complicato"
È addirittura banale
Ma come vedi non sei stato in grado nemmeno di spiegarlo, hai dovuto ricorrere ad un video non tuo

Fino a che non sarai in grado di spiegarti chiaramente tu, non avrai le idee chiare
E quindi non caverai ragni da buchi

Parlare prima di programmi, codici, macchine a stati finiti e similia è solo mettere troppa carne al fuoco
E induce confusione, in noi che non ne abbiamo bisogno, ma soprattutto in te che già hai difficoltà a focalizzare il problema
Insomma è deleterio

PS ne io né il fratello andremo a vedere il video
Non serve che io capisca quello che volava fare quello la
Serve che "tu" capisca quello che vuoi fare "tu"