Arduino Arduino IR Übertragung

[Bording]

Hallo,

es gibt ja eine recht umfangreich Arduino Libary für die IR Übertragung. Ich möchte allerdings nicht über eine IR Diode und Empfänger übertragen, sondern über Draht.
Dazu habe ich zwei Arduino Nano miteinander verbunden (+ / - / Datenleitung)
Es werden auch Daten übertragen, aber die "passen" nicht.

Gemessen mit dem Programm "Reveiver Timing Analysis bekomme ich folgende Werte:

13:41:53.713 -> Mark : SampleCount=190 Minimum=32 @13 Maximum=84 @3 Delta=52 Average=41
13:41:53.713 -> ShortSpace: SampleCount=80 Minimum=20 @60 Maximum=576 @54 Delta=556 Average=57
13:41:53.713 -> LongSpace : SampleCount=11 Minimum=1672 @6 Maximum=4504 @0 Delta=2832 Average=1941
13:41:53.713 -> Analysis :
13:41:53.713 -> Average (Mark + ShortSpace)/2=49us Delta (to NEC standard 560)=-511us
13:41:53.713 -> Mark - Average -> MARK_EXCESS_MICROS=-8us
13:41:53.713 ->

Auf dem Sender läuft bei mir folgendes Programm

/*
 * SimpleSender.cpp
 *
 *  Demonstrates sending IR codes in standard format with address and command
 *  An extended example for sending can be found as SendDemo.
 *
 *  Copyright (C) 2020-2021  Armin Joachimsmeyer
 *  armin.joachimsmeyer@gmail.com
 *
 *  This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
 *
 *  MIT License
 */
#include <Arduino.h>

/*
 * Define macros for input and output pin etc.
 */
//#include "PinDefinitionsAndMore.h"
#define IR_RECEIVE_PIN      2
#define IR_SEND_PIN       3
//#define IR_SEND_PIN         9
#define TONE_PIN            4
#define APPLICATION_PIN     5
#define ALTERNATIVE_IR_FEEDBACK_LED_PIN 6 // E.g. used for examples which use LED_BUILDIN for example output.
#define IR_TIMING_TEST_PIN  7


#include <IRremote.hpp>

void setup() {
    pinMode(LED_BUILTIN, OUTPUT);

    Serial.begin(115200);

    // Just to know which program is running on my Arduino
    Serial.println(F("START " __FILE__ " from " __DATE__ "\r\nUsing library version " VERSION_IRREMOTE));

    /*
     * The IR library setup. That's all!
     */
    IrSender.begin(IR_SEND_PIN, ENABLE_LED_FEEDBACK); // Specify send pin and enable feedback LED at default feedback LED pin

    Serial.print(F("Ready to send IR signals at pin "));
    Serial.println(IR_SEND_PIN);
}

/*
 * Set up the data to be sent.
 * For most protocols, the data is build up with a constant 8 (or 16 byte) address
 * and a variable 8 bit command.
 * There are exceptions like Sony and Denon, which have 5 bit address.
 */
uint16_t sAddress = 0x0102;
uint8_t sCommand = 0x34;
uint8_t sRepeats = 0;

void loop() {
    /*
     * Print current send values
     */
    Serial.println();
    Serial.print(F("Send now: address=0x"));
    Serial.print(sAddress, HEX);
    Serial.print(F(" command=0x"));
    Serial.print(sCommand, HEX);
    Serial.print(F(" repeats="));
    Serial.print(sRepeats);
    Serial.println();

    Serial.println(F("Send NEC with 16 bit address"));
    Serial.flush();

    // Results for the first loop to: Protocol=NEC Address=0x102 Command=0x34 Raw-Data=0xCB340102 (32 bits)
    IrSender.sendNEC(sAddress, sCommand, sRepeats);

    /*
     * If you cannot avoid to send a raw value directly like e.g. 0xCB340102 you must use sendNECRaw()
     */
//    Serial.println(F("Send NECRaw 0xCB340102"));
//    IrSender.sendNECRaw(0xCB340102, sRepeats);
    /*
     * Increment send values
     * Also increment address just for demonstration, which normally makes no sense
     */
  /*  sAddress += 0x0101;
    sCommand += 0x11;
    sRepeats++;
    // clip repeats at 4
    if (sRepeats > 4) {
        sRepeats = 4;
    }
*/
    delay(1000);  // delay must be greater than 5 ms (RECORD_GAP_MICROS), otherwise the receiver sees it as one long signal
}

