64 Eingänge für Arduino

[Eugen T. (weaver)]

Ich habe eine interessante Aufgabe. Es gibt ein System mit Arduino wo 
man über BT und Telefon etwa 64 Ausgänge schalten kann:
Arduino Nano über I2C Bus kontrolliert 8 PCF8475 Module.
Die Eingabe über Telefon ist nicht gerade optimal, und alle Eingänge 
existieren in mechanischem Form ( Schalter, Taster oder Relais 
Kontakte).
Wie wäre es am besten diese etwa 64 Eingänge Byteweise einzulesen und 
über I2C verteilen?
Vom 74LS373 oder mit uraltem Intel 8255 könnte man einen Vorspeicher 
(Flip-Flop) bauen mit 64 Eingängen, aber beide Lösungen scheinen mir als 
uralt. Ich habe noch eine originale Karte mit 8255 - wahrscheinlich 
schon über 30 J alt:-)
Gibt es etwas moderneres oder einfacheres?

Danke für die Vorschläge.

[Stefan F. (Gast)]

Deine Aufgabenbeschreibung ist unklar.

Du hast als Eingabegerät ein Telefon. Daran hängt ein Mikrocontroller, 
der 64 Ausgänge schaltet. Nutzt du von dem Telefon die Wählscheibe bzw. 
das Tastenfeld als Eingabegerät?

Möchtest du das Eingabegerät durch ein anderes ersetzen? Welches denn? 
Kommt es dabei in Frage, den Mikrocontroller neu zu programmieren? Was 
hast du mit 64 Eingänge vor?

[Joachim B. (jar)]

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.

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

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.

[CD4021 (Gast)]

Eine Reihe Schieberegister löst Deine Aufgabenstellung.

[Eugen T. (weaver)]

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

[165 (Gast)]

acht 74hct165 hintereinander könnten das ....

[Forist (Gast)]

Eugen T. schrieb:
> IMG_4067.PNG

Guckst du dir das Zeugs, was du hochlädst, auch vorher mal an? :-(

[Eugen T. (weaver)]

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  .. :-)

[Eugen T. (weaver)]

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

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

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/

[Eugen T. (weaver)]

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

[Forist (Gast)]

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

Dann lass dir was anderes einfallen. Auch zwischen 3 Rechnern kann man 
Bilder verlustfrei übertragen. Das ganze Internet funktioniert so.

Die Bildqualität ist unter aller Sau, sorry.
Da kann keiner was vernünftig mit anfangen.

[Wolfgang (Gast)]

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

Natürlich haben gleiche I2C-Bausteine den gleichen Adressbereich. Was 
ist daran blöde?

Die PCF8575 kannst du über die 3 Adressbists auf 8 verschiedene Adressen 
legen, d.h. damit kannst du 8*16 = 128 Eingänge einlesen.

Mit PCA9554 und PCA9554A hättest du auch jeweils die Kodiermöglichkeit 
für jeweils 8 Adressen, so dass du bei Verwendung dieser beiden 
Bausteine (jeweils 8x) ebenfalls auf 2*8*8 = 128 mögliche Eingänge 
kämest.

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

Vergiss es, es ist sowieso uninteressant....

[Peter D. (peda)]

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.

[Eugen T. (weaver)]

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

[Joachim B. (jar)]

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/

[Ratanplan (Gast)]

Musst ja nicht dort kaufen, aber so was in der Richtung hilft dir 
weiter:
https://www.ramser-elektro.at/shop/module-sensoren-adapter-und-co/mcp23017-i2c-16bit-i-o-port-erweiterung/

4 davon und du haben fertig.

[Eugen T. (weaver)]

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.

[Gerald B. (gerald_b)]

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

[Eugen T. (weaver)]

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.

[Joachim B. (jar)]

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

[Eugen T. (weaver)]

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

[Falk B. (falk)]

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

[Falk B. (falk)]

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

Eine ERBÄRMLICHE Ausrede!

Siehe Bildformate.

