Eine intelligente Lampe für die "Reichen" mit ihren "faulen" Händen. Sie ist "einfach" und praktisch



Einführung


Er machte eine „moderne“ Beleuchtung in der Küche für ein Waschbecken, einen Herd und einen Schneidetisch auf der Grundlage eines LED-Streifens unter der Kontrolle von Arduino (nennen wir es Lampe 1). Dieses Design hat 2 Jahre lang funktioniert, bis sich der Leistungsteil des "Gehirns" verschlechtert hat. Dies ist eine hervorragende Gelegenheit, das Rad aus dem „improvisierten Müll“ wieder neu zu erfinden (Lampe 2). Diesmal ist der "Müll" zwar teuer und mit dem Z-Wave-Smart-Home kompatibel. Das Folgende ist eine Geschichte über das Ersetzen von Arduino durch ZUNo (ein Arduino-kompatibles Modul zum Erstellen eines Z-Wave-Geräts) mit maximaler Codespeicherung und einer Erläuterung der erforderlichen Änderungen.

Was ist passiert, bevor ich dort aufgetaucht bin?


Es war einmal, um Geschirr zu spülen oder Essen zu kochen, musste die Lampe über dem Waschbecken eingeschaltet werden. Es war eine überarbeitete Tischlampe.

Ich wollte den kleinen Schalter nicht mit nassen Händen drücken, weil er 220 Volt an die Glühlampe schaltete.



Auch das Licht der Lampe fiel hauptsächlich auf das Waschbecken, aber ich wollte den Kochtisch und den Herd besser beleuchten.

Ziele:

  • Machen Sie das Ein / Aus-Licht in der Küche berührungslos;
  • Beleuchten Sie das Waschbecken, den Kochtisch und den Herd gleichmäßig.
  • Sparen Sie Energie, indem Sie Glühlampen durch LEDs ersetzen.

Er baute die Lampe 1 zusammen. Sie bestand aus einer 2 Meter langen Aluminiumbox mit einem Diffusor für RGB-Band und einer Steuereinheit. Eine Schachtel und ein Diffusor wurden fertig im Laden gekauft, es gab ein Klebeband, und die Steuereinheit war schon lange in der Ecke und wartete in den Flügeln.

Das Gehäuse war industriell (staubdicht, wasserdicht). Da das Band 12 Volt hat, befindet sich das Netzteil von 220 V bis 12 V in der Einheit. Die galvanische Trennplatine zur Steuerung des Bandes auf Basis von TLP250 (Optokoppler) hat auch all dieses Arduino in kompaktem Design gesteuert.
Ich habe die galvanische Trennung vom alten Projekt erhalten. Einmal machte ich eine Hintergrundbeleuchtung für eine Minibar in meinem Nachttisch. Beim Öffnen der Tür zeichnete das Touchpad eine Kapazitätsänderung auf und schaltete sanft schimmerndes Licht ein. Das heißt, das Board war für das aktuelle Projekt gut geeignet. Alles, was übrig blieb, war, alles Unnötige abzuschneiden. Auf der Platine befand sich ein 5-Volt-Linearwandler, der von ZUNo betrieben wurde.

Es war geplant, die Lampe mit einer Handablage zum Ultraschall-Entfernungsmesser einzuschalten. Er montierte es in den Deckel und alle anderen Teile kamen in die Schachtel. Alles "zuverlässig" mit Schmelzkleber fixiert. Zum Zeitpunkt des Tests habe ich eine Taste in der Nähe gedrückt, um die Steuereinheit über einen Lichtschalter für die externe Installation mit Strom zu versorgen.



Das Einschalten der Lichter ist bequemer und sicherer geworden. Es war verkehrt herum am Boden des Küchenschranks angebracht, und es war schwieriger, Wasser aus nassen Händen von innen zu bekommen.

Schlussfolgerungen aus der vorherigen Steuereinheit


