Go Down

Topic: Arduino + LCD i2c + Rapberry Pi connessi tramite i2c. Come usare il display? (Read 3794 times) previous topic - next topic

subnet

Ciao a tutti,
primo post in questo forum, lieto di conoscervi  :)

premetto che sono un programmatore dilettante e un "elettronico" ancor più dilettante, ma da quando ho scoperto Arduino m'è venuta una "febbre elettro-informatica" e mi sono addirittura messo a saldare Atmega su millefori, anche con discreto (ma sofferto  :)) successo.

Vorrei creare una "board" che si connetta a Raspberry Pi via i2c, e sono in fase di sperimentazione della cosa.
Ho preso ispirazione da questo post

http://blog.oscarliang.net/raspberry-pi-arduino-connected-i2c/

e mi pare che tutto funzioni (Rpi e Arduino si "parlano" :)), ma se provo a usare dal raspberry il display LCD connesso all'arduino via i2c tramite un MCP23017 ehm... non mi riesce granché...

questo è il mio "ignobile" codice, ho soltanto aggiunto la parte per il display al codice di oscarliang.net

Code: [Select]

#include <Wire.h>
#include <LiquidTWI2.h>
LiquidTWI2 lcd(0);

// indirizzo slave di Arduino
#define SLAVE_ADDRESS 0x04
int number = 0;
int state = 0;

void setup() {
   pinMode(13, OUTPUT);
   Serial.begin(9600);
   Wire.begin();  // connetto il display?
   
   // inizializzo la connessione slave di Arduino
   Wire.begin(SLAVE_ADDRESS);
   
   // mi connetto al display... ?
   lcd.setMCPType(LTI_TYPE_MCP23017);
     lcd.begin(16, 2);  

   // define callbacks for i2c communication
   Wire.onReceive(receiveData);
   Wire.onRequest(sendData);

   Serial.println("Ready!");
}

void loop() {
   delay(100);
}

// callback for received data
void receiveData(int byteCount){

   while(Wire.available()) {
       number = Wire.read();
       Serial.print("data received: ");
       Serial.println(number);

       if (number == 1){

           if (state == 0){
               digitalWrite(13, HIGH); // set the LED on
               Serial.println("ho acceso il led 13");
               lcd.clear();      
               lcd.home();
               lcd.print("led acceso");                
               state = 1;
           }
           else{
               digitalWrite(13, LOW); // set the LED off
               Serial.println("ho spento il led 13");  
               lcd.clear();      
               lcd.home();
               lcd.print("led spento");                                
               state = 0;
           }
        }
    }
}

// callback for sending data
void sendData(){
   Wire.write(number);
}



nulla di che... se dal raspberry invio un "1" dovrei accendere il led 13 e comunicarlo sul display... se lo invio ancora spengo il led e lo scrivo sul display. Lo script in python usato sul raspberry è quello trovato sul link indicato, e funziona se non uso il display...

uhm... mi viene il dubbio che Arduino non possa gestire il fatto di essere slave su i2c e di comandare un display i2c allo stesso tempo... oppure sbaglio io (ancor più probabile) qualcosa nel codice? come faccio a dire a wire.begin di essere slave e di connettere il display allo stesso tempo?

dimenticavo.. al raspberry ho connessi due MCP23017, uno all'indirizzo 0x20 e l'altro al 0x21.
Visto che l'MCP23017 dell'Arduino è saldato con indirizzo 0x20, ho provato a cambiare quello di uno dei due connessi al raspberry, mettendolo a 0x24, ma niente..
infine, all'Arduino è saldato un RTC con DS1307, sempre su i2c, all'indirizzo 0x68

un'ultima osservazione...quando connetto l'arduino al raspberry (seguendo lo schema del link indicato sopra) noto che:
se NON collego il GND dal raspberry vedo (con il comando $ i2cdetect -y 0)

Code: [Select]

subnet@raspberrypi ~/esperimenti/arduino $ i2cdetect -y 0
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- 04 -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: 20 21 -- -- 24 -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --


ovvero i tre MCP23017 (21 e 24 del raspberry e il 20 dell' arduino) e l'arduino (0x04), mentre se collego il GND tra i due vedo anche il DS1307

Code: [Select]

subnet@raspberrypi ~/esperimenti/arduino $ i2cdetect -y 0
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- 04 -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: 20 21 -- -- 24 -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --


uhm... è normale che dal raspberry veda le periferiche i2c connesse all'arduino? e... (fantasia finale) quindi (nel migliore dei mondi possibili) se tutto riuscisse funzionare potrei usarle direttamente dal raspberry, dotandolo anche di un RTC?

beh, pare sia tutto... mi scuso per la lungaggine e per la confusione del post, ma sono confuso pure io sulla cosa, quindi grazie per la pazienza e per l'eventuale aiuto che vorrete darmi :)

Piero

uwefed

Il problema é che vuoi usare sia Arduino che Rasberry come master sul bus I2C. Esiste la possibilitá di un sistema multimaster ma non so dirti di piú.
Ciao Uwe

subnet

Ciao e grazie per la risposta :)

uhm sì, avevo sospettato qualcosa del genere... ma in giro si trova pochino... ho visto questo

http://digitalcave.ca/resources/avr/arduino-i2c.jsp

ma tratta del collegamento tra due arduino...
devo ragionarci un po' su...

ciao,
Piero

paulus1969

Il bus è unico, quindi non hai periferiche connesse all'Arduino e periferiche connesse al Raspberry. Non c'è niente di strano nel fatto che tu possa usare l'RTC sul Raspberry.
Quando crei il sistema, TUTTO (periferiche, Arduino e Raspberry) è collegato in una unica struttura.
La cosa più conveniente da fare in questo caso è scegliere un componente che funga da Master e ti conviene scegliere il Raspberry. L'Arduino lo userai come slave, quindi nel programma Arduino lascia soltanto l'istruzione per collegarsi al bus come slave.
Se vuoi far sapere all'Arduino l'orario (tanto per dirne una), potrai comunicarlo tramite il Raspberry che prima interrogherà l'RTC e poi passerà il risultato.
Anche il display è collegato AL BUS ed anche in questo caso lo piloterai dal Master (quindi dal Raspberry). Nel caso in cui volessi scrivere sul display un valore letto da un ingresso analogico di Arduino (sempre tanto per dirne una), il Raspberry interrogherà l'Arduino e poi invierà al display il valore. E così via.
Un solo master, quello che ha più memoria e più velocità (Raspberry) e tutto il resto è Slave. Con il Python ci puoi fare di tutto, ti divertirai.

subnet


Un solo master, quello che ha più memoria e più velocità (Raspberry) e tutto il resto è Slave. Con il Python ci puoi fare di tutto, ti divertirai.


spettacolare...
in pratica, anche se non carico lo sketch slave su Arduino, posso pilotare il display a lui connesso con python da raspberry... provato e funziona :-)
ovviamente è solo una prova, visto che lo sketch slave su arduino poi serve a prescindere...
grazie dell'aiuto, vedo davanti a me nuovi entusiasmanti orizzonti... :-D

a presto
Piero

testato

perche' dici "display a lui connesso" inteso come se fosse connesso ad arduino ? Il display e' sul bus i2c, per questo puoi scriverci sopra, arduino e' nel tuo caso un semplice slave, e puoi anche smontarlo fisicamente, il display continuera' a funzionare via raspberry
- [Guida] IDE - http://goo.gl/ln6glr
- [Lib] ST7032i LCD I2C - http://goo.gl/GNojT6
- [Lib] PCF8574+HD44780 LCD I2C - http://goo.gl/r7CstH

subnet


perche' dici "display a lui connesso" inteso come se fosse connesso ad arduino ? Il display e' sul bus i2c, per questo puoi scriverci sopra, arduino e' nel tuo caso un semplice slave, e puoi anche smontarlo fisicamente, il display continuera' a funzionare via raspberry


vero, vero... dicevo così perché è connesso "fisicamente" all'arduino...
ora è tutto un po' più chiaro (ehm... almeno sembra :))

Go Up