Feb 28

Lange nichts mehr aus der Welt der Elektronik hier gepostet. Also dann mal 🙂

Es gibt seit 2-3 Jahren 5050-LED-Stripes (oder auch einzelne LEDs) mit aufgelötetem Controller (in SMD). zB diese hier. Das Coole an den Dingern ist, dass die ĂŒber 3 AnschlĂŒsse verfĂŒgen (+5V/GND Data-In, bzw. Data-Out) und man mit diesen 3 AnschlĂŒssen zig StĂŒck aufmal ansteuern kann. Technisch funktioniert die Schnittstelle so, dass man auf den D-In-Port des Strips ein 800kHz-Signal gibt, mit dem man dann jeder LED einzelnd den R/G/B-Wert mitgeben kann. Lauflichter, Uhren, alles was sich blinkt und bewegt sind damit also kein Problem. In der Community gibt es zig Libraries, die das Leben mit dem Ding etwas einfacher gestaltet. Hervorheben möchte ich die FastLED-Lib. Die ist zwar relativ gross (Ein Arduino/ATMEL mit min. 16kB Flash sollte es schon sein), man hat dafĂŒr aber an nahezu alles gedacht.

Im Code werden die LEDs per Array angesteuert. Das ist quasi ein Array of Arrays (untendrunter liegen noch jeweils 3 Elemente fĂŒr RGB).

Jetzt hat der Arduino/ATMel als solches ein kleines Problem mit der Genauigkeit der internen Uhr. Um das zu umschiffen, gibt es RTC’s die per SPI ansteuerbar sind. 5er Pack am Fluss fĂŒr ca. 10 Euro. Die Dinger sind deartig PrĂ€zise, dass ich – nach jetzt 1,5Monaten keinerlei (sichtbare) Abweichung feststellen kann. Zum Vergleich: Ohne RTC lief der Arduino nach etwa 24h um 30sek. falsch. Klar kann man versuchen den mC mit ein paar Tricks (bspw. dem OSCCAL) zu eichen. Aber sobald sich die Umgebungstemperatur Ă€ndert, war es das auch wieder.

Nun, was kommt raus? Kombiniert man, die bei Adafruit erhÀltlichen, 2812-Viertelkreise mit einem Arduino Pro micro, IKEA-Bilderrahmen, ein wenig Handarbeit und einem externen(!) 5V-Netzteil (die LEDs saugen da etwas) eine nette Uhr:


Den entsprechenden Code (schmutzig, as usual 🙂 ) hab ich mal bei  github abgelegt.

Tagged with:
Apr 01

Ein wenig herumgespielt mit dem Arduino habe ich ja schon bei dem Rauchmelder und dem BetaBrite-Display. Nicht gebloggt wurde bisher ĂŒber die Funksteckdosen, die derweil per Webserver an- und ausgeschaltet werden können (Dank dieser Library).

Das mĂŒsste doch ansich auch mit dem Garagentoröffner funktionieren. Der tut doch auch auf 433,92MhZ. Letztes Jahr hatte ich mir bei Watterod einen 433er Sender und einen EmpfĂ€nger, der bisher noch nicht zum Einsatz kam, geordert. Den EmpfĂ€nger also fix mal startklar gemacht und an den Arduino angeflanscht. Allerdings ist das auslesen eines Senders, bei dem man keinen Schimmer hat welche Codierung genutzt wird, alles andere als trivial. Habe es dann ersteinmal mit der 433MhZ-Wetterstation von Tchibo probiert. Nach diversen Bitfriemeleien purzelte da dann auch tatsĂ€chlich die Temperatur heraus. Nungut – wir wollen ja einen Garagentoröffner simulieren, nicht Funkthemometer auslesen.

Aus dem ollen Code bin ich allerdings nicht schlau geworden. Hier mal ein oszillografierter Ausschnitt (due to security reasons 🙂 ) des Senders:

