Problem MCP23S17 und avr-gcc

[Stefan S. (sschultewolter)]

Hallo,

ich habe ein Problem, dass meine Leds nichts anzeigen.

Angeschlossen ist das ganze auf dem Steckbrett wie im oben hinterlegten 
Schaltplan.

Der avr-gcc Code sieht wie folgt aus


Ich werde gleich noch einmal schauen, ob ich einen LogikAnalyser am 
laufen bekomme, um zu schauen, wie der Datenfluss ist.

/*
 * spi.h
 */ 


#ifndef SPI_H_
#define SPI_H_

#include <avr/io.h>

#define SPI_DDR    DDRA
#define SPI_PORT  PORTA
#define SPI_SCK    4
#define SPI_MISO  5
#define SPI_MOSI    6
#define SPI_SS    7

void spi_init(void);
uint8_t spi_transfer(uint8_t data);

#endif /* SPI_H_ */

/*
* spi.c
*/

#include "spi.h"

void spi_init(void)
{
  SPI_DDR |= (1<<SPI_SS) | (1<SPI_MOSI) | (1<<SPI_SCK);
  SPI_DDR &= ~(1<<SPI_MISO);
  
  SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR0);
}

uint8_t spi_transfer(uint8_t data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
}

/*
 * mcp23s17.h
 */ 


#ifndef MCP23S17_H_
#define MCP23S17_H_

#include "spi.h"

#define MCP_OPCODE    0x40
#define MCP_WRITE    0x00
#define MCP_READ    0x01

#define MCP_BANK    0x40
#define MCP_SEQOP    0x20
#define MCP_HAEN    0x08

// MCP23S17 Register BANK = 0
#define MCP_IODIRA    0x00  // DDR PortA (0 = Ausgang, 1 = Eingang)
#define MCP_IODIRB    0x01  // DDR PortA (0 = Ausgang, 1 = Eingang)
#define MCP_IOCONA    0x0A
#define MCP_GPPUA    0x0C
#define MCP_GPPUB    0x0D
#define MCP_GPIOA    0x12
#define MCP_GPIOB    0x13


void mcp_write(uint8_t hwaddr, uint8_t reg, uint8_t data);
uint8_t mcp_read(uint8_t hwaddr, uint8_t reg);

#endif /* MCP23S17_H_ */


/*
* mcp23s17.c
*/

#include "mcp23s17.h"

void mcp_write(uint8_t hwaddr, uint8_t reg, uint8_t data)
{
  SPI_PORT &= ~(1<<SPI_SS);
  
  spi_transfer(MCP_OPCODE | ((hwaddr<<1) & 0x0e)  | MCP_WRITE);
  spi_transfer(reg);
  spi_transfer(data);

  SPI_PORT |= (1<<SPI_SS);
}


uint8_t mcp_read(uint8_t hwaddr, uint8_t reg)
{
  uint8_t data = 0;
  SPI_PORT &= ~(1<<SPI_SS);
  
  spi_transfer(MCP_OPCODE | ((hwaddr << 1) & 0x0e) | MCP_READ);
  spi_transfer(reg);
  data = spi_transfer(0x00);

  SPI_PORT |= (1<<SPI_SS);
  
  return data;
}

/*
* main.c
*/

#include <avr/io.h>
#include <util/delay.h>

#include "spi.h"
#include "mcp23s17.h"

