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.
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?
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.
:
Bearbeitet durch User
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/
:
Bearbeitet durch User
Vielen Dank. Ich versuche es mit dem PCF. Blöderweise alle haben die selben Adressenbereich...
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.
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.
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. 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/
:
Bearbeitet durch User
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.
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
:
Bearbeitet durch User
Damit habe ich angefangen, aber davon braucht man auch 16 Stück! :-) und dazu noch wenigstens 1 16Bit Expander.
:
Bearbeitet durch User
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.
Ich würde auch eine Reihe Schieberegister nehmen, weil sie einfach und billig sind. Mein Favorit ist der 74HC165.
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.
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.
Ein 16 Bit PCF auf fertiger Platine kostet etwa 2,5 € - ich glaube bei diesem Preis muss man nicht sehr viel spekulieren.
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
Das werde ich noch überlegen, vielleicht komme ich aus mit 128 Ports. Danke für euere Hilfe und Ideen.
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
Ich habe auch daran gedacht, Dazu muss ich aber Platine mavhen lassen usw. Ich werde sehen was ist einfacher. Danke
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. 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!
:
Bearbeitet durch User
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?
Cyblord -. schrieb: > 8 Schieberegister sind wahrscheinlich nicht fancy genug? Nee, die haben kein Bluetooth.
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
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.
:
Bearbeitet durch User
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.
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.
:
Bearbeitet durch User
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.
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.
:
Bearbeitet durch User
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.
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.
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.
:
Bearbeitet durch User
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?
Mit vollständigen Fehlermeldungen können potentielle Helfer mehr anfangen. Möchtest du, dass man Dir hilft?
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.
Eugen T. schrieb: > Die Fehlermeldung ist: PCF8574' does not name a type. Da fehlt
1 | #include "PCF8574.h" |
Ev. auch noch init, begin oder so was. Wenn du eines der Beispiele ausprobierst tuts du dir leichter. leo
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.
Eugen T. schrieb: > 'Class pCF8574' has no member named 'read8' Vielleicht liest du ja mal die Doku der uns unbekannten Library. leo
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.
:
Bearbeitet durch User
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.
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.
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.
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!
> 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.
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!
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..
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
Joachim B. schrieb: > Einen PCF8574 aus Arduino anzusteuern braucht nicht mal eine LIB Du glaubst wirklich, dass dein Code einem Ahnungslosen helfen kann? leo
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 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.
Eugen T. schrieb: > aber mein Sohn braucht es für Arduino, deswegen kämpfe ich > damit. Jetzt fehlen mir die Worte.
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.
:
Bearbeitet durch User
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.
Du hast dich immer noch nicht an die Anleitung gehalten. Ich geb's auf - es hat keinen Sinn.
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.
:
Bearbeitet durch User
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: > 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.
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.
:
Bearbeitet durch User
Vielleicht kommt dein Sohn damit besser zurecht, als du. So sollte das jedenfalls sein.
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.
:
Bearbeitet durch User
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.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.