PCF8574 Ausgänge

[Philipp P. (Gast)]

Hallo,

habe mit einem Atmega328PU eine Schaltung aufgebaut, die einen PCF8574PA
ansteuern soll. Er soll nur für Ausgänge benutzt werden. Bevor ein 
Ausgang geschrieben wird, sollte der PCF ausgelesen werden und der 
aktuelle Zustand in der Struktur bbbk gespeichert werden. Per Uart 
Befehl soll der Schreibvorgang für den entsprechenden Ausgang gestartet 
werden z.B. 32 soll A0 setzen. Verbindung habe ich, er schaltet auch die 
Ausgänge bis A0 durch, aber merkt sich nicht den vorherigen Zustand. 
Könnt ihr mir ein Hinweis geben warum es nicht funktioniert? Die I2C lib 
ist von Peter Fleury.

MfG Philipp

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdio.h>
#include "uart.h"
#include "lcd.h"
#include "i2cmaster.h"
#include <util/delay.h>


/* 9600 baud */
#define UART_BAUD_RATE      9600 
     
#define DS1307     0xD0         //Adresse des DS1307
#define PCF_Write  0x70      //Adresse für PCF Porterweiterung schreiben
#define PCF_Read   0x71     //Adresse für PCF Porterweiterung lesen


  unsigned char time_s;        
  unsigned char time_m;        
  unsigned char time_h;         
  unsigned char time_dayofweek;  //nicht benutzt  
  unsigned char time_day;        //nicht benutzt 
  unsigned char time_month;      //nicht benutzt 
  unsigned char time_year;      
  unsigned char buffer1[10];      // Buffer für itoa RTC 
  unsigned char buffer2[10];    // Buffer für Pcf Ausgangswert
  

  uint8_t ausgangswert;

int main(void)
{


  union          //8Bit Array
{
  uint8_t byte;
  struct
  {
    uint8_t b0 : 0;
    uint8_t b1 : 0;
    uint8_t b2 : 0;
    uint8_t b3 : 0;
    uint8_t b4 : 0;
    uint8_t b5 : 0;
    uint8_t b6 : 0;
    uint8_t b7 : 0;

  }bit;
}bbbk;
  


    char set_clock (unsigned char reg, unsigned char val) //Uhr setzen
    {
       if (i2c_start(DS1307+I2C_WRITE) != 0) return 1;
       i2c_write(reg);
       i2c_write(val);
       i2c_stop();
       return 0;
    } 

    char get_time(unsigned char reg)  //Zeit aus dem RTC lesen
    {
    unsigned char val;

        i2c_start(DS1307+I2C_WRITE);
       i2c_write(reg);
       i2c_stop();
       i2c_start(DS1307+I2C_READ);
       val = i2c_readNak();
       i2c_stop();
       return val;
    }

  

    char pcf_read()  //Byte vom Pcf lesen
    {
       uint8_t val;
           
       i2c_start(PCF_Read);
       val = i2c_readNak();
       i2c_stop();
       return val;
    }


    char pcf_set2(int a)  //Byte vom Pcf lesen
    {
    uint8_t Pcf_Ausgang;
    
           
       i2c_start(PCF_Read);
       Pcf_Ausgang = i2c_readNak();
       bbbk.byte = Pcf_Ausgang;
       //Pcf_Ausgang |= (1 << a);

       switch (a) 
       
       {
          case 0:  bbbk.bit.b0 = 1;    // A0 Led
          break;
          case 1:   bbbk.bit.b1 = 1;    // A1 Led
          break;
          case 2:  bbbk.bit.b2 = 1;    // A2 Led
          break;
          case 3:   bbbk.bit.b3 = 1;   // A3 Led
          break;
          case 4:   bbbk.bit.b4 = 1;    // A4 Relais über ULN2003 Ein
          break;
          case 5:  bbbk.bit.b5 = 1;    //  n. A.
          break;
        case 6:  bbbk.bit.b4 = 0;    // A4 Relais über ULN2003 Aus
       }

       i2c_start(PCF_Write);
       i2c_write(bbbk.byte);
       _delay_ms(100);
       i2c_stop;
       return 0;
       }


    int int_to_char(int B)            //int to char
    {
    unsigned char Buffer[10];
      
      itoa( B, Buffer, 10 );
      return( Buffer ); 
    }

    int digit_to_int(unsigned char d)    //strtol
    {
     char str[2];

     str[0] = d;
     str[1] = '\0';
     return (int) strtol(str, NULL, 10);
    }

    void lcd_puti( int number )        //itoa
    {
      char buffer[10];

       itoa( number, buffer, 10 );
        lcd_puts( buffer );
    }

  
    void lcd_putu( unsigned int number )  //utoa
    {
         char buffer[10];

      utoa( number, buffer, 10 );
      lcd_puts( buffer );
    }








    i2c_init();                //I2c starten

      _delay_ms(300);              // delay


    lcd_init(LCD_DISP_ON);          //Lcd starten

   
      uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );   // Uart starten
    
   
      sei();
    
         

 
    uart_putc('\r');
    lcd_clrscr();


      //set_clock(0x07, 0x00);   // CH 0 setzen

         //set_clock(0x02, 0x00);
         //set_clock(0x01, 0x00);
         //set_clock(0x00, 0x00); 
      

  
    for(;;)

  
  