Auf dem Empfänger dies hier

/*
 *  ReceiverTimingAnalysis.cpp
 *
 *  This program enables the pin change interrupt at pin 3 and waits for NEC (or other Pulse-Distance-Coding) IR Signal.
 *  It measures the pulse and pause times of the incoming signal and computes some statistics for it.
 *
 *  Observed values:
 *  Delta of each signal type is around 50 up to 100 and at low signals up to 200. TSOP is better, especially at low IR signal level.
 *  VS1838      Mark Excess -50 to +50 us
 *  TSOP31238   Mark Excess 0 to +50
 *
 *
 *  Copyright (C) 2019-2020  Armin Joachimsmeyer
 *  armin.joachimsmeyer@gmail.com
 *
 *  This file is part of IRMP https://github.com/ukw100/IRMP.
 *  This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
 *
 *  IRMP is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/gpl.html>.
 *
 */

#include <Arduino.h>

#define IR_INPUT_PIN    3

/*
 * Helper macro for getting a macro definition as string
 */
#define STR_HELPER(x) #x
#define STR(x) STR_HELPER(x)

void measureTimingISR(void);

void setup()
{
    pinMode(LED_BUILTIN, OUTPUT);
    Serial.begin(115200);
#if defined(__AVR_ATmega32U4__) || defined(SERIAL_USB) || defined(SERIAL_PORT_USBVIRTUAL) || defined(ARDUINO_attiny3217)
    delay(4000); // To be able to connect Serial monitor after reset or power up and before first print out. Do not wait for an attached Serial Monitor!
#endif
    // Just to know which program is running on my Arduino
    Serial.println(F("START " __FILE__ " from " __DATE__));

#if defined(EICRA) && defined(EIFR) && defined(EIMSK)
    // enable interrupt on pin3 on both edges for ATmega328
    EICRA |= _BV(ISC10);
    // clear interrupt bit
    EIFR |= 1 << INTF1;
    // enable interrupt on next change
    EIMSK |= 1 << INT1;
#else
    attachInterrupt(digitalPinToInterrupt(IR_INPUT_PIN), measureTimingISR, CHANGE);
#endif
    Serial.println(F("Ready to analyze NEC IR signal at pin " STR(IR_INPUT_PIN)));
    Serial.println();
}

uint8_t ISREdgeCounter = 0;
volatile uint32_t LastMicros;
struct timingStruct
{
    uint16_t minimum;
    uint8_t indexOfMinimum;
    uint16_t maximum;
    uint8_t indexOfMaximum;
    uint16_t average;

    uint16_t SumForAverage;
    uint8_t SampleCount;
//    uint8_t LastPrintedCount;
};

struct timingStruct Mark;
struct timingStruct ShortSpace;
struct timingStruct LongSpace;

/*
 * Compute minimum, maximum and average
 */
void processTmingValue(struct timingStruct *aTimingStruct, uint16_t aValue)
{
    if (aTimingStruct->SampleCount == 0)
    {
        // initialize values
        aTimingStruct->minimum = 0xFFFF;
        aTimingStruct->maximum = 0;
        aTimingStruct->SumForAverage = 0;
    }

    if (aTimingStruct->minimum > aValue)
    {
        aTimingStruct->minimum = aValue;
        aTimingStruct->indexOfMinimum = aTimingStruct->SampleCount;
    }
    if (aTimingStruct->maximum < aValue)
    {
        aTimingStruct->maximum = aValue;
        aTimingStruct->indexOfMaximum = aTimingStruct->SampleCount;
    }

    aTimingStruct->SampleCount++;
    aTimingStruct->SumForAverage += aValue;
    aTimingStruct->average = (aTimingStruct->SumForAverage + (aTimingStruct->SampleCount / 2)) / aTimingStruct->SampleCount;

}

void printTimingValues(struct timingStruct *aTimingStruct, const char *aCaption)
{
//    if (aTimingStruct->LastPrintedCount != aTimingStruct->SampleCount)
//    {
//        aTimingStruct->LastPrintedCount = aTimingStruct->SampleCount;
    Serial.print(aCaption);
    Serial.print(F(": SampleCount="));
    Serial.print(aTimingStruct->SampleCount);
    Serial.print(F(" Minimum="));
    Serial.print(aTimingStruct->minimum);
    Serial.print(F(" @"));
    Serial.print(aTimingStruct->indexOfMinimum);
    Serial.print(F(" Maximum="));
    Serial.print(aTimingStruct->maximum);
    Serial.print(F(" @"));
    Serial.print(aTimingStruct->indexOfMaximum);
    Serial.print(F(" Delta="));
    Serial.print(aTimingStruct->maximum - aTimingStruct->minimum);
    Serial.print(F("   Average="));
    Serial.print(aTimingStruct->average);

    Serial.println();
//    }
}