[Falk B. (falk)]

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

[Joerg W. (joergwolfram)]

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

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

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

[Gerald B. (gerald_b)]

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.

[Stefan F. (Gast)]

Ich würde auch eine Reihe Schieberegister nehmen, weil sie einfach und 
billig sind. Mein Favorit ist der 74HC165.

[Eugen T. (weaver)]

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.

[Stefan F. (Gast)]

Eugen T. schrieb:
> etwa 1 m weiter usw. Also mit 16 Bit Expander und ein I2C Bus bin ich
> besser bedient.

Ja, in dem Fall sehe ich das auch so. I²C Chips sind bei der 
Leitungslänge schon ohne besondere Maßnahmen weniger Störanfällig.

[Eugen T. (weaver)]

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

[Wolfgang (Gast)]

Eugen T. schrieb:
> Denn das Arduino hat schon 7 PCF8574, also nur eine Adresse ist frei.
> ...
> Wenn ich die 8 Bit Expanders für die 16 Bits austausche dann reicht es
> gerade....

Du kannst auch deine 16 Bit GPIO-Expander verwenden und zu deiner 
Eingangsabfrage einen I2C-Multiplexer dazwischen schalten, z.B. PCA9544A

[Eugen T. (weaver)]

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

[Harry (Gast)]

zu Hause hab ich 24-Bit-Bus-Extender für I²C in einem recht kleinen 
Gehäuse (ca.5x5mm) ..... mir fällt nur grad nicht ein, wie die heißen.

gefunden: TCA6424

[Eugen T. (weaver)]

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

[Stefan F. (Gast)]

Für so etwas habe ich mal einen Arduino Nano Klon zweckentfremdet. Das 
war billiger, als jeder Port-/Bus-Expander, den ich hätte kaufen können 
(glaube ich jedenfalls). Außerdem habe immer reichlich Arduino Nanos 
vorrätig.

[Eugen T. (weaver)]

Ich auch.   . ?

[Joachim B. (jar)]

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?

[Eugen T. (weaver)]

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!

[Cyblord -. (cyblord)]

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?

[Stefan F. (Gast)]

Cyblord -. schrieb:
> 8 Schieberegister sind wahrscheinlich nicht fancy genug?

Nee, die haben kein Bluetooth.

[Wolfgang (Gast)]

Eugen T. schrieb:
> Danke, leider in die Modulen baut niemand die PCF8574A-s ein, alle sind
> nur mit PCF8574 bestückt.

Deine acht PCF8574 können auch da bleiben, wo sie sind. Nur für deine 64 
Eingänge könntest du die PCF8574A verwenden. Dann lägen deine Module auf 
den Slave Adressen 0100xxx und deine Eingänge auf 0111xxx.
Lass dich im TI-Datenblatt zum PCF8574A nicht von der Figure 13. 
(Interrupt Voltage Waveforms) auf S.9 verwirren. Die dort gezeigte 
fehlerhafte Slave Adresse (0100xxx) ist wohl vom PCF8574 kopierte und 
hat anscheinend 14 Jahre nach der Erstausgabe auch die Rev 2015 
unkorrigiert überstanden :-(
Auf S.12 unter 8.3.2 (Interface Definition) steht richtig 0111xxx.
(s.a. NXP Datenblatt zum PCF8574; PCF8574A Kap. 7.1 Device address, S.5)
https://www.ti.com/lit/ds/symlink/pcf8574a.pdf
https://www.nxp.com/docs/en/data-sheet/PCF8574_PCF8574A.pdf

[Gerhard O. (gerhard_)]

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 (Gast)]

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.

[Gerhard O. (gerhard_)]

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 (Gast)]

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.

[Gerhard O. (gerhard_)]

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.

[Peter D. (peda)]

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 (Gast)]

Peter D. schrieb:
> Besonders bei langen Leitungen ist I2C natürlich deutlich robuster, als
> SPI.

