64 Eingänge für Arduino

Eugen T. schrieb:
> über I2C Bus kontrolliert 8 PCF8475 Module.

über I2C Bus mit 2 PCF8475a Module eine 8x8 Matrix machen die 64 Taster 
einliest.

Nein es gibt ein App, wo die Schalter dargestellt sind und dort kann man 
die bedienen. (Auf dem Smartphone).
Ich will die Signale von richtigen Schalter einlesen und dann 
weiterleiten. Beide Möglichkeiten sollen bleiben ( nicht gleichzeitig).
Ja die uC wird neu programmiert und die 64 Eingänge werden eingelesen 
(mit Adresse) und gleich weitergeleitet über I2C Bus.

Kann ich leider keine Matrix machen, die Schalter sind schon vorhanden 
und alle schalten gegen GND. (Sie schalten verschiedene Anlagefunktionen 
usw.) Diese Signal kann ich nur abzapfen.

Sowtwas könnte funktionieren, nur gibt es etwas moderneres, einfacheres?

Leider ist die Auflösung schlecht ( musste ich über 3 Rechner machen). 
Es sind 4 74LS373 auf dem Bild. (32 Eingänge). Das funktioniert, nur ist 
ein IC Friedhof  .. :-)

Ich habe schon eine Option gefunden, den PCF 8575,  es hat schon sogar 
einen I2C Bus. 4 solche werden reichen.

Kann man auch mit einem Parallel In-Serial Out Schieberegister machen. 
CD4014, 74166/165 etc:
https://www.allaboutcircuits.com/textbook/digital/chpt-12/parallel-in-serial-out-shift-register/

Vielen Dank. Ich versuche es mit dem PCF. Blöderweise alle haben die 
selben Adressenbereich...

Denn das Arduino hat schon 7 PCF8574, also nur eine Adresse ist frei.
Die haben den selben Adressen Bereich: 0100 A2,A1,A0
Wenn ich die 8 Bit Expanders für die 16 Bits austausche dann reicht es 
gerade.... die Module mit TCA6424 wären besser, aber habe ich noch keine 
gefunden.

Vergiss es, es ist sowieso uninteressant....

Eugen T. schrieb:
> Denn das Arduino hat schon 7 PCF8574, also nur eine Adresse ist frei.

I2C-Master geht auch sehr bequem in Software, d.h. SCL gemeinsam und 
mehrere SDA (2..8) über eine Maske auswählbar.

Danke, das wusste ich noch nicht. Ich muss etwas nachlernen...gibt es 
dazu irgendwo Info?
Danke!

Peter D. schrieb:
> d.h. SCL gemeinsam

solange die Treiberleistung vom AVR reicht wenn Module den pullup schon 
eingebaut haben......

Eugen T. schrieb:
> PCF8574

Eugen T. schrieb:
> den PCF 8575

haben verschiedene Basisadressen, zum PCF8574 für 8x passt PCF8574a 
ebenfalls 8x wegen anderer Basisadresse

und dann gibt es noch MCP
https://www.nikolaus-lueneburg.de/2015/11/mcp23017-i2c-io-port-expander/

Danke, leider in die Modulen baut niemand die PCF8574A-s ein, alle sind 
nur mit PCF8574 bestückt.
Vom PCF8575 gibt es überhaupt keine A Version.
Ich schaue noch die MCP-s an.

Mit Optokopplern die Schaltkontakte überwachen, die Fototransen der OK 
zur Matrix verschalten und diese Matrix, wie weiter oben vorgeschlagen, 
mit 2 ICS auslesen.

Das war ursprünglich auch eine Option, nur 64 Optokopplers sind auch 
nicht gerade wenig. Einige werde ich sowieso brauchen, glaube ich etwa 
8-10 Schalter muss ich galvanisch trennen.

Eugen T. schrieb:
> Das war ursprünglich auch eine Option, nur 64 Optokopplers sind
> auch
> nicht gerade wenig. Einige werde ich sowieso brauchen, glaube ich etwa
> 8-10 Schalter muss ich galvanisch trennen.

ich habe aber schon 4-fach Optokoppler in einem Gehäuse gesehen, IMHO 
leider nur in SMD