void loop()
{
    if (Mark.SampleCount >= 32)
    {
        /*
         * This check enables statistics for longer protocols like Kaseikyo/Panasonics
         */
#if !defined(ARDUINO_ARCH_MBED)
        noInterrupts();
#endif
        uint32_t tLastMicros = LastMicros;
#if !defined(ARDUINO_ARCH_MBED)
        interrupts();
#endif
        uint32_t tMicrosDelta = micros() - tLastMicros;

        if (tMicrosDelta > 10000)
        {
            // NEC signal ended just now
            Serial.println();
            printTimingValues(&Mark, "Mark      ");
            printTimingValues(&ShortSpace, "ShortSpace");
            printTimingValues(&LongSpace, "LongSpace ");

            /*
             * Print analysis of mark and short spaces
             */
            Serial.println(F("Analysis  :"));
            Serial.print(F(" Average (Mark + ShortSpace)/2="));
            int16_t MarkAndShortSpaceAverage = (Mark.average + ShortSpace.average) / 2;
            Serial.print(MarkAndShortSpaceAverage);
            Serial.print(F("us   Delta (to NEC standard 560)="));
            Serial.print(MarkAndShortSpaceAverage - 560);
            Serial.print(F("us\r\n Mark - Average -> MARK_EXCESS_MICROS="));
            Serial.print((int16_t) Mark.average - MarkAndShortSpaceAverage);
            Serial.print(F("us"));
            Serial.println();
            Serial.println();

            Mark.SampleCount = 0; // used as flag for not printing the results more than once
        }
    }
}

/*
 * The interrupt handler.
 * Just add to the appropriate timing structure.
 */
#if defined(ESP8266)
void ICACHE_RAM_ATTR measureTimingISR()
#elif defined(ESP32)
void IRAM_ATTR measureTimingISR()
#else
#  if defined(EICRA) && defined(EIFR) && defined(EIMSK)
ISR(INT1_vect)
#  else
void measureTimingISR()
#  endif
#endif
{
    uint32_t tMicros = micros();
    uint32_t tMicrosDelta = tMicros - LastMicros;
    LastMicros = tMicros;
    /*
     * read level and give feedback
     */
    uint8_t tInputLevel = digitalRead(IR_INPUT_PIN);
    digitalWrite(LED_BUILTIN, !tInputLevel);

    if (tMicrosDelta > 10000)
    {
        // gap > 10 ms detected, reset counter to first detected edge and initialize timing structures
        ISREdgeCounter = 1;
        LongSpace.SampleCount = 0;
        ShortSpace.SampleCount = 0;
        Mark.SampleCount = 0;
    }
    else
    {
        ISREdgeCounter++;
    }

    /*
     * Skip header mark and space and first bit mark and space
     */
    if (ISREdgeCounter > 4)
    {
        if (tInputLevel != LOW)
        {
            // Mark ended
            processTmingValue(&Mark, tMicrosDelta);
//            Serial.print('M');
        }
        else
        {
            // Space ended
            if (tMicrosDelta > 1000)
            {
                // long space - logical 1
                processTmingValue(&LongSpace, tMicrosDelta);
                Serial.print('1');
            }
            else
            {
                // short space - logical 0
                processTmingValue(&ShortSpace, tMicrosDelta);
                Serial.print('0');
            }
        }
    }
}

Was mache ich da falsch?

 

[Rasenmäher]

Wäre die Verwendung des I2C-Buses nicht besser?

http://www.netzmafia.de/skripten/hardware/Arduino/Programmierung/wire_library.html

http://www.sachsendreier.com/asw/projekteundexperimente/i2c/i2c.php

 

[PhilWil91]

Hallo Bert,

Hast du Pull-up/ -down Widerstände an den Datenleitungen? Ohne, kann es sein, dass nur Müll ankommt.
Ich denke bei der IR-Bibliothek müsste es Pulldown sein…
I2C wäre natürlich eine Alternative, ich benutze das mittlerweile gerne.

Gruß Philipp

 

[Bording]

Hallo Stefan und Phillip,