Immerhin ist SPI mit seinen Push-Pull Ausgänge bei beiden Flanken 
schnell. I2C mit seinen Open-Kollektor-Ausgängen schwächelt deutlich auf 
den steigenden Flanken.
Für Robustheit und Übertragungsgeschwindigkeit zählen also Kriterien wie 
Störleistung auf der Leitung und kapazitive Last.

[Peter D. (peda)]

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.

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

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!

////
// 
//

#include <Wire.h>

// adjust addresses if needed
PCF8574 PCF_20(0x20);  // add switches to lines  (used as input)
PCF8574 PCF_39(0x39);  // add LEDs to lines      (used as output)

void setup()
{
  Serial.begin(115200);
  Serial.println("\nTEST PCF8574\n");

  uint8_t value = PCF_20.read8();
  Serial.print("#20:\t");
  Serial.println(value);

  for (int i=0; i<255; i++)
  {
    PCF_39.write8(i);
    delay(100);
  }

  PCF_39.write(0, 1);
  for (int i=0; i<7; i++)
  {
    PCF_39.shiftLeft();
    delay(100);
  }

  for (int i=0; i<7; i++)
  {
    PCF_39.shiftRight();
    delay(100);
  }

  for (int i=0; i<8; i++)
  {
    PCF_39.write(i, 1);
    delay(100);
    PCF_39.write(i, 0);
    delay(100);
  }

  for (int i=0; i<8; i++)
  {
    PCF_39.toggle(i);
    delay(100);
    PCF_39.toggle(i);
    delay(100);
  }
}

void loop()
{
  // echos the lines
  uint8_t value = PCF_20.read8();
  PCF_39.write8(value);
  delay(100);
}
//
// END OF FILE

[Joachim B. (jar)]

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?

[Stefan F. (Gast)]

Mit vollständigen Fehlermeldungen können potentielle Helfer mehr 
anfangen. Möchtest du, dass man Dir hilft?

[Eugen T. (weaver)]

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.

[leo (Gast)]

Eugen T. schrieb:
> Die Fehlermeldung ist: PCF8574' does not name a type.

Da fehlt

#include "PCF8574.h"

Ev. auch noch init, begin oder so was.
Wenn du eines der Beispiele ausprobierst tuts du dir leichter.

leo

[Eugen T. (weaver)]

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.

[leo (Gast)]

Eugen T. schrieb:
> 'Class pCF8574' has no member named 'read8'

Vielleicht liest du ja mal die Doku der uns unbekannten Library.

leo

[Stefan F. (Gast)]

Eugen T. schrieb:
> Leider bin ich noch ganz neu in Arduino Sprache

Das würde ich dir dringend empfehlen, dich zunächst mit dem Umfang der 
"Arduino Sprache" zu begnügen und keine fremden Bibliotheken 
einzubinden.

Erst wenn du die Sprache und Arbeitsmittel gut kennst, ist der richtige 
Zeitpunkt für Erweiterungen da. Bis dahin wirst du auch die 
Fehlermeldungen verstehen und dir selbst helfen können.

> 'Class pCF8574' has no member named 'read8'

Dann ist die Klasse eben nicht kompatibel zu deinem Quelltext. Du hast 
wohl die falsche Variante verwendet. Von PCF8574 gibt es unzählige 
Varianten.

Hier ist vermutlich der richtige Download Link: 
https://playground.arduino.cc/Main/PCF8574Class/

> pCF8574

Ist das kleine p ein Tippfehler? Scheint so.

[Eugen T. (weaver)]

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.

[Platinen Frickler (Gast)]

Mit Shift Register w.z.B. den HC165 könnte man die 64 Eingänge bei 8MHz 
SPI Clock Frequenz im AVR in unter 10us einlesen. Zuerst den 165ern 
einen kurzen Übernahme Impuls senden und dann 8 SPI HW Reads - Fertig.

Ein einziges I2C Byte bei 400kHz braucht mindestens 25us. Da ist der 8x 
HC165 Lesevorgang in ein Drittel der Zeit fertig bevor mal erst mal ein 
einziges  Slave Adress Byte senden kann.