Man erkennt insgesamt 3 Arten von Pulsen – kurze, lange und mittlere (WTF ?). Habe erst auf einen Manchester-Code getippt. War mir dann aber irgendwie zu doof den zu analysieren. Also fix mit gtkwave die PulslĂ€ngen in ein Array gepackt, und fertig ist der Garagentoröffner per Arduino. Hier der (Draft !) des Sourcecodes mit dem PulslĂ€ngenarray (Negativ = LOW, Positiv = HIGH):

int garage[45]={  // Block 1 (21 x das gepulse)
               -16382,-16382, // Blocktrenner (2)
               // Block 2 (22 x das gepulse)
};


void setup() {
  pinMode(8,OUTPUT);
  pinMode(13,OUTPUT);
  digitalWrite(8,LOW);
}

void loop() {
  fire(garage,0);          // Garage Toggeln
  digitalWrite(8,LOW);
  digitalWrite(13,HIGH);
  delay(10000);
  digitalWrite(13,LOW);
}

void fire(int what[],int corr) {  // what: PositiverWert: Dauer des HIGHPulses, NegativerWert: Dauer des LowPulses; corr = Korrekturzeit pro Puls
    for (int i=0;i<26;i++) {
      int del=what[i]+corr;
      if (del>0) {
        digitalWrite(8,HIGH);
        delayMicroseconds(del);
      } else {
        del=del*(-1);
        digitalWrite(8,LOW);
        delayMicroseconds(del);
    }
  }
}
									

Fazit: Funktioniert perfekt. Wenn allerdings jemand ‘ne Ahnung hat welches Protokoll (bzw. Leitungscode) das sein könnte – immer her damit 🙂

Update 22.08.2012 – Hier, auf Nachfrage, der Sourcecode fĂŒr den Wetterstationsempfang. Das Ding ist echt nur ein “Proof of concept” – also alles andere als schön. Vom Aufbau her:

  • 433MhZ-EmpfĂ€nger Serial-Out hĂ€ngt an PIN2

-----------------------------------------------------------------------------
/*
  Liest dieses komische Tchibo-Wetterdingens per 433MhZ aus.
*/

boolean cnt=false;
int reader=0;
int cnter=0;
char reading[28];
void setup() {
  Serial.begin(9600);
  Serial.println("go!");
  pinMode(2, INPUT);
 // pinMode(13,OUTPUT);
}

void loop() {
    int LowVal=pulseIn(2,LOW);
    if (LowVal < 11000) {  // Kuezer als 1100ms Low ? Koennte unserer Sensor sein
      if (decodeTime(LowVal) == 'S') {  // Startsequenz ?
        cnt=true;                       // Dann go fuer die Sammlung
        cnter=0;                        // BitCounter auf 0
      }
      if ( (cnter<=27) && cnt && ((decodeTime(LowVal) == '0') || (decodeTime(LowVal)=='1'))) { // Stream noch nicht voll und ein Bit erkannt ?
//       Serial.print(decodeTime(LowVal)); 
       reading[cnter]=decodeTime(LowVal);  // Ab ins Array damit
       cnter=cnter+1;                      // Arraycounter fuers naechste Bit inkrementieren
      }
    } else {
      cnt=false;                           // Zurueck auf Anfang - nix fuer uns.
    }

      if ((cnter==28)) {                   // Arrray Voll ?
        Serial.print('/');
        Serial.print(reading);
        Serial.print('/');
        Serial.println(decodeTemp(reading));
        cnter=0;
        cnt=false; 
      }
  
}

float decodeTemp(String bitstream) {  // Versucht aus dem Bitstrom die Temp. zu berechnen
  int x=0;
  int chk=0;
  for (int i=16;i<24;i++) {      // Extrahiert das Byte zwischen Bit 16 und 24 und packt es als integer in "x"
    if (bitstream[i] == '1') {
      bitSet(x,(23-i));
    }
  }
  for (int i=4;i<15;i++) {      // Kenner aus den 3 Nibbles zwischen Bit 4 und 15 holen (koennte auch der Kanal sein ?)
    if (bitstream[i] == '1') {
      bitSet(chk,(14-i));
    }
  }
  if (chk != 136) {            // Kenner = 136 ? Dann ist es unserer Sensor !
    return(-999);              // Wenn nicht, dann -999 zurueck
  } else {
    return ((float)x/10);
  }
}

