Wie kann ich die RCSwitch Library weglassen

Hallo, habe versucht einen eigenen Sketch zu schreiben. Er soll bei betätigung eines Endschalters den Entsprechenden Servo betätigen, und per Funk eine Funksteckdose aktivieren. Das klappt auch soweit, nur würde ich das ganze gerne auf den Tiny 2313 packen, und dafür ist die RCSwitch Library zu groß.
Habe es auch schon ohne versucht, hiermit http://www.dserv01.de/howtos/funksteckdose-fernsteuern-mit-arduino/, aber das klappt einfach nicht. Kann mir jemand da helfen ? Danke im Vorraus.

#include <RCSwitch.h> 

RCSwitch sauger = RCSwitch(); 

#define sch_anzahl 2 
#define z_winkel  0 
#define a_winkel  170 

int schalter[sch_anzahl] = {22, 23}; 
int servo[sch_anzahl] = {52, 53}; 

void setup() {
sauger.enableTransmit(10); 
  for (int a = 0; a < sch_anzahl; a++) { 
    pinMode(schalter[a], INPUT);
    pinMode(servo[a], OUTPUT);
    schliessen(a);
  }
}

void loop() {
  for (int a = 0; a < sch_anzahl; a++) {
    if (digitalRead(schalter[a]) == HIGH) {
      oeffnen(a);
      delay(500);
      starten();
      while (digitalRead(schalter[a]) == HIGH);
      beenden();
      delay(500);
      schliessen(a);
    }
  }
}

void oeffnen(int a) {
  for (int pos = z_winkel; pos < a_winkel; pos++) {
    int pwm = (pos * 11) + 500;
    digitalWrite(servo[a], HIGH);
    delayMicroseconds(pwm);
    digitalWrite(servo[a], LOW);
    delay(5);
  }
}

void schliessen(int a) {
  for (int pos = a_winkel; pos > z_winkel; pos -= 1) {
    int pwm = (pos * 11) + 500;
    digitalWrite(servo[a], HIGH);
    delayMicroseconds(pwm);
    digitalWrite(servo[a], LOW);
    delay(5);
  }
}


void starten() {
sauger.send(83281, 24);
}

void beenden() {
sauger.send(83284, 24);
}

Saubr:
Kann mir jemand da helfen ?

Die billigen 433MHz-Funksteckdosen arbeiten mit ASK/OOK-Modulation und senden zum Schalten eher weniger als fünf Dutzend Bits in einem bestimmten On/Off-Rhythmus. Das ist eine minimale Datenmenge.

Wenn Du einen solchen Schaltbefehl ohne eine umfangreiche Super-Duper-Library senden möchtest, musst Du das genaue Sendeprotokoll kennen, die Bitcodierung und welche Bits mit welchen Bitlängen gesendet werden sollen. Dann kannst Du über eine Schleife ganz simpel mit “digitalWrite(pin,HIGH)”, “delayMicroseconds(bitDauerHigh)”, “digitalWrite(pin,LOW)”, “delayMicroseconds(bitDauerLOW)” die Bits nacheinander in einer Schleife wegsenden.

Eine Möglichkeit wäre, sich das Sendeprotokoll auf einem Oszilloskop sichtbar zu machen, die Bitcodierung nach in Augenscheinnahme zu decodieren und dafür eine Senderoutine zu machen.

Oder wenn Du kein Oszilloskop hast, aber dafür eine funktionierende Library zum erfolgreichen Senden des Schaltcodes, die Library zu einer Debug-Version der Library umzuschreiben, so dass der Code nicht auf direkt auf einem Pin ausgegeben wird, sondern die Schaltzeiten mit Mikrosekundenauflösung im RAM zwischengespeichert und danach auf Serial ausgegeben wird, um danach die eigene Senderoutine zu basteln.

Hallo, also ich kann die FB ja mit der Library lesen. Das Ergebniss sieht dann so aus:

Decimal: 83281 (24Bit) Binary: 000000010100010101010001 Tri-State: 000FF0FFFF0F PulseLength: 330 microseconds Protocol: 1 Raw data: 10252,296,1024,292,1024,296,1020,296,1024,292,1024,296,1024,292,1028,948,368,288,1028,948,372,284,1032,292,1024,292,1024,952,364,292,1028,948,368,292,1024,948,372,292,1024,948,368,292,1028,292,1024,292,1028,944,376,

Anhand von 000000010100010101010001 wollte ich dann das oben genannte Beispiel anpassen, um die Library zu umgehen. Habe dann nach zwei Stunden aufgegeben.

Saubr: Anhand von 000000010100010101010001 wollte ich dann das oben genannte Beispiel anpassen, um die Library zu umgehen. Habe dann nach zwei Stunden aufgegeben.