Die Beleuchtung des Arbeitsbereichs der Küche wurde gleichmäßiger und angenehmer. Aufgrund der unnatürlichen Farbwiedergabe meines LED-Streifens änderte sich die Farbe einiger Produkte. Zum Beispiel: Karotten wirkten aufgrund der helleren Farbe viel appetitlicher. Aber es hat nicht viel gestört und ich hoffe, es hat nicht viel geschadet.

Beim kontaktlosen Ein- und Ausschalten stellte sich heraus, dass alles schlimmer war. Es funktionierte. Nach 5 Minuten im ausgeschalteten Zustand begannen die Blitze auf dem LED-Streifen. Ich fing nicht an, die Schaltung auf Optokopplern zu wiederholen und ließ alles so wie es ist. Nur zum Ein- und Ausschalten begann der neue Schalter zu benutzen. Jeder mochte seine Lage und Form.
Über zwei Jahre lang sammelten sich Fett und andere Verbindungen, die während des Kochens abgesondert wurden, am Körper und im Inneren an. Diese Plakette drang teilweise durch die Löcher für den Eintritt von Drähten in das Gehäuse ein. Aufgrund der glänzenden Oberfläche des Körpers kondensiert diese Substanz jedoch zu einer gallertartigen Masse. Es fühlt sich angenehm an, geruchlos und ... (ich habe es nicht probiert). Ich habe ein paar Fotos von der Stelle in Form eines Drachenkeims gemacht.





An den Wänden verwandelt sich diese Substanz in einen schrecklichen Überfall, der nicht nur gewaschen wird.

Was ist geworden


Nachdem ich in Behältern gestöbert hatte, fand ich ein unvollendetes Erweiterungsmodul für ZUNo. ZUNo ist ein Arduino-ähnliches Board zum Entwerfen eines eigenen Geräts, das mit dem Z-Wave Smart Home kompatibel ist. Es ist aus der Umgebung von Arduino programmiert.

Herstellerspezifikationen:
  • 28 kB Flash memory for your sketches
  • 2 kB RAM available
  • Z-Wave RF transmitter at 9.6/40/100 kbps
  • 26 GPIO (overlaps with special hardware controllers)
  • 4 ADC
  • 5 PWM
  • 2 UART
  • 1 USB (serial port)
  • 16 kB EEPROM
  • 1 SPI (master or slave)
  • 4 IR controllers, 1 IR learn capability
  • 1 TRIAC/ZEROX to control dimmer
  • 3 Interrupts
  • 1 Timer 4 MHz
  • I2C (software)
  • 1-Wire (software)
  • 8x6 Keypad Scanner (software)
  • 2 service LED, 1 service button
  • 1 user test LED


Das Erweiterungsmodul macht ZUNo zu einer vollwertigen Debug-Karte, die nach dem Debuggen des Prototyps als komplettes Gerät verwendet werden kann.

Einige Informationen vom Hersteller:
  • One 0-10 V analog output — control industrial dimmers
  • Up to four PWM or switch outputs (up to 5 A per channel) — control contactors, switches, halogen bulbs or LED strips
  • Up to eight digital 0/3 V inputs or outputs — connect various low voltage digital senors and actors
  • Up to four digital 0/3, 0/5 or 0/12 V digital or analog inputs — connect industrial 10 V sensors or any Arduino-compatible sensor
  • RS485 or UART — for industial meters
  • OneWire — for DS18B20 or other sensors


Für mein Projekt benötige ich 3 leistungsstarke Transistoren zum Umschalten von 12 Volt auf einen LED-Streifen und einen Wandler von 12 Volt auf 5 Volt, um ZUNo mit Strom zu versorgen. Der Rest der Peripherie des Erweiterungsmoduls wird nicht gelötet oder getestet.



