Kommunikation mellan olika processorer - Hur gör ni?

[Al_Bundy]

Hej!

Jag håller på skapa kommunikation mellan två processorer. En processorn ska skicka talet 10 till den andra processorn och 10 är nyckel för en viss operation. Processorn som tar emot ett tal ska gå in i en viss sekvens och skicka tillbaka. Men jag har mycket problem med det också.

I min kod så skickar jag ett tal och direkt efter börjar en while(1) loop som läser av om något kommer med en if-sats. Om något finns att läsa så läser koden det och skickar det vidare, dvs går ur while(1) loopen som befinner sig inom en funktion.

Men problemet är att går det för snabbt så fungerar det inte riktigt och min kommunikation måste vara snabb. Däremot så fungerar det ganska bra om jag håller seg kommunikation, vilket jag vill helst undvika.

Jag undrar hur ni gör?

[MagnusK]

Nu skriver du ju inte alls vilken typ av kommunikation du använder eller vilka processorer men här är exempel på I2C (wire)
kommunikation:
http://www.instructables.com/id/I2C-bet ... /?ALLSTEPS

[Icecap]

Al:
Steg 1 är att bestämma vilken sorts kommunikation. Rätt typ beror på avstånd, hastighetskrav osv.
Steg 2 är att göra specifikationer för krav på hastighet, feltolerans och dylikt.
Steg 3 är att göra ett kommunikationsprotokoll som beskriver funktionerna kontra data.

Efter det är resten enkelt.

Med tanke på vad du har visat av kunnande tidigare är jag rimligt övertygad om att du känner till avståndet som det ska kommuniceras över.

Resten lär väl i vanlig ordning vara en dimma - och du skiter ju till slut i det ändå för att du inte klarar det.
Men nu vet du hur man gör och hur man hittar rätt lösning.

[Al_Bundy]

Just nu kör jag bara RX,TX via software serial på digitala pinnarna 12,13.

Mitt protokoll är att om den inte får något svar så skicka igen. Jag frågar bara om temperatur.

[Al_Bundy]

Al:
Steg 1 är att bestämma vilken sorts kommunikation. Rätt typ beror på avstånd, hastighetskrav osv.
Steg 2 är att göra specifikationer för krav på hastighet, feltolerans och dylikt.
Steg 3 är att göra ett kommunikationsprotokoll som beskriver funktionerna kontra data.

Efter det är resten enkelt.

Med tanke på vad du har visat av kunnande tidigare är jag rimligt övertygad om att du känner till avståndet som det ska kommuniceras över.

Resten lär väl i vanlig ordning vara en dimma - och du skiter ju till slut i det ändå för att du inte klarar det.
Men nu vet du hur man gör och hur man hittar rätt lösning.

Okej, ursäkta mig. Jag skulle aldrig ha frågat.
Men tack ändå.

Jag tolkar att det verkar vara väldigt fritt att bygga ett protokoll.

[Icecap]

Du har frågat om det några gångar, du har fått samma svar (i stort) från olika personer - och du har varje gång skitit i det för att det var för komplicerat.

Menar du att det finns en ny komponent i spelet denna gång får du gärna motbevisa min spådom.

Men du har ju - i vanlig ordning efter vad du påstår - löst problemet redan.

[Al_Bundy]

Nej, det har jag inte.

Jag har inga problem att skicka från master -> slave, men slave -> master har jag problem med. Det är som att master inte läser. Ibland läser den, ibland inte.

Kan det vara så att jag måste skicka data före innan den läser? Eller kan jag skicka data när som helst och den läser det som datan står utan för och väntar?

[Icecap]

1: Vad med att ange vilket typ kommunikation du använder?
2: Vad med att ange hur du har ställd upp interrupten osv.?
3: Självklart måste data skickas klart innan man kan ta emot dom! Iaf. på byte-nivå.

Det är i grunden extremt enkelt - om man har ett protokoll.