I2C wollte ich nicht nehmen, da brauche ich eine Datenleitung und eine Taktleitung + Masse. Außerdem ist der I2C auch nicht störfest.
Pull down Widerstand hatte ich auch schon drin. Die Lietung geht von einem digitalen Ausgang zu einem digitalen Eingang, da sollte kein Pull Down oder Pull up drin sein.

Ich habe mir jetzt mal einen IR Bausatz mit Empfänger und einfacher Fernsteuerung bestellt. Wenn das funktioniert kann ich gezielter weiter suchen, so weis man nicht wo man anfangen soll. Sender, Empfänger, Datenleitung vielleicht invertiert?

 

[PhilWil91]

Hallo Bert,
Ich würde die Pull-Widerstände auf Datenleitungen immer einbauen, auch wenn sie nicht zwingend nötig sind. Die Ein und Ausgänge können sich gegenseitig runterziehen und die Übertragung ist im Eimer. Es kann auch helfen mal 1K in Reihe in die Datenleitung zu setzen.
Vielleicht schaffe ich es am Mittwoch noch den Sketch mal zu testen… vorher schaffe ich das leider nicht

 

[Bording]

Hallo Philipp,

ich habe mir mal die IR Empfänger angesehen die für den Arduino angeboten werden. Das ist ein VS1838B, dort gibt es ein interessantes Bild über das Signal. Die Trägerfrequenz der IR Diode beträgt 38 kHz, das heißt die Datenpakete werden aus 38 kHz Impulsen zusammengesetzt. Der IR Empfänger filtert dann die 38 kHz raus, er gibt dann ein glattes High oder Low aus.
Das wir ein Grund sein warum ich das so nicht zum laúfen bekommen.

das habe ich eben noch gefunden

 

[PhilWil91]

Hallo Bert,

ich habe, während wir aufs Essen gewartet haben, den Sender doch schon mal aufgespielt und ans Scope gehängt. Das dürften deine 38KHz sein. Über den Rechner verzerrt das leider immer ein Bisschen.
Wenn du unbedingt die Variante nehmen möchtest, könntest du versuchen die 38kHz mit einem Kondensator rauszufiltern. Ob I2C oder eine normale Serielle Übertragung dann nicht doch zuverlässiger wäre sei mal dahin gestellt...
Invertiert ist es aber nicht ;-)

 

[Bording]

Hallo

heute ist meine IR Diode und der Empfänger angekommen. Die Software ist ok, aber die Übertragung per Draht wird wie schon befürchtet durch die 38 kHz Modulation "gestört".

Ich habe jetzt drei Möglichkeiten:
1. eine IR Strecke bauen und dann per Draht weiter
2. die Modulation aus der Libary heraus nehmen (erst mal finden)
3. mir ein eigenes Übertragungsprotokoll ausdenken, oder eines abwandeln

 

[Bording]

und manchmal ist es so einfach

#define USE_NO_SEND_PWM                        // damit schaltet man die 38 kHz Trägerfrequenz ab

 

[Winni]

Da musst du aber erst mal drauf kommen. Hätte ich auch nicht gewusst!

 

[Bording]

Hallo,

das IR Übertragunsprotokoll funktionierte, hat aber einen Zeitversatz. Deutlich sieht man das bei einen Blinkerfunktion
Daher ist das Protokoll nicht zu gebrauchen.

Alternativ habe ich mal das SoftwareSerial ausprobiert das funktioniert und hat keinen sichtbaren Zeitversatz, auch bei 9600 Baud nicht. Man benötigt insgesamt auch nur 2 Leitungen: Masse und die TX vom Sender

/* Sender 2021-11-07
 * Serielle Datenübertragung one Way
 *
 * https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html
 *https://www.arduino.cc/en/Reference/softwareSerial
 *
  */

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);                 // RX, TX Create the SoftSerial object.  

const byte Licht = 8;                          // PB0          
const byte Bremslicht = 9;                     // PB1
const byte Rueckfahrlicht = 10;                // PB2
const byte Blinker_rechts = 11;                // PB3
const byte Blinker_links = 12;                 // PB4                                                                                         
byte Eingaenge = 0;
byte data;


