Go Down

Topic: Misuratore Ampere / Volt / Continuità per pista Slot (Read 17024 times) previous topic - next topic

Etemenanki

il codice funziona, ma non cancella la cifra precedente.
Per forza ... invece di stampare pstato in nero e stato in bianco, stampi due volte di seguito stato, una in nero ed una in bianco ... ;)
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

Si, mi ero accorto della svista ed ho sistemato. Però continua anche con questo codice:

Code: [Select]

  if (millis() - displayTime >= 1000) {
    display1.setTextColor(ST7735_BLACK);
    display1.setTextSize(3);
    display1.setCursor(50, 65);
    display1.print(pStato);
    Stato++;
    if (Stato > 9){Stato = 0;}
    display1.setTextColor(ST7735_WHITE);
    display1.print(Stato);
    pStato = Stato;
    displayTime = millis();
  }

Etemenanki

#212
Jun 29, 2018, 04:02 pm Last Edit: Jun 29, 2018, 04:03 pm by Etemenanki
Uhm ... non devi rimettere setcursor anche nello stampare in bianco, per farlo ricominciare dal punto corretto ? ... puoi mettere un video anche di questo test su youtube ? (non googlecloud che non funziona)

poi, questa
Code: [Select]

    display1.setTextSize(3);


non basta farla una sola volta nel setup ? ... o bisogna specificarla per ogni comando di stampa anche se non cambi grandezza ? ... se si, la parte nell'if diventerebbe, tipo, una cosa del genere ...

Code: [Select]

   Stato++;
   if (Stato > 9){Stato = 0;}
   display1.setTextColor(ST7735_BLACK);
   display1.setCursor(50, 65);
   display1.print(pStato);
   display1.setTextColor(ST7735_WHITE);
   display1.setCursor(50, 65);
   display1.print(Stato);
   pStato = Stato;
   displayTime = millis();


E' dura cercare di indovinare cosa non va, non avendo un display con cui provare ...
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

#213
Jun 29, 2018, 05:06 pm Last Edit: Jun 29, 2018, 05:10 pm by ricki158
Che errore scemo! Anche io non ci sto più con la testa. Effettivamente bisogna riposizionare settando il pixel da scrivere :D

Si, settare la dimensione una sola volta si può fare, ma ho preso l'abitudine di metterlo nelle funzioni che stampano per comodità.

https://www.youtube.com/watch?v=Q-CxMY8ObEg

Etemenanki

Be', cosi come cambiamento delle cifre mi sembra "leggermente" meglio di prima ... o no ? ... ;)

Ora, per controllare se usare due display rallenta i refresh di molto, riesci ad inserire anche il secondo display, lasciando tutto il resto invariato nello sketch ? ... (nel senso di inviare semplicemente i comandi di scrittura su entrambi i display, scrivi pstato nero su 1, scrivi stato bianco su 1, scrivi pstato nero su 2, scrivi stato bianco su 2, ovviamente dopo averli inizializzati entrambi nel setup eccetera ... per ora, limitiamoci a scrivere contemporaneamente lo stesso numero su entrambi e vediamo se il fatto di dover inviare i comandi a due invece che ad uno lo rallenta troppo o no)

nella tua prova del video, hai lasciato il settaggio della dimensione nell'if ? ... se no, prova a rimetterlo, giusto per "appesantirlo" un po di piu inviando anche un comando inutile ... cerco di capire se l'invio di piu comandi influisce troppo, se ti chiedevi il perche' ...
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

Interno o esterno all'if non cambia nulla.

Code: [Select]

#define sclk 15
#define mosi 16
#define cs1 4
#define dc1 5
#define rst1 6
#define cs2 7
#define dc2 8
#define rst2 9

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

Adafruit_ST7735 display1 = Adafruit_ST7735(cs1, dc1, rst1);
Adafruit_ST7735 display2 = Adafruit_ST7735(cs2, dc2, rst2);

unsigned long displayTime = millis();

byte Stato;
byte pStato;

void setup() {

  pinMode(sclk, OUTPUT);
  pinMode(mosi, OUTPUT);
  pinMode(cs1, OUTPUT);
  pinMode(dc1, OUTPUT);
  pinMode(rst1, OUTPUT);
 
  display1.initR(INITR_BLACKTAB);
  display1.fillScreen(ST7735_BLACK);

  display1.setTextSize(3);

  display2.initR(INITR_BLACKTAB);
  display2.fillScreen(ST7735_BLACK);

  display2.setTextSize(3);

}