{

      time_s = get_time(0x00);    //Zeiten auslesen
      time_m = get_time(0x01);
      time_h = get_time(0x02);

      _delay_ms(10);
  
        lcd_clrscr();

      sprintf(buffer1, "Zeit: %02x:%02x:%02x", time_h, time_m, time_s);
          lcd_puts(buffer1);


      //uart_puts(buffer1);
      //ausgangswert = pcf_read();
      //itoa(ausgangswert, buffer2, 10);
      //uart_puts(buffer2);




    // Per UART Zeichen einlesen
    c = uart_getc();
      if (!( c & UART_NO_DATA ))
    {
      // In Char-Array "command" speichern & testweise ausgeben
      command[ci] = c;
      ci = ci<20 ? ci+1 : 0;
      /*uart_putc(c);*/

  /*intwert = digit_to_int(c);*/
  
  lcd_putu(c);
  

     
      // Wenn CR empfangen wurde


    if (c == 0x32) // A0 Ein
    {
      pcf_set2(0);
    }
          else if (c == 0x33) //A1 Ein
    {    
      pcf_set2(1);    
    }
        else if (c == 0x34) //A2 Ein
    {
      pcf_set2(2);
    }
          else if (c == 0x35) //A3 Ein
    {
      pcf_set2(3);
    }
        else if (c == 0x36) //A4 Ein
    {
      pcf_set2(4);    
    }
      else if (c == 0x37) //A4 Aus
    {
      pcf_set2(6);
    }
      else if (c == 0x38) //
    {
    
    }
      else if (c == 0x39) //
    {    
    
    }

    }


    }
   
             
}

[Uwe S. (de0508)]

Hallo  Philipp,

warum definierst Du alles - UNION, Proceduren und Funktionen in der 
main() {..} ?

Die Anweisungen

if (c == 0x32) // A0 Ein

 wären in seiner |switch case(arg)| einfache zu lesen.

[Falk B. (falk)]

@Philipp P. (Gast)

>habe mit einem Atmega328PU eine Schaltung aufgebaut, die einen PCF8574PA
>ansteuern soll. Er soll nur für Ausgänge benutzt werden. Bevor ein
>Ausgang geschrieben wird, sollte der PCF ausgelesen werden und der
>aktuelle Zustand in der Struktur bbbk gespeichert werden.

Wozu? Halte einfach eine Kopie der Daten im Prozessor und gut. Deutlich 
einfacher, schneller und sicherer!

> Per Uart
>Befehl soll der Schreibvorgang für den entsprechenden Ausgang gestartet
>werden z.B. 32 soll A0 setzen.

Was für ein A0? A0 ist eine Adresseingang am IC, der fest auf LOW oder 
HIGH geleget wird. Per Software wird dort nichts eingestellt. Die IOs 
heißen P0-P7.

> Verbindung habe ich, er schaltet auch die
>Ausgänge bis A0 durch, aber merkt sich nicht den vorherigen Zustand.
>Könnt ihr mir ein Hinweis geben warum es nicht funktioniert?

Zuserst solltest du die Netiquette beherzigen, lange Quelltexte 
gehören in den Anhang.

Dann solltest du DRINGEND deinen Quelltexte besser formatieren, vor 
allem die Einrückung ist WICHTIG!

Siehe Strukturierte Programmierung auf Mikrocontrollern

>      else if (c == 0x37) //A4 Aus
>    {
>      pcf_set2(6);
>    }

Hier stimmen Quelltext und Kommentar nicht überein! Ja was denn nun?
Wie bereits gesagt ist ein switch hier DEUTLICH besser, weil 
übersichtlicher!

  switch(c) {
    case 0x32: pcf_set2(0); break;
    case 0x33: pcf_set2(1); break;
    case 0x34: pcf_set2(2); break;
    case 0x35: pcf_set2(3); break;
    case 0x36: pcf_set2(4); break;
    case 0x37: pcf_set2(5); break;
    case 0x38: pcf_set2(6); break;
    case 0x39: pcf_set2(7); break;
  }

Aber auch das ist hier noch reichlich akademisch und umständlich. 
Einfacher und ausreichend ist hier.

  if (c >= 0x32 && c <= 0x39) {
    pcf_set2(c-0x32)
  }

[Falk B. (falk)]

>       i2c_start(PCF_Read);
>       Pcf_Ausgang = i2c_readNak();
>       bbbk.byte = Pcf_Ausgang;
>       //Pcf_Ausgang |= (1 << a);

Hier fehlt ein I2c_stop

[Falk B. (falk)]

Es ist auch SEHR schlechter Stil, in einer Funktion, die

char pcf_set2(int a)  //Byte vom Pcf lesen

heißt, auch Bits zu LÖSCHEN! (auch zusätzlich wieder ein Widerspruch 
zwischen Funktionsname und Kommentar)

[Philipp (Gast)]

Hallo, vielen Dank für die Antworten ich werde heute Abend den Code 
ordnen und eure Ratschläge befolgen:)

MfG Philipp P.

[Philipp P. (Gast)]

Hallo,

Danke für eure Hilfestellungen, es funktioniert. An meiner 
Programmformatierung muss ich noch arbeiten. Sorry bin da noch ziemlich 
am Anfang. Der Code ist im Anhang, falls es jemanden interessiert.


MfG Philipp P.

[Stefan (Gast)]

Hallo,

was das den ?

 union          //8Bit Array
{
  uint8_t byte;
  struct
  {
    uint8_t b0 : 0;
    uint8_t b1 : 0;
    uint8_t b2 : 0;
    uint8_t b3 : 0;
    uint8_t b4 : 0;
    uint8_t b5 : 0;
    uint8_t b6 : 0;
    uint8_t b7 : 0;

  }bit;
}bbbk

steht nicht hinter dem Doppelpunkt die Länge des Bitfeldes ???

[Falk B. (falk)]

Richtig, ist aber in der neuen Version korrigiert.

http://www.mikrocontroller.net/attachment/highlight/235566