void setup() {
    pinMode(Licht, INPUT_PULLUP);              // Eingang Licht, low-aktiv, Pullup 20k zu 5V
    pinMode(Bremslicht, INPUT_PULLUP);         // Eingang Bremslicht, low-aktiv, Pullup 20k zu 5V
    pinMode(Rueckfahrlicht, INPUT_PULLUP);     // Eingang Rueckfahrlicht, low-aktiv, Pullup 20k zu 5V
    pinMode(Blinker_rechts, INPUT_PULLUP);     // Eingang Blinker_rechts, low-aktiv, Pullup 20k zu 5V
    pinMode(Blinker_links, INPUT_PULLUP);      // Eingang Blinker_links, low-aktiv, Pullup 20k zu 5V
        
    Serial.begin(115200);

   while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
    }
   Serial.println("Goodnight moon!");

   mySerial.begin(9600);                       // initialize the port to communicate at a specific baud rate. 
   mySerial.println("Hello, world?");
}



void loop() {
    Eingaenge = 31 - (PINB & B00011111);       // alle Eingänge high = 31, B00011111 maskiert die oberen 3 bit aus, PINB lies Port B aus
     
    mySerial.write(Eingaenge);                // send a byte with the value "Eingaenge"

    Serial.println(Eingaenge);
    delay (10);
  }

/* Empfänger 2021-11-07
 * Serielle Datenübertragung one Way
 *
 * https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html
 *https://www.arduino.cc/en/Reference/softwareSerial
 */

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);                       // RX, TX Create the SoftSerial object.  Nur RX wird benutzt, 10 k Pull down

const byte Licht = 8;                                // PB0          
const byte Bremslicht = 9;                           // PB1
const byte Rueckfahrlicht = 10;                      // PB2
const byte Blinker_rechts = 11;                      // PB3
const byte Blinker_links = 12;                       // PB4                                                                                         
byte data = 0;
int timeout = 0;


void setup() {
    pinMode(Licht, OUTPUT);                          // Ausgang Licht, 
    pinMode(Bremslicht, OUTPUT);                     // Ausgang Bremslicht, 
    pinMode(Rueckfahrlicht, OUTPUT);                 // Ausgang Rueckfahrlicht,
    pinMode(Blinker_rechts, OUTPUT);                 // Ausgang Blinker_rechts, 
    pinMode(Blinker_links, OUTPUT);                  // Ausgang Blinker_links, 
   
    Serial.begin(115200);

    while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
    }
    Serial.println("Empfänger");

   mySerial.begin(9600);                             // initialize the port to communicate at a specific baud rate. 
   mySerial.println("Empfänger");
 
  }

void loop() {

   if (mySerial.available()>0) {                     // Returns the number of bytes received, which can be read.
   data = mySerial.read();                           // Reads the next byte from the port. If nothing has been received, -1 is returned. 
   timeout = 0;                                      // setzt den Timeout zurück
   PORTB = (B00011111 & data);                       // schiebt die Daten in die Ausgänge 
   PORTB ^= (1 <<4);                                 // invertiert das 4te bit, Zähler startet bei 0!
   }
   
   Serial.println(data);

   timeout ++;                                       // setzt den Timeout einen hoch
   if (timeout >= 10) {                              // wenn Timeout über 10
   timeout = 11;                                     // verhindert einen Überlauf
   data = 0;                                         // Daten werden auf Null gesetzt
   PORTB = B00000000;                                // setzt alle Ausgänge auf Null
   }
   
  }

 

[Mac Gayver]

Hallo Bert,

genau so was wollte ich an Winnis Lichtschaltung implementieren. Hatte dann aber schnell aufgegeben und mich lieber mit anderem beschäftigt.

Ist meine Überlegung richtig, dass ich mehrere Empfänger an die Leitung hängen kann. Z.B. Einen für die Rücklichter und einen weiteren für die Lichter vom Anhänger ...vom 2. Anhänger ...
Schließlich läuft die serielle Schnittelle hier ohne Rückmeldung.

 

[PhilWil91]

Hallo,

das IR Übertragunsprotokoll funktionierte, hat aber einen Zeitversatz. Deutlich sieht man das bei einen Blinkerfunktion
Daher ist das Protokoll nicht zu gebrauchen.

Alternativ habe ich mal das SoftwareSerial ausprobiert das funktioniert und hat keinen sichtbaren Zeitversatz, auch bei 9600 Baud nicht. Man benötigt insgesamt auch nur 2 Leitungen: Masse und die TX vom Sender

/* Sender 2021-11-07
 * Serielle Datenübertragung one Way
 *
 * https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html
 *https://www.arduino.cc/en/Reference/softwareSerial
 *
  */

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);                 // RX, TX Create the SoftSerial object.  

