Costruiamo un visualizzatore per 4 sonde EGT??

[Fabius72]

Capito. Grazie.
Non vedo la luce in fondo a questo tunnel
Porc...

[Tony Evo]

Vabbe,ma il tuo è un progetto ipervalido,ma purtroppo il knock è essenziale,una volta trovato il giusto anticipo poi monitori gli egt.

[Fabius72]

Piccolo aggiornamento: oggi mi è arrivato un modulino che include RTC e un chip di memoria sram da 4Kbyte (32Kbit), tutto I2C! Pagato 5,50€ batteria inclusa
Siccome non è possibile lavorare sulle 4 trimtable simultaneamente, pena burn ad ogni cambio pagina per non perdere le correzioni fatte, ho intenzione di caricare in ram tutte e 4 le trimTable (250 byte ognuna) e lavorare in ram!
Poi ogni volta che il codice si accorge dal decel che è stato chiuso il gas, oppure quando si attiva l'overrun, verrà effettuato il write di tutte le celle e poi il burn, di una pagina alla volta.
In una frazione di secondo saranno aggiornate tutte e 4 le trimTable senza che ci si accorga di nulla.

Prossimo passo sarà prendere un piccolo ciscuitino da mettere dietro al display per convertirlo in I2C, così libero qualche porta all'arduino...

[ricki158]

Quella dell'i2c è una cosa semplice e veloce Occhio che poi dovrai rivedere la libreria per stampare sull'LCD e dovrai fare qualche modifica ai comandi. Dovrai mettere anche le due resistenze di pull-up (non ricordo da quanto, io l'ho fatto ma attualmente non ho il circuito sotto mano).

[Fabius72]

Cosa intendi con "rivedere la libreria"?
Le resistenze sono già sul circuitino e poco fa ho fatto la prima prova.
Su LCD ho stampato 3 valori memorizzati agli indirizzi 0, 1023 e 4095 e la data.
Non ho dovuto effettuare nessuna modifica alla libreria. Che culo...
Spento tutto, riacceso dopo un po' ed RTC e i dati erano precisi

Il modulino è questo e nella descrizione si legge "56 byte" di memoria, quando invece sono 4K! Più tardi avviso il venditore.
Che bella sorpresa

http://www.ebay.it/itm/Shield-DS-1307-RTC-real-time-clock-memoria-I2C-Arduino-PIC-/230993139734?pt=Componenti_elettronici_attivi&hash=item35c8439816

Scusate, ma non scrivo codice in modo ordinato
I comandi per leggere e scrivere l'EEPROM li ho trovati un po' qua e un po' la. Alla fine di memoria ne porta via poco niente, visto che non c'è da importare nessun'altra libreria se non la wire.h che nel progetto è già usata.

Codice: Seleziona tutto

// LCD
#include <LiquidCrystal.h>
 LiquidCrystal lcd(3, 2, A0, A1, A2, A3);     // misto pin analogici e digitali. Funzia!

// RTC ed EEPROM
#include "RTClib.h"
RTC_DS1307 RTC;
#include <Wire.h>   
#define I2C24C32Add 0x50    // L'indirizzo del 24C32

void setup () {                           
                     pinMode (2, OUTPUT);                 // display
                     pinMode (3, OUTPUT);                 // display
                     pinMode (A0, OUTPUT);                // display
                     pinMode (A1, OUTPUT);                // display
                     pinMode (A2, OUTPUT);                // display
                     pinMode (A3, OUTPUT);                // display   
 
                     Wire.begin();
                     RTC.begin();
                     lcd.begin(16, 1);             
                     Serial.begin(115200);       

// Memorizza su RTC l'ora e la data del computer
// RTC.adjust(DateTime(__DATE__, __TIME__));  // tolta dopo prima memorizzazione

  unsigned short address1 = 0;
  unsigned short address2 = 1023;
  unsigned short address3 = 4095;

// tolte dopo la prima memorizzazione
//  writeEEPROM(I2C24C32Add, address1, 123); 
//  writeEEPROM(I2C24C32Add, address2, 252);
//  writeEEPROM(I2C24C32Add, address3, 200);

  lcd.print(readEEPROM(I2C24C32Add, address1), DEC); lcd.print("  ");
  lcd.print(readEEPROM(I2C24C32Add, address2), DEC); lcd.print("  ");
  lcd.print(readEEPROM(I2C24C32Add, address3), DEC);
 
delay(2000);
lcd.clear();

        DateTime now = RTC.now();
        lcd.print(now.day(), DEC);
        lcd.print('/');
        if (now.month() < 10) lcd.print('0');
        lcd.print(now.month(), DEC);
        lcd.print('/');
        lcd.print(now.year(), DEC);
        lcd.print(' ');
        lcd.print(now.hour(), DEC);
        lcd.print(':');
        lcd.print(now.minute(), DEC);
        lcd.print(':');
        lcd.print(now.second(), DEC);
}


void loop(){}
 

void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data )
{
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
 
  delay(5);  // fatta la prova senza e sembra non essere necessario. Indago
}
 
