Posielanie dát z arduina do arduina pomocou 433mhz

[007ToMMaS]

Ahojte, chcel by som sa poradiť s skúsenejšími a s tými čo majú v programovaní čosi za sebou. Riešim odosielanie z arduina mini pro do arduino mega. Na arduine mini pro mi beží program na prebytky zároveň chcem odosielať data o stave teda napätie cielové napätie a hodnotu pwm. Program som použil od dramu. V arduino mega prímam hodnoty. Pre zatiaľ prímam iba jednu hodnotu lebo kdesi je zádrhel a neviem kde. Odoslať odošlem tri hodnoty ale príde iba jedna. V prílohe je knižnica. Chcel by som sa spýtať či by ste mi vedeli poradiť kde mám chybu. Ďakujem

Prijímač:

Kód: Vybrat vše

#include <LwRx.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(14, 15, 16, 17, 18, 19);

int led = 13;
int hodnota = 0;
int u_cele = 0;
int napatie = 0;
int u_tg = 0;
int pwm = 0;
void setup() {
  lwrx_setup(2); // pin na ktorý je pripojený prímač na arduine
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(led, OUTPUT);
}
 
void loop() {
  byte data[10];
  byte len = 10;
 
  if (lwrx_message()) {
     lwrx_getmessage(data,&len);

hodnota = data[9] + (data[8] << 4) + (data[7] << 8) + (data[6] << 12);
if (data[0] == 1) pwm = hodnota;
if (data[0] == 2) u_cele = hodnota;
if (data[0] == 3) u_tg = hodnota;

Serial.println(hodnota);
float u_tgd =(float)u_tg / 1000;
float napatie =(float) u_cele / 1000;
Serial.println("U_tg");
Serial.println(u_tgd);
Serial.println("Napatie");
Serial.println(u_cele);
Serial.println("Pwm - ");
Serial.println(pwm);
Serial.println(" ");
lcd.setCursor(0, 0);
lcd.print( "U_tg " );
lcd.print(u_tgd);
lcd.setCursor(0, 1);
lcd.print( "PWM - " );
lcd.print(pwm);
  digitalWrite(led, HIGH);   
  delay(1000);               
  digitalWrite(led, LOW); 
lcd.setCursor(15, 0);
lcd.print( "R" );
delay(1000);
lcd.setCursor(15, 0);
lcd.print( " " );
delay(3000);
  }
}

Vysielač:

Kód: Vybrat vše

#include <LwTx.h>
byte data[] = {0,0,0,0,0,0,0,0,0,1};
long timeout = 0;
int hodnota = 0 ;

