AdSense

Montag, 9. Juni 2014

Helligkeitssensor BH1750FVI

(English version) Für mein "Home Automation"-Projekt habe ich auch eine Automatisierung des Rollladens geplant. Dabei soll der Rollladen geschlossen werden, wenn die Sonne ins Zimmer scheint um so ein Aufheizen des Zimmers zu verhindern. Um Sonneneinstrahlung zu erkennen verfolge ich im Moment zwei Ansätze: Erkennung über Helligkeit und Temperatur.

Zur Erkennung der Sonneneinstrahlung über die Helligkeit setze ich einen Helligkeitssensor vom Typ BH1750FVI ein. Dieser ist (wie so oft) für unter 2 Euro bei Ebay erhältlich.

Der Sensor misst die Helligkeit zwischen 0 und 65535 lx und schickt das Ergebnis der Messung über den I2C-Bus an den Mikrocontroller. Die Messung der Helligkeit kann kontinuierlich oder einmalig mit einer Auflösung von 0.5, 1 oder 4 lx erfolgen.

Die Ansteuerung des Sensors bzw. die Abfrage der Helligkeit über I2C funktioniert "von Hand" schon ziemlich einfach, noch komfortabler wird es jedoch mit dem Arduino unter Verwendung der passenden Library. Ich habe die Lib von Christopher Laws verwendet.

Der Sensor wird einfach über VCC und GND mit 5V verbunden, SDA und SCL werden an die entsprechenden Pins des Arduino, ATmega oder ATtiny angeschlossen.

Dann kann der Beispiel-Code der Library übertragen werden:
#include <Wire.h>
#include <BH1750.h>

BH1750 lightMeter;

void setup(){
  Serial.begin(9600);
  lightMeter.begin();
  Serial.println("Running...");
}


void loop() {
  uint16_t lux = lightMeter.readLightLevel();
  Serial.print("Light: ");
  Serial.print(lux);
  Serial.println(" lx");
  delay(1000);
} 
 
Der Code ist weitestgehend selbsterklärend. Im Setup wird der Sensor mit der begin()-Funktion initialisiert. Wenn gewünscht kann hier durch Übergabe eines entsprechenden Parameters der Mess-Modus (einmalig/kontinuierlich bzw. die Auflösung) eingestellt werden. Näheres dazu ist dem h-File der Library zu entnehmen. Der aktuelle Helligkeitswert in Lux kann dann über die Funktion readLightLevel() ausgelesen werden. Und das war es auch schon, mehr gibts dazu nicht zu sagen ;)

Mittwoch, 23. April 2014

Arduino - I2C Scanner

(English version) Ich habe schon öfters das Problem gehabt, dass ich ein cooles I2C-Gerät hatte, leider aber keine Ahnung hatte, welche Adresse es hatte. Das kann frustrierend sein, da die Adresse meistens als bekannt vorausgesetzt wird. Daher möchte ich heute ein simples Programm vorstellen, welches alle verfügbaren I2C-Geräte scannt.

Die Funktionsweise ist simpel: Ein Counter zählt von 0 hoch und versucht ein I2C-Gerät anzusprechen. Gelingt dies nicht, so fährt er mit der nächsten Adresse fort. Das sieht dann folgendermaßen aus:

for (int i = 0; i < 120; i++)
{
  Wire.beginTransmission(i);
  error = Wire.endTransmission();
  sprintf(buf, "scan %i - %i",i,error);
  lcd.setCursor(0,1);
  lcd.print(buf);
  if (error == 0)
  {
    //success!
    delay(1000);
  }
}

Statt dem lcd.print kann man auch jede beliebige andere Ausgabe benutzen. Sobald ein Gerät gefunden wurde, wird eine Sekunde gewartet, danach wird weiter gescannt.

Sonntag, 23. März 2014

Handy - Kameraabdeckung zerkratzt, Fotos unscharf

(English version) Mein Bruder besitzt ein HTC Desire Z. Seit einiger Zeit sind alle Fotos die er macht verschwommen. Ein Blick auf die Kameraabdeckung verrät auch warum: Die Mitte ist zerkratzt, nur der Rand sieht noch gut aus.
Leicht zerkratzte Kameraabdeckung, das Bild wurde durch eine polierte Kameraabdeckung aufgenommen.
Das Problem ist, dass auf der Abdeckung ein Anti-Reflex-Coating drauf ist. Das sorgt einerseits für schönere Bilder, sobald es jedoch zerkratzt ist bringt es nichts mehr.

