GPIO aggiuntivi MCP23x17 - Cronologia

Dave4rp il 13:10, 17 mar 2015

2015-03-17T13:10:22Z

Mostra modifiche

Aldus il 00:13, 23 mag 2013

2013-05-23T00:13:37Z

Dancast78 il 21:43, 22 mag 2013

2013-05-22T21:43:11Z

Aldus il 17:50, 19 mag 2013

2013-05-19T17:50:09Z

Mostra modifiche

Dancast78 il 11:22, 24 apr 2013

2013-04-24T11:22:14Z

Dancast78: Aggiunto setup pullps port altrimenti non funziona la lettura degli ingressi

2013-04-24T11:21:43Z

Aggiunto setup pullps port altrimenti non funziona la lettura degli ingressi

Dancast78 il 11:46, 9 apr 2013

2013-04-09T11:46:45Z

Dancast78: Creata pagina con 'E’ possibile collegare dei GPIO aggiuntivi al Raspberry Pi in modo da aumentare il numero di pin comandabili. Ad esempio si possono collegare i chip [http://ww1.microchip.c...'

2013-04-08T17:19:28Z

Creata pagina con 'E’ possibile collegare dei GPIO aggiuntivi al Raspberry Pi in modo da aumentare il numero di pin comandabili. Ad esempio si possono collegare i chip [http://ww1.microchip.c...'

Nuova pagina

E’ possibile collegare dei GPIO aggiuntivi al Raspberry Pi in modo da aumentare il numero di pin comandabili.

