KAKU uitlezen

[bmw02 Profiel Privébericht]

Hallo,

Ik ben nieuw hierin en probeer zoveel mogelijk zelf maar heb nu hulp nodig.
Overal lees ik dat het mensen gelukt is maar nergens duidelijk een uitleg.

Ik wil mijn KAKU via de arduino gaan schakelen.
Veel gelezen over het uitlezen van de afstandsbediening en kan nu via de volgende sketch data uitlezen en dan krijg ik veel cijfers onder elkaar te zien.
Als je meerdere keren op dezelfde knop drukt is de uitgelezen code ook anders.
En dan is het voor mij over.

Hoe kan ik nu veder?


Groet, Jan

cpp code

#include <RemoteReceiver.h>
#include <RemoteTransmitter.h>

int Daan = 472418; //vaste waarde

void setup() {
   Serial.begin(9600);
  
  // See example Show_received_code for info on this
  RemoteReceiver::init(0, 3, retransmitter);
}

void loop() {
}

void retransmitter(unsigned long receivedCode, unsigned int period) {  
  // Disable the receiver; otherwise it might pick up the retransmit as well.
  Serial.print("Data:");
  Serial.println(receivedCode);
  
  RemoteReceiver::disable();
  
  
  
  // Need interrupts for delay()
  interrupts();
    
  // Wait 5 seconds before sending.
  delay(5000);

  // Retransmit the signal 8 times ( == 2^3) on pin 11. Note: no object was created!
  RemoteTransmitter::sendCode(11, ('Daan',BIN), period, 3); // was(11, receivedCode, period, 3);
  Serial.print("Data:");
  Serial.println('Daan');
  
  RemoteReceiver::enable();
}

[bmw02 Profiel Privébericht]

Hallo,

Ik kan enigszins begrijpen dat ik geen reactie heb maar geen welkom als nieuwe gebruiker op dit forum vind ik wel jammer.

Het is het zoveelste bericht over KAKU maar dan nog.
Al schrijft er maar iemand, welkom hier, maar er is al zoveel over geschreven we hebben hier geen zin meer in, dan is er in ieder geval iemand die een reactie geeft.
Meer dan 60 keer gelezen geeft ook wel aan dat er toch mensen zijn die willen weten wat er gevraagd wordt.

Als ik te grof ben dan hoor ik dat wel maar op andere fora wordt je gewoon welkom geheten.

[snewpers Profiel Privébericht]

Uhm.. welkom

Ik heb het bericht gelezen maar heb geen ervaring met KAKU of het in/uitlezen van signalen. Kan je niet helpen maar het onderwerp is wel interessant.

Succes!

[FonzieBonzo Profiel Privébericht]

Welkom nukkige BMW

Ik heb ook de KAKU maar met de standaard USB bediening en heb geen ervaring i.c.m. de Arduino anders had je alles al werkend.

[nicoverduin Profiel PrivéberichtWebsite]

Hallo,

Ik kan enigszins begrijpen dat ik geen reactie heb maar geen welkom als nieuwe gebruiker op dit forum vind ik wel jammer.

Het is het zoveelste bericht over KAKU maar dan nog.
Al schrijft er maar iemand, welkom hier, maar er is al zoveel over geschreven we hebben hier geen zin meer in, dan is er in ieder geval iemand die een reactie geeft.
Meer dan 60 keer gelezen geeft ook wel aan dat er toch mensen zijn die willen weten wat er gevraagd wordt.

Als ik te grof ben dan hoor ik dat wel maar op andere fora wordt je gewoon welkom geheten.

ach soms hebben mensen ff geen tijd om de luiers te verwisselen
Met betrekking tot jouw probleem:
a) Als dezelfde code opnieuw wordt verzonden, dan stuurt ie maar een deel weg. De ontvanger weet dat het dezelfde code is.
b) zitten er geen voorbeelden bij de library?
c) waar heb je de library vandaan gehaald.

[bruu Profiel Privébericht]

Jan,

er zijn 2 modellen van de kaku afstandsbediening.
Als je het nieuwste model hebt en de Uno gebruikt zoek dan op internet naar NewRemoteSwitch library.
Installeer die in de library-map van de arduino ide.
Bij de voorbeelden van de NewRemoteSwitch library staat de sketch ShowReceivedCode.
Ontvangertje aansluiten op pin 2 van de uno of nano.
Upload pogramma ( het kan zijn dat je bij Serial.begin de 115200 moet wijzigen in 9600)
Als je dan een toets op de afstandsbediening indrukt moet de code op het scherm komen. ( zie bijgevoegde schermafdruk)