Mitt standard sätt är att ha en buffer för att ta emot. Den används ihop med recieve-interrupten och fylls på eftersom men bara om flaggan är noll.

Varje byte som tas emot kollas för om det är "slut på meddelende" och är det så sätter jag en flagga till ett värde.

När den flagga är icke-noll räknas det ner av en timer-interrupt för att undvika låsning. Samtidig kollas det i main-loop och är det icke-noll exekverad funktionen som finns däri och flaggan nollas.

På detta vis har jag en timeout, rimlig plats för att ha block med många bytes och enkel handhavande.

[Al_Bundy]

1. Jag använder mig av TX, RX kommunikation med Softwareserial biblioteket
2. Jag börjar först med att skicka, vänta 5 sekunder innan jag läser, men när jag skickar så är det ett program på andra processorn som loopar och läser av temperatur och samlar det i listor. Sedan när den läser av det jag har skickat så plockar den fram vald temperatur och skickar det till mig. Då hinner den skicka, och sedan läser jag av den.

Jag tror att jag får göra så att jag får programmera om min mottagare(slave) så den gör bara en operation vid en oändlig loop(). Nämligen bara läsa.

[Icecap]

1: Jag antar att du använder seriell kommunikation via UART.
2: Du har alltså inget kommunikationsprotokoll.

"Jag tror att jag får göra så att jag får programmera om min mottagare(slave) så den gör bara en operation vid en oändlig loop(). Nämligen bara läsa."

Då var min spådom korrekt. Inget nytt från västfronten. *SUCK*

[Al_Bundy]

1. Ja, inbyggt UART. http://arduino.cc/en/Reference/softwareSerial
2. Nej, jag får inte slave att skicka riktigt så därför håller jag på bygga ett.

Men nu när jag tänker efter!
Jag har en AVR som jag byggt själv, den är master och slave är en inköpt Arduino UNO. Kan det vara det som är problemet?

[Al_Bundy]

Här sammanfattar jag min kod.

Masterkoden fungerar så att den skickar, vänta 5 sekunder, och sedan tar emot. Ibland är det så att den inte tar emot, både slave som master, eller skickar.

Kod: Markera allt

int get(int list)
{
  mySerial.write(list); // get info about the state
  int value;
  delay(5000);
  while(1)
  {
    if (mySerial.available() >= 1)
    { 
      value = mySerial.read();
      LED();
      return value;
    }
    else
    {
       mySerial.write(list); // get info about the state
       delay(5000);
    }
  }
}

Här är min slavekod

Kod: Markera allt

#include <OneWire.h>
#include <DallasTemperature.h>
#include <SoftwareSerial.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

SoftwareSerial mySerial(13, 7); // RX, TX


void setup(void)
{
  // start serial port
  Serial.begin(9600);
  mySerial.begin(9600);
  sensors.begin();

  pinMode(8, INPUT_PULLUP);
  pinMode(9, INPUT_PULLUP);
}

void loop(void)
{ 
  if (mySerial.available() >= 1)
  {
    int state = mySerial.read();
    Serial.println(state);
    
    if (state >= 10 && state <= 15)
    {
      sendState(state);
    }
    
  }
}
  
void sendState(int state)
{
  // Send the command to get temperatures
  sensors.requestTemperatures(); 
  int mesh_temp = sensors.getTempCByIndex(0);  
  int water_temp = sensors.getTempCByIndex(1); 
  int boiler_temp = sensors.getTempCByIndex(2);
  int condenser_temp = sensors.getTempCByIndex(3);
  
  Serial.println(mesh_temp);
  Serial.println(water_temp);
  Serial.println(boiler_temp);
  Serial.println(condenser_temp);
  
  // Get states of tanks
  int boiler_tank = digitalRead(8);
  if (boiler_tank == 0)
  {
    boiler_tank = 1; // invert
  }
  else
  {
    boiler_tank = 0; // invert
  }
  
  int bottom_tank = digitalRead(9);
  if (bottom_tank == 0)
  {
    bottom_tank = 1; // invert
  }
  else
  {
    bottom_tank = 0; // invert
  }
  
  if (state == 10)
  {
    mySerial.write(mesh_temp);
  }
  
  else if (state == 11)
  {

    mySerial.write(water_temp);
  }
  
  else if (state == 12)
  {

    mySerial.write(boiler_temp);
  }
   
  else if (state == 13)
  {

    mySerial.write(condenser_temp);
  }
  
  else if (state == 14)
  {
    mySerial.write(boiler_tank); // t.ex. 0 or 1
  }
  
  else if (state == 15)
  {
    mySerial.write(bottom_tank);  // t.ex. 0 or 1
  }
  else
  {
    //mySerial.write(state);
  }
}