int analogPin     = 1;  // pin na kterem merime napeti na baterii
float targetVoltage = 16.40; // hodnota ciloveho napeti
float minVoltage = 14.20; // minimalni hodnota napeti, pri ktere se vypina PWM
float analogVoltage = 0;  // hodnota na pinu analogPin
float analogVoltageSum = 0; // promenna pro prumerovani analogVoltage
int pwmPin        = 13; // pin na kterem vyrabime PWM signal
float analogDivision= 17.897; // rozliseni na 1 volt (zapocitan o. delic) 
float diffMax      = 0.2; // maximalni odchylka od ciloveho napeti
byte pwmDuty      = 0; // kolik % PWM cyklu bude rele zapnuto
byte pwmStepUp    = 2; // minimalni zmena skoku PWM nahoru
byte pwmStepDown  = 3; // minimalni zmena skoku PWM dolu
int pwmMax        = 100; // maximalni povoleny vykon v %
int pwmFreq      = 50; // frekvence PWM - maximalne 100Hz!
int pwmCycle     = 1; // cas v sekundach mezi zmenou PWM duty
int sumTime      = 0; // celkova delka PWM cyklu v ms
int pwmLength    = 0; // delka jednoho cyklu v milisekundach
int i               ; // pomocna promenna
// funkce se provede po startu
void setup() {
  // inicializace serioveho portu na rychlost 115200 bps:
  Serial.begin(115200);
  lwtx_setup(9, 10); // pin na ktorom je pripojený vysielač  a počet odoslaných kopii
  // nastaveni digitalniho pinu jako vystup
  pinMode(pwmPin, OUTPUT);
  // par odberu pro odstraneni hlouposti;
  analogRead(analogPin);
  analogRead(analogPin);
  delay(500);
  analogRead(analogPin);
  delay(500);
  analogRead(analogPin);
  delay(500);
  analogRead(analogPin);
  delay(500);
  analogRead(analogPin);
  delay(500);
  // pojistka, aby jsme si nezapamatovali prilis
  // nizke cilove napeti 
  //while (analogVoltage < minVoltage + diffMax)
//  {
//    // pulsekunda na usazeni
//    delay(500);
//    // sto odberu na zprumerovani
//    analogVoltageSum=0;
    for (i=0; i<100; i++)
      {
      // napeti na analogPin bude brano jako cilove napeti
      // (po zprumerovani)
      analogVoltage=analogRead(analogPin)/analogDivision;
      analogVoltageSum=analogVoltageSum+analogVoltage;
      delay(50);
      }
//    // zprumerujeme
    analogVoltage=analogVoltageSum/100; 
//    // vypiseme
//    Serial.print("Aktualni napeti (prumer): ");
//    Serial.println(analogVoltage);
//  }
  // napeti je dostatecne vysoke, takze ho bereme jako cilove  
  targetVoltage=analogVoltage;
  Serial.print("Cilove napeti nastaveno na: ");
  Serial.println(analogVoltage);
}

void loop() {

  // nacteme aktualni napeti
  analogVoltage=analogRead(analogPin)/analogDivision;
  delay(5);
  analogVoltage=(analogVoltage+analogRead(analogPin)/analogDivision)/2;
  // pokud je rozdil napeti skutecneho a ciloveho 
  // ve stanovene mezi, zvysime vykon, jinak snizujeme
  if (targetVoltage - analogVoltage < diffMax)
  {
    if (pwmDuty+pwmStepUp > pwmMax)
    {
      pwmDuty=pwmMax;
    }
    else
    {
      pwmDuty=pwmDuty+pwmStepUp;
    }
  }
  else
  {
    if (pwmDuty-pwmStepDown < 0)
    {
      pwmDuty=0;
    }
    else
    {
      pwmDuty=pwmDuty-pwmStepDown;
    }
  }
  // skokove stazeni vykonu, pokud dojde k poklesu napeti  
  if ( analogVoltage < minVoltage)
  {
    pwmDuty=0;
  }
 Serial.print("Cilove napeti:   ");
 Serial.println(targetVoltage);
 Serial.print("Aktualni napeti: ");
 Serial.println(analogVoltage);  
 Serial.print("PWM:             ");
 Serial.println(pwmDuty);
  // Vlastni PWM cyklus
  sumTime = 0;
  pwmLength = 1000 / pwmFreq;
  while ( sumTime < pwmCycle * 1000)
    {
    if (pwmDuty > 0)
      {
      sumTime=sumTime+pwmLength+pwmLength*(100-pwmDuty)/pwmDuty;
      digitalWrite(pwmPin, HIGH);
      delay(pwmLength);
      digitalWrite(pwmPin, LOW);
      delay(pwmLength*(100-pwmDuty)/pwmDuty);
      }
    else
      {
      digitalWrite(pwmPin, LOW);
      sumTime=pwmCycle * 1000+1;
      delay(pwmCycle * 1000+1);
      }  
    }
float u_cele = analogVoltage * 1000;
float u_tg = targetVoltage * 1000;
hodnota = u_cele;
hodnota = pwmDuty ;
hodnota = u_tg ;
Serial.println(u_cele);
Serial.println(u_tg);
data[0] = 1;
data[0] = 2;
data[0] = 3; 
data[9] = hodnota;
data[8] = hodnota >> 4;
data[7] = hodnota >> 8;
data[6] = hodnota >> 12;



   if (lwtx_free())
   {
   lwtx_send(data);
   }
   
}