int main(void)
{
  spi_init();

  // MCP23S17 #1
  mcp_write(0, MCP_IOCONA, 0x28); // default: BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1
  mcp_write(0, MCP_IODIRA, 0xff); // GPIOA Eingang
  mcp_write(0, MCP_IODIRB, 0xff); // GPIOB Eingang
  mcp_write(0, MCP_GPPUA, 0xff);  // PullUp aktiv

  // MCP23S17 #2
  mcp_write(1, MCP_IOCONA, 0x28); // default: BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1
  mcp_write(1, MCP_IODIRA, 0x00);  // GPIOA Ausgang
  mcp_write(1, MCP_GPIOA, 0x00);  // Ausgaenge ausschalten
  mcp_write(1, MCP_IODIRB, 0x00);  // GPIOB Ausgang
  mcp_write(1, MCP_GPIOB, 0x00);  // Ausgaenge ausschalten


  while (1)
  {
    static uint8_t ct = 0;
    uint8_t read = 0;

    // Lauflicht auf MCP23S17 #2 GPIOB
    mcp_write(1, MCP_GPIOB, 1<<ct);
    if(++ct >= 8) ct = 0;
    
    // Kodierschalter auslesen auf MCP23S17 #1 GPIOA
    read = mcp_read(0, MCP_GPIOA);
    // Kodierschalter Einstellung auf MCP23S17 #2 GPIOA ausgeben
    mcp_write(1, MCP_GPIOA, read);
    _delay_ms(100);
  }
}

[Stephan (Gast)]

Hi

Deine Verdrahtung geht gar nicht.
Kannst du mal beschreiben was du machen wolltest?
(Beide einzeln ansprechen oder beide mit einem /CS betreiben, die 
Telegramme durch einen Chip 'durchreichen'????)

 // MCP23S17 #2
  mcp_write(1, MCP_IOCONA, 0x28); // default: BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1

Das Telegramm müßte dürfte nicht durchgehen. Denn:

If disabled (HAEN = 0), the device’s hardware address
is A2 = A1 = A0 = 0.

Aber die nächsten dürften dann laufen da deine Adresse eine 1 ist (A0 
=1).

[Stefan S. (sschultewolter)]

Was ist an der Verdrahtung falsch?

Es soll an den MCPs die Hardware Adresse, welche einstellbar über A0 - 
A2 ist, genutzt werden. Deshalb CS zusammen.

 mcp_write(1, MCP_IOCONA, 0x28); // default: BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1

[quote]
bit 3 HAEN: Hardware Address Enable bit (MCP23S17 only).
Address pins are always enabled on MCP23017.
1 = Enables the MCP23S17 address pins.[/quote]
Sollte somit doch richtig sein, dass hier MCP_HAEN = 1 gesendet wird.

Quelle: http://ww1.microchip.com/downloads/en/DeviceDoc/21952b.pdf

[Stephan (Gast)]

Beide SO-Pins der MCP arbeiten gegen einander. Da beide nicht das 
gleiche zurück geben werden, dürfte das Krach geben.

Löse bitte mal den SS von Chip mit A0=1 und teste dann die Software mit 
nur einem Chip. Ich glaube da könnte sogar schon einiges laufen.(hab 
noch nicht alles durch)

Das du MCP_HAEN nutzen möchtest ist gut und auch richtig, nur so lange 
ist die default Adr des Chips immer 0!
Du hast in den Funktion Call aber eine 1 stehen.