DIP soll es auch geben
4-fach optokoppler -> google Bildersuche

Damit habe ich angefangen, aber davon braucht man auch 16 Stück!
:-) und dazu noch wenigstens 1 16Bit Expander.

Eugen T. schrieb:
> Vielen Dank. Ich versuche es mit dem PCF. Blöderweise alle haben die
> selben Adressenbereich...

Ja und? Man kann aber die exakte Adresse am IC einstellen!

https://www.mikrocontroller.net/articles/Port-Expander_PCF8574

Eugen T. schrieb:
> Leider ist die Auflösung schlecht ( musste ich über 3 Rechner machen).

Eine ERBÄRMLICHE Ausrede!

Siehe Bildformate.

Eugen T. schrieb:
> Damit habe ich angefangen, aber davon braucht man auch 16 Stück!
> :-) und dazu noch wenigstens 1 16Bit Expander.

Man muss sich nicht der allgemeinen Hysterie unterwerfen und jeden 
Scheiß mit einem Optokoppler machen. Einfache, nach GND schaltende 
Schalter kann man einfach und sicher mit einem RC-Filter und Pull-Up 
Widerstand einlesen, der schützt bei passender Dimensionierung auch vor 
kleinen bis mittleren Störungen.

https://www.mikrocontroller.net/articles/Entprellung#Einfacher_Taster

Ein XC9572(XL) mit genügend Pins sollte ausreichen. 64 Eingänge mit 
Pull-UPs, Takt, Seriell/Parallel Umschaltung und ein Ausgang für die 
"durchgeschobenen" Daten.

Jörg

Das ist klar, nur damit kannst du keine Matrix bilden, also bleibt die 
Notwendigkeit von 64 Eingängen.
Ich glaube wir haben das Problem gründlich ausdiskutiert. Ich muss 
schauen was ich einfacher bekommen kann.

Schön! Ich weiß es nicht ob diesen Chip zu Hause nur so einfach löten 
kann.. ?

Habe grade mal bei TME geguckt. Preislich fährst du mit Einzel - Ob's 
besser. Ab 6 Cent bei Abnahme von 25 Stück, was ja gegeben ist, wenn du 
64 brauchst.
4er kosten Stückpreis ab 49 Cent, was aber auch noch bezahlbar wäre.
(Reed)Relais sind teurer.

Danke, es ging nicht unbedingt um die Kosten, eher für realisierbarkeit. 
Die Schalter sind teilweise auf einem Tafel, die Relais in einem Kasten 
etwa 1 m weiter usw. Also mit 16 Bit Expander und ein I2C Bus bin ich 
besser bedient. Ein Modul in Kasten für die Relais und 3 auf dem Tafel. 
Die einzelne Optokoppler bruache ich meistens im Schrank.

Ein 16 Bit PCF auf fertiger Platine kostet etwa 2,5 € - ich glaube bei 
diesem Preis muss man nicht sehr viel spekulieren.

Das werde ich noch überlegen, vielleicht komme ich aus mit 128 Ports.
Danke für euere Hilfe und Ideen.

Ich habe auch daran gedacht, Dazu muss ich aber Platine mavhen lassen 
usw. Ich werde sehen was ist einfacher. Danke

Ich auch.   . ?

Eugen T. schrieb:
> Damit habe ich angefangen, aber davon braucht man auch 16 Stück!
> :-) und dazu noch wenigstens 1 16Bit Expander.

16x 4 OK du widersprichst dir ja selber

Eugen T. schrieb:
> Einige werde ich sowieso brauchen, glaube ich etwa
> 8-10 Schalter muss ich galvanisch trennen.

das wären 2-3 vierfach OK nicht 16

sag mal trollst du?

Wieso, ich habe 64 Eingänge, dazu brauche ich 16 Quad Optokopplers (für 
Matrix) und zwei 8 Bit Expander oder einen 16 Bit Expander.

Das ist alles, vielen Dank für allen die mir geholfen haben!

Eugen T. schrieb:
> Wieso, ich habe 64 Eingänge, dazu brauche ich 16 Quad Optokopplers (für
> Matrix) und zwei 8 Bit Expander oder einen 16 Bit Expander.


