Comunicazioni sincronizzate: I2c SPI

Introduzione Due tipici esempi di interfacce seriali sincrone più utilizzate sono:  SPI (Serial  Peripheral  Interface) sviluppata da Motorola e I2C (Inter Integrated Circuits) sviluppata da Philips. Le interfacce seriali sincrone sono caratterizzate dalla presenza di un segnale di sincronizzazione, clock che determina la cadenza con cui i dati transitano attraverso il bus. Generalmente, il segnale di sincronizzazione viene generato da una unità Master e viene utilizzato dagli Slave per la trasmissione e ricezione dati.

Differenze I2C è più semplice perché ha meno bus e quindi meno pin da pilotare; non possiede la linea chipselect perché comunica in banda SPI possiede un chipselect e rischia di comunicare a vuoto; il vantaggio è quello di poter trasferire lunghi flussi dati. I2C trasmette i dati in half duplex mentre SPI in full duplex

I2c I2c=Inter-Integrated Circuit, è stato creato dalla Philips Semiconductors Costituito da due fili che rappresentanoi collegamenti denominati SCL ed SDA. I2c=protocollo di comunicazione La comunicazione i2c avviene tra un solo master e più slave; un master può essere anche slave e viceversa; tutti gli slave sono collegati su un unico bus scambio dati La comunicazione tra un master e tutti gli slave avviene su due linee: SCL ed SDA SCL viene utilizzata per i segnali di clock per sincronizzare il trasferimento dei dati su un bus SDA è il bus per il trasferimento dati che avviene in maniera half duplex

I2c Oltre ai bus SDA ed SCL c’è bisogno anche della linea per il ground e quella per l’alimentazione a 5 V I resistori possono avere valori da 1800 Hom a 4700 Hom

Master e slave Il master inizializza e termina la comunicazione; invia i segnali di clock per la sincronizzazione Le comunicazioni di start e di stop sono codici particolari, diversi dagli altri e mostrati in figura:

Trasferimento dati I dati vengono trasferiti tramite una sequenza di 8 bit partendo dal MSB sul bus SDA in maniera half duplex, visto che il bus è unico Per ogni treno di bit inviati, il device che riceve invia un segnale di ACK su SDA Il segnale ACK può essere emesso sia dal master che dallo slave, dipende da chi riceve il segnale. Siccome il cavo SDA è unico sia per trasmettere che per ricevere, il treno complessivo di dati è di 9 bit

Frequenza di trasferimento La frequenza clock per l’I2C è superiore a 100 KHz In base alla frequenza di trasferimento dati, vengono date le seguenti definizioni: Fast mode per frequenze superiori a 400 KHz High speed mode per frequenze superiori a 3.4 MHz

Indirizzamento Gli slave sono tutti collegati su un solo bus e devono avere un indirizzo per essere distinti I bit dedicati agli indirizzi sono in totale 7 Ciò vuol dire che il numero di slave indirizzabili sono 128 da 0 a 127 Prima di trasmettere o ricevere i dati, il master deve individuare l’indirizzo dello slave sul bus inviando un segnale di 8 bit fatto in questo modo: A6 A5…A0 sono i bit di indirizzo R/W indica se la trasmissione è si lettura o scrittura R/W=0 il master deve inviare allo slave dei dati e quindi si ha la scrittura R/W=1 il master deve leggere dei dati dallo slave

Treno di dati

I2C Arduino

I2C Arduino

Programma master #include<Wire.h> int x = 0; void setup() { Wire.begin(); } void loop() { Wire.beginTransmission(9); // trasmette al device 9 Wire.write(x); Wire.endTransmission(); x++; if (x > 5) x = 0; delay(500);