byte readEEPROM(int deviceaddress, unsigned int eeaddress )
{
  byte rdata = 0xFF;
 
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,1);
 
  if (Wire.available()) rdata = Wire.read();
 
  return rdata;
}



[ricki158]

Quando mi è arrivato il display 20x4 direttamente con il modulino I2C saldato ho avuto qualche piccolo prolemino di comunicazione. Mi sembra che si debba scaricare una libreria per LCD I2C per comunicare, da includere poi nel codice, e costruire l'oggetto lcd in maniera un po' diversa. Nulla di preoccupante, solo che io ho provato 4 librerie prima di trovare quella che funzionava. E' da un po' che non lavoro con Arduino, potrebbero aver aggiornato il software e può darsi che ci sia già, senza doverla scaricare.

Codice: Seleziona tutto

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display

void setup(){
  Serial.begin(115200);
  lcd.init();                      // initialize the lcd
  lcd.backlight();
  lcd.setCursor(3,0);
  lcd.print("Hello, world!");
  lcd.setCursor(2,1);
  lcd.print("Ywrobot Arduino!");
  lcd.setCursor(0,2);
  lcd.print("Arduino LCM IIC 2004");
  lcd.setCursor(1,3);
  lcd.print("Button");
//  lcd.setCursor(10,3);
//  lcd.print("is pushed");
}

void loop(){
  int keyboard = 0;
  keyboard = analogRead(0);
//  if (keyboard>=800 and keyboard<=900){
//    lcd.setCursor(8,3);
//    lcd.print("1");
//    return;
//  }
//  else if (keyboard>=700 and keyboard<=799){
//    lcd.setCursor(8,3);
//    lcd.print("2");
//    return;
//  }
//  else if (keyboard>=500 and keyboard<=620){
//    lcd.setCursor(8,3);
//    lcd.print("3");
//    return;
//  }
//  else if (keyboard>=400 and keyboard<=499){
//    lcd.setCursor(8,3);
//    lcd.print("4");
//    return;
//  }
//  else if (keyboard>=200 and keyboard<=320){
//    lcd.setCursor(8,3);
//    lcd.print("5");
//    return;
//  }
//  else if (keyboard>=100 and keyboard<=199){
//   lcd.setCursor(8,3);
//    lcd.print("6");
//    return;
//  }
  lcd.setCursor(8,3);
  lcd.print(keyboard);
  delay(10);
}