8 Schieberegister sind wahrscheinlich nicht fancy genug?

Es gibt von NXP einen 40-IO Expander:

https://www.digikey.ca/product-detail/en/nxp-usa-inc/PCA9698DGG512/568-3241-5-ND/1033526

https://www.nxp.com/documents/data_sheet/PCA9555.pdf?

Interessant wäre hier der PCA9698 und der PCA9555 als Möglichkeit. 
Zusammen ergibt dieses Paar 64 Eingänge.

Mit der Input Maske läßt sich ein Interrupt Ausgang aktivieren. (Siehe 
Abschnitt 7, Seite 18) Damit braucht der uC nicht einmal zu Pollen um 
eine Änderung des Schalterzustand zu erkennen.

Beim PCA9555 funktioniert die Interrupt Erkennung etwas anders. Der 
Interrupt Ausgang aktiviert immer dann wenn das XOR einen Unterschied 
zwischen Output Flip-flop und IO-Pin Zustand feststellt.

Wolfgang schrieb:
> Gerhard O. schrieb:
>> Interessant wäre hier der PCA9698 und der PCA9555 als Möglichkeit.
>> Zusammen ergibt dieses Paar 64 Eingänge.
>
> Gerade bei I2C bietet sich doch ein modularer Aufbau an. Warum soll man
> das alles in einen Chip quetschen. Das führt nur dazu, dass ein dickes
> Leitungsbündel auf einer einzigen, große Platine zusammengeführt werden
> muss. Bei einem modularen Aufbau mit mehreren Chips, kann man eine
> kleine Platine mehrfach einsetzen und so einen viel einfacheren und
> flexibleren Aufbau erreichen.

Hast recht. Nur erspart dieses Konzept I2C Adressen. Prinzipiell wären 
verteilte IO-Expander praktisch gesehen sicherlich angenehmer in der 
Verdrahtung. Speziell wenn man kleine Bords macht die sich mit einem 
Kabel anreihen lassen. Bords sind ja heutzutage nicht mehr teuer.

Viele Wege führen hier natürlich zum Ziel. Persönlich habe ich auch gute 
Erfahrungen mit (xx165) Schieberegistern gemacht. Die lassen sich im 
Hintergrund mit einer Timer-ISR innerhalb von 10us allesamt Pollen und 
belasten durch HW SPI den CPU kaum. Entprellen ist dann auch kein 
Problem. Ist wahrscheinlich auch die billigste Lösung.

Wolfgang schrieb:
> Gerhard O. schrieb:
>> Nur erspart dieses Konzept I2C Adressen.
>
> Für eingesparte I2C Adressen gibt es kein Geld zurück. Mit den
> vorgeschlagenen Bausteinen kannst du mehr als genug IO zur Verfügung
> stellen, ohne auf solche "Monster" zurück zu greifen. Oder hast du noch
> erheblich größere Ausbaupläne. Dann gäbe es immer noch die Möglichkeit,
> auf einen eigenen kleinen uC für das IO-Handling zu gehen und damit auch
> die. Software zu entzerren.

Viele Wege führen von Rom. Dein stichaltigstes Argument ist den 
Drahtigel vermeiden zu wollen.

Was mich betriftt, wären die xx165er meine Wahl. Die Billigkeit und 
Einfachheit sind nicht zu unterbieten. 8 SR kosten wahrscheinlich 
zusammen unter einem Euro. Eine n x ms Timer ISR pollt alle SR im 8MHz 
Takt, so daß ein SR nur 1us zum Lesen eines SR braucht. Zuerst wird der 
auf alle SR wirkende Übergabe Puls gegeben und dann die SR nacheinander 
abgefragt. Das verbraucht lediglich rund 10us für 8 SR. Mit einfacher 
Logik behandelt man Prellungen und minimale Schalterbetätigungszeitdauer 
um Schaltzustandsänderungen erfassen zu können. Von Peter D. Gibt es 
sowieso schon erprobte Ansätze für die Logikverarbeitung. HW SPI ist 
hier geschwindigkeitsmäßig über I2C den Vorzug zu geben.