Die Lösung für das Problem ist nun, das Coating komplett weg zu polieren. Dazu nimmt man einfach Zahnpaste und ein Wattestäbchen und rubbelt ca. 2 Minuten lang über das Glas. Anschließend sollte es dann so aussehen:
Polierte Kameraabdeckung, das Bild wurde durch eine nicht-polierte Kameraabdeckung aufgenommen.

Es gibt einen Qualitätsunterschied zwischen den beiden Bildern. Dennoch ist die Qualität nach dem Polieren deutlich besser als vor dem Polieren, wo alle Bilder unscharf waren.

Sonntag, 2. März 2014

Register Pointer - mit Arduino bestimmte Register über I2C ansprechen

(English Version) Bei manchen Anwedungen ist es erforderlich, dass man beim lesen und schreiben über den I2C-Bus ein ganz bestimmtes Register eines I2C-Slaves ausliest oder beschreibt, z.B. wenn man bei der Real Time Clock DS1307 nur die Stunden auslesen bzw. ändern möchte.

Dazu gibt es die sogenannten Register Pointer. Mit diesen Pointern "zeigt" man auf das Register, das man lesen oder beschreiben möchte.

Mit dem Arduino funktioniert das denkbar einfach: beim Schreibzugriff wird mit dem ersten über den write()-Befehl gesendeten Byte der Register Pointer gesetzt. Ein Beispiel anhand des DS1307 soll das verdeutlichen;
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(0x02); //Pointer auf Register 2 setzen
  Wire.write(decToBcd(hour)); //Wert für Stunden ins Register 2 schreiben 
  Wire.write(decToBcd(weekDay)); //Wert für Wochentag ins Register 3 schreiben    
  Wire.endTransmission();

Das erste geschriebene Byte nach dem Befehl beginTransmission() setzt hier den Pointer auf  das Register 2 (hier werden die Stunden gespeichert). Mit dem zweiten write()-Befehl wird dann der eigentlich Wert in dieses Register geschrieben. Dann wird automatisch ins nächste Register gesprungen. Der folgende write()-Befehl schreibt also ins Register 3 und so weiter.

Beim Auslesen von Daten aus einem bestimmten Register wird ähnlich vorgegangen:
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(0x02); //Pointer auf Register 2 setzen
  Wire.endTransmission();

  Wire.requestFrom(DS1307_ADDRESS, 7);//Datenabfrage ab Register 2 beginnen
  int hour = bcdToDec(Wire.read()); //Stunden aus Register 2 auslesen
  int weekDay = bcdToDec(Wire.read()); //Wochentag aus Register 3 auslesen
  
Auch hier wird zuerst der Pointer durch Senden einer 2 auf das Register 2 gesetzt. Dann können mit dem Befehl requestFrom() Daten angefordert werden. Der read()-Befehl liest daraufhin Daten aus dem Register 2 aus. Dann wird wieder automatisch zum nächsten Register gesprungen, so dass der nächste read()-Befehl das Register 3 ausliest und so weiter.

Montag, 17. Februar 2014

Ein kostenloses Programm um Schaltkreise zu zeichnen

(English version) An dieser Stelle will ich auf ein nützliches Programm hinweisen:
TinyCAD
Mit diesem Programm kann man auf extrem einfache Weise Schaltkreise zeichnen und als Bild exportieren, kein Account erstellen oder ähnliches ist nötig. Einarbeitungszeit benötigt es auch keine, alles funktioniert intuitiv.

LED-Band mit ATmega / Arduino ansteuern

(English version) In letzter Zeit erfreuen sich LED-Streifen erhöhter Beliebtheit. Inzwischen gibt es sogar schon für Preise unter 20 Euro LED-Streifen aus China bei Ebay. Normalerweise hat ein LED-Streifen ein Steuergerät, ein Netzteil und eine Fernbedienung. Für die meisten Menschen mag das reichen, wer aber mehr will (z.B. gezielt Sequenzen durchfahren) der muss ein (ganz kleines) bisschen Arbeit hineinstecken.

