433Mhz Modul sendet nicht. Modul heile und Code richtig. Radiohead ASK lib

Hey Leute.

Vorweg ich bin blutiger Anfänger in sachen Programiersprache und Arduino.

Ich habe folgendes Problem:
Ich habe auf einem Uno eine Art Stoppuhr mit zwei Zeiten(wechselnd zählend). Anzeige der Werte auf einem Display(LCD16x2). An dem Uno kann ich die Zeitnahme starten, wechseln, stoppen und zurücksetzen. Nun habe ich einen Nano an dem ich ebenfalls stoppen und zurücksetzen kann. Diese Befehle werden per 433Mhz Modul (die billigen einfachen dinger) und der Radiohead RH_ASK.h per Funk übertragen. Soweit alles schön, klappt auch. Nun soll bei “Stop” über eine weitere Funkverbindung(Rückstrecke) ein Ergebniss gesendet werden. Soweit alles gut klappt auch, AAAAABER nur wenn ich bei der Rückstrecke den TX und RX Pin direkt verbinde mit Kabel. Klemme ich die Funkmodule rein geht nix. Habe die beiden Funkmodul paare gegeneinander schon vertauscht daher weis ich das kein defekt vorliegen kann.

Also kurz zusammengefasst:
1.-Starten der Zeitnahme am Uno
2.-Stoppenbefehl am Nano
3.-Stoppbefehl: Nano TX----Funk1----RX Uno
4.-Zeitnahme stoppt am Uno
5.-Auswertung der Zeiten am Uno
5.-Ergebnis von Uno TX—Funk2—RX Nano
6.-Ergebniss am Nano auf LCD ausgeben

Das Problem liegt im Schritt 5.
Bei einer Drahtverbindung der TX und RX Pins geht alles. Wenn die Funkmodule dazwischen hängen nicht mehr.

Verwendete Module:Funkmodul

Mein Code:Uno

#include <RH_ASK.h>
#include <spi.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

RH_ASK funknetz(2000,19,18);

const int trigger_gelb_funk = 8;
const int trigger_rot_funk = 9;
const int trigger_stop_funk = 10;
const int trigger_reset_funk = 14;
bool gelb_stat_funk;
bool rot_stat_funk;
int16_t ticks_rot_funk = 0;
int16_t ticks_gelb_funk = 0;
const int rot_led_funk = 6;
const int gelb_led_funk = 7;
const char *orga_stop = "S";
const char *orga_reset = "R";
int8_t ergebniss_funk = 0;
int8_t *data = NULL;
uint32_t loopcount_funk;

