Hallo,
mir ist noch was eingefallen:

PCA9555
16x I/O

Gruß Reinhard

Hallo,

ich bin vor kurzem auf den I2C Switch PCA9546 gestossen.
Da Du ja bei 3 variablen Adress-Bits nur 8 I2C-Chips mit derselben Grundadresse ansprechen kannst, könnte dieser Chip die Lösung für noch mehr I2C Chips sein.

So, wie ich die Beschreibung verstanden habe, kann man damit die Arduino I2C Leitung in 4 I2C Leitungen aufsplitten und diese sogar gezielt ab/anschalten.

Dann kann man also jeweils eine Leitung á 8 Chips öffnen und die anderen 3 schliessen.
Damit sollten 4x8 Chips x 8 Ausgänge funktionieren.

Da der Switch auch 2 Adressbits hat, kannst Du sogar 4x4x8 Chips ansprechen.....
oder wenn Du an einen Switch einen anderen Switch hängst, der wiederum an einem anderen Switch hängt..... 

Gruß Reinhard

PS.: Da mein Gedankenmodell nur theoretischer Natur ist, wäre ein Praxisbericht mit einem I2C-Switch super!

Hallo,

ich möchte für das Touch-LCD MIO283QT-2 von Watterott eine eigene Ergänzungs-Library schreiben.
Damit meine ich, die originale Lib "lcd" und meine eigene Lib "mylcd" (die die Funktionen der ersten verwendet) werden gleichzeitig verwendet.

Der erste Ansatz hat zwar funktioniert, aber sobald ich mehrere Funktionen mische, kommt es zu folgendem Effekt:

Absicht:
1. "lcd"      Der LCD wird Orange ausgemalt
2. "mylcd"  Der komplette LCD wird mit Rot überschrieben
3. "lcd"      Es wird eine weiße Linie gezogen
4. "mylcd"  Es wird eine schwarze Linie gezogen
5. "mylcd"  Der komplette LCD wird mit Gelb überschrieben
6. "mylcd"  Der komplette LCD wird mit Blau überschrieben

Effekt:
1. ok
2. ok
3. ok
4. passiert nichts
5. die weiße Linie wird gelb ausgemalt
6. die Linie wird nun blau ausgemalt
1. wieder ok
2. ......

Test_eigene_Lib

Code:

#include <MI0283QT2.h>
#include <ADS7846.h>
#include <Wire.h>
#include <LcdT.h>

MI0283QT2 lcd;
ADS7846 tp;
LcdT mylcd;

void setup()
{
  lcd.init(4);
  tp.init();
  Wire.begin();
  lcd.led(60);
}

void loop()
{
  lcd.clear(RGB(255,127,0));                    // Orange
  delay(1000);
  mylcd.clear(2);                               // Rot
  lcd.drawLine(0,20,100,20, RGB(255,255,255));  // Weiß
  delay(1000);
  mylcd.Strich(0,20,100,20,0);                  // Schwarz
  mylcd.clear(4);                               // Gelb
  mylcd.clear(6);                               // Blau
}

LcdT.h

Code:

#ifndef LcdT_h
#define LcdT_h
 
#include "WConstants.h"
#include "MI0283QT2.h"

class LcdT
{
  private:
    MI0283QT2 lcd;
       
  public:
    LcdT();
    void clear( byte Nr);
    void Strich( unsigned int X1, unsigned int Y1, unsigned int X2, unsigned int Y2, byte Nr);
};

#endif

LcdT.cpp

Code:

#include "WProgram.h"
#include "LcdT.h"
#include "MI0283QT2.h"




byte Farben[][3] = { {   0,   0,   0 },   //  0 Schwarz
                     { 255, 255, 255 },   //  1 Weiß

                     { 255,   0,   0 },   //  2 Rot
                     { 255, 127,   0 },   //  3 Orange
                     { 255, 255,   0 },   //  4 Gelb
                     {   0, 255,   0 },   //  5 Grün
                     {   0,   0, 255 },   //  6 Blau
                     { 255,   0, 255 },   //  7 Violett

                     {   0, 255, 255 },   //  8 Türkis
                     { 100, 100, 255 },   //  9 Blau2
                     {   0, 204,   0 },   // 10 Grün2
 };


LcdT::LcdT()
{return;}


void LcdT::clear(byte Nr)
{
  lcd.clear(RGB(Farben[Nr][0],Farben[Nr][1],Farben[Nr][2]));
  delay(1000);
}

void LcdT::Strich( unsigned int X1, unsigned int Y1, unsigned int X2, unsigned int Y2, byte Nr)
{
  lcd.drawLine( X1, Y1, X2, Y2, RGB(Farben[Nr][0],Farben[Nr][1],Farben[Nr][2]));
  delay(1000);
}
 

Was mache ich falsch?

Danke im Voraus für Eure Hilfe!
Gruß Reinhard
PS.: Das ganze läuft auf einem Arduino Mega 2560 direkt mit dem Display verkabelt.

Hallo
@Uwe
Mein Ansatz ist nicht eine Stromversorgung des Sensors direkt über einen Ausgang, sondern über einen I2C Chip mit einem integrierten Optokoppler (giebts so was überhaupt?) direkt oder über einen I2C-Chip + Optokoppler die +5V (von der Arduino +5V-Schiene) zum Sensor zu leiten und auch den Sensorausgang mithilfe diesem Chip/+Opto auf einen Arduino-Eingang zu legen.
Ein Sensor wäre zum Beispiel das Mikrofon-Shield von Sparkfun.