void loop() {
 
  if (millis() - displayTime >= 1000) {
    display1.setTextColor(ST7735_BLACK);
    display1.setCursor(50, 65);
    display1.print(pStato);
    display2.setTextColor(ST7735_BLACK);
    display2.setCursor(50, 65);
    display2.print(pStato);
    Stato++;
    if (Stato > 9){Stato = 0;}
    display1.setTextColor(ST7735_WHITE);
    display1.setCursor(50, 65);
    display1.print(Stato);
    display2.setTextColor(ST7735_WHITE);
    display2.setCursor(50, 65);
    display2.print(Stato);
    pStato = Stato;
    displayTime = millis();
  }

}


https://www.youtube.com/watch?v=a6RkkwLtouY

Etemenanki

E' decisamente meglio che con i flash neri :D

Pero' prova a cambiare l'ordine di invio dei comandi, per ridurre ancora di piu il tempo morto (tu nel tuo sketch prima scrivi in nero entrambi i display, poi fai alcune altre operazioni, poi scrivi in bianco entrambi i display ... con un solo numero probabilmente non si nota molto, ma se dovessi aggiornare piu roba, tutte le operazioni che fai fra le scritture in nero e le riscritture in bianco ti allungherebbero il tempo in cui rimane il nero, rendendo piu evidenti i flash ed i cambiamenti di cifra ...

vorrei provare a scriverti una cosa in due modi diversi per farti provare se ne hai voglia, ma mi serve sapere su quel display quanti caratteri ci puoi far stare ... o per essere piu precisi, quanti pixel in altezza tiene via un carattere, e qual'e' nel setcursor l'asse verticale (immagino il secondo, 65, giusto ?)
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

Etemenanki

Oppure, ma qui tiro ad indovinare con le posizioni del cursore, prova addirittura queste due versioni della stessa cosa ... in entrambe ho aggiunto un delay(20) per simulare diverse operazioni senza eseguirle davvero ... giusto per vedere se la semplice differenza nell'ordine di invio degli stessi  comandi al display, crea molta differenza nel risultato finale ...

versione che in teoria dovrebbe essere peggiore
Code: [Select]

#define sclk 15
#define mosi 16
#define cs1 4
#define dc1 5
#define rst1 6
#define cs2 7
#define dc2 8
#define rst2 9

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

Adafruit_ST7735 display1 = Adafruit_ST7735(cs1, dc1, rst1);
Adafruit_ST7735 display2 = Adafruit_ST7735(cs2, dc2, rst2);

unsigned long displayTime = millis();

byte Stato;
byte pStato;

void setup() {
  pinMode(sclk, OUTPUT);
  pinMode(mosi, OUTPUT);
  pinMode(cs1, OUTPUT);
  pinMode(dc1, OUTPUT);
  pinMode(rst1, OUTPUT);
  display1.initR(INITR_BLACKTAB);
  display1.fillScreen(ST7735_BLACK);
  display1.setTextSize(3);
  display2.initR(INITR_BLACKTAB);
  display2.fillScreen(ST7735_BLACK);
  display2.setTextSize(3);
}

void loop() {
  if (millis() - displayTime >= 1000) {
    display1.setTextColor(ST7735_BLACK);
    display1.setCursor(20, 35);
    display1.print(pStato);
    display1.setCursor(20, 65);
    display1.print(pStato);
    display1.setCursor(20, 95);
    display1.print(pStato);
    display1.setCursor(50, 35);
    display1.print(pStato);
    display1.setCursor(50, 65);
    display1.print(pStato);
    display1.setCursor(50, 95);
    display1.print(pStato);
    display1.setCursor(80, 35);
    display1.print(pStato);
    display1.setCursor(80, 65);
    display1.print(pStato);
    display1.setCursor(80, 95);
    display1.print(pStato);

    display2.setTextColor(ST7735_BLACK);
    display2.setCursor(20, 35);
    display2.print(pStato);
    display2.setCursor(20, 65);
    display2.print(pStato);
    display2.setCursor(20, 95);
    display2.print(pStato);
    display2.setCursor(50, 35);
    display2.print(pStato);
    display2.setCursor(50, 65);
    display2.print(pStato);
    display2.setCursor(50, 95);
    display2.print(pStato);
    display2.setCursor(80, 35);
    display2.print(pStato);
    display2.setCursor(80, 65);
    display2.print(pStato);
    display2.setCursor(80, 95);
    display2.print(pStato);

    Stato++;
    if (Stato > 9){Stato = 0;}

    delay(20); //tanto per simulare un'altra manciata di operazioni

    display1.setTextColor(ST7735_WHITE);
    display1.setCursor(20, 35);
    display1.print(Stato);
    display1.setCursor(20, 65);
    display1.print(Stato);
    display1.setCursor(20, 95);
    display1.print(Stato);
    display1.setCursor(50, 35);
    display1.print(Stato);
    display1.setCursor(50, 65);
    display1.print(Stato);
    display1.setCursor(50, 95);
    display1.print(Stato);
    display1.setCursor(80, 35);
    display1.print(Stato);
    display1.setCursor(80, 65);
    display1.print(Stato);
    display1.setCursor(80, 95);
    display1.print(Stato);

    display2.setTextColor(ST7735_WHITE);
    display2.setCursor(20, 35);
    display2.print(Stato);
    display2.setCursor(20, 65);
    display2.print(Stato);
    display2.setCursor(20, 95);
    display2.print(Stato);
    display2.setCursor(50, 35);
    display2.print(Stato);
    display2.setCursor(50, 65);
    display2.print(Stato);
    display2.setCursor(50, 95);
    display2.print(Stato);
    display2.setCursor(80, 35);
    display2.print(Stato);
    display2.setCursor(80, 65);
    display2.print(Stato);
    display2.setCursor(80, 95);
    display2.print(Stato);

    pStato = Stato;
    displayTime = millis();
  }
}


versione che in teoria dovrebbe essere migliore
Code: [Select]

#define sclk 15
#define mosi 16
#define cs1 4
#define dc1 5
#define rst1 6
#define cs2 7
#define dc2 8
#define rst2 9

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

Adafruit_ST7735 display1 = Adafruit_ST7735(cs1, dc1, rst1);
Adafruit_ST7735 display2 = Adafruit_ST7735(cs2, dc2, rst2);

unsigned long displayTime = millis();

byte Stato;
byte pStato;

void setup() {
  pinMode(sclk, OUTPUT);
  pinMode(mosi, OUTPUT);
  pinMode(cs1, OUTPUT);
  pinMode(dc1, OUTPUT);
  pinMode(rst1, OUTPUT);
  display1.initR(INITR_BLACKTAB);
  display1.fillScreen(ST7735_BLACK);
  display1.setTextSize(3);
  display2.initR(INITR_BLACKTAB);
  display2.fillScreen(ST7735_BLACK);
  display2.setTextSize(3);
}

void loop() {
  if (millis() - displayTime >= 1000) {
    Stato++;
    if (Stato > 9){Stato = 0;}

    delay(20); //tanto per simulare un'altra manciata di operazioni

    display1.setTextColor(ST7735_BLACK);
    display1.setCursor(20, 35);
    display1.print(pStato);
    display1.setCursor(20, 65);
    display1.print(pStato);
    display1.setCursor(20, 95);
    display1.print(pStato);
    display1.setCursor(50, 35);
    display1.print(pStato);
    display1.setCursor(50, 65);
    display1.print(pStato);
    display1.setCursor(50, 95);
    display1.print(pStato);
    display1.setCursor(80, 35);
    display1.print(pStato);
    display1.setCursor(80, 65);
    display1.print(pStato);
    display1.setCursor(80, 95);
    display1.print(pStato);

    display1.setTextColor(ST7735_WHITE);
    display1.setCursor(20, 35);
    display1.print(Stato);
    display1.setCursor(20, 65);
    display1.print(Stato);
    display1.setCursor(20, 95);
    display1.print(Stato);
    display1.setCursor(50, 35);
    display1.print(Stato);
    display1.setCursor(50, 65);
    display1.print(Stato);
    display1.setCursor(50, 95);
    display1.print(Stato);
    display1.setCursor(80, 35);
    display1.print(Stato);
    display1.setCursor(80, 65);
    display1.print(Stato);
    display1.setCursor(80, 95);
    display1.print(Stato);

    display2.setTextColor(ST7735_BLACK);
    display2.setCursor(20, 35);
    display2.print(pStato);
    display2.setCursor(20, 65);
    display2.print(pStato);
    display2.setCursor(20, 95);
    display2.print(pStato);
    display2.setCursor(50, 35);
    display2.print(pStato);
    display2.setCursor(50, 65);
    display2.print(pStato);
    display2.setCursor(50, 95);
    display2.print(pStato);
    display2.setCursor(80, 35);
    display2.print(pStato);
    display2.setCursor(80, 65);
    display2.print(pStato);
    display2.setCursor(80, 95);
    display2.print(pStato);

    display2.setTextColor(ST7735_WHITE);
    display2.setCursor(20, 35);
    display2.print(Stato);
    display2.setCursor(20, 65);
    display2.print(Stato);
    display2.setCursor(20, 95);
    display2.print(Stato);
    display2.setCursor(50, 35);
    display2.print(Stato);
    display2.setCursor(50, 65);
    display2.print(Stato);
    display2.setCursor(50, 95);
    display2.print(Stato);
    display2.setCursor(80, 35);
    display2.print(Stato);
    display2.setCursor(80, 65);
    display2.print(Stato);
    display2.setCursor(80, 95);
    display2.print(Stato);

    pStato = Stato;
    displayTime = millis();
  }
}
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

#218
Jul 01, 2018, 05:02 pm Last Edit: Jul 01, 2018, 05:52 pm by ricki158
E' decisamente meglio che con i flash neri :D

Pero' prova a cambiare l'ordine di invio dei comandi, per ridurre ancora di piu il tempo morto (tu nel tuo sketch prima scrivi in nero entrambi i display, poi fai alcune altre operazioni, poi scrivi in bianco entrambi i display ... con un solo numero probabilmente non si nota molto, ma se dovessi aggiornare piu roba, tutte le operazioni che fai fra le scritture in nero e le riscritture in bianco ti allungherebbero il tempo in cui rimane il nero, rendendo piu evidenti i flash ed i cambiamenti di cifra ...

vorrei provare a scriverti una cosa in due modi diversi per farti provare se ne hai voglia, ma mi serve sapere su quel display quanti caratteri ci puoi far stare ... o per essere piu precisi, quanti pixel in altezza tiene via un carattere, e qual'e' nel setcursor l'asse verticale (immagino il secondo, 65, giusto ?)
Decisamente si :D Io ho messo così l'ordine dei comandi non so bene per quale motivo, ma mi sembrava giusto prima cancellare tutto del clock precedente, fare le operazioni e poi scrivere. Buono a sapersi anche questo, per ottimizzare tutto.

Quanti pixel in altezza non lo so, un po' perché i pixel sono piccoli, un po' perché non so se i pixel neri fanno parte della stringa oppure no.

setcursor(orizzontale, verticale);

128x160 pixel

Più tardi provo i due sketch

EDIT:

Primo sketch (peggiore):
https://youtu.be/az7yQFbsLJ8

Secondo sketch (migliore):
https://youtu.be/_7M9ueu6YLw

Etemenanki

Come vedi, cambia il risultato anche solo mandando gli stessi comandi con sequenza diversa (anche se non so perche' scrive solo 6 cifre, io ne avevo inserite 9 ... magari ho semplicemente sbagliato il set del punto di start) ... ogni volta che scrivi una nuova cifra, il ritardo fra la cancellazione e la scrittura deve essere il piu breve possibile, per ridurre al massimo il flickering (sfarfallio) ...

Il risultato migliore credo lo si otterrebbe addirittura facendo ogni singola scrittura subito dopo la cancellazione, ma comporterebbe un sacco di setcolor ... a meno di non provare a fare un'altra cosa diversa, ma anche qui, serve vedere nella pratica il risultato finale ... voglio dire, tu hai, se non sbaglio, la necessita' di scrivere 4 gruppi di valori, uno per ogni traccia, giusto ?

Si potrebbe provare a creare 4 funzioni (funzioni a cui, oviamente, tu possa passare dei valori dallo sketch), una per ogni gruppo di valori, ognuna ovviamente con gia le posizioni delle cifre inserite, che scrivano sul display SOLO nel momento in cui vengono richiamate, e SOLO le cifre del proprio gruppo ... ed ovviamente lo sketch poi le richiamera' SOLO nel momento in cui uno di questi valori cambia ... oppure in sequenza, a tempi fissi, tipo aggiornare le scritte ogni mezzo secondo, dovrebbe essere piu che sufficente ...

Come struttura dovrebbero essere il piu "dirette" e semplici possibile ... e contenere solo i comandi necessari a cancellare la cifra in nero e riscriverla subito dopo in bianco, senza altre istruzioni in mezzo ... ad esempio, se un gruppo contiene 2 valori, se li devi cambiare, tu mandi alla funzione sia i vecchi che i nuovi valori ... in modo che la funzione che aggiorna le scritte non faccia "niente altro" che quello, il resto lo deve fare lo sketch all'esterno ...

cosi una funzione che stampa due valori, dovrebbe ricevere 4 variabili, le 2 con il vecchio valore e le 2 con il nuovo (diciamo ad esempio old1, new1, old2, new2 ... e limitarsi a fare

setcolor nero
setcursor posizione 1
stampa old1
setcursor posizione 2
stampa old2
setcolor bianco
setcursor posizione 1
stampa new1
setcursor posizione 2
stampa new2

e "niente altro", l'impostazione old1=new1 prima di cambiare new1, eccetera (ed ovviamente "qualsiasi" altra cosa) la deve fare lo sketch "fuori" dalle funzioni, prima di inviargli i dati ... credo questo sia il sistema piu semplice per avere cambi di cifre piu fluidi senza troppi casini ... altri non me ne vengono in mente ...

 

 
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

Forse adesso ho capito qual è il mio problema:

Guarda lo sketch che ho condiviso e cerca di seguirmi. Io ho fatto una funzione per ogni cosa nello schermo che si deve aggiornare "quando voglio io". Per esempio il nome delle piste ha una funzione a sè (e una funzione gemella per la cancellazione) e viene cancellata alla modalità 4 mentre viene scritta solamente alla modalità 1, quindi teoricamente una sola volta, ma non è così ma lo spiego meglio dopo.

Mentre i caratteri "variabili" vengono scritti e cancellati ogni volta. In questo modo non ho bisogno di trascrivere il valore precedente di una variabile in maniera tale da cancellarla se cambia. Da un certo punto di vista aumenterebbe la velocità, cancellando "solo se serve" ma in realtà i dati della tensione istantanea e della corrente istantanea si devono aggiornare solo nel momento in cui ho una "media" nuova. E spero sia molto veloce. Gli altri valori (v max, a max, errori) non li ho ottimizzati, anche se sono pochi pixel.

Adesso riprendo il discorso di prima: io come ho detto stampo le cose in base alla modalità e le cancello. Solo che stampando non lo faccio una sola volta ma lo faccio ad ogni ciclo. Anche per questo credo ci siano i rallentamenti.
Quindi provo a farmi venire un'idea (per esempio utilizzare le variabili booleane cleanX che già utilizzo per cancellare quando cambio modalità le cose che non voglio vengano visualizzate dalla modalità precedente) e carico.

In questo periodo sono un po' incasinato con gli esami e delle volte non rispondo dopo qualche giorno. Comunque non ho molto tempo da dedicarci.

ricki158

Aggiornamenti:

in velocità ho modificato il programma in modo che le cose "statiche" vengano scritte una sola volta, mentre le cose "dinamiche" vengono prima cancellate e poi scritte ad ogni "clock". Non ho ancora fatto nessun tipo di Flag per i valori "massimi" (siccome già faccio una funzione per salvare i massimi se cambiano rispetto al precedente, tanto vale metterci dentro una flag che diventa true quando cambia il valore. quando cambia il valore cancello il precedente e scrivo il nuovo valore, scrivendo il nuovo valore al posto del precedente. in questo modo ottimizzo anche quella scrittura. idem per il conteggio degli errori) mentre per le letture di tensione e corrente non posso fare molto secondo me, dal momento che cambiano in continuazione.

Sono riuscito ad avere un refresh molto più veloce (sotto i 250 millisecondi non vedo nessun cambiamento però) e soprattutto il refresh non è a caso come prima ma segue la velocità che imposto io.

Per quel che riguarda la funzione che gestisce il dht11, continua a non funzionare, stampandomi valori 0.

Come vedete ho qualche problema nella cancellazione completa dei valori sullo schermo, credo sia dovuto all'ordine delle funzioni che chiamo. La funzione che gestisce le modalità e cosa stampare e quando si chiama state() ed è vicino al void setup().

Code: [Select]

bool clean0;
bool clean1;
bool clean2;
bool clean3 = true;

void state(){
  switch (mode){
    case 0:
   
      if (clean3){
        clean3 = false;
        print_T_Static_Clean();
        print_H_Static_Clean();
        print_T_Clean();
        print_H_Clean();
        print_CH();
        print_V_Static();
        print_V_Max_Static();
      }
     
      if (varSelFlag){
        print_VarSel_Clean();
        print_VarSel();
      }
     
      print_V_Clean();
      print_V();
      print_V_Max_Clean();
      print_V_Max();
      reset_V_Max();
      clean0 = true;
      break;
    case 1:
   
      if (clean0) {
        clean0 = false;
        print_V_Static_Clean();
        print_V_Max_Static_Clean();
        print_V_Clean();
        print_V_Max_Clean();
        print_A_Static();
        print_A_Max_Static();
      }

      if (varSelFlag){
        print_VarSel_Clean();
        print_VarSel();
      }
     
      print_A_Clean();
      print_A();
      print_A_Max_Clean();
      print_A_Max();
      print_VarSel();
      reset_A_Max();
      clean1 = true;
      break;
    case 2:
   
      if (clean1) {
        clean1 = false;
        print_A_Static_Clean();
        print_A_Max_Static_Clean();
        print_A_Clean();
        print_A_Max_Clean();
        print_E_Static();
      }

      if (varSelFlag){
        print_VarSel_Clean();
        print_VarSel();
      }
     
      print_E_Clean();
      print_E();
      print_VarSel();
      reset_Error();
      clean2 = true;
      break;
    case 3:
   
      if(clean2){
        clean2 = false;
        print_CH_Clean();
        print_E_Static_Clean();
        print_E_Clean();
        print_VarSel_Clean();
        print_T_Static();
        print_H_Static();
      }
     
      print_T_Clean();
      print_T();
      print_H_Clean();
      print_H();
      clean3 = true;
      break;
  }
}


https://www.youtube.com/watch?v=HOyslvFBjY8

ricki158

Con questo codice sono riuscito ad avere gli aggiornamenti ogni 100 millisecondi.
Praticamente adesso ad ogni clock stampo e cancello le tensioni e le correnti, mentre la X per selezionare la pista e la tensione massima e la corrente massima vengono stampate e cancellate solamente quando cambiano, idem il numero degli errori.

Ho però alcuni problemi nella cancellazione dei valori, cosa che non posso prevedere nel momento in cui faccio il programma ma non sono a casa per collegare il circuito e provare.

Allego l'ultimo programma aggiornato così da vedere la funzione di gestione dei display e le nuove funzioni per quanto riguarda la stampa.

ricki158

Sistemato anche la parte di pulizia, adesso funziona perfettamente.

Gli unici problemi sono: flickering diminuito ma sempre presente, non mi legge il sensore DHT11.

Credo che più ottimizzato di così non si possa fare.

Allego video e programma del video.

https://youtu.be/f6mji4VyTyo

Etemenanki

Purtropp oquei display non sono veloci piu di tanto, quindi un minimo di flickering lo avrai sempre ... puoi renderlo un po meno evidente facendo 4 aggiornamenti al secondo soltanto, se ti bastano ... e forse ridurlo leggermente anche facendo le scritture subito dopo le cancellazioni in una sola routine che "aggiorna" invece che in due separate, una che prima cancella tutto e l'altra che poi riscrive tutto ...

Voglio dire ... tu adesso hai per ogni impostazione una funzione che cancella tutti e 4 i display (le "clean"), ed un'altra che ristampa i nuovi valori, e le richiami in sequenza ogni volta che aggiorni questi valori ... questo significa che prima scrivi tutte e 4 le posizioni in nero, poi le riscrivi con i loro colori, per cui il tempo in cui rimane il nero e' leggermente lungo ...

Potresti provare, giusto per vedere se ti migliora la cosa, a tenere le "clean" per quando devi semplicemente cancellare, ma scrivere una nuova funzione per la stampa, fatta in questo modo:

colore nero
set posizione 1
stampa vecchio valore 1
colore verde
set posizione 1
stampa nuovo valore 1
colore nero
set posizione 2
stampa vecchio valore 2
colore giallo
set posizione 2
stampa nuovo valore 2
...

e cosi via ... cioe', in una sola funzione, fare sia la cancellazione del vecchio valore, che la riscrittura (immediatamente dopo la cancellazione) del nuovo, per ogni posizione ... e poi, quando devi aggiornare il valore, invece di richiamare prima la funzione "clean" e poi quella che stampa, richiami solo questa (chiamala "aggiorna", per non confonderla) ... se non ti velocizza il cambio riducendo lo sfarfallio in questo modo, non so proprio come altro si possa fare ...

Poi probabilmente eliminarlo del tutto sara' impossibile, e' gia un po lento di suo il display ... al masismo, lo riduce ... ma di quanto possa ridurlo, senza provare non lo so ...
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

Go Up