void setup(){ 
  pinMode(8, INPUT);
  pinMode(9, INPUT);
  pinMode(10, INPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(14, INPUT);

  lcd.begin(16, 2);
  Serial.begin(9600);
  funknetz.init();
  if (!funknetz.init())
    {
    Serial.println("init failed");
    }
      else
      {
      Serial.println("init ok");
      }
      
  ticks_rot_funk = 0;
  ticks_gelb_funk = 0;
  gelb_stat_funk = false;
  rot_stat_funk = false;
  digitalWrite(rot_led_funk, LOW);
  digitalWrite(gelb_led_funk, LOW);
  
  lcdanzeige();
}

void loop() {
  for(uint32_t loopcount_funk = 0; loopcount_funk < 50000; loopcount_funk++)
    {
    if(digitalRead(trigger_gelb_funk) == HIGH)
      {
      gelb_stat_funk = true;
      rot_stat_funk = false;
      digitalWrite(gelb_led_funk, HIGH);
      digitalWrite(rot_led_funk, LOW);
      }
      
    if(digitalRead(trigger_rot_funk) == HIGH){
      rot_stat_funk = true;
      gelb_stat_funk = false;
      digitalWrite(rot_led_funk, HIGH);
      digitalWrite(gelb_led_funk, LOW);
      }
      
    if(digitalRead(trigger_stop_funk) == HIGH){
      gelb_stat_funk = false;
      rot_stat_funk = false;
      digitalWrite(rot_led_funk, LOW);
      digitalWrite(gelb_led_funk, LOW);
      }
      
    if(digitalRead(trigger_reset_funk) == HIGH)
      {
      ticks_rot_funk = 0;
      ticks_gelb_funk = 0;
      }
      
    uint8_t buf[RH_ASK_MAX_MESSAGE_LEN];
    uint8_t buflen = sizeof(buf);
    if (funknetz.recv(buf, &buflen))
      {
      if(buf[0]=='S'){
        gelb_stat_funk = false;
        rot_stat_funk = false;
        digitalWrite(rot_led_funk, LOW);
        digitalWrite(gelb_led_funk, LOW);
        ergebniss_funk = ticks_rot_funk - ticks_gelb_funk;
        data = &ergebniss_funk;
        Serial.println(ergebniss_funk);
        funknetz.send(data, sizeof(ergebniss_funk));
        funknetz.waitPacketSent();                
        }
      if(buf[0]=='R'){
        ticks_rot_funk = 0;
        ticks_gelb_funk = 0;        
        }      
      }
    }
  
  if(gelb_stat_funk == true){
    ticks_gelb_funk ++;
  }
  if(rot_stat_funk == true){
    ticks_rot_funk ++;
  }
  
  loopcount_funk = 0;
  
  lcdanzeige();

}

void lcdanzeige(){
  lcd.begin(16, 2);
  lcd.print("Rot :");
  lcd.setCursor(6, 0);
  lcd.print(ticks_rot_funk);
  lcd.setCursor(11, 0);
  lcd.print("Pkt.");
  lcd.setCursor(0, 2);
  lcd.print("Gelb:");
  lcd.setCursor(6, 2);
  lcd.print(ticks_gelb_funk);
  lcd.setCursor(11, 2);
  lcd.print("Pkt.");
}

Mein Code: Nano

#include <RH_ASK.h>
#include <spi.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 10);

RH_ASK funknetz(2000,7,6);

const char *orga_stop = "S";
const char *orga_reset = "R";
const int8_t trigger_stop_orga = 8;
const int8_t trigger_reset_orga = 9;
int8_t ergebniss_funk = 0;
int data;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  funknetz.init();
  if (!funknetz.init())
    {
    Serial.println("init failed");
    }
      else
      {
      Serial.println("init ok");
      }

  pinMode(trigger_stop_orga,INPUT);
  pinMode(trigger_reset_orga,INPUT);
  
  lcd.print("System aktiv!");
}

void loop() {
  if(digitalRead(trigger_stop_orga) == HIGH)
    {
    funknetz.send((uint8_t *)orga_stop, strlen(orga_stop));
    funknetz.waitPacketSent();
    }
    
  if(digitalRead(trigger_reset_orga) == HIGH)
    {
    funknetz.send((uint8_t *)orga_reset, strlen(orga_reset));
    funknetz.waitPacketSent();
    }

  int8_t buf[RH_ASK_MAX_MESSAGE_LEN];
  int8_t buflen = sizeof(buf);

  if (funknetz.recv(buf, &buflen))
    {
    Serial.println(buf[0]);  
    ergebniss_funk = buf[0];
    if (ergebniss_funk == 0)
      {
      Serial.print("Unbekannter Code");
      } 
        else
        {
        if(ergebniss_funk < 0)
          {
          int8_t ergebniss_funk_conv = abs(ergebniss_funk);
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("Gelb gewinnt mit");
          lcd.setCursor(0, 1);
          lcd.print(ergebniss_funk_conv);
          lcd.setCursor(4, 1);
          lcd.print("Pkt. vorspr."); 
          }
            else{
            lcd.clear();
            lcd.setCursor(0, 0);
            lcd.print("Rot gewinnt mit");
            lcd.setCursor(0, 1);
            lcd.print(ergebniss_funk);
            lcd.setCursor(4, 1);
            lcd.print("Pkt. vorspr.");
            }
        }     
    }
}

Falls ihr mehr Infos braucht dann einfach fragen. Im Notfall versuch ich ein Demovideo zu machen.
Falls mir jemand helfen kann wäre ich sehr glücklich.

Wofür ist die "spi.h" im Sketch ?

Hast du an den Modulen Antennen montiert ?

Wie weit sind die Module (Sender / Empfänger) jeweils voneinander entfernt ?

