eFlow arduino koodi

 #include <SPI.h>
#include <SoftwareSerial.h>
#include <CAN.h>

#define BAUDRATE 125

//CAN muuttujat
byte candata[8];
byte candata_OnOff[0];
unsigned long id_Kaasu=0x65;
unsigned long id_OnOff=0x64;
byte rx_len;
byte rx_msg[8]={0};
unsigned long rx_id;
byte viesti1=0;
byte viesti2=0;
byte viesti3=0;
byte viesti4=0;
byte viesti5=0;
byte viesti6=0;
byte viesti;


//RS232 muuttujat
byte rx = 0;
byte tx = 1;
byte CAN_kaasu;
byte PWM_suunta=30;
byte PWM_kauha=30;
byte MoottoriOnOff=0;
byte MoottoriVanha;
signed int Kaasu;

int bitDelay;
int Delay;
int suuntaPin = 6;
int kauhaPin = 9;


void setup()
{
  //CAN setup
  CAN.begin(); //CANin alustus, alustaa samalla myös SPI:n
  CAN.baudConfig(BAUDRATE); //asettaa baudraten 125kbit/s
  CAN.setMode(NORMAL); //asettaa CAN moden
  candata[0]=0x00;
  candata[1]=0x00;
  candata[2]=0x00;
  candata[3]=0x00;
  candata[4]=0x00;
  candata[5]=0x00;
  candata[6]=0x00;
  candata[7]=0x00;
 
  candata_OnOff[0]=0x00;
  candata_OnOff[1]=0x00;
  candata_OnOff[2]=0x00;
  candata_OnOff[3]=0x00;
  candata_OnOff[4]=0x00;
  candata_OnOff[5]=0x00;
  candata_OnOff[6]=0x00;
  candata_OnOff[7]=0x00;
 
  Serial.begin(9600); //sarjaväylän alustus

  pinMode(suuntaPin, OUTPUT); // pwm lähtö suunnalle outputiksi
  pinMode(kauhaPin, OUTPUT);  // pwm lähtö kauhalle outputiksi
   
  // sarjaväylän alustus radio modeemeille
  pinMode(rx,INPUT);   
  pinMode(tx,OUTPUT);
  digitalWrite(tx,HIGH);
  bitDelay=1000000 / 9600;
  Delay = bitDelay - clockCyclesToMicroseconds(50);  
  delayMicroseconds(bitDelay);
}



void loop()
{
    CAN.readDATA_ff_1(&rx_len, rx_msg, &rx_id); // luetaan CAN-väylää
    
    //jos CAN viestin ID 0x66, luetaan viestin kuusi ensimmäistä alkiota muuttujiin
    if(rx_id==0x00000066)
    {     
      viesti1=rx_msg[0]; // RPM / 8 eniten merkitsevää bittiä
      viesti2=rx_msg[1]; // RPM / 8 vähiten merkitsevää bittiä
      viesti3=rx_msg[2]; // akun jännite / 8 eniten merkitsevää bittiä  
      viesti4=rx_msg[3]; // akun jännite / 8 vähiten merkitsevää bittiä
      viesti5=rx_msg[4]; // moottorin virta / 8 eniten merkitsevää bittiä
      viesti6=rx_msg[5]; // moottorin virta / 8 vähiten merkitsevää bittiä
    }
    //TÄNNE GEPSIN LUKEMINEN. LISÄÄ MYÖS GEPSITIETOJEN LÄHETYS (VIESTI7...)
        //heading_radians = (unsigned int)(radian(heading)*10000);
    //speed_metres = (unsigned int)(speed*0.5144*100);
        //nmea2000_buffer[0] = (unsigned char)(fix); // position fix
    //nmea2000_buffer[1] = 0xfc; // 11111100 True heading 00 + resv 6 bits
    //nmea2000_buffer[2] = (unsigned char)(heading_radians >> 0);
    //nmea2000_buffer[3] = (unsigned char)(heading_radians >> 8);
    //nmea2000_buffer[4] = (unsigned char)(speed_metres >> 0);
    //nmea2000_buffer[5] = (unsigned char)(speed_metres >> 8);
    //nmea2000_buffer[6] = 0xff; // resv 8 bits
    //nmea2000_buffer[7] = 0xff; // resv 8 bits
      //FIX ON OIKEASTI BOOL-TYYPPINEN JA KERTOO, SAAKO GPS YHTEYDEN SATELLIITTEIHIN, TS. ONKO TIETO LUOTETTAVAA
      //uncommentaa seuraavat
      /*
          if(rx_id==ID_GPS)
    {
      viesti7=rx_msg[2];
      viesti8=rx_msg[3];
      viesti9=rx_msg[4];
      viesti10=rx_msg[5];    
      
    }*/
 
  delay(10);
  CAN_kaasu=SWread(); // luetaan radiomodeemin ensimmäinen viesti = kaasu
  PWM_suunta=SWread(); // luetaan radiomodeemin toinen viesti = suunta
  PWM_kauha=SWread();  // luetaan radiomodeemin kolmas viesti = kauha
  MoottoriOnOff=SWread(); // // luetaan radiomodeemin neljäs viesti = moottorin ON/OFF tieto

// lähetetään CAN-viestin tiedot moodeemilla
  Serial.println(viesti1, BYTE);
  Serial.println(viesti2, BYTE);
  Serial.println(viesti3, BYTE);
  Serial.println(viesti4, BYTE);
  Serial.println(viesti5, BYTE);
  Serial.println(viesti6, BYTE);

// annetaan arvot pwm lähdöille
  analogWrite(suuntaPin, PWM_suunta);
  analogWrite(kauhaPin, PWM_kauha);
 
  //Pitääkö MoottoriOnOff-viestiä pommittaa koko ajan ettei moottori sammu???
  if(MoottoriOnOff!=MoottoriVanha)
  {
     if (MoottoriOnOff==0x51) // Moottori päälle
       {
        // lähetetään CAN-viesti moottori päälle
        candata_OnOff[0]=0x01;
        CAN.load_ff_0(8,id_OnOff,candata_OnOff);
        CAN.send_0();
       }
     else if (MoottoriOnOff==0x50) // Moottori pois päältä
       {
         // lähetetään CAN-viesti moottori pois päältä
         candata_OnOff[0]=0x00;
         CAN.load_ff_0(8,id_OnOff,candata_OnOff);
         CAN.send_0();
       }
  MoottoriVanha=MoottoriOnOff;
  //Pitääkö CAN-viestien välillä olla viive?
  delay(10);
  }
  // lasketaan radiomoodemilta saatu kaasun arvo oikeaan muotoon
  // ja lähetetään se CAN-viestinä moottorille
  Kaasu=0x8000-(12*(CAN_kaasu*10));
  candata[0]=Kaasu>>8;
  candata[1]=Kaasu & 0xFF;
  candata[2]=0x00;
  CAN.load_ff_0(8,id_Kaasu,candata);
  CAN.send_0();
}

// funktio radiomodeemin lukemiseen
int SWread()
{
  byte val = 0;
 

  while (digitalRead(rx));

  if (digitalRead(rx) == LOW) {
    delayMicroseconds(Delay / 2 - clockCyclesToMicroseconds(50));
    for (int offset = 0; offset < 8; offset++) {
     delayMicroseconds(Delay);
     val |= digitalRead(rx) << offset;
    }
    //wait for stop bit + extra
    delayMicroseconds(bitDelay);
    
    return val;
  }
  //return -1;
}