Lesevorgang PCF8574: 2x I2C Worte @ 25us/Wort > 47.5us bei 400kHz SCL 
(2.5us/bit)
Lesevorgang HC165:   1x 1us bei 8MHz SCK Frequenz (125ns/bit)

Und zuverlässiger wie I2C ist es wegen der einfacheren Logik auch; 
billiger obendrein.

Ein PCF8574 kostet $2. das sind zusammen 16$ und ist über 50x langsamer
Ein HC165 kostet $0.60, also $4.80 für 8 Stück.

Das einzige was man dem PCF8574 zugute halten könnte, wäre, daß das 
Layout bei I2C wesentlich weniger kritisch ist. Bei 8Mhz SCK muss man 
natuerlich schon aufpassen.

[Stefan F. (Gast)]

Eugen T. schrieb:
> 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.

Damit kann ich nichts anfangen, zu unkonkret.

Schonmal was von Bildschirmfotos und Zwischenablage gehört? Außerdem 
solltest du dir dringend angewöhnen, genau anzugeben, womit wir es zu 
tun haben. Denn PCF8574 Bibliotheken gibt es viele, wie du selbst 
bemerkt hast.

[Eugen T. (weaver)]

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!

[Stefan F. (Gast)]

> Jetzt habe ich ... alle PCF8574 gelöscht und neu runtegeladen
> Multiple Libraries were found for "PCF8574.h"

Ich denke, diese Meldung ist eindeutig. Es wird wohl nicht 
funktionieren, wenn du viele Libraries gleichzeitig installierst.

Folge der Anleitung auf https://playground.arduino.cc/Main/PCF8574Class/

Da steht genau drin, wie man es richtig installiert.

[Eugen T. (weaver)]

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

[Joachim B. (jar)]

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 (Gast)]

Hallo, also dein Beispielcode ist sicher nicht für die lib aus deinem 
github bild (die du übrigens imo auch gleich verlinken hättest sollen):
Öffne mal https://github.com/xreef/PCF8574_library/blob/master/PCF8574.h 
(oder .c) und du wirst keine read8 methode finden. Du musst bedenken, 
nur weil 2 Libraries von 2 Autoren den selben Namen (und mit etwas 
"Glück" den Klassennamen) haben , wirst du so gut wie nie "Beispiel für 
Lib A" auf Lib B anwenden können, weil sie anders implementiert sind. 
Was hier also wohl passiert ist, ist dass du ein Beispiel für eine 
andere Library hattest, die vorher eingebunden war (vllt vorinstallierte 
Lib?), jetzt die von dir gewünschte Lib einbindest und damit auch dein 
Beispiel flöten geht.
Du hast 2 Optionen: Entweder du findest die ursprüngliche Lib und Doku 
und benutzt die mitsamt ihrer Beispiele/Methoden , oder du benutzt die, 
die du auf github gefunden hast - dann musst du dich aber auch an deren 
Beispielen orientieren (da gibts im Unterordner gleich 9 Beispiele als 
.ino)

Und ich muss mich hier dem Vorposter anschließen: Es ist ja absolut ok 
wenn man was nicht weiß oder auch kompletter Anfänger in einer Materie 
ist, manchmal weiß man dann nicht mal was man fragen sollte. Trotzdem 
sollte man halt versuchen, es den anderen halbwegs leicht zu machen, 
eine Antwort zu finden. Dazu gehört dann gleich Links mitzuschicken, 
gleich die detaillierte Fehlermeldung zu schreiben und auch gleich zu 
sagen von hier hab ich den Beispielcode. Dann kann man auch in 5 
Sekunden sagen, deswegen passt das nicht, statt dass man es sich 
zusammenreimen oder das github repo selber googlen muss..

[Joachim B. (jar)]

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