Henk

[bmw02 Profiel Privébericht]

Dank voor jullie reactie's.

Ik weet dat ik soms nukkig kan zijn maar dat is uiterlijke schijn
Ik heb er waarschijnlijk veel te makkelijk over gedacht, dat doe ik wel even, omdat ik meerdere berichten had gelezen dat het gelukt was bij anderen.

Ik had al zoveel gelezen en pagina's met libraries gezien dat ik niet meer weet waar ik deze vandaan heb maar met deze krijg ik wel wat op de monitor te zien maar vaak verschillend.

Ik heb NewRemoteSwitchen, RemoteSwitch en RCSwitch onder andere geïnstalleerd.
Bij alle drie de optie van show received code geprobeerd maar helaas geen geluk.

De zender is deze: http://www.klikaanklikuit.nl/advies/productwijzer/productwijzer-par-1000/ maar ik weet niet of dit het nieuwe model is.

[bruu Profiel Privébericht]

Dat is het oude model Jan, dat werkt met code schijfjes lees ik.
Wordt niet meer geleverd staat er ook bij.
Met dat model heb ik niet ge-experimenteerd en heb daar geen ervaring mee ,wel met de afstandsbediening ayct102 en het pakket apa3-1500r.
Dat werkt goed met de newremoteswith library. Je kon de schakelaars zelfs bedienen met eigen gemaakte codes.
Bij mij viel het bereik van het zendertje nogal tegen, ong. 1 meter, terwijl een meter of 10 en door 2 muren heen nodig is.
De kaku afstandsbediening overbrugt dat wel dus die maar weer in gebruik genomen.
Ik kan je niet verder helpen Jan , want met dat oude systeem heb ik geen ervaring.
Groetjes,
Henk

[bmw02 Profiel Privébericht]

Dank voor je reactie Henk.

Ik weet nu weer wat meer.
Dan ga ik verder met een ander setje.
Ik heb nog een setje van Quigg, de DMV-700F.
Deze kun je zelf met een knop instellen, op de ontvanger moet je een knop ingedrukt houden en dan 'leert' hij de code van de afstandsbediening.
Daar heb ik ook over gelezen dus ga ik dat proberen.

Wordt vervolgd....

[Beamer Profiel Privébericht]

Ik gebruik onderstaand verhaal thuis met een mini pro.
Wellicht heb je er iets aan.


cpp code

/* Programma voor het automatisch aan en uitschakelen van KaKu lichtschakelaars
   Aanschakelen gebeurt met een lichtsensor, uitschakelen op tijd.
   Er wordt rekening gehouden met de vrijdagavond en de zaterdagavond en met zomer en wintertijd
*/
//-----------------------------------------------------------------------------------------------------
// libraries
#include <RemoteReceiver.h>            // ontvangen 433 MHz signalen
#include <EEPROM.h>                    // opslaan waardes in EEPROM
#include <Wire.h>                      // I2c nodig voor de RTC klok
#include <RTClib.h>                    // RTC klok lezen en in begrijpelijke variabelen neerzetten
#include <RemoteTransmitter.h>         // aansturen 433 MHZ transmitter
#include <OneButton.h>                 // afvragen knopvoor kort en lang drukken
//#include <LiquidCrystal_I2C.h>         // I2C LCD scherm
//-----------------------------------------------------------------------------------------------------
// class aanmaken
//LiquidCrystal_I2C lcd(0x27, 20, 4);    // initialiseer LCD
RTC_DS1307 rtc;                        // klok
OneButton knop(6, true);               // knop
KaKuTransmitter kaKuTransmitter(10);   // 433 MHz transmitter op pin 10