Programma slave int LED = 13; int x = 0; void setup() {Serial.begin(9600); pinMode (LED, OUTPUT); Wire.begin(9); //lo slave prende indirizzo 9 Wire.onReceive(receiveEvent); } void receiveEvent(int bytes) { x = Wire.read(); Serial.println(x); void loop() { void receiveEvent(); if (x != '0') digitalWrite(LED, HIGH); delay(200); digitalWrite(LED, LOW);

Lcd I2c

Pin raspberry

I2c Raspberry Per poter utilizzare il protocollo I2C su Raspberry è più complicato Bisogna installare le librerie e configurare la scheda Raspberry Il procedimento è il seguente: Bisogna digitare I seguenti comandi: sudo apt-get update sudo apt-get install -y python-smbus sudo apt-get install -y i2c-tools

Configurare il kernel sudo raspi-config

Configurare il kernel

Testare i2c Per testare I2c su Raspeberry Pi3 bisogna digitare il seguente comando: sudo i2cdetect -y 1 Per testare I2c su modelli precedenti di Raspberry bisogna digitare il seguente comando: sudo i2cdetect -y 0

Testare i2c

Codice esempio Raspberry import smbus bus = smbus.SMBus(1) # 0 = /dev/i2c-0 (port I2C0) #1 = /dev/i2c-1 (port I2C1) DEVICE_ADDRESS = 0x15 DEVICE_REG_MODE1 = 0x00 DEVICE_REG_LEDOUT0 = 0x1d #Write a single register bus.write_byte_data(DEVICE_ADDRESS, DEVICE_REG_MODE1, 0x80) #Write an array of registers ledout_values = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff] bus.write_i2c_block_data(DEVICE_ADDRESS, DEVICE_REG_LEDOUT0, ledout_values)

I2c arduino raspberry Codice raspberry import smbus import time # for RPI version 1, use "bus = smbus.SMBus(0)" bus = smbus.SMBus(1) # This is the address we setup in the Arduino Program address = 0x04 def writeNumber(value): bus.write_byte(address, value) # bus.write_byte_data(address, 0, value) return -1 def readNumber(): number = bus.read_byte(address) # number = bus.read_byte_data(address, 1) return number while True: var = input("") if not var: Continue writeNumber(var) number = readNumber()

I2c arduino raspberry Codice arduino #include <Wire.h> #define SLAVE_ADDRESS 0x04 #define RELAY1 9 int number = 0; int state = 0; void setup() { pinMode(RELAY1, OUTPUT); Serial.begin(9600); // start serial for output // initialize i2c as slave Wire.begin(SLAVE_ADDRESS); // 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(RELAY1, HIGH); // set the LED on state = 1; } else{ digitalWrite(RELAY1, LOW); // set the LED off state = 0; } } } } // callback for sending data void sendData(){ Wire.write(number); }

SPI Seriale Sincrono Master/slave (1 master) Protocollo semplice Diffuso per MCU e altri dispositivi come ADC, memorie etc..

SPI

SPI Protocollo per scambio dati master slave Ogni slave ha uno shift register contenente i dati Il master indirizza lo slave Il clock ha un bus separato da quello dei dati Necessita di 3+n cavi dove n è il numero di slave: MOSI, MISO, CS, n Velocità di trasmissione 10 Mbps

SPI sincronizzazione

SPI:ricevere i dati Il master genera il clock Il problema è che ci possono essere più slave; ogni slave viene selezionato dal Chip Select Il master invia i dati dal pin MOSI Master Output Slave Input Se lo slave necessita di rispondere, il master continua ad inviare segnali di clock fino a che lo slave risponde sul pin MISO Master Input Slave Output Lo scambio dati può avvenire in contemporaneo perché su bus differenti L’ultimo pin è dedicato alla selezione del device CS Chip Select o SS Slave Select

SS

Slave multipli

Immunità dei disturbi La lettura o scrittura dati viene effettuata sul fronte di salita o di discesa del segnale di clock a seconda della modalità di comunicazione scelta. Questa tecnica aumenta fortemente l’immunità al rumore in quanto il dato viene campionato solamente per un breve periodo di tempo.

Esempio con SPI, I2C, Onewire /* * analog sensors on analog ins 0, 1, and 2 * SD card attached to SPI bus as follows: ** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN) scl A5; sda A4 */

#include <SPI. h> #include <SD. h> #include <OneWire #include <SPI.h> #include <SD.h> #include <OneWire.h> #include <DallasTemperature.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x20,16,2); #define ONE_WIRE_BUS 14 //A0 OneWire ourWire(ONE_WIRE_BUS); DallasTemperature sensors(&ourWire); #define analogPin A0 const int chipSelect = 4;

void setup() {lcd.init(); lcd.setBacklight(1); pinMode(10,OUTPUT); Serial.begin(9600); Serial.println("Misura la temperatura con sensore DS18B20"); Serial.println("Mariangela"); delay(1000); sensors.begin(); while (!Serial) { ; } Serial.print("Initializing SD card..."); if (!SD.begin(chipSelect)) { Serial.println("Card failed, or not present"); return; Serial.println("card initialized.");

void loop() { String dataString = ""; sensors.requestTemperatures(); Serial.print("Temperatura = "); Serial.print(sensors.getTempCByIndex(0)); Serial.println(" gradi C"); dataString += String(sensors.getTempCByIndex(0)); dataString += ",";//scrive i dati del sensore in una stringa File dataFile = SD.open("datalog.txt", FILE_WRITE); if (dataFile) { dataFile.println(dataString); dataFile.close(); digitalWrite(10,HIGH); Serial.println(dataString); lcd.clear(); lcd.print(dataString); } else { Serial.println("error opening datalog.txt"); } delay(3000);}