Edit:
Zeitkritische Dinge (Stopuhr) würde ich nicht per Funk übertragen, schon garnicht auf der "Allerwelts-Jedermannfrequenz" 433 MHz.

Die spi.h soll bei der rh_ask zum kompilieren benötigt werden. Hab ich wo gelesen.

Ich habe an allen Modulen 17,3cm Drähte angelötet.

Aktuell habe ich einen Abstand von 5-30cm.

Das System ist nicht Zeitkritisch. Mache keine Zeitmessung sondern es werden pro Sekunde(kann auch +-0,2sek oder so sein) Punktestände hochgezählt. Soll nur ein gleichmäßiger Intervall sein.

Auszug aus dem Beispielsketch.

// ask_receiver.pde
// -*- mode: C++ -*-
// Simple example of how to use RadioHead to receive messages
// with a simple ASK transmitter in a very simple way.
// Implements a simplex (one-way) receiver with an Rx-B1 module
#include <RH_ASK.h>
#include <SPI.h> // Not actualy used but needed to compile
RH_ASK driver;
// RH_ASK driver(2000, 2, 4, 5); // ESP8266: do not use pin 11

Scantraxx:
Die spi.h soll bei der rh_ask zum kompilieren benötigt werden. Hab ich wo gelesen.

Ok, das ist mir neu, aber kannst du testen. Einfach mal auskommentieren.

Ich habe an allen Modulen 17,3cm Drähte angelötet.

Das ist ok.

Aktuell habe ich einen Abstand von 5-30cm.

Da wird das Problem sein.
Diese billigen "Schrott"-Empfänger müssen zu einem anderen Empfänger einen Mindestabstand von 1 Meter haben. So beeinflussen die sich gegenseitig. Die haben einen Sender drauf, der den Empfang eines weiteren Empfängers stört.

Nimm lieber die besseren Empfänger, z.B. diese hier.

Edit:
Ok, hat sich überschnitten. Dann sollte das mit SPI.h korrekt sein.

Wie kann ein Empfänger einen anderen Empfänger stören? Ist das Modul was du verlinkt hast ein Kombimodul aus Sender und Empfänger? Meine sind ja getrennte Module für Senden und Empfangen oder verstehe ich da was falsch?

Scantraxx:
Wie kann ein Empfänger einen anderen Empfänger stören? Ist das Modul was du verlinkt hast ein Kombimodul aus Sender und Empfänger? Meine sind ja getrennte Module für Senden und Empfangen oder verstehe ich da was falsch?

Ja, die Technik ist nicht so ganz einfach. :wink:

Ich hatte ja geschrieben, die billigen Empfänger haben einen Sender (ist ein Oszillator) drauf, der fast auf der Empfangsfrequenz schwingt. Dieser stört damit andere, in der Nähe befindliche Empfänger.

Diese uralte Technik nennt sich Pendler oder Pendelaudion. Die neuen Generationen sind Superheterodyn oder Doppelsuperhet. Die sind einfach technisch moderner und auch den alten überlegen. Und der verlinkte ist ein reiner Empfänger (Doppelsuperhet). Der stört keine anderen Empfänger und du kannst diesen mit deinem Sender betreiben.

Dann werd ich das mal testen mit höherer Distanz. Komisch zwar das die eine Funkrichtung geht und die andere nicht. Sonst werd ich die anderen Empfänger mal testen. Werde hier dann meine Erkentnisse teilen. Danke schon mal soweit.

Funk geht manchmal seltsame Wege.
Ich hatte mir auch deine Sketche angesehen, um einen evtl. Fehler zu finden.
Leider kenne ich deine Library nicht und die Sketche sind nicht dokumentiert, das macht es nicht einfacher.

Ich habe mir jetzt deinen Sketch angesehen und vermute es liegt an deiner zu schnell aufeinanderfolgenden Empfangs- Sendesteuerung.
Da ich deine Library nicht kenne, ist das eine Vermutung.
Du sendest eine Quittung innerhalb der Empfangsroutine, das wird nicht funktionieren.
Du solltest erst den Empfang abschließen, das Ergebnis in eine Variable schreiben und anschließend die Quittung senden.