boolean geldig, actief, stby = false;  // geldig = 's avonds, actief = licht aan, stby = stand by
boolean L1, L2, L3 = false;            // lampgroepen zijn uit, deze variabelen voorkomen dat de groep elke loop wordt aangeschakeld.
int LDRValue;                          // variabele voor LDR waarde
unsigned long tijd, tijdaan;           // variabelen voor de unixtime
int jaar;                              // variabele voor jaar
int maand;                             // variabele voor maand
int dag;                               // variabele voor dag
byte weekdag;                          // variabele voor dag van de week
byte uur;                              // variabele voor uur
byte dspuur;                           // variable voor klok
byte minuut;                           // variabele voor minuut
byte weekend;                          // weekend, later naar bed
int RndOut;                            // randomwaarden voor het uitschakelen van de lampen
volatile long KAKU;                    // variabele voor ingedrukte KAKU code
int schakel_1;                         // variabele voor schakelmomenten
int schakel_2;
int schakel_3;

#define eerstAan  15                   // licht mag aan vanaf 15.00 uur
#define dinsdag    2
#define vrijdag    5
#define zaterdag   6

#define TX_Pin    10                   // definieer pin voor transmitter
#define Button     5                   // button op pin 5 voor handmatige geldig aan
#define statusLed  7                   // statusLed geeft geldigheid aan
#define stbyLed   13                   // geeft status stand by aan
#define LDR       A1                   // LDR zit op poort A1
#define RX_5V      6                   // 5 volt voor receiver
#define TX_5V      8                   // 5 volt voor transmitter
int ButtonState;                       // variabele voor knop

//-----------------------------------------------------------------------------------------------------
void setup ()
{
  pinMode(16, OUTPUT);                 // gebruik pins 16 (A2) & 17 (A3) voor voeding van RTC
  pinMode(17, OUTPUT);                 // RTC gebruikt I2C op A4 en A5
  digitalWrite(16, LOW);               // 0 V
  digitalWrite(17, HIGH);              // 5 V

  pinMode(statusLed, OUTPUT);
  pinMode(stbyLed, OUTPUT);
  digitalWrite(stbyLed, HIGH);

  pinMode(TX_Pin, OUTPUT);             // TXPin is uitgang

  pinMode(Button, INPUT);

  pinMode(RX_5V, OUTPUT);             // pin als output
  digitalWrite(RX_5V, HIGH);          // geef receiver spanning, gaat uit bij TX !!
  pinMode(TX_5V, OUTPUT);
  digitalWrite(TX_5V, HIGH);          // zet transmitter aan

  randomSeed(analogRead(0));           // Maak een random seed aan
  RndOut = random(30);                 // 30 min

  Wire.begin();                        // start Wire voor I2C

  rtc.begin();                         // start klok

  RemoteReceiver::init(0, 3, showCode);// zet interrupt voor receiver op pen 2

  knop.attachClick(click);            // void voor simpele klik
  knop.attachPress(press);            // void voor lange klik

  //  lcd.init();                         // zet LCD aan
  //  lcd.backlight();                    // en backlight ook aan

  getvalues();                        // haal oude waardes uit ROM
}
//-----------------------------------------------------------------------------------------------------
void loop ()
{
  Klok();                              // Tijd ophalen
  watisgedrukt();                      // Welke KAKU toets is gedrukt?
  //  update_Display();                    // update het display
  knop.tick();                         // vraag knop af

  LDRValue = analogRead(LDR);          // Momentele waarde van LDR

  //-----------------------------------------------------------------------------------------------------
  if (geldig == true)                   // zet een LED aan als de actieve tijd in gaat (eerstAan)
  {
    digitalWrite(statusLed, HIGH);
  }
  else
  {
    digitalWrite(statusLed, LOW);
  }
  //-----------------------------------------------------------------------------------------------------
  if (weekdag == dinsdag || weekdag == vrijdag || weekdag == zaterdag)  // dinsdag vrijdag en zaterdag 's avonds een uur later uit
  {
    weekend = 30;
  }
  else
  {
    weekend = 0;
  }
  //-----------------------------------------------------------------------------------------------------
  if ( uur + adjustDstEurope() == eerstAan // actief worden op eerstAan en als we niet op standby staan
       && minuut == 00)
  {
    geldig = true;
  }
  //-----------------------------------------------------------------------------------------------------
  if (LDRValue < schakel_1
      && geldig == true
      && L1 == false)                  // eerste keer donker
  {
    actief = true;                     // doe het licht maar aan
  }
  //-----------------------------------------------------------------------------------------------------
  if (actief == true && L1 == false)   // eerste groep schakelt direkt in, maar alleen als die nog uit was, voorkomt meermalig schakelen
  {
    zend('A', 2, true);
    L1 = true;                         // LDRValue is aan , maar 1 keer aanzetten in de loop

  }
  //-----------------------------------------------------------------------------------------------------
  if (LDRValue < schakel_2
      && actief == true
      && L1 == true
      && L2 == false)                  // tweede groep schakelt
  {
    zend('A', 1, true);
    L2 = true;

    delay (2000);                      // wacht met schakelen van groep 3 L2 moet opkomen
    LDRValue = 999;                    // zet licht op max om te voorkomen dat groep 3 direkt mee schakelt
    // zo wordt de sensor uitgelezen in de volgende loop
  }
  //-----------------------------------------------------------------------------------------------------
  if (LDRValue < schakel_3
      && actief == true
      && L2 == true
      && L3 == false)                   // derde groep schakelt
  {
    zend('A', 3, true);
    L3 = true;
  }
  //-----------------------------------------------------------------------------------------------------
  /* aanschakelen is niet afhankelijk van tijdstip,
     uitschakelen gaat wel op tijdstip, daarom hier uren en minuten
  */
  if (uur + adjustDstEurope() == 23
      && minuut == RndOut + weekend
      && geldig == true)       // slapies doen, maar op vrijdag en zaterdag een half uur later en gecorrigeerd voor zomertijd
  {
    actief = false;
    geldig = false;

    allesUit();                      // schakel alle lampen uit
    L1 = false;                      // ook de reminders uit
    L2 = false;
    L3 = false;
  }
  //-----------------------------------------------------------------------------------------------------
  if (uur = 0 && minuut == 0)
  {
    randomSeed(analogRead(0));       // Maak een nieuwe random seed aan
    RndOut = random(30);             // 30 min
  }
}
//-----------------------------------------------------------------------------------------------------
int adjustDstEurope()                // routine om data te bepalen voor zomertijd
{
  // last sunday of march
  int beginDSTDate =  (31 - (5 * jaar / 4 + 4) % 7);
  int beginDSTMonth = 3;
  //last sunday of october
  int endDSTDate = (31 - (5 * jaar / 4 + 1) % 7);
  int endDSTMonth = 10;
  // DST is valid as:
  if (((maand > beginDSTMonth) && (maand < endDSTMonth))
      || ((maand == beginDSTMonth) && (dag >= beginDSTDate))
      || ((maand == endDSTMonth) && (dag < endDSTDate)))
    return 1;                      // zomertijd = RTC + 1
  else return 0;                   // wintertijd = RTC tijd
}