Hast Du denn mal mit beispielsweise einem UNO oder einem anderen von der Arduino-IDE direkt unterstützten Board getestet, ob Du einen funktionierenden Schaltbefehl bekommst, wenn Du den send-Befehl der Library verwendest?

Mir ist jetzt nicht ganz klar, ob Du bereits "mit der Library" und einem "Arduino-Board" keinen funktionierenden Schaltcode gesendet bekommst, oder Du "nur mit dem selbstgemachten eigenen Code ohne die Library" und einem "von Arduino standardmäßig nicht unterstützten Controller" keinen funktionierenden Schaltcode senden kannst.

Ja. Mit dem Mega und der Library funktioniert der Sketch so wie er oben ist. Ohne Library auf dem Arduino geht es nicht.

Saubr: Ohne Library auf dem Arduino geht es nicht.

Dann ist Dein Code "ohne die Library" fehlerhaft, d.h. Dein geänderter Code "ohne die Library" macht mit dem Sender nicht dasselbe wie "der Code mit der Library".

Den Fehler müßtest Du als erstes ausbessern.

Du mußt die Funktionen der Library, die Du brauchst, in Deinen Sketch übernehmen. Grüße Uwe

Ja, und da beißt sich die Katze in den Schwanz, meine Kentnisse reichen nicht um die Library zu verstehen, und wenn ichs Versuche funktioniert es eben nicht. Wenn ich das richtig verstehe muss ich ja die Einsen und Nullen senden wie oben genannt (Binary: 000000010100010101010001) . Eine Eins müsste dann heißen:

Ausgang HIGH, drei mal 3x350 Microsekunden warten, Ausgang LOW und 1x350 Microsekunden warten.

Eine Null dann enstsprechend 1x350 HIGH und 3x350 LOW, richtig ?

Saubr: Wenn ich das richtig verstehe muss ich ja die Einsen und Nullen senden wie oben genannt (Binary: 000000010100010101010001) . Eine Eins müsste dann heißen:

Ausgang HIGH, drei mal 3x350 Microsekunden warten, Ausgang LOW und 1x350 Microsekunden warten.

Eine Null dann enstsprechend 1x350 HIGH und 3x350 LOW, richtig ?

Hast Du nicht oben "PulseLength: 330 microsecond" gepostet? Egal wie, Hauptsache einheitlich. Das Protokoll ist ein wenig Fehlertolerant. Ich gehe jetzt mal von 330µs aus.

Jedenfalls Du vergißt jetzt komplett, was Du oben selbst gepostet hast: den Startimpuls mit Überlänge.

Raw data: 10252,296,1024,292,1024,296,1020,296,1024,292,1024,296,1024,292,1028,948,368,288,1028,948,372,284,1032,292,1024,292,1024,952,364,292,1028,948,368,292,1024,948,372,292,1024,948,368,292,1028,292,1024,292,1028,944,376,

Zu Anfang der Sendung ist da ein "superlanger Startimpuls", den Du mit 10252 µs ausgemessen hast. Im Quellcode der Library finde ich die Angabe, dass dieser Startimpuls 31x länger ist als die Impulsdauer.

Also Startimpuls 31*330µs = 10230 µs. Danach kommen dann die aus der Impulsdauer von 330µs gebildeten Impulse, vergleiche mit den von Dir oben selbst geposteten "Raw data"!

Wobei ich mir nicht sicher bin, ob vor dem ersten Impuls nicht auch noch ein Vorlauf aus "Trainings-Bits" oder ein anderer "Startcode" gesendet werden muß. Ich kenne das Protokoll von Deinem Sender nicht, aber bei vielen solchen einfachen Sendern mit "überlangem Startbit" ist es so, dass vorher noch Trainingsbits gesendet werden, z.B. gesamtes Sendeprotokoll:

9x Trainingsbits zu je 330µs HIGH und 330µs LOW 1x überlanges Startbit zu 330µs HIGH und 10230µs LOW und dann erst die Datenbits

Also, vielen Dank für die Denkanstöße !!! Nachdem ich dann in Ruhe Informationen, mehr oder weniger, zusammengefügt habe, hat es geklappt.

Dabei ist dann noch mal eine halbe Stunde drauf gegangen bis ich gemerkt hab das Sender und Empfänger zu weit auseinander sind. :cold_sweat:

Hier jetzt der Fertige Sketch, falls es jemanden Interessiert:

#define sch_anzahl 2 //Anzahl der Schalter(Stationen) festlegen
#define z_winkel  0 //Winkel für Servo: Zu
#define a_winkel  170 //Winkel für Servo: Auf
#define rc_pin 10 //Pin für Sender festlegen

int schalter[sch_anzahl] = {22, 23}; //Pins für Schalter festlegen
int servo[sch_anzahl] = {52, 53}; //Pins für Schalter festlegen