#if (ARDUINO>0)
          int _address, _data, _error; //  Wire.begin();
          if(_i2c_key=='A') _address = 0x38;
          if(_i2c_key==' ') _address = 0x20;
          Wire.beginTransmission(_address); Wire.requestFrom(_address, 1);
          _data = readIIC();
          _error = Wire.endTransmission();
          if(!_error) ii = key_state ^ ~_data;
#else
          if(_i2c_key=='A')
          {  if(!i2c_start(PCF8574A_0+I2C_READ))  //;  // set device address and write mode
               ii = key_state ^ ( ( ~(unsigned char)i2c_readNak() ) ); //jar key1 kaputt    
             i2c_stop();
          }
          else
          {  if(!i2c_start(PCF8574_0+I2C_READ))  //;  // set device address and write mode
               ii = key_state ^ ( ( ~(unsigned char)i2c_readNak() ) ); //jar key1 kaputt    
             i2c_stop();
          }
#endif
          ii &= ALL_KEYS;
          ct0 = ~( ct0 & ii );                             // reset or count ct0
          ct1 = ct0 ^ (ct1 & ii);                          // reset or count ct1
          ii &= ct0 & ct1;                                 // count until roll over ?
          key_state ^= ii;                                 // then toggle debounced state
          key_press |= key_state & ii;                     // 0->1: key press detect
               
          if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
            rpt = REPEAT_START;                          // start delay
          if( --rpt == 0 )
          {  rpt = REPEAT_NEXT;                            // repeat delay
             key_rpt |= key_state & REPEAT_MASK;
          }
        } // if(!_i2c_busy)
      } // if(_i2c_key)

[Eugen T. (weaver)]

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

[leo (Gast)]

Joachim B. schrieb:
> Einen PCF8574 aus Arduino anzusteuern braucht nicht mal eine LIB

Du glaubst wirklich, dass dein Code einem Ahnungslosen helfen kann?

leo

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

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.

[Stefan F. (Gast)]

Eugen T. schrieb:
> Leider der Link von Playground hat keine
> Option die Libraries unter zu laden: (siehe Bild)

Ich bin Sprachlos!

Ich weise jetzt zum dritten mal auf die Anleitung hin: 
https://playground.arduino.cc/Main/PCF8574Class/

Da steht "To use the library, make a folder in your 
SKETCHBOOKPATH\libraries with the name PCF8574 and put the .h and .cpp 
there."

Das heißt auf deutsch, du sollst in deinem Projektverzeichnis ein 
Unterverzeichnis \libraries erstellen und dort die beiden Dateien 
ablegen. Weist du wie man mit dem Web Browser eine Datei abspeichert?

Wenn nicht, würde ich Dir dringend raten, erst einmal die Bedienung 
deines Computers zu erlernen, bevor du selber Computer programmierst.

[Wortweg (Gast)]

Eugen T. schrieb:
> aber mein Sohn braucht es für Arduino, deswegen kämpfe ich
> damit.

Jetzt fehlen mir die Worte.

[Franz M. (elmo64)]

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.

[Joachim B. (jar)]

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.

[Eugen T. (weaver)]

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.

[Stefan F. (Gast)]

Du hast dich immer noch nicht an die Anleitung gehalten. Ich geb's auf - 
es hat keinen Sinn.

[Cyblord -. (cyblord)]

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.

[Eugen T. (weaver)]

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!

[Franz M. (elmo64)]

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.

[Eugen T. (weaver)]

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.

[Eugen T. (weaver)]

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.

[Wolfgang (Gast)]

Eugen T. schrieb:
> 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.

Wenn du dir einen Gefallen tun willst, lässt du die ganzen 
PCF8574-Library erstmal links liegen und verwendest nur die Wire 
Bibliothek. Anhand der mitgelieferten Beispiele und des Datenblattes vom 
PCF8574 kannst du die paar Registerzugriffe einfacher direkt schreiben.

[Franz M. (elmo64)]

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.

[Stefan F. (Gast)]

Vielleicht kommt dein Sohn damit besser zurecht, als du. So sollte das 
jedenfalls sein.

[Joachim B. (jar)]

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.

[Peter D. (peda)]

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.