Zuerst zum Aufbau des LED-Streifens: Es gibt 4 Anschlüsse, einer für + 12 V und dann noch einen je Farbe, also rot, grün und blau. Der Streifen funktioniert nun so: Schließt man + 12 V an und legt dann an einen Farb-Kanal Masse, so leuchtet diese Farbe. Die Helligkeit pro Farbe wird normalerweise per PWM eingestellt. Um den Streifen komplett selber anzusteuern braucht man jetzt:
  • Einen Microcontroller (ATmega / Arduino).
  • 3 bipolare Transistoren (NPN), diese sollten einen ausreichend hohen Strom vertragen!
Die Schaltung sieht nun folgendermaßen aus: Vom Microcontroller aus werden 3 PWM-Signale auf die Basis der Transistoren gegeben (ein kleiner Vorwiderstand ist notwendig, ich benutze 470 Ohm). Der Emitter der Transistoren liegt auf Masse (gemeinsame Masse von 12 V Stromversorgung und Microcontroller), der Kollektor wird dem entsprechenden Farb-Kanal verbunden.


Vom Microcontroller wird der entsprechende Kanal folgendermaßen geschaltet:


analogWrite(8, 127);

Dieser Befehl würde nun den Transistor, welcher an Pin 8 angeschlossen ist auf 50% setzen (255 ist Maximum), sodass die daran angeschlossene Farbe mit 50% der Helligkeit leuchtet. Zu beachten ist, dass man natürlich nur PWM-Kanäle benutzen kann (Im Datenblatt sind PWM-Kanäle mit OCR gekennzeichnet).

Um nun beliebige Farben zu mischen geht man folgendermaßen vor:
Man sucht sich eine Farbe im RGB-Raum aus, z.B. orange: diese ist R: 255, G: 255, B:0. Genau das lässt man nun den Microcontroller machen:


analogWrite(RED_PIN, 255);
analogWrite(GREEN_PIN, 255);
analogWrite(BLUE_PIN, 0);  

Es kann vorkommen dass verschiedene Farben unterschiedlich hell sind, das müsste man ausprobieren und dann z.B. für grün 127 als obere Grenze festlegen (grün wird vom Auge sehr stark wahrgenommen, daher wird es vermutlich zu hell erscheinen).

Sonntag, 16. Februar 2014

"Home Automation" mit dem Arduino und 433 MHz - Die komplette Fernsteuerung

(English version) Seit meinem letzten Beitrag zu diesem Thema sind ja nun einige Monate vergangen. Aber nun habe ich es endlich mal geschafft, die Steuerung für die Steckdose und den Rolladen in ein Programm zu bringen und vorallem das ganze vom Steckbrett auf eine Platine zu übertragen.

Hardware

Die Hardware ist recht unspektakulär:

Im Prinzip besteht die Fernbedinung nur aus einem Attiny44A, einem Pullup-Widerstand für den Reset-Eingang, drei Knöpfen (hoch, runter, stopp), einem Halter für eine CR3032-Knopfzelle und natürlich dem 433MHz-Sender. Die drei Knöpfe sind jeweils mit einem Eingang des Attiny verbunden und ziehen den Eingang bei Betätigung auf Ground

Software

Die einzelnen Funktionen der Software wurden bereits in den vorhergehenden Posts zum Thema erläutert. Außerdem ist der Code (für meine Verhältnisse) gut kommentiert. Ich werde daher nicht auf den kompletten Code eingehen.

#include <RCSwitch.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

RCSwitch mySwitch = RCSwitch();
unsigned char buttonDown = 10;
unsigned char buttonStopp = 9;
unsigned char buttonUp = 7;
unsigned char buttonPressed = 0;

char stopRequest = 0;