char decodeTime(int time){  // Wandelt die Pulse in Bits um.
  if (time > 1500 && time < 11000) { // passendes Signal (zwischen 150ms und 11000ms) ?
        if (time < 2500) {           // kleiner 250ms ? Dann LOW
          return '0';
        } 
        if (time < 5000 && time >3000) {  // Zwischen 500ms und 1000ms dann HIGH
          return '1';
        }
        if (time >8000) {                // Groesser 800ms dann Startsequenz !
          return 'S';
        }
  } else {
    return 'X';
  }  
}
									

Tagged with:
Dez 10


Seit geraumer Zeit sind Rauchmelder in Neubauten ja Pflicht. Macht ja auch durchaus Sinn. Gerade wenn man an solche USV-Aktionen denkt 🙂 Also muss ein Rauchmelder her. Der Otto-Normal-Nerd möchte aber mindestens irgendwas haben, was sich auch in die Standardhaustechnik integrieren lĂ€sst – am besten noch ein Set von mehreren Rauchmeldern. Da gibts es zig Varianten:

  1. Die Billigrauchmelder (um die 5-10 Euro)
  2. Die Billgrauchmelder die per 433MhZ miteinander sprechen (ab 60 Euro im Set mit 4 StĂŒck)
  3. Die teueren Systemrauchmelder die nichts anderes als (2) machen, nur das G*ra oder sonstwas draufsteht.
  4. Die sĂŒndhaft teueren Rauchmelder mit eingebauten GSM-Modul (ab ca. 150 Euro aufwĂ€rts…)

Gelinde gesagt: Alles doof – da es entweder meinen AnsprĂŒchen nicht genĂŒgt, oder massivst zu teuer ist.

Nun denn erstmal Dinge sichten – also ab zum Baumarkt und mal einen Rauchmelder der Kategorie “1” gekauft. Schimpft sich RM120 und hat schlappe 8,- gekostet. Laut ist das Ding ja, wenn man Zigarettenrauch reinblĂ€st, oder mal den Testknopf drĂŒckt – bringt nur nix, wenn niemand zu hause ist 🙁 Nach dem öffnen des GerĂ€ts, schaut einen ein wenig SMD-Technik (Oha) an, darunter ein IC mit der Aufschrift “CS2105go“. Wie sollte es anders sein, dazu gibts leider kein Datenblatt. Aber Moment, vielleicht ist der CS2105GO-M12 ja Pinkompatibel mit dem MC145010 – Bingo, ist er ! Der MC145010 (manchmal auch MC145012) wird in fast allen Rauchmeldern der Kategorie 1 und 2 (teilweise auch 3) verkauft.

Der aufmerksame Leser merkt was: Bei 2 ist doch eine Vernetzung möglich ! Korrekt, so ist es. Mit anderen Worten: In den Rauchmeldern der Kat.1 ist derselbe IC verbaut, wie in 2, nur das in 1 halt das 433MhZ Modul fehlt. Brauch ich (zumindest jetzt zum Testen) eh erstmal nicht –  doch dazu spĂ€ter. Der MC145010 verfĂŒgt ĂŒber einen sog. I/O Pin, der bei 2er Rauchmeldern dann das 433MhZ-Modul per TTL-High triggert, sobald es qualmt. Beim 1er liegt PIN7 (I/O) tot herum. Perfekt. Also fix den Ground (-) und PIN7 per Kabel rausgefĂŒhrt und an den Arduino geklemmt:

 

Links (Schwarz) die Masse – Also GND direkt mit dem GND des Arduino’s verbinden,