Damit hat man alle notwendigen Informationen zur weiteren Verarbeitung. 
Das Ganze läuft im Hintergrund und verbraucht sehr wenig CPU Zeit. Die 
SR lassen sich dann jeweilig bequem in der Nähe der betroffenen Schalter 
anordnen. In seinem Fall hat Pollen keine Nachteile. Die SR Eingänge 
sollten über hochohmige Serienwiderstände verbunden sein. Je nach 
Schalterkonstruktion sollten die Schalter Pullups entsprechend 
dimensioniert sein um zuverlässig zu funktionieren. Ich würde da auf 
einige mA hinaufgehen.

Besonders bei langen Leitungen ist I2C natürlich deutlich robuster, als 
SPI.
Um SPI etwas störsicherer zu machen, könnt man die langsamen 4000-er 
CMOS nehmen, z.B. CD4021.

Wolfgang schrieb:
> I2C mit seinen Open-Kollektor-Ausgängen schwächelt deutlich auf
> den steigenden Flanken.

Und genau das ist ja der große Vorteil, es gibt deutlich schwächere 
Reflexionen und die I2C-ICs haben interne Filter gegen Spikes.
Ein 74HC165 kann typisch bis 56MHz takten, d.h. ein Übersprechen oder 
eine Reflexion von 9ns kann eine falsche Taktflanke erzeugen.
Der CD4021 ist mit 3MHz deutlich unkritischer.
I2C mit 100kHz ist aber noch robuster, Spikes von bis zu 100ns sind lt. 
PCF8574 Datenblatt zulässig.

Hallo

Ich bin schon in Arduino IDE so weit das ich zwei Module lesen und 
schreiben kann. Die Adressen sind 0x20 zum lesen und 0x39 zum schreiben. 
Individuell kann ich beide PCFs lesen und schreiben aber in der Loop 
meldet mir einen Fehler: redefined address.
Die Aufgabe wäre die Daten (word) von Modul A einlesen und gleich in 
Modul B schreiben. Gibt es irgendwo ein Mustercode dazu? Leider ich habe 
noch keine Erfahrung in C Sprache.

Vielen Dank.

Inzwischen habe ich ein Musterprogram gefunden, leider funktioniert auch 
nicht:
Gleich am Anfang meldet einen Fehler: PCF8574 PCF_39......

Leider auch von Github kann ich nicht die richtige PCF8574 unterladen, 
es fehlt der Download Knopf.

Danke für die Hilfe!

1

////

2

// 

3

//

4

5

#include <Wire.h>

6

7

// adjust addresses if needed

8

PCF8574 PCF_20(0x20);  // add switches to lines  (used as input)

9

PCF8574 PCF_39(0x39);  // add LEDs to lines      (used as output)

10

11

void setup()

12

{

13

  Serial.begin(115200);

14

  Serial.println("\nTEST PCF8574\n");

15

16

  uint8_t value = PCF_20.read8();

17

  Serial.print("#20:\t");

18

  Serial.println(value);

19

20

  for (int i=0; i<255; i++)

21

  {

22

    PCF_39.write8(i);

23

    delay(100);

24

  }

25

26

  PCF_39.write(0, 1);

27

  for (int i=0; i<7; i++)

28

  {

29

    PCF_39.shiftLeft();

30

    delay(100);

31

  }

32

33

  for (int i=0; i<7; i++)

34

  {

35

    PCF_39.shiftRight();

36

    delay(100);

37

  }

38

39

  for (int i=0; i<8; i++)

40

  {

41

    PCF_39.write(i, 1);

42

    delay(100);

43

    PCF_39.write(i, 0);

44

    delay(100);

45

  }

46

47

  for (int i=0; i<8; i++)

48

  {

49

    PCF_39.toggle(i);

50

    delay(100);

51

    PCF_39.toggle(i);

52

    delay(100);

53

  }

54

}

55

56

void loop()

57

{

58

  // echos the lines

59

  uint8_t value = PCF_20.read8();

60

  PCF_39.write8(value);

61

  delay(100);

62

}

63

//

64

// END OF FILE