const byte Licht = 8;                          // PB0          
const byte Bremslicht = 9;                     // PB1
const byte Rueckfahrlicht = 10;                // PB2
const byte Blinker_rechts = 11;                // PB3
const byte Blinker_links = 12;                 // PB4                                                                                         
byte Eingaenge = 0;
byte data;


void setup() {
    pinMode(Licht, INPUT_PULLUP);              // Eingang Licht, low-aktiv, Pullup 20k zu 5V
    pinMode(Bremslicht, INPUT_PULLUP);         // Eingang Bremslicht, low-aktiv, Pullup 20k zu 5V
    pinMode(Rueckfahrlicht, INPUT_PULLUP);     // Eingang Rueckfahrlicht, low-aktiv, Pullup 20k zu 5V
    pinMode(Blinker_rechts, INPUT_PULLUP);     // Eingang Blinker_rechts, low-aktiv, Pullup 20k zu 5V
    pinMode(Blinker_links, INPUT_PULLUP);      // Eingang Blinker_links, low-aktiv, Pullup 20k zu 5V
        
    Serial.begin(115200);

   while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
    }
   Serial.println("Goodnight moon!");

   mySerial.begin(9600);                       // initialize the port to communicate at a specific baud rate. 
   mySerial.println("Hello, world?");
}



void loop() {
    Eingaenge = 31 - (PINB & B00011111);       // alle Eingänge high = 31, B00011111 maskiert die oberen 3 bit aus, PINB lies Port B aus
     
    mySerial.write(Eingaenge);                // send a byte with the value "Eingaenge"

    Serial.println(Eingaenge);
    delay (10);
  }

/* Empfänger 2021-11-07
 * Serielle Datenübertragung one Way
 *
 * https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html
 *https://www.arduino.cc/en/Reference/softwareSerial
 */

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);                       // RX, TX Create the SoftSerial object.  Nur RX wird benutzt, 10 k Pull down

const byte Licht = 8;                                // PB0          
const byte Bremslicht = 9;                           // PB1
const byte Rueckfahrlicht = 10;                      // PB2
const byte Blinker_rechts = 11;                      // PB3
const byte Blinker_links = 12;                       // PB4                                                                                         
byte data = 0;
int timeout = 0;


void setup() {
    pinMode(Licht, OUTPUT);                          // Ausgang Licht, 
    pinMode(Bremslicht, OUTPUT);                     // Ausgang Bremslicht, 
    pinMode(Rueckfahrlicht, OUTPUT);                 // Ausgang Rueckfahrlicht,
    pinMode(Blinker_rechts, OUTPUT);                 // Ausgang Blinker_rechts, 
    pinMode(Blinker_links, OUTPUT);                  // Ausgang Blinker_links, 
   
    Serial.begin(115200);

    while (!Serial) {
    ; // wait for serial port to connect. Needed for Native USB only
    }
    Serial.println("Empfänger");

   mySerial.begin(9600);                             // initialize the port to communicate at a specific baud rate. 
   mySerial.println("Empfänger");
 
  }

void loop() {

   if (mySerial.available()>0) {                     // Returns the number of bytes received, which can be read.
   data = mySerial.read();                           // Reads the next byte from the port. If nothing has been received, -1 is returned. 
   timeout = 0;                                      // setzt den Timeout zurück
   PORTB = (B00011111 & data);                       // schiebt die Daten in die Ausgänge 
   PORTB ^= (1 <<4);                                 // invertiert das 4te bit, Zähler startet bei 0!
   }
   
   Serial.println(data);

   timeout ++;                                       // setzt den Timeout einen hoch
   if (timeout >= 10) {                              // wenn Timeout über 10
   timeout = 11;                                     // verhindert einen Überlauf
   data = 0;                                         // Daten werden auf Null gesetzt
   PORTB = B00000000;                                // setzt alle Ausgänge auf Null
   }
   
  }

In dem IR Programm ist am Ende eine Sekunde Delay drin, hattest du die mal rausgenommen oder erheblich kleiner gemacht?

 

[Bording]

Hallo Milan,

theoretisch kannst du mehrere Empfänger dranhängen. Die bekommen dann alle das gleiche Signal. Der Empfänger muss sich dann die relevanten Signale "raussuchen".


Hallo Philipp

die 1000ms habe ich bis runter auf 7 oder 8ms reduziert, das hats auchn nicht gebracht. Ich denke das Protokoll ist einfach zu komplex (lang). Beim Serial wird einfach nur 1 Byte übertragen + Start und Stop Bits.
Da sind keine Adressen und Checksummen drin.