[Icecap]

Problemet är att du är extremt ostrukturerat och utan inblick i vad du gör!

Så länge µC'arna kommunicerar med rätt antal bitar och rätt hastighet är det utan betydelse om det är ATmega, PIC, Fujitsu, Renesas eller liknande. Detta är just grejen med att seriell kommunikation har en viss standard.

Jag känner mig ganska säker på att värdet du vill skicka är i form av fler bytes per meddelande varför du ju måste hämta alla byten och "stycka ihop" dom igen.

Det har ju tidigare visat sig att du inte ha ett skvatt insikt i vad du egentligen gör så det är väl knappast någon ändring denne gång, du har ju alltid visad dig att inte lära dig något.

Man bygger inte ett kommunikationsprotokoll, man skriver det!
Man planerar hur meddelanden ska formateras, hur de ska överföras, hur man kan särskilja ett block från ett annat osv.

När det är klart skapar man en rutin som hämtar datan och samlar ihop till man har ett block. Enklast är oftast att använda interruptrutine för mottagna data, då styr den mottagningen och alla dessa idiotiska "fråga, vänta 5 sek. och sedan läsa" (som ju inte fungerar) kan kastas.

Detta betyder dock att man måste planera sin programmering och det lär ju ställa till med problem.

[Al_Bundy]

Enligt mig så tycker jag att det är dålig kvalité om man har en kort oändligt whilelloop som gör bara en sak supersnabbt, nämligen läsa av. Och den missar ofta att läsa av.

Då är det inte programmeringen som är problemet, snarare kvalitén på AVR.

Jag har exakt samma baudrate och jag skickar vid ett tillfälle som slaven väntar på att ta emot, ändå blir det fel. Jag ser inget annat sätt att skriva det på. Tyvärr, men du verkar kunna allt som inte är möjligt.

[Al_Bundy]

Nu när jag läser vad den skickar tillbaka så verkar den skicka värden som är mellan 254-255. Och det är ju över en bytes och .write() funktionen skickar bara ett byte i taget.

aha!

Jag gjorde en avläsning igenom att läsa temperaturen från slave arduinon, omvandla den till nummer 22 om den vara t.ex. 22.56 grader. Skicka den igenom mySerial.write(temperature), där temperature = 22.

Efter det tog jag emot den på min master och skickade tillbaka talet igen till min slave, för att slaven ska skriva ut det på min datorskärm. Då fick jag dessa tal, 252, 254, 255.

Slaven har kommunikation med datorn, då mastern saknar en UART mellan dator och uC.

Jag testade skicka talet talet 22, inte variabeln temperature via mySerial.write(22);.
Resultatet blev att antingen så skickade slaven 22 till master, master tog emot och skickade tillbaka till slaven, slaven tog emot och skickade till datorn och då visade den 254. Nej, detta är inte ASCII, detta är tal.

Eller så hände det inget då 22 representerade ett tal högre än 255.

EDIT igen.
Jag testade även att skicka till en LCD från mastern och då visade LCD också 254, 255,252 osv.
För att samanfatta detta: Jag skickar 22, men jag får talet 252 eller 255.
Så nu vet jag vart jag ska leta efter.