Eugen T. schrieb:
> Inzwischen habe ich ein Musterprogram gefunden

interessant, erzähle mehr darüber :)

Eugen T. schrieb:
> Leider auch von Github kann ich nicht die richtige PCF8574 unterladen

ach

ist heute Freitag?

Die Fehlermeldung ist: PCF8574' does not name a type.

Leider bin ich noch ganz neu in Arduino Sprache. Ich dachte mir 
vielleicht probiere ich es aus, in ASM funtioniert schon ganz gut.

Danke!

Das habe ich schon eingetragen ( schon die richtige von Github)

Jetzt meldet mir einen Fehler in Loop:


uint8_t value = PCF_20.read8();

'Class pCF8574' has no member named 'read8'

Der Code ist von arduino.cc.

Danke

Jetzt habe ich die neueste von Github untergeladen, aber bei jede 
PCF8574 meldet Arduino IDE einen Fehler, aber in der Library ist die 
PCF8574 vorhanden. Der PCF8575.ZIP ist fehlerfrei. ( das brauche ich 
später).
Ich versuche alle zu löschen und neu installieren.

Jetzt habe ich alles neu installiert, und alle PCF8574 gelöscht und neu 
untegeladen: Es meldet noch interessante Fehler. (Beim füheren Versuche 
nur lesen und schreiben funktionierte alles ohne Probleme).

Hier sind die Screenshots:

PCF1 ist von früherer Version, der Fehler wenn ich eine PCF8574 Library 
installierte. Nach löschen von allen alten PCF8574.h war alles OK.
Ich habe aber alles gelöscht und neu installiert. Der Code hat noch 
immer den selben Fehler. (libraries).

Vielen Dank!

Genau von dort habe ich alles kopiert, nur die Adresse wurde angepasst. 
Die Library ist von dem Link in Github.

Eugen T. schrieb:
> Jetzt habe ich die neueste von Github untergeladen

verrate uns nur nicht mit einem Link welche.....

mal ehrlich
sprichst du auch so im echten Leben:

Anruf in der Auto-Werkstatt:
"Mein Auto fährt nicht, was soll ich machen?"

verrate nur nicht um welches Auto es geht.

Also wenn du einen Link zur Github Lib hast, dann poste ihn hier!

Dann könnten andere evtl. versuchen zu helfen!

Jazz schrieb:
> oder das github repo selber googlen

ja welches denn?

es gibt einige

Einen PCF8574 aus Arduino anzusteuern braucht nicht mal eine LIB

man beginnt einfach einen wire Cyclus

und macht einen wire write oder wire read

Beispiele gibts doch:
https://www.arduino.cc/en/Reference/WireBeginTransmission
aber ich sehe ein dazu braucht man Grundlagen und Übung

1

#if (ARDUINO>0)

2

          int _address, _data, _error; //  Wire.begin();

3

          if(_i2c_key=='A') _address = 0x38;

4

          if(_i2c_key==' ') _address = 0x20;

5

          Wire.beginTransmission(_address); Wire.requestFrom(_address, 1);

6

          _data = readIIC();

7

          _error = Wire.endTransmission();

8

          if(!_error) ii = key_state ^ ~_data;

9

#else

10

          if(_i2c_key=='A')

11

          {  if(!i2c_start(PCF8574A_0+I2C_READ))  //;  // set device address and write mode

12

               ii = key_state ^ ( ( ~(unsigned char)i2c_readNak() ) ); //jar key1 kaputt    

13

             i2c_stop();

14

          }

15

          else

16

          {  if(!i2c_start(PCF8574_0+I2C_READ))  //;  // set device address and write mode

17

               ii = key_state ^ ( ( ~(unsigned char)i2c_readNak() ) ); //jar key1 kaputt    

18

             i2c_stop();

19

          }

20

#endif

21

          ii &= ALL_KEYS;

22

          ct0 = ~( ct0 & ii );                             // reset or count ct0

23

          ct1 = ct0 ^ (ct1 & ii);                          // reset or count ct1

24

          ii &= ct0 & ct1;                                 // count until roll over ?

25

          key_state ^= ii;                                 // then toggle debounced state