Recht (Rot), etwas fuckeliger, den PIN7 (I/O) des CS2105GO-M12 auf einen Analogen Input-PIN des Mikrocontrollers legen.

Auf dem Arduino selbst habe ich derzeit die gute Wohnzimmerinfo-Anzeige am laufen, da ist also schon ein “Ethernet-Shield” drauf. Da dort noch diverse Analoge Ports frei sind, und der Rauchmelder auch direkt deben dem Display wohnen soll, also optimal. Vom Code her gestaltet sich das ganze relativ simpel (siehe unten). Das allerfeinste ist jedoch, dass man nichtmal gegen irgendwelche Vorschriften verstösst, wenn man sich anstelle von Variante 1 fĂŒr einen Rauchmelder der Variante “2” entscheidet. Denn alle Rauchmelder bleiben so wie sie sind (sprich: Die piepen trotzdem). Nur einen, in dem 433MhZ-“Netz”, muss man dann an den Arduino anklemmen. Der verbaute Standalone-RM120 piept ĂŒbrigens auch noch – denn genau dafĂŒr ist PIN7 gedacht: I/O !


#include
#include

#define SmokePIN 0

int Smoke=0;
boolean mailsent=false;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192,168,0, 100 };

void setup () {
Ethernet.begin(mac,ip);
}

void loop() {
// Read Smokedetector
Smoke=analogRead(SmokePIN);

// GGf. RESET der Variable mailsent

if (Smoke > 900) {
if (mailsent==false) {
firemail();
mailsent=true;
}
}
}

void firemail() {
// IP des Mailservers
byte mserver[] = {192,168,0,101};
Client Mail(mserver,25);
if (Mail.connect()) {
Mail.println(“HELO arduino.domain.tld”); /* say hello (statement after helo is needed but irrelevant)*/
Mail.println(“MAIL From: et_brennt@domain.tld”); /* identify sender, this should be the same as the smtp server you are using */
Mail.println(“RCPT To: et_brennt@domain.tld”); /* identify recipient */
Mail.println(“DATA”);
Mail.println(“To: et_brennt@domain.tld”); /* identify recipient */
Mail.println(“Subject: Burning down the House”); /* insert subject */
Mail.println(“WARNING – Smoke detected !”); /* insert body */
Mail.println(“.”); /* end email */
Mail.println(“QUIT”); /* terminate connection */
Mail.println();
Mail.stop();
}
}

Tagged with:
Mrz 26

Sehr cool was mit dem Arduino so alles machbar ist. Um es vorweg zu nehmen: Mit dem Ding habe ich eine Ansteuerung eines BetaBrite LED-Moduls via Netzwerk gebaut (also im “Live-Betrieb” OHNE Rechner benutzbar).

Doch vorne angefangen:

Vor ein paar Jahren hatte ich mir bei eBay ein BetaBrite geschossen – Das ist so eine nette Laufschrift, die man zum Leute quĂ€len draussen an seinen Copyshop hĂ€ngen kann, so man(n) den einen hat. Die Idee war damals die Temperaturdaten meiner Wetterstation und ein paar andere Dinge anzeigen zu lassen. Ist aber nie so richtig umgesetzt worden, da mein “Serverpark” im Keller steht, und die Anzeige dort natĂŒrlich null Nutzwert hat. Vor ein paar Tagen bin ich dann auf das Arduino-Projekt gestossen – klang (und ist auch) alles sehr vielversprechend:

Eine simple Plattform incl. Entwicklungsumgebung fĂŒr die ATMEGA-Microcontroller Serie mit massenweise Zubehör. Wer das Ding nicht kennt, einfach mal bei arduino.cc umschauen. Bezugsquellen sind u.a. watterod, komputer.de oder auch farnell.com, sofern man (bei farnell) denn im Besitz eines Stundentenausweises ist (Die Spareffekte dort sind vernachlĂ€ssigbar). Der Knaller an dem Ding ist jedoch der Preis. So gibt es den Arduino fĂŒr ca. 20-28 Euronen incl. Versand zu haben. Der Microcontroller lĂ€sst sich ĂŒber die USB-Schnittstelle (sowohl auf Mac, PC oder Linux) in einer Art C-Dialekt fĂŒr Kids programmieren (Ist wirklich extremst Easy). Das ganze geht so in Richtung SPS – daher heisst der Dialekt wohl auch “Processing”. Man hat im Template quasi 2 vorgefertigte “Prozeduren”:

  • void setup – wird einmalig aufgerufen, wenn der ATMEGA hochgefahren wird und dient zum initialisieren der Ports, etc.
  • void loop – wird, wie der Name schon sagt, im Loop kontinuierlich durchlaufen – bei mir kamen da direkt Errinerungen an die Lehrzeit wieder hoch (SPS – Merker setzen und sowas)

Hardwaretechnisch verfĂŒgt das Ding ĂŒber 14 Digitale I/O Pins, von denen 6 per PWM ansteuerbar sind (alles TTL-Pegel), sowie 6 Analoge ein/AusgĂ€nge mit einer 8bittigen genauigkeit im A/D bzw. D/A Wandler. SĂ€mtliche AnschlĂŒsse sind auch fĂŒr Wurstfinger, wie meine, leicht verfĂŒgbar, sodass Löten – wenn man es denn nicht gerade drauf anlegt – ausfĂ€llt.

ZurĂŒck zum Titel dieses Eintrags. ZusĂ€tzlich zum Board habe ich mir noch eine Ethernet-Shield gegönnt. Shields sind sowieso die Erfindung hier uberhaupt. Man kann sich das als “Huckepack”-Platine vorstellen, die bestimmte Pins des Arduinos belegen und dann weiter FunktionalitĂ€ten bereitstellen. Das eth-Shield stellt also einen Netzanschluss zur VerfĂŒgung, und genehmigt sich dafĂŒr 6 Pins. (Eine gute ĂŒbersicht ĂŒber den “Pinverbrauch” und verfĂŒgbare Shields gibts ĂŒbrigens bei shieldlist.org). Das Shield selbst lĂ€sst sich dann im “Processing” ĂŒber ein paar Simple Funktionen ansteuern / auslesen.

Problematisch beim BetaBrite war, dass dieses ĂŒber eine RS232 (vulgo: Serielle) Schnittstelle verfĂŒgt, der Arduino aber nur TTL-Pegel verarbeiten kann. Es gibt fĂŒr den Ard. eine Serial-Library, mit der man aus zwei weiteren Pins einen Seriellen Anschluss “emulieren” kann, aber ohne korrekte RS232-Pegel ist das suboptimal. Was tun ? Mal ein wenig gekramt, und dann ist mir ein MAX232 zwischen die Finger gekommen – quasi genau das was man braucht. Die Schaltung mit dem MAX232 ist mehr als simpel (Einfach ausgedrĂŒckt konvertiert der 232 die Pegel). Somit steht das ganze HardwaremĂ€ssig schonmal. Ethernet-Shield -> Arduino -> MAX232 -> BetaBrite. Fehlt nur noch die “Software”. Die Ansteuerung der BetaBrites ist schnell im Netz gefunden (z.B. hier, bzw. als PDF direkt beim Hersteller). Der Code auf dem Arduino umfasst gerade mal 2kB (incl. inline-Dokumentation !!!). Falls interesse besteht, stell ich den gerne mal hier ein.

Was kann das ganze jetzt ?

Nun, Der Microcontroller mit Ethernetanschluss “horcht” auf TCP-Port 23. Immer wenn sich etwas connected und eine Zeile schreibt, dann gibt der Controller das an das Betabrite weiter. Serverseitig kann ich nun, aus dem Keller heraus :-), das BetaBrite ansteuern, wo immer auch Netz verfĂŒgbar ist…

Tagged with:
preload preload preload