//-------------------------------------------------------------------------------------------------
void zend(char groep, int lamp, boolean aan)  // routine voor zenden signaal
{
  digitalWrite(RX_5V, LOW);       // zet receiver uit zodat we geen interrupt krijgen op het eigen signaal
  kaKuTransmitter.sendSignal(groep, lamp, aan);
  digitalWrite(RX_5V, HIGH);      // zet receiver weer aan
  delay(10);
}
//-------------------------------------------------------------------------------------------------
void allesAan()                 // zet alle lampen aan
{
  zend('A', 1, true);
  zend('A', 2, true);
  zend('A', 3, true);
}
//-------------------------------------------------------------------------------------------------
void allesUit()                 // zet alle lampen uit
{
  zend('A', 1, false);
  zend('A', 2, false);
  zend('A', 3, false);
}
//-------------------------------------------------------------------------------------------------
void tweeAan()                  // twee lampen aan voor 's morgens
{
  zend('A', 2, true);
  zend('A', 3, true);
}
//-------------------------------------------------------------------------------------------------
void click()                      // routines voor gewoon drukken of een lange druk
{
  geldig = true;
  digitalWrite(TX_5V, HIGH);
  digitalWrite(stbyLed, HIGH);
}
//-------------------------------------------------------------------------------------------------
void press()                      // schakel standby
{
  digitalWrite(TX_5V, LOW);
  digitalWrite(stbyLed, LOW);
}
//-------------------------------------------------------------------------------------------------
// Callback function is called only when a valid code is received.
void showCode(unsigned long receivedCode, unsigned int period) {
  // Note: interrupts are disabled. You can re-enable them if needed.

  KAKU = receivedCode;

}
//-------------------------------------------------------------------------------------------------
void saveValue(int loc, int value) {     // routine om int waarde op te slaan in EEPROM

  byte lowByte = ((value >> 0) & 0xFF);  // lage byte
  byte highByte = ((value >> 8) & 0xFF); // hoge byte

  EEPROM.write(loc, lowByte);
  EEPROM.write(loc + 1, highByte);

}
//-------------------------------------------------------------------------------------------------
int readValue(int loc) {                    // routine om int waarde uit EEPROM te halen
  {
    byte lowByte = EEPROM.read(loc);
    byte highByte = EEPROM.read(loc + 1);

    return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
  }
}
//-------------------------------------------------------------------------------------------------
void resetvalues() {

  saveValue(0, 0xFFFF);       // reset rom
  schakel_1 = 0;
  saveValue(2, 0xFFFF);
  schakel_2 = 0;
  saveValue(4, 0xFFFF);
  schakel_3 = 0;

}
//-------------------------------------------------------------------------------------------------
void getvalues() {

  schakel_1 = readValue(0);               // haal oude waardes op
  if (schakel_1 == 0xFFFF) schakel_1 = 0; // blanco ROM, eerste keer opstarten
  schakel_2 = readValue(2);
  if (schakel_2 == 0xFFFF) schakel_2 = 0;
  schakel_3 = readValue(4);
  if (schakel_3 == 0xFFFF) schakel_3 = 0;

}
//-------------------------------------------------------------------------------------------------
void watisgedrukt() {

  switch (KAKU) {

    case 118124:                  // aan knop code voor groep 1 (KAKU op C )
      LDRValue = analogRead(LDR); // haal LDR waarde op
      schakel_1 = LDRValue;
      saveValue (0, LDRValue);    // bewaar waarde in EEPROM
      break;

    case 122498 :                 // aan knop code voor groep 2
      LDRValue = analogRead(LDR);
      schakel_2 = LDRValue;
      saveValue (2, LDRValue);
      break;

    case 119582:                  // aan knop code voor groep 3
      LDRValue = analogRead(LDR);
      schakel_3 = LDRValue;
      saveValue(4, LDRValue);
      break;

    case 119580:                  // uit knop code voor groep 3
      resetvalues();              // wis EEPROM
      break;

    case 354320:
      //      alles aan schakelen
      allesAan();
      break;

    case 354318:
      //      alles uitschakelen
      allesUit();
      break;

    case 358694:
      // voor's morgen twee lampen aan
      tweeAan();
      break;

    case 358692:
      geldig = true;
      break;

    case 355776:
      //zet zender uit voor standby mdus
      digitalWrite(TX_5V, LOW);
      digitalWrite(stbyLed, LOW);
      break;

    case 355778:
      //zet zender aan voor normale modus
      digitalWrite(TX_5V, HIGH);
      digitalWrite(stbyLed, HIGH);
      break;
  }

  KAKU = 0;
}
//-------------------------------------------------------------------------------------------------
/*
  void update_Display() {

  lcd.setCursor(0, 0);
  lcd.print("LDR ");
  lcd.print(LDRValue);
  lcd.setCursor(0, 1);
  lcd.print("Schakelmoment 1 :");
  if (schakel_1 != 0) lcd.print(schakel_1);
  else lcd.print("---");
  lcd.setCursor(0, 2);
  lcd.print("Schakelmoment 2 :");
  if (schakel_2 != 0) lcd.print(schakel_2);
  else lcd.print("---");
  lcd.setCursor(0, 3);
  lcd.print("Schakelmoment 3 :");
  if (schakel_3 != 0) lcd.print(schakel_3);
  else lcd.print("---");

  }
*/
//-------------------------------------------------------------------------------------------------
void Klok() {
  // digital clock display tijd

  DateTime now = rtc.now();            // haal tijd van RTC
  tijd = (now.unixtime());             // bewaar unixtime in tijd
  weekdag = (now.dayOfTheWeek());      // haal de dag van de week op
  uur = (now.hour());                  // haal uur op
  minuut = (now.minute());             // haal minuut op
  jaar = now.year();                   // haal jaar op
  maand = now.month();                 // haal maand op
  dag = now.day();                     // haal dag op
  /*
    lcd.setCursor(10, 0);
    lcd.print ("Tijd:");
    dspuur = uur + adjustDstEurope();  // corrigeer voor zomertijd
    if (dspuur < 10) lcd.print(" ");
    lcd.print(dspuur);
    lcd.print(":");
    if (minuut < 10) lcd.print("0");
    lcd.print(minuut);
  */
}