26

          key_press |= key_state & ii;                     // 0->1: key press detect

27

28

          if( (key_state & REPEAT_MASK) == 0 )            // check repeat function

29

            rpt = REPEAT_START;                          // start delay

30

          if( --rpt == 0 )

31

          {  rpt = REPEAT_NEXT;                            // repeat delay

32

             key_rpt |= key_state & REPEAT_MASK;

33

          }

34

        } // if(!_i2c_busy)

35

      } // if(_i2c_key)

Ja, habe ich schon bemerkt. Leider der Link von Playground hat keine 
Option die Libraries unter zu laden: (siehe Bild)
Ich weiß es noch nicht, wie kann man die Files (was sind in Playground: 
PCF8574.cpp und PCF8574.h) umwandeln und als Library benutzen oder 
importieren

Danke, das habe ich noch in Arduino nicht. Ich habe alles schon in ASM 
gemacht, aber mein Sohn braucht es für Arduino, deswegen kämpfe ich 
damit. Schreiben und lesen kann ich schon die Ports, nur gleichzeitig 
kombinieren noch nicht. Vielleicht morgen oder später. :-)

Vielen Dank für eure Hilfe.

Jetzt geht schon gar nichts, (gelöscht). Ich habe mit xreef und den 
anderen PFC8574 versucht. Es sind nur zwei auf dem Github (die andere 
sind für LCD) Beide machten den gleichen Fehler, deswegen habe ich beide 
gelöscht.

Eugen T. schrieb:
> Leider bin ich noch ganz neu in Arduino Sprache
Eugen T. schrieb:
> Ich habe alles schon in ASM gemacht

Die "Arduino Sprache" heisst c++.
Wenn du AVRs in ASM programmieren kannst, wäre vielleicht ein c++ Buch 
eine gute Wahl, sowie das AVR-GCC-Tutorial eine gute Ergänzung, da C 
kompatibel ist.
Der Weg zu einer eigenen Lib ist dann nichtmehr weit, es geht ja nur 
darum Quellcode in eine andere Sprache zu migrieren. (inline asm wäre 
auch eine Möglichkeit).

Eugen T. schrieb:
> aber mein Sohn braucht es für Arduino

Braucht er wirklich das Arduino-Framework? Du könntest mit ihm doch 
gemeinsam "richtiges" C lernen? Dabei ist der Lerneffekt sicher höher, 
denn er wird auch mal einen Blick ins Datenblatt werfen und hoffentlich 
eine richtige IDE nutzen. Das Atmel-Studio (MS Visual-Studio) gibt es 
kostenlos. Ein Arduino addon wäre auch vorhanden.

leo schrieb:
> Du glaubst wirklich, dass dein Code einem Ahnungslosen helfen kann?

nö, lernen kann man niemand abnehmen, ich meinte ja nur das genau für 
diesen Stein keine LIB nötig ist, nur Forschergeist.

Danke für eure Hilfe:

Ich habe es geschafft die Libraries vom Playground fertig machen. Leider 
der Code ist trotzdem nicht ganz in Ordnung. Es gibt kein Fehler mehr im 
Code, aber kann man für NANO nicht compilieren;

Hier ist die Fehlermeldung:
(nicht ganz, nur wo ich einen Fehler (error) sah.


C:\Users\ETD\AppData\Local\Temp\arduino_build_781969\libraries\PCF8574\P 
CF8574.cpp.o  (symbol from plugin): In function `PCF8574::PCF8574(int)':

(.text+0x0): multiple definition of `PCF8574::shiftLeft(unsigned char)'

C:\Users\ETD\AppData\Local\Temp\arduino_build_781969\sketch\PCF8574A.ino 
.cpp.o  (symbol from plugin):(.text+0x0): first defined here

collect2.exe: error: ld returned 1 exit status

Multiple libraries were found for "Wire.h"
 Used: C:\Program
Multiple libraries were found for "PCF8574.h"
 Used: C:\Users\ETD\Documents\Arduino\libraries\PCF8574
Using library PCF8574 in folder: 
C:\Users\ETD\Documents\Arduino\libraries\PCF8574 (legacy)
Using library Wire at version 1.0 in folder: C:\Program Files
exit status 1
Error compiling for board Arduino Nano.

Ich würd ja erst mal programmieren lernen. Das was du da machst ist 
rummatschen im Schlamm und dann heulen weil kein Haus daraus geworden 
ist.

Das verstehe ich nicht.

Ich habe alles genau so gemacht wie geschrieben. Ich habe die PCF8574.h 
und PCF8574.cpp in Library gemacht, ganz genau wie er das geschrieben 
hat.

Na, macht es nicht ich versuche es vielleicht noch lernen, aber in ASM 
habe ich den ganzen Code in 2-3 Std geschrieben und funktioniert. Dort 
sind die Help files bedeutend besser als hier. Aber macht es nichts, Ich 
werde noch versuchen... :-)
Schönen Abend noch!