mfg Reinhard

Hallo,
da das Ganze ja eh mit I2C funktioniert...

Es gibt ja I/O-Chips die über I2C gesteuert werden.
(vielleicht ein PCA 9555. Hab ich irgendwo im Forum gelesen. Würde so einer funktionieren ? )

Vielleicht kennt ja jemand ICs, mit denen man mehrere Sensoren abwechselnd auf einen Eingang legen kann!
- GND immer verbunden
- VCC wird an den jeweiligen Sensor durchgeschaltet
- Entsprechender Sensor-Out wird auf den Analog-Pin des Arduino gelegt

Gruß Reinhard

Hallo,

ich glaube, es fehlt noch

Code:

#include<EEPROM.h>

am Anfang.

Gruß Reinhard

Hallo,
vielleicht ein verrückter Ansatz, aber könnte ja funktionieren:

Die 5V + erhält der Arduino über einen Optokoppler, der über einen Out-Pin desselben Arduino angesteuert wird.
Output 5V bedeutet, der Optokoppler schaltet durch und der Arduino hat Strom.
Wird der Output auf 0V gelegt, schließt der Optokoppler und der Arduino ist ohne Strom.

Zum Starten wird der Opto mit einem Taster überbrückt, sodaß der Arduino booten kann und sofort den Optokoppler schaltet, sodaß die Stromversorgung aufrecht erhalten bleibt.

Den Vorteil dieser Idee sehe ich darin, daß der Arduino ausgeschaltet total ohne Strom ist.

Anbei eine Skizze, wie ich´s mir vorstelle.

Hallo,

warum extra abschalten, wenn eh "kurze Zeit später die Versorgungsspannung ausgeht"?
Erledigt sich da das Problem nicht von selbst?

Gruß Reinhard

Hallo,
Teste mal, ob die I2C Verbindung überhaupt funktioniert:
Die I2C-Adresse der DS1307 sollte 0x68 sein

Folgende Funktionen zum direkten beschreiben/auslesen der Speicherzellen.

Code:

#define DS1307           0x68  //I2C Adresse

byte read_I2C_Byte ( int I2C_Adresse, byte Daten_Adresse)
{
  Wire.beginTransmission(I2C_Adresse);
  Wire.send(Daten_Adresse);
  Wire.endTransmission();
  Wire.requestFrom(I2C_Adresse,1);
  return (Wire.receive());
}

void write_I2C_Byte ( byte I2C_Adresse, byte Daten_Adresse, byte Daten )
{
  Wire.beginTransmission (I2C_Adresse);
  Wire.send (Daten_Adresse);
  Wire.send (Daten);
  Wire.endTransmission();

Zugriffsbeispiel:

Code:

Byte Daten_Adresse = 15; // RTC benutzt Byte 0-7
byte Wert = 145;            // irgendein Wert zum testen
write_I2C_Byte            ( DS1307, Daten_Adresse    , Wert    );
byte gelesenesByte = read_I2C_Byte ( DS1307, Daten_Adresse);

Dann kannst Du ja "gelesenesByte" mit print zur Überprüfung ausgeben lassen...

Gruß Reinhard

Hallo,

hast Du
   Wire.begin();
in die
   void setup()
geschrieben?

Die richtige I2C-Adresse gesetzt?

Gruß Reinhard

Hallo,

ist zwar unter diesem Threat-Titel widersinnig (sorry), paßt aber zu Plotter & Co!
Gibt es nicht vielleicht ätzresistente Schreibstifte, die man zum Herstellen der Schutzschicht im Plotter verwenden könnte?
Oder Permanent-Stifte, mit denen man eine Belichtungs-Schutzschicht aufbringt?

Gruß Reinhard

Hallo Jan,
ich hab zwar noch nicht diese Funktion ausprobiert, sollte aber funktionieren .
Gruß Reinhard

Hallo Jan,

ich bin zwar nicht der Arduino Ober-Checker, aber ich probiers mal (falls es jemand besser weiß, bitte korrigieren) 

dir ist als Interger (16 Bit) definiert und kann deshalb mittels 2 Bytes (a 8 Bit) dargestellt werden.
Davon bilden die ersten 8 Bits das "high byte" und die zweiten 8 Bit das "low byte".
Bei I2C werden nun die 2 Byte separat als einzelne Byte gesendet; in diesem Fall eben zuerst das "low byte" und dann das "high byte".
Um nun die 2 separat herauszufiltern, wir die die 2 Bytes mittels "0xFF & " und "dir >>8" aus der integer Zahl "dir" herausgefiltert.
siehe:
http://www.arduino.cc/playground/Code/BitMath

Gruß Reinhard

Einfach 3mm Stahlstange (Meterware) kaufen und passend abschneiden.

Gruß Reinhard

Plan A: Die Türen selbst bewegen sich unten und oben in einer Führungsschiene, wodurch sie sich nur seitlich bewegen können, durch die 2 Kraftansatzpunkte aber nicht verkanten. (Soweit ich eine Lifttür vor Augen habe, wird dies auch in der Praxis so angewandt)

Plan B: An den "Zapfen" jeweils eine weitere Führungsschiene (siehe Skizze). Dann könnten die Türen sogar frei hängen.

Gruß Reinhard