void setup() {

  pinMode(rc_pin, OUTPUT);
  for (int a = 0; a < sch_anzahl; a++) { //Alle Schalter als Eingang festlegen
    pinMode(schalter[a], INPUT);
    pinMode(servo[a], OUTPUT);
    schliessen(a);
  }


}

void loop() {

  for (int a = 0; a < sch_anzahl; a++) {

    if (digitalRead(schalter[a]) == HIGH) {
      long start_zeit = millis();

      while (digitalRead(schalter[a]) == HIGH) {
        long ende_zeit = millis();

        if (start_zeit + 500 < ende_zeit) {
          oeffnen(a);
          delay(500);
          senden("000000010100010101010001");
          while (digitalRead(schalter[a]) == HIGH);
          senden("000000010100010101010100");
          delay(500);
          schliessen(a);
        }

      }

    }
  }


}

void oeffnen(int a) {


  for (int pos = z_winkel; pos < a_winkel; pos++) {
    int pwm = (pos * 11) + 500;
    digitalWrite(servo[a], HIGH);
    delayMicroseconds(pwm);
    digitalWrite(servo[a], LOW);
    delay(5);

  }

}

void schliessen(int a) {

  for (int pos = a_winkel; pos > z_winkel; pos -= 1) {
    int pwm = (pos * 11) + 500;
    digitalWrite(servo[a], HIGH);
    delayMicroseconds(pwm);
    digitalWrite(servo[a], LOW);
    delay(5);
  }

}






void senden(char code[]) {

  for (int w = 0; w < 7; w++) {

    for (int a = 0; a < strlen(code); a++) {

      char i = code[a];
      
      switch (i) {

        case '0': {

            digitalWrite(rc_pin, HIGH);
            delayMicroseconds(350);
            digitalWrite(rc_pin, LOW);
            delayMicroseconds(1050);
            break;
          }

        case '1': {

            digitalWrite(rc_pin, HIGH);
            delayMicroseconds(1050);
            digitalWrite(rc_pin, LOW);
            delayMicroseconds(350);
            break;
          }
      }
    }

    digitalWrite(rc_pin, HIGH);
    delayMicroseconds(350);
    digitalWrite(rc_pin, LOW);
    delayMicroseconds(10850);
  }

}

Danke, und ich hoffe ich kann auch mal jemandem so helfen.

Saubr:
Also, vielen Dank für die Denkanstöße !!! Nachdem ich dann in Ruhe Informationen, mehr oder weniger, zusammengefügt habe, hat es geklappt.

Na bravo!

Saubr:
Dabei ist dann noch mal eine halbe Stunde drauf gegangen bis ich gemerkt hab das Sender und Empfänger zu weit auseinander sind. :cold_sweat:

Diese kleinen Sender benötigen eine am “Ant” Anschluss befestigte 433MHz-Antenne, um eine gute Reichweite zu erzielen. Im einfachsten Fall reicht ein einfacher Draht als Lambda-Viertel-Antenne. Nimm einen Draht von 17,5 cm Länge und löte ihn am “Ant” Anschluss des Senders an! Dann sollte die Reichweite deutlich besser sein als ohne Antenne.

Saubr:
Hier jetzt der Fertige Sketch, falls es jemanden Interessiert:

Dein gesendetes Protokoll sieht nun allerdings so aus, dass Du die Datenfolge 7x sendest, und das “überlange Startbit” wird von Dir nicht am Anfang der Folge, sondern am Ende der Folge ausgesendet. So dass quasi bei der ersten Sendung kein überlanges Startbit kommt und tatsächlich sendest Du 6x ein korrektes Protokoll:

    1. Sendung - kein überlanges Startbit am Anfang, aber eins am Ende (ungültige Sendung)
    1. Sendung - das überlange Startbit der 1. Sendung ist gültig für die 2. Sendung
    1. Sendung - das überlange Startbit der 2. Sendung ist gültig für die 3. Sendung
    1. Sendung - das überlange Startbit der 3. Sendung ist gültig für die 4. Sendung
    1. Sendung - das überlange Startbit der 4. Sendung ist gültig für die 5. Sendung
    1. Sendung - das überlange Startbit der 5. Sendung ist gültig für die 6. Sendung
    1. Sendung - das überlange Startbit der 6. Sendung ist gültig für die 7. Sendung
  • das überlange Startbit am Ende der 7. Sendung ist über den Durst

Na ja, 6 von 7 Sendungen sind insofern korrekt und immerhin schaltet es ja damit.

Ein völlig korrektes Protokoll sendest Du dann, wenn die Schaltung auch dann funktioniert, wenn Du den Schaltbefehl nur 1x sendest, ohne die mehrfache Wiederholung zur Sicherheit.