mcp_write(1,....

Aber der Befehl könnt jetzt schon laufen:

// MCP23S17 #1
  mcp_write(0, MCP_IOCONA, 0x28); // default: BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1

Beide Chips haben die Adresse 0 (Default) dort werden die folgenden 
Register gemeinsam gesetzt:
>BANK = 0, MCP_SEQOP = 1, MCP_HAEN = 1
ABER gut ist das nicht!

[Stefan S. (sschultewolter)]

Ich habe nun gestern das Problem gehabt, dass ich überhaupt nicht mehr 
senden konnte mit meinem Attiny. Fehler im Programm noch nicht weiter 
rausgesucht. Am LogicAnalyer wurden die Signale nicht mehr 
rausgeschickt.

Hab dann den ganzen Code deutlich verringert, und teste das ganze gerade 
erst einmal mit einem Register. Das 2. folgt heute/morgen.

Mit der Problematik der Adressierung bin ich noch nicht wirklich weiter. 
Wenn ich das Datenblatt richtig deute, ist es doch so, dass wenn ich die 
Hardwareadressierung(A0 - A3) nutzte, alle Signale 1:1 durchgeschleift 
werden dürfen. Das sollte doch gerade der große Vorteil sein bei den 
Teilen. Die wären somit deutlich flexibler als HC595 Bausteine mit 
entsprechenden Gegenstück für Parallel->Seriell. Die Kosten für die 
Bausteine liegen bei Reichelt 1,30€, Großhändler wie Mouser bereits ab 
25Stk 1,00€.

Da muss man sich dann auch nicht großartig mit den HC595 Modulen 
herumschlagen, auch wenn hier die Preise noch etwas drunter liegen.

/*
* attiny841_spi.c
*
* Created: 04.10.2015 11:02:38
* Author : sschultewolter
*/



#include <avr/io.h>
#include <util/delay.h>

//////////////////////////////////////////////////////////////////////////
// SPI
#define SPI_DDR      DDRA
#define SPI_PORT    PORTA
#define SPI_SCK      PORTA4
#define SPI_MOSI    PORTA6
#define SPI_MISO    PORTA5
#define SPI_SS      PORTA7
#define SPI_FCK_DIV    2

void spi_init(void);
uint8_t spi_transfer(uint8_t data);
//////////////////////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////////////////////
// MCP23S17
#define MCP_OPCODE    0x40
#define MCP_WRITE    0x00
#define MCP_READ    0x01

#define MCP_BANK    0x40
#define MCP_SEQOP    0x20
#define MCP_HAEN    0x08

// MCP23S17 Register BANK = 0
#define MCP_IODIRA    0x00  // DDR PortA (0 = Ausgang, 1 = Eingang)
#define MCP_IODIRB    0x01  // DDR PortA (0 = Ausgang, 1 = Eingang)
#define MCP_IOCONA    0x0A
#define MCP_GPPUA    0x0C
#define MCP_GPPUB    0x0D
#define MCP_GPIOA    0x12
#define MCP_GPIOB    0x13

void mcp_write_byte(uint8_t hwaddr, uint8_t reg, uint8_t data);
void mcp_write_bit(uint8_t hwaddr, uint8_t reg, uint8_t bit, uint8_t data);

uint8_t mcp_read_byte(uint8_t hwaddr, uint8_t reg);
uint8_t mcp_read_bit(uint8_t hwaddr, uint8_t reg, uint8_t bit);
//////////////////////////////////////////////////////////////////////////



int main(void)
{
  DDRA |= (1<<PORTA3);  // Ausgang Zeitmessung
  spi_init();
  mcp_write_byte(0, MCP_IOCONA, 0x28);
  
  mcp_write_byte(0, MCP_IODIRA, 0x0f);  // Eingang GPIOA0-3; Ausgang GPIOA4-7
  mcp_write_byte(0, MCP_GPPUA, 0x0f);    // PullUp GPIOA0-3
  mcp_write_byte(0, MCP_IODIRB, 0x00);  // Ausgang GPIOB0-7 (0x00 entspricht bei AVR 0xff)
  while (1)
  {
    
    PORTA |= (1<<PORTA3);
    // Einzelne Pins auslesen, Pins aendern und ein Port jedes mal zurueckschicken (nicht optimal)!
    // 230µs
    for(uint8_t i = 0; i < 4; i++)
    {
      if(mcp_read_bit(0, MCP_GPIOA, i)) mcp_write_bit(0, MCP_GPIOA, i+4, 1);
      else mcp_write_bit(0, MCP_GPIOA, i+4, 0);
    }
    
    // Gesamten Port einlesen, Port aendern und einmal senden (besser)!
    // 30µs
    uint8_t recData = mcp_read_byte(0, MCP_GPIOA);
    recData = recData | (recData<<4);
    mcp_write_byte(0, MCP_GPIOA, recData);
    
    PORTA &= ~(1<<PORTA3);
  }
}

void spi_init(void)
{
  SPI_DDR |= (1<<SPI_SS) | (1<<SPI_MOSI) | (1<<SPI_SCK);
  
  SPCR = (1<<SPE) | (1<<MSTR);
  
  #ifdef SPI_FCK_DIV
  switch(SPI_FCK_DIV)
  {
    case 2:
    SPSR |= (1<<SPI2X);
    break;
    case 8:
    SPCR |= (1<<SPR0);
    SPSR |= (1<<SPI2X);
    break;
    case 16:
    SPCR |= (1<<SPR0);
    break;
    case 32:
    SPCR |= (1<<SPR1);
    SPSR |= (1<<SPI2X);
    break;
    case 64:
    SPCR |= (1<<SPR1) | (1<<SPR0);
    SPSR |= (1<<SPI2X);
    break;
    case 128:
    SPCR |= (1<<SPR1) | (1<<SPR0);
    break;
  }
  #endif
}

uint8_t spi_transfer(uint8_t data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
}

void mcp_write_byte(uint8_t hwaddr, uint8_t reg, uint8_t data)
{
  SPI_PORT &= ~(1<<SPI_SS);
  
  spi_transfer(MCP_OPCODE | ((hwaddr<<1) & 0x0e)  | MCP_WRITE);
  spi_transfer(reg);
  spi_transfer(data);
  
  SPI_PORT |= (1<<SPI_SS);
}

uint8_t mcp_read_byte(uint8_t hwaddr, uint8_t reg)
{
  uint8_t recData = 0;
  SPI_PORT &= ~(1<<SPI_SS);
  
  spi_transfer(MCP_OPCODE | ((hwaddr << 1) & 0x0e) | MCP_READ);
  spi_transfer(reg);
  recData = spi_transfer(0x00);

  SPI_PORT |= (1<<SPI_SS);
  
  return recData;
}

void mcp_write_bit(uint8_t hwaddr, uint8_t reg, uint8_t bit, uint8_t data)
{
  uint8_t recData = mcp_read_byte(hwaddr, reg);
  if(data) recData |= (1<<bit);
  else recData &= ~(1<<bit);
  
  mcp_write_byte(hwaddr, reg, recData);
}

uint8_t mcp_read_bit(uint8_t hwaddr, uint8_t reg, uint8_t bit)
{
  uint8_t recData = mcp_read_byte(hwaddr, reg);
  if(recData & (1<<bit)) return 1;
  else return 0;
}

[Stephan (Gast)]

Hi
das wollte ich doch auch von dir wissen wie du arbeiten wolltest.
Du willst die Daten durch reichen ok, der Anschluß sieht wie folgt aus:

SCL - auf beide -> war Ok
AVR SS - auf beide -> war Ok
AVR MOSI -> SI (ADR:0) -> SO (ADR:0) -> SI (ADR:1) -> SO (ADR:1) -> AVR 
MISO

Willst du das machen???

Für die SW ist es zu spät, ich schau mal morgen drüber.

[Stefan S. (sschultewolter)]

Stephan schrieb:
> Hi
> das wollte ich doch auch von dir wissen wie du arbeiten wolltest.
> Du willst die Daten durch reichen ok, der Anschluß sieht wie folgt aus:
Nein, dass wollte ich gerade nicht. Ich hatte gehofft, dass ich alles 
parallel anschließen kann

AVR SCK  -> MCP0 CLK -> MCP1 CLK 
AVR MOSI -> MCP0 SI  -> MCP1 SI
AVR MISO -> MCP0 SO  -> MCP  S0
AVR SS   -> MCP0 CS  -> MCP0 CS

http://ww1.microchip.com/downloads/en/AppNotes/01043a.pdf
Seite 8
[quote]
The “S” devices (MCP23S08 and MCP23S17) have
SPI interfaces. These devices use a chip select for
selecting the part, however, these parts also have hardware
address pins, thereby giving the advantage of
attaching multiple devices on the bus while only
consuming one MCU pin for chip select (see Figure 9).[/quote]

Der SO soll sich doch nur melden, wenn der MCP über die richtige Adresse 
angesprochen wurden. Andernfalls kommt nichts aus SO.

Leider sind auch viele fremdsprachige Seiten bei Google dabei :([1] / 
Link/Bild


[1]
https://translate.google.de/translate?hl=de&sl=be&tl=en&u=http%3A%2F%2Fsmanuals.ru%2Fmeasurement-technology%2Farticles5439.html%23.VhHBmXrtmkoNUoEySNnsxrhM%3A&docid=qjvEhHeF-0jjcM&ei=1sARVtyOBcissgGTz6KQAg&tbm=isch&iact=rc&uact=3&dur=1198&page=1&start=0&ndsp=27&ved=0CEcQrQMwDWoVChMI3NHKpYaqyAIVSJYsCh2Tpwgi

Wie gesagt, ich werde es morgen noch einmal in Angriff nehmen. Werde mir 
dazu mal ein paar Leds aufs Breadboard setzen.

[Stefan S. (sschultewolter)]

Hallo Stephan,

ich habe das ganze nun doch noch mal schnell zusammengesetzt. An dem 2. 
MCP habe ich nur einen Taster angeschlossen, sollte für den Test 
reichen.
Es funktioniert wie ich es wollte.

int main(void)
{
[...]
  mcp_write_byte(0, MCP_IOCONA, 0x28);

  mcp_write_byte(0, MCP_IODIRA, 0x0f);  // Eingang GPIOA0-3; Ausgang GPIOA4-7
  mcp_write_byte(0, MCP_GPPUA, 0x0f);    // PullUp GPIOA0-3
  mcp_write_byte(0, MCP_IODIRB, 0x00);  // Ausgang GPIOB0-7 (0x00 entspricht bei AVR 0xff)
  mcp_write_byte(1, MCP_IODIRA, 0xff);  // Eingang GPIOA0-7
  mcp_write_byte(1, MCP_GPPUA, 0xff);    // PullUp GPIOA0-7
  while (1)
  {
    // Kodierschalter an MCP_0_GPIOA0-3 auslesen
    uint8_t recData = mcp_read_byte(0, MCP_GPIOA);
    // Werte des Kodierschalters an MCP_0_GPIOA4-7 an den Leds ausgeben
    mcp_write_byte(0, MCP_GPIOA,(recData<<4));
    
    // Taster an MCP_1_GPIOA0 auslesen und Muster umschalten
    if(mcp_read_bit(1, MCP_GPIOA, 0)) mcp_write_byte(0, MCP_GPIOB, recData ^ 0xF0);
    else mcp_write_byte(0, MCP_GPIOB, recData ^ 0x0F);
  }
}

Es reicht nach einem Reset aus, wenn

mcp_write_byte(0, MCP_IOCONA, 0x28);

einmal ausgeführt wird. Da nach dem Reset das Register im MCP nicht mehr 
gesetzt wird, werden alle MCPs gleichzeitig angesprochen. Danach sind 
diese über die Hardwareadressen ereichbar. SI, SO, SCK und CS können 
zusammengeschaltet werden. Kaskadenschaltung wie bei dem HC595 o.ä. ist 
NICHT notwendig und in meinen Fall auch nicht erwünscht. Mit 128 IOs 
sollten für mich voll ausreichen am kleinen Attiny841 ;) Zur Not wird 
ein weiter CS für die nächsten 128 IOs genutzt.

Der derzeitige Code belegt auch nicht sonderlich viel an Speicher.

        Program Memory Usage   :  328 bytes   4,0 % Full
        Data Memory Usage     :  0 bytes   0,0 % Full

P.S.: Der MCP scheint auch Taster bereits ganz gut zu entprellen!

    static uint8_t last = 0;
    uint8_t now = mcp_read_bit(1, MCP_GPIOA, 0);
    static uint8_t ct = 0;
    if(now != last)
    {
      last = now;
      if(now) ct++;
      mcp_write_byte(0, MCP_GPIOB, ct);
    }

Reicht schon aus. Das Programm läuft ohne Delay mit ca 65µs durch.

[Won K. (Firma: Outside the Asylum) (the_sane)]

Stefan S. schrieb:
> Nein, dass wollte ich gerade nicht. Ich hatte gehofft, dass ich alles
> parallel anschließen kann

Ja kannst Du auch, dafür sind die Adresspins gedacht, I2C-Adressierung 
auf SPI umgesetzt.

Eine Kaskadierung wie bei normalen Schieberegistern würde nicht 
funktionieren, da keine Daten von SI nach SO durchgereicht werden.

Aber das hast Du ja jetzt schon selbst festgestellt.

Stephan schrieb:
> Deine Verdrahtung geht gar nicht.
Das ist nur Deine Meinung.

[Stefan S. (sschultewolter)]

So,

ich habe nun so einiges durchgetestet und bin der Meinung, es 
funktioniert so, wie ich es mir gedacht habe. Der SPI Bus ist parallel 
zu den MCPs angeschlossen. Die HWAdressen 0x00 und 0x01 wurden vergeben.

Im Anhang das Programm. Die eigentlich Libary ist kompakt gehalten, ohne 
unnötig viele Funktionen bereit zustellen.

Das Testszenario besteht aus 3*8Leds an MCP0 PORTB, MCP1 PORTA und MCP1 
PORTB. An MCP0 PORTA sind 6 Kodierschalter angeschlossen, die das Muster 
bereitstellen. Mit den 2 Tastern kann das Muster nach Rechts oder Links 
auf den Ledreihen verschoben werden.

Kurzes Video gibt es unter
https://www.dropbox.com/s/nrslobw8l60iv30/WP_20151006_22_20_49_Pro.mp4?dl=0

[Mathias O. (m-obi)]

Muss SEQOP und HAEN nicht auch für den Zweiten gesetzt werden in der 
Init-Funktion?

[Stefan S. (sschultewolter)]

Hallo Mathias,

nach dem Spannungsverlust, bzw. nach dem Betätigen von Reset wird der 
MCP wieder in Werkseinstellung gesetzt.

Im Datenblatt Seite 9/10 sind die Werte danach für das IOCON Register 
wieder auf "0000 0000". Das heißt bei der Initialisierung werden zuerst 
einmal alle MCPs gleichzeitig angesprochen. Erst nach der 
Initialisierung sind die Hardwareaddressen aktiv.

P.S. Im Anhang noch eine etwas überarbeitete Version. Hauptsächlich 
wurden aus der Dokumentation die Beschreibungen der Register lediglich 
hinzugefügt.

[Mathias O. (m-obi)]

Jo klingt logisch. HAEN ist ja noch garnicht aktiv, also ist ihm die 
Adresse egal.

[Stefan S. (sschultewolter)]

Werde mich die Tage noch ein bisschen mit dem Teil auf dem Steckbrett 
versuchen. Vorallem werde ich testen, ob es klappt bei der Adressierung, 
dass diese 0x00 ist, wenn ich je Adressbit ein PullDown von 10-20k 
setze. Dann müsste man nur noch 2 Pins (Solderpads) gebrauchen, um die 
Adresse auf 1 zu setzen. Derzeit ist das noch mit 3 Pins geplant.

Das ganze soll dann eine 5x5cm Platine werden mit 2 Expandern. Optional 
sollen dort Reset, sowie alle 4 Interrupts herausgeführt werden. Diese 
ist getrennt von der eigentlichen SPI Schnittstelle. Sodass ich die SPI 
Schnittstelle (2x3 Pinheader) direkt mit Flachband durchschleifen kann.

An der Platine ist noch einiges an Arbeit zu machen, aber hier einmal 
der Vorab Entwurf.