Ad esempio si possono collegare i chip [http://ww1.microchip.com/downloads/en/devicedoc/21952b.pdf MCP23x17]:

-MCP23017 che usa il protocollo I2C

-MCP23S17 con protocollo SPI.

Questi integrati hanno due PORT con 8 pin ciascuno, una porta di comunicazione I2C o SPI secondo il modello, alimentazione, reset e 2 pin per la gestione degli interrupt.

Possono essere collegati sul bus assieme ad altri chip dello stesso tipo indirizzandoli con tre bit, quindi se ne possono collegare fino ad 8, questo permette di arrivare a comandadare fino 128 pin di input/output.

I pin non hanno funzioni particolari, possono essere solo ingressi o uscite ed è possibile settarne il pullup, ma non ci sono ad esempio funzioni di pwn o altro.

Per la configurazione bisogna settare alcuni registri sul chip per indicare la configurazione delle porte, ingressi, uscite, pullup, interrupt come riportato in questa [https://gist.github.com/ChickenProp/3183960 pagina] oltre che sul datasheet riportato sopra.

I due bus a cui possono essere collegati questi integrati si basano su una configurazione di tipo master-slave, perciò normalmente vengono usati in polling, questo non comporta molto dispendio di CPU però se le variazioni sui pin sono veloci si rischia di perderne.

In questo [http://www.retrosemi.co.uk/mcp23s17/Getting_started_with_the_mcp23s17.pdf documento] viene illustrato come interagire dialogando sul bus SPI ed utilizzando un programmino in c.

Non vengono utilizzate però le possibilità di utilizzo degli interrupt.

Volendo ottimizzare l’uso di risorse della CPU ci sembrava utile riuscire a sfruttare questa funzione.

In pratica si tratta di collegare uno o due pin dell’integrato ad un pin del GPIO di Raspberry Pi per scatenare la lettura del porta in input quando si verifica un evento. Questo può essere fatto praticamente settando tre registri del MCP23X17.

Le possibilità sono diverse:

- Sulle porte settate come ingressi, ogni singolo pin può generare interrupt, si può settare uno stato predefinito a cui si deve trovare il pin (questo però spesso non é l’ideale, vedi sotto).

- In alternativa é possibile settare i registri in modo che venga emesso un interrupt ad ogni variazione sui pin dichiarati.

La gestione degli interrupt é leggermenre diversa da quanto avviene in altri circuiti, infatti il registro degli interrupt viene resettato appena viene letto il registro degli interrupt oppure il port.

Questo significa che un settaggio come indicato al primo punto genera interrupt a raffica se sul pin arrivano segnali stabili nel tempo e li leggiamo subito.

Per questi test abbiamo utilizzato una scheda [http://pi.cs.man.ac.uk/interface.htm Pi-Face] nella versione già assemblata venduta da Farnell in modo da velocizzare i test.

Qui sotto il codice creato, probabilmente non ancora definitivo: per utilizzarlo salvarlo su un file di testo (es piface.c) e compilare ad esempio con:

gcc piface.c -o piface

poi lanciarlo con

./piface /dev/spi0.0

/****************************************
* basic SPI demo for mcp23s17
*
*****************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdint.h>
#define CMD_WRITE 0x40
#define CMD_READ 0x41
static char *spiDevice = "/dev/spidev0.0" ;
static uint8_t spiMode = 0 ;
static uint8_t spiBPW = 8 ;
static uint32_t spiSpeed = 5000000 ;
static uint16_t spiDelay = 0;
// MCP23S17 Registers
#define IOCON 0x0A
#define IODIRA 0x00
#define IPOLA 0x02
#define GPINTENA 0x04
#define DEFVALA 0x06
#define INTCONA 0x08
#define GPPUA 0x0C
#define INTFA 0x0E
#define INTCAPA 0x10
#define GPIOA 0x12
#define OLATA 0x14
#define IODIRB 0x01
#define IPOLB 0x03
#define GPINTENB 0x05
#define DEFVALB 0x07
#define INTCONB 0x09
#define GPPUB 0x0D
#define INTFB 0x0F
#define INTCAPB 0x11
#define GPIOB 0x13
#define OLATB 0x15

int spi_fd;

int readconf()
{

}

int pinsetup ()
{
int fd = 0;

fd = open("/sys/class/gpio/export",O_WRONLY);
write(fd,"25\n",3);
close(fd);

fd = open("/sys/class/gpio/gpio25/direction",O_WRONLY);
write(fd,"in\n",3);
close(fd);

fd = open("/sys/class/gpio/gpio25/edge",O_RDWR);
write(fd,"falling\n",8); // i valori possibili sono rising/falling/both/none consigliato falling
close(fd);

fd = open("/sys/class/gpio/gpio25/value",O_RDWR);

return fd;
}

static uint8_t readByte (uint8_t reg)
{
uint8_t tx [4] ;
uint8_t rx [4] ;
struct spi_ioc_transfer spi ;

tx [0] = CMD_READ ;
tx [1] = reg ;
tx [2] = 0 ;

spi.tx_buf =(unsigned long)tx ;
spi.rx_buf =(unsigned long)rx ;
spi.len =3;
spi.delay_usecs = spiDelay ;
spi.speed_hz = spiSpeed ;
spi.bits_per_word = spiBPW ;
ioctl (spi_fd, SPI_IOC_MESSAGE(1), &spi) ;
return rx [2] ;
}
static void writeByte (uint8_t reg, uint8_t data)
{
uint8_t spiBufTx [3] ;
uint8_t spiBufRx [3] ;
struct spi_ioc_transfer spi ;
spiBufTx [0] = CMD_WRITE ;
spiBufTx [1] = reg ;
spiBufTx [2] = data ;
spi.tx_buf
= (unsigned long)spiBufTx ;
spi.rx_buf
= (unsigned long)spiBufRx ;
spi.len
=3;
spi.delay_usecs = spiDelay ;
spi.speed_hz = spiSpeed ;
spi.bits_per_word = spiBPW ;
ioctl (spi_fd, SPI_IOC_MESSAGE(1), &spi) ;
}

static void ruota_led()
{
uint8_t leds;
leds = readByte (GPIOA) ;
if (leds==4 || leds==0) {
writeByte(GPIOA,128);
} else {
writeByte(GPIOA,leds/2);
}
}
/*spi_open
*
- Open the given SPI channel and configures it.
*
- there are normally two SPI devices on your PI:
*
/dev/spidev0.0: activates the CS0 pin during transfer
*
/dev/spidev0.1: activates the CS1 pin during transfer
*
*/
int spi_open(char* dev)
{
if((spi_fd = open(dev, O_RDWR)) < 0){
printf("error opening %s\n",dev);
return -1;
}
return 0;
}
int main(int argc, char* argv[])
{
unsigned char data = 0xAF;
struct timeval tv;
int pin25;
fd_set set, setbackup;
char pin25buf[1024];

pin25 = pinsetup();
FD_ZERO(&set);
FD_SET(pin25,&set);
setbackup = set;

int val;
if(argc <= 1){
printf("too few args, try %s /dev/spidev0.0\n",argv[0]);
return -1;
}
// open and configure SPI channel. (/dev/spidev0.0 for example)
if(spi_open(argv[1]) < 0){
printf("spi_open failed\n");
return -1;
}
writeByte (IODIRA, 0x00) ;
// Port A -> Outputs
writeByte (GPIOA, 0x00) ;
//writeByte (IPOLB, 0x01) ; // invert lsb
//writeByte (GPPUB, 0xFF) ; // enable pullups.

writeByte (IODIRB, 0xFF) ;

writeByte (GPINTENB,0xFF); //Abilita l'interrupt sul portB
writeByte (DEFVALB,0xFF); //Setta il valore di default dei pin del port B se un un pin non è a uno emette interrupt
writeByte (INTCONB,0x00); //Setta il valore di per il confronto se a 1 compara con il valore di DEFVAL altrimenti controlla le variazioni di stato

while (1)
{
tv.tv_sec = 30;
tv.tv_usec = 0;

val = select(pin25+1, NULL, NULL, &set, &tv);

set = setbackup;
if(val > 0)
{
if(FD_ISSET(pin25,&set))
{
write(1,"evento su pin 25\n",17);

/* antirimbalzo */
tv.tv_sec = 0;
tv.tv_usec = 50000;
val = select(0, NULL, NULL, &set, &tv);
/* fine antirimbalzo */

lseek(pin25,0,SEEK_SET);
read(pin25,pin25buf,1024);
}
else write(1,"???\n",4);
}
else
if(val < 0) write(1,"SIGNAL NON BLOCCATO\n",20);
else write(1,"TIMEOUT\n",8);

// Port B -> Inputs
data = readByte (GPIOB) ;
printf("RECEIVED: %.2X\n",data);

//ruota_led();

}
close(spi_fd);
return 0;
}

@@ Riga 283: / Riga 283: @@
 * DEFVAL: è il registro con cui viene fatto il confronto con GPIOA per scatenare gli interrupts
 * GPINTENA: abilita gli interrupt sul port A
-* INTCONA: sceglie con quale modalità far scattare gli interrupt, cioè confrontando GPIOA con DEFVAL;
+* INTCONA: sceglie con quale modalità far scattare gli interrupts, se il bit è a 1 confrontando GPIOA con DEFVAL se a 0 solo nei cambi di stato (nel nostro caso erano tutti a 0 quindi l'interrupt scattava una volta quando veniva premuto uno dei tasti e una volta quando veniva rilasciato);
@@ Riga 424: / Riga 424: @@
+	}
-         writeByte(GPPUA, 0xFF); // set port B pullups on
+         writeByte(GPPUA, 0xFF); // setto pullups sul PORTA
-	writeByte(IODIRA, 0xFF); // setto port A tutti input
+	writeByte(IODIRA, 0xFF); // setto PORTA come ingressi
-         writeByte(GPINTENA,0xFF); //Abilita l'interrupt sul portB
+         writeByte(GPINTENA,0xFF); //Abilita gli interrupts sul PORTA
-         writeByte(DEFVALA,0xFF); //Setta il valore di default dei pin del port B se un un pin non Ã¨ a uno emette interrupt
+         //writeByte(DEFVALA,0xFF); //Setta il valore di default del PORTA (usato per la configurazione alternativa)
-         writeByte(INTCONA,0x00);  //Setta il valore di per il confronto se a 1 compara con il valore di DEFVAL altrimenti controlla le variazioni di stato
+         writeByte(INTCONA,0x00);  //Setta il registro per far scattare interrupt alle variazioni di stato
-         writeByte(GPIOA,0x00); //setto a zero tutti i bit del port A, anche se probabilmente non è mportante essendo il pullup a on
+         //writeByte(GPIOA,0x00); //setto a zero tutti i bit del port A,  probabilmente non è mportante essendo il pullup a on
-	writeByte(IODIRB,0x00); // setto il port b come output
+	writeByte(IODIRB,0x00); // setto PORTB come uscite
          while (1)

@@ Riga 265: / Riga 265: @@
+  }
+Ulteriori esempi qui: [https://github.com/dcast78/MCP23x17/ su github]
 La seguente è una versione di codice funzionante per MCP23017, basata sul codice soprastante, essenzialmente sono stati reimplementati solo i metodi per la scrittura/lettura sul bus i2c.

@@ Riga 215: / Riga 215: @@
          writeByte(GPPUA, 0xFF); // set port A pullups on
          writeByte(GPPUB, 0xFF); // set port B pullups on
   	writeByte (IODIRB, 0xFF) ;
   	writeByte (GPINTENB,0xFF); //Abilita l'interrupt sul portB
   	writeByte (DEFVALB,0xFF); //Setta il valore di default dei pin del port B se un un pin non è a uno emette interrupt

@@ Riga 213: / Riga 213: @@
   	// Port A -> Outputs
   	writeByte (GPIOA, 0x00) ;
- 	//writeByte (IPOLB, 0x01) ; // invert lsb
+        writeByte(GPPUA, 0xFF); // set port A pullups on
- 	//writeByte (GPPUB, 0xFF) ; // enable pullups.
+        writeByte(GPPUB, 0xFF); // set port B pullups on
-−
   	writeByte (IODIRB, 0xFF) ;

@@ Riga 241: / Riga 241: @@
                   tv.tv_sec = 0;
                   tv.tv_usec = 50000;
-                  val = select(0, NULL, NULL, &set, &tv);
+                  val = select(0, NULL, NULL, NULL, &tv);
                   /* fine antirimbalzo */