In diesem Teil der Schaltung ist nicht genügend Diode für die Stromversorgung, zum Schutz gegen "Polaritätsumkehr" vorhanden, und Widerstände an den Gates von Leistungsfeldeffekttransistoren mussten an das Gate und nicht vor den Begrenzungswiderstand angeschlossen werden. Ich werde in den Schlussfolgerungen mehr darüber schreiben.

Dieses Erweiterungsmodul wird in einem Gehäuse von Gainta geliefert. Mein bisheriges Steuergerät war ebenfalls im Fall von dieser Firma, jedoch von anderer Größe. Leider passten die Befestigungen am Modul nicht zum alten Gehäuse, und ich wollte kein neues bohren, ich ließ das alte Gehäuse. Die Platte wurde auf Schmelzkleber "gepflanzt".



Ein bisschen über das Programmieren von Arduino und ZUNo


Z-Wave-Geräte müssen eine bestimmte Anzahl von Klassen haben. Klassen beschreiben Gerätefunktionen und Interaktionsschnittstellen. Zum Beispiel steuert meine Lampe einen LED-Streifen, der aus drei Farben besteht (rot, grün, blau). Diese Funktionen werden von der mehrstufigen Switch-Klasse ausgeführt. Wenn wir es der Skizze hinzufügen, können wir die Helligkeit einer der Farben aus der Ferne ändern. Um drei Farben zu steuern, müssen Sie drei Instanzen dieser Klasse erstellen. Ich werde nicht näher darauf eingehen. Weil die routinemäßige Klassenmanipulation für ZUNo-Benutzer durch den Begriff „Kanal“ verborgen ist. Zum Beispiel benötige ich drei Klassen von Switch-Multilevels, daher sollten im Code 3 Kanäle von Switch-Multilevels und mehrere Rückruffunktionen für die Funksteuerung erscheinen. Wie macht man das? Sie müssen auch die Switch-Basisklasse hinzufügen.Ein- und Ausschalten der Lampe auf Knopfdruck (über die Netzwerkcontroller-Schnittstelle) und nicht jedes Mal 3 Kanäle konfigurieren.

Sie müssen zur Entwickler-Website gehen, auf der Beispiele für z-uno.z-wave.me/Reference/ZUNO_SWITCH_MULTILEVEL aufgeführt sind . Jede von ZUNo unterstützte Klasse hat eine Beschreibung und ein Beispiel. Kopieren Sie anschließend die vorgeschlagenen Funktionen und fügen Sie sie in Ihre Skizze ein. In der Skizze gibt es jetzt drei mehrstufige Schaltkanäle und 6 Rückruffunktionen zum Reagieren auf Befehle im Radio. Ich bin in Z-Wave-Klassen nicht sehr anspruchsvoll, daher hat mein vorheriges LED-Streifengerät mit diesen Klassen gearbeitet.

Die Kanäle wurden wie folgt deklariert:

Spoiler Überschrift
ZUNO_SETUP_CHANNELS(
      ZUNO_SWITCH_MULTILEVEL(getRed, setRed),
      ZUNO_SWITCH_MULTILEVEL(getGreen, setGreen),
      ZUNO_SWITCH_MULTILEVEL(getBlue, setBlue),
      ZUNO_SWITCH_BINARY(switch_getter, switch_setter)
);


Dies führte nach dem Hinzufügen zum Netzwerk zur Generierung der folgenden Widgets im Controller:



Um die Farbe anzupassen, musste jede Farbe im Controller-Menü separat geöffnet und konfiguriert werden. Es ist nicht bequem und langsam. Ich hatte jedoch Glück. Es stellte sich heraus, dass ich nicht allein bin. Sie haben an uns gedacht und den Kanal z-uno.z-wave.me/Reference/ZUNO_SWITCH_COLOR erstellt . Jetzt enthält die Skizze nur noch einen Kanal und zwei Rückruffunktionen. Im Menü des Controllers wird die Farbeinstellung für jede Farbe sowie für alle gleichzeitig durch Auswahl aus der Palette vorgenommen.

ZUNO_SETUP_CHANNELS(ZUNO_SWITCH_COLOR(SWITCH_COLOR_FLAGS_RED|SWITCH_COLOR_FLAGS_GREEN|SWITCH_COLOR_FLAGS_BLUE, getterFunction, setterFunction));

Und im Controller-Menü sieht es so aus:



Die nächste Funktion reagiert auf Anfragen per Funk. Möglicherweise wird eine Anforderung zum Lesen des Status eines der Farbkanäle gesendet.

BYTE getterFunction(BYTE component) {
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      return pwmR;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      return pwmG;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      return pwmB;
      break;
  }
  return 3;
}

Und dies ist eine Funktion zum Einstellen von Farben über die Controller-Oberfläche.

void setterFunction(BYTE component, BYTE newValue) 
{
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      pwmR = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      pwmG = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      pwmB = newValue;
      break;
  }
  radio_action = 1;
}

Das ist der gesamte Code, den Sie hinzufügen müssen, um aus einer Arduino-Skizze eine Skizze für ZUNo zu machen.

Fazit


Nach der Montage und Installation wurden alle deklarierten Aufgaben abgeschlossen. Die Gewohnheit, das Licht mit dem Schalter einzuschalten, blieb jedoch bestehen (es stellte sich als sehr praktisch heraus). Die kontaktlose Einschlussoption funktioniert ebenfalls. Unter den Mängeln möchte ich das Flackern der LED-Lampe für eine Sekunde nach dem Einschalten der Steuereinheit bemerken. Dies ist auf die lange Initialisierung der ZUNo-Peripheriegeräte zurückzuführen. Zu diesem Zeitpunkt sind die Beine unvorhersehbar. Ich denke, der Pull-up-Widerstand am Gate des Transistors wird die Situation korrigieren, wenn Sie ihn hinter den Begrenzungswiderstand setzen. Wenn der Initialisierungscode die Beine an den Ausgang anpasst und die Logikpegel gezielt ändert, können Sie mit dem RC-Filter experimentieren, der keine kurzen Impulse durchlässt. Ich habe es noch nicht getan und vielleicht werde ich es nie tun!

Ergebnisse


ZUNo und sein Erweiterungsmodul vereinfachen die „technische Kreativität zu Hause“ erheblich. Ich halte diese Produkte jedoch für sehr teuer. Wenn ich anderswo arbeiten würde und Z-Wave-Geräte nicht herumliegen würden, würde ich alles auf ESP8266 tun. Während der Entwicklung habe ich einen neuen „Standard“ zum Markieren von Drähten aus dem Netzteil gelernt.



Jetzt ist nicht nur die Erde mit einem schwarzen Streifen markiert, sondern wie in meinem Fall der „positive“ Draht. Für das Erweiterungsmodul erwies sich dies als wichtig. Der 5-Volt-LM2594-Wandler ist ausgefallen (der Preis für Chip und Dip beträgt ca. 200 Rubel). Ich hoffe, dass es in der nächsten Version des Erweiterungsmoduls eine Schutzdiode gegen „Polaritätsumkehr“ geben wird. Und ich werde die Polarität der Versorgungskabel überprüfen. Ein weiterer Nachteil ist mit dem Körper verbunden. Das Gehäuse sieht gut aus, aber ich konnte die Drähte ohne Pinzette nicht an die Klemmenblöcke anschließen. Ich hoffe, dass es eine Version mit anderen Klemmenblöcken gibt (zum Anschließen von Drähten von oben oder in einem Winkel).

Ich mag es nicht, Fotos in Cloud-Diensten zu speichern und oft Backups zu machen. Daher sind die meisten Fotos, die mit dem Entwurfsprozess und der Lampe 1 verbunden sind, unwiederbringlich verfälscht.



Dies ist alles, was vom Assemblierungs- und Debugging-Prozess übrig bleibt.

Und es sieht so aus, als würde die Hintergrundbeleuchtung in Betrieb genommen, wenn Sie sich ein wenig biegen. Wenn Sie sich gerade richten, sind die Box und der Schalter nicht sichtbar.



Skizze für ZUNo. Ich füge hinzu, nur um zu bestätigen, dass alles elementar ist
#include "EEPROM.h"
#include "EEPR.h"

int readPin = 9;
int triggerPin = 10;
byte controlState = 0;
word lastValue;
#define REDPIN   PWM1     // pin connection R 
#define GREENPIN PWM2     // pin connection G
#define BLUEPIN  PWM3     // pin connection B

ZUNO_SETUP_CHANNELS(ZUNO_SWITCH_COLOR(SWITCH_COLOR_FLAGS_RED|SWITCH_COLOR_FLAGS_GREEN|SWITCH_COLOR_FLAGS_BLUE, getterFunction, setterFunction));

#define ON 1
#define OFF 0
uint8_t switch_=OFF;

uint8_t pwmR=0;
uint8_t pwmG=0;
uint8_t pwmB=0;
uint8_t b_pwmR=0;
uint8_t b_pwmG=0;
uint8_t b_pwmB=0;

enum
{
  DEF_R = 255,
  DEF_G = 255,
  DEF_B = 255
};
uint8_t radio_action = 0;

void setup() 
{ 
  init_EEPROM();
  Serial.begin();
  pinMode(readPin, INPUT);
  pinMode(triggerPin, OUTPUT);
  digitalWrite(triggerPin, LOW);
  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN, OUTPUT);
  analogWrite(REDPIN, pwmR & 0xff);
  analogWrite(GREENPIN, pwmG & 0xff);
  analogWrite(BLUEPIN, pwmB & 0xff);
  
} 
int act=1;
int actf = 0;
int cnt=57; 

void loop()
{
  int tmp;
  // trigger measurement
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(10);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  // read pulse width
  tmp = pulseIn(readPin, HIGH, 100000);
  lastValue = tmp / 58;
  Serial.print(" cm= ");
  Serial.println(lastValue);
  if (lastValue < 30)
  {
    cnt++;
  }
  else
  {
    cnt--;
  }
  if (cnt > 55)
  { 
    act=1;
  }
  if (cnt > 60)
    cnt= 60;
  if (cnt < 50)
  {
    act=0;
    actf=0;
  }
  if (cnt < 45 )
    cnt = 45;
  
  if ((act == 1) && (actf == 0))
  {  
    actf = 1;
    if (switch_ == OFF)
    {
      switch_=ON;
      b_pwmG = pwmG;
      b_pwmB = pwmB;
      b_pwmR = pwmR;
    }
    else
    {
      switch_=OFF;
      b_pwmR=0;
      b_pwmG=0;
      b_pwmB=0;
    }
    analogWrite(REDPIN, b_pwmR & 0xff);
    analogWrite(GREENPIN, b_pwmG & 0xff);
    analogWrite(BLUEPIN, b_pwmB & 0xff); 
  } 
  
  Serial.print("cnt = ");    
  Serial.print(cnt);  
  Serial.print(" || ");    
  Serial.print(pwmR);  
  Serial.print(" ");      
  Serial.print(pwmG);  
  Serial.print(" ");
  Serial.print(pwmB);  
  Serial.print(" ");
  Serial.println("");
 // delay(10);

 if(radio_action)
 {
    radio_action = 0;
    eepr_save_col();
    analogWrite(REDPIN, pwmR & 0xff);
    analogWrite(GREENPIN, pwmG & 0xff);
    analogWrite(BLUEPIN, pwmB & 0xff);
 }
}

BYTE getterFunction(BYTE component) {
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      return pwmR;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      return pwmG;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      return pwmB;
      break;
  }
  return 3;
}

void setterFunction(BYTE component, BYTE newValue) 
{
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      pwmR = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      pwmG = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      pwmB = newValue;
      break;
  }
  radio_action = 1;
}


All Articles