void setup() {
  //Interrupts global deaktivieren
  cli();

  //Pins initialisieren
  pinMode(buttonDown, INPUT_PULLUP);
  pinMode(buttonStopp, INPUT_PULLUP);
  pinMode(buttonUp, INPUT_PULLUP);

  //Funkmodul intialisieren und Steckdose ausschalten
  mySwitch.enableTransmit(0);  //Sender hängt an Pin 0
  mySwitch.setProtocol(1);
  mySwitch.switchOff("11011", "10000");

  //Energie sparen
  ADCSRA &= ~(1<<ADEN); //Deaktiviere ADC
  ACSR = (1<<ACD); //Deaktiviere Analog Comparator

  //Pin-Change-Interrupt intialisieren
  PCMSK1 |= (1<<PCINT8); //Pin-Change-Interrupt an Pin 2 (Arduino Pin  10)
  PCMSK1 |= (1<<PCINT9); //Pin-Change-Interrupt an Pin 3 (Arduino Pin 9)
  PCMSK0 |= (1<<PCINT7); //Pin-Change-Interrupt an Pin 6 (Arduino Pin 7)
 
  //Power-Down-Modus vorbereiten
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);

  //Interrupts global aktivieren
  sei();
}
void loop() {
  sendCommand();
  powerDown();
} 

void sendCommand() {
  if (buttonPressed == buttonDown) {
    mySwitch.switchOn("11011", "10000");
    delay(750);
    sendCommandDown();
    powerDown(25);
    mySwitch.switchOff("11011", "10000");
    buttonPressed = 0;
  }

  else if (buttonPressed == buttonUp) {
    mySwitch.switchOn("11011", "10000");
    delay(750);
    sendCommandUp();
    powerDown(25);
    mySwitch.switchOff("11011", "10000");
    buttonPressed = 0;
  }
}

//Befehl Rolladen rauf
void sendCommandUp() {
  mySwitch.setProtocol(4);
  mySwitch.sendQuadState("0F0F0100QQ0F100F0F0F");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0F1Q");
  mySwitch.setProtocol(1);
}

//Befehl Rolladen stopp
void sendCommandStopp() {
  mySwitch.setProtocol(4);
  mySwitch.sendQuadState("0F0F0100QQ0F100FFFFF");
  mySwitch.setProtocol(1);
}

//Befehl Rolladen runter
void sendCommandDown() {
  mySwitch.setProtocol(4);
  mySwitch.sendQuadState("0F0F0100QQ0F100F0101");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0110");
  mySwitch.setProtocol(1);
}

//lässt Attiny für time Sekunden warten
void powerDown(char time) {
  GIMSK |= (1<<PCIE1); //Pin-Change-Interrupt aktivieren
  GIMSK |= (1<<PCIE0);
  
  stopRequest = 0;

  for (char i = 1; i<= time*1000; i++) {
    if (stopRequest == 0) {
      delay(1);
    }
  }

  GIMSK &= ~(1<<PCIE1); //Pin-Change-Interrupt deaktivieren
  GIMSK &= ~(1<<PCIE0);
}

//setzt Attiny solange in Powerdown-Modus, bis Pin-Change-Interrupt ausgelöst wurde
void powerDown() {
  GIMSK |= (1<<PCIE1); //Pin-Change-Interrupt aktivieren
  GIMSK |= (1<<PCIE0);
  sleep_mode();  //Schlafen gehen
  //hier gehts weiter nach aufwachen
  GIMSK &= ~(1<<PCIE1); //Pin-Change-Interrupt deaktivieren
  GIMSK &= ~(1<<PCIE0);
}

void checkButton() {
  if (digitalRead(buttonDown) == LOW) {
    buttonPressed = buttonDown;
  }

  else if (digitalRead(buttonStopp) == LOW) {
    stopRequest = 1;
    mySwitch.switchOff("11011", "10000");
  }

  else if (digitalRead(buttonUp) == LOW) {
    buttonPressed = buttonUp;
  }
}

//ISR für PCINT1 und PCINT0 (Pin-Change-Interrupts)
ISR(PCINT1_vect)
{
  checkButton();
} 
ISR(PCINT0_vect)
{
  checkButton();
} 

Einige Details der Software möchte ich dennoch erläutern. Die Spannungsversorgung der Fernbedienung erfolgt über eine CR2032-Knopfzelle. Da diese so lange wie möglich halten soll und die Fernbedienung 99,999% der Zeit sowieso nur rum liegt und nichts tut, geht der Attiny bei Inaktivität mit der Funktion powerdown() in den Schlaf-Modus. Er schläft so lange, bis er durch einen Tastendruck (Pin Change Interrupt) wieder geweckt wird. Um im Schlaf-Modus so wenig Energie wie möglich zu verbrauchen, wird zu Beginn zusätzlich der AD-Wandler sowie der Analog Comparator abgeschaltet. Dadurch sinkt der Ruhestrom auf wenige µA.