Quando fai l'oggetto dei specificare l'indirizzo giusto (di solito lo trovi nelle specifiche del chip di comunicazione I2C, non seguire il commento che c'è sul mio codice perché è sbagliato), le colonne e le righe. Io ho avuto qualche problema di libreria perché, pur mettendo l'indirizzo giusto continuava a non funzionare bene la libreria. In allegato ti ho messo quella che funziona a me, ma ripeto che non so se le versioni nuove del software la inglobano già.

Una cosa però non ho capito, come si fa a gestire il fatto che sia la memoria sia l'LCD stanno sull'I2C? Avendo indirizzi diversi non c'è problema, ma se avessero indirizzi uguali? Poi se entrambe le "periferiche" condividono lo stesso bus come avviene lo scambio di dati? Un byte da una parte, uno dall'altra? Sarebbe interessante anche per questioni di velocità di scrittura lettura dalla memoria, cosa che mi sembra sia essenziale per il progetto dell'anticipo.

[Fabius72]

Ahh, ok. Devo ancora prenderlo il modulino da saldare dietro al display per convertirlo in I2C. E' ancora collegato al bus SPI...
Per l'altro progetto, le operazioni di lettura/scrittura avverranno su memoria SPI che viaggia infinitamente più veloce rispetto all'I2C.

Per il discorso conflitti di indirizzi, non so ancora come avvenga l'assegnazione. Chi la fa? Il costruttore? Forse c'è qualche convenzione...
Io mi sono appena affacciato al mondo I2C, quindi non so praticamente nulla, però credo d'aver capito che quando nel bus I2C ci sono collegati vari dispositivi succede che chi sta effettuando uno scambio dati lo porta a termine, poi sarà il turno del successivo.

Grazie per l'info. Adesso che so del probabile problema, valuterò l'acquisto del convertitore per il display solo se dovrò liberare qualche porta dell'arduino. Ora sono occupate tutte...

[PierGSi]

Cosa intendi con "rivedere la libreria"?
Le resistenze sono già sul circuitino e poco fa ho fatto la prima prova.
Su LCD ho stampato 3 valori memorizzati agli indirizzi 0, 1023 e 4095 e la data.
Non ho dovuto effettuare nessuna modifica alla libreria. Che culo...
Spento tutto, riacceso dopo un po' ed RTC e i dati erano precisi

Il modulino è questo e nella descrizione si legge "56 byte" di memoria, quando invece sono 4K! Più tardi avviso il venditore.
Che bella sorpresa

http://www.ebay.it/itm/Shield-DS-1307-RTC-real-time-clock-memoria-I2C-Arduino-PIC-/230993139734?pt=Componenti_elettronici_attivi&hash=item35c8439816

E' giusta l'inserzione,nella ram tamponata del DS1307 ci sono 56 byte disponibili all'utente, in piu' sulla board è presente una memoria EEPROM I2C da 32kb che condivide il bus I2C.
Di quei cosi ne ho comprati 3 in Cina ad una cifra insignificante (mi pare 2€ l'uno spediti)...
PS. complimenti, stai facendo delle cose veramente interessanti.

[Fabius72]

Ciao Pier, grazie

L'inserzione però è ingannevole

-----------------------------------------------------------
1 scheda RTC modello DS1307 + memoria 24C32

E' un orologio calendario a basso consumo che implementa anche una memoria non volatile da 56 Byte con batteria di backup.
-----------------------------------------------------------

non essendoci altre parole riguardanti la memoria...

Onestamente, non sapevo che nel DS1307 ci fossero dei byte allocabili
Non sono molti, ma possono servire!

[ricki158]

Visto che si parlava (mi sembra) di leggere una pulsantiera con 6 bottoni o più, con una sola entrata analogica: http://www.freetronics.com/pages/16x2-l ... zCHPRU4uSo

In pratica si utilizza una resistenza di pull-up e quando non schiacci nessun pulsante hai 5 volt, per cui 1023 come valore. Se pigi il primo pulsante hai 0 volt, quindi il valore 0, gli altri funziona con il partitore di tensione, per cui

[ (R eq della serie) / (R eq della serie + R pull-up) ] x V in

ed hai la tensione che poi converti in un valore numerico facendo una semplice proporzione.

Per il codice io ho usato questo ovviamente rivisto

Codice: Seleziona tutto

/*
  The circuit:
 * LCD RS pin to digital pin 8
 * LCD Enable pin to digital pin 9
 * LCD D4 pin to digital pin 4
 * LCD D5 pin to digital pin 5
 * LCD D6 pin to digital pin 6
 * LCD D7 pin to digital pin 7
 * LCD BL pin to digital pin 10
 * KEY pin to analogl pin 0
 */

#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);

char msgs[5][16] = {"Right Key OK ",
                    "Up Key OK    ",               
                    "Down Key OK  ",
                    "Left Key OK  ",
                    "Select Key OK" };

int adc_key_val[5] ={50, 200, 400, 600, 800 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;

void setup()
{
  lcd.clear();
  lcd.begin(16, 2);
  lcd.setCursor(0,0);
  lcd.print("ADC key testing");
}

void loop()
{
  adc_key_in = analogRead(0);    // read the value from the sensor
  key = get_key(adc_key_in);  // convert into key press
 
  if (key != oldkey)   // if keypress is detected
   {
    delay(50);  // wait for debounce time
    adc_key_in = analogRead(0);    // read the value from the sensor
    key = get_key(adc_key_in);    // convert into key press
    if (key != oldkey)   
    {   
      lcd.setCursor(0, 1);
      oldkey = key;
      if (key >=0){
           lcd.print(msgs[key]);             
      }
    }
  }
 delay(100);
}

// Convert ADC value to key number
int get_key(unsigned int input)
{
    int k;
   
    for (k = 0; k < NUM_KEYS; k++)
    {
      if (input < adc_key_val[k])
 {
            return k;
        }
   }
   
    if (k >= NUM_KEYS)k = -1;  // No valid key pressed
    return k;
}


Però alcuni if non capisco come funzionano.