Eugen T. schrieb:
> in ASM habe ich den ganzen Code in 2-3 Std geschrieben und funktioniert.

Bei DEM Vorwissen bist du nach DREI Monaten noch nicht am Ziel?

Ich sage nur Inline Assembler, wenn du deinen alten code quasi 
weiternutzen möchtest und AVR-GCC-Tutorial für c. Das wird dir 
möglicherweise leichter fallen als das Arduino-framework, weil es 
einfach hardwarenäher ist. Die Funktionen kannst du später auch "mit 
Arduino" aufrufen.

Eugen T. schrieb:
> In ASM [..] sind die Help files bedeutend besser als hier

Die Zielgruppe von Arduino sind absolute Anfänger, Leute, die zum ersten 
Mal programmieren. Die würden mit tiefergehenden Informationen wenig 
anfangen können. Für alle Anderen bietet diese Seite und das Internet 
ausreichend Informationen.

Ich habe es mit diesem Code aufgegeben. Habe ich einen anderen gefunden, 
wo schon 4 Schalter und 12 LEDs funktionieren.... ich weiß nicht was ist 
hier schief gegangen.

vielen Dank für euren Geduld und Hilfe.

Wie gesagt ich habe den Code in Assembler schon vor Monaten geschrieben. 
Mein Sohn jetzt braucht etwas ähnliches für sein Arduino in der Schule. 
Ich habe es versucht ihm zu helfen. Mit dem neuen Code wird es schon 
funktionieren. Mit diesen hatte ich Pech gehabt... ( ich habe nie C oder 
andere höhere Sprachen gelernt :-( ) ich programierte alles über ISP 
oder JTAG nie von Arduino IDE.

Eugen T. schrieb:
> Mein Sohn jetzt braucht etwas ähnliches für sein Arduino in der Schule.

Möglicherweise liegt die Schule bei mir bereits zu lange zurück, aber 
falls das Projekt? benotet wird, sollte er vielleicht seinen Lehrer 
fragen, ob er grundsätzlich Code aus dem Netz als Basis benutzen darf. 
Kritisch könnte es bei kompletten Libs werden.

Wolfgang schrieb:
> Wenn du dir einen Gefallen tun willst, lässt du die ganzen
> PCF8574-Library erstmal links liegen und verwendest nur die Wire
> Bibliothek.

meinte ich ja auch

evtl. hilft
http://homepage.hispeed.ch/peterfleury/avr-software.html

mir hats zu Anfang vor Arduino geholfen und kann man auch in der Arduino 
IDE verwenden, aber mit wire LIB gehts genauso.

Es geht doch nur um ein Byte Lesen oder Schreiben.

Eugen T. schrieb:
> aber in ASM
> habe ich den ganzen Code in 2-3 Std geschrieben und funktioniert.

Das glaub ich Dir nicht. Denn dann könntest Du das ja auch in C 
hinschreiben. Statt LDI und OUT nimmt man in C einfach das '=' Zeichen.

Wenn Du mit irgendwelchen Arduino-Blackboxes nicht klarkommst und auch 
die Beschreibung und Hilfe dazu nicht lesen willst, dann zwingt Dich 
auch niemand dazu, sie zu benutzen.
Du darfst auch in C die IO-Register direkt ansprechen, wie Du es in 
Assembler getan haben willst.