Page History

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

#define BAUDRATE 125250

//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;
unsigned long id_vertaa=;
byte viesti1 = 0;
byte viesti2 = 0;
byte viesti3 = 0;
byte viesti4 = 0;
byte viesti1viesti5 = 0;
byte viesti6 viesti2= 0;
byte viesti3viesti7 = 0;
byte viesti4viesti8 = 0;
byte viesti9 viesti5= 0;
byte viesti10 viesti6= 0;
byte viesti;

// laskuri CAN:lle
int laskuri;


//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 Kaasukaasu;

int _bitPeriodbitDelay;
int bitDelayDelay;
int ledPinsuuntaPin = 6;
int ledPin2kauhaPin = 9;



//Ajetaan kerran Arduinon käynnistyessä
void setup()
{
  //CAN setup
  CAN.begin(); //initCANin CANClassalustus, whichalustaa alsosamalla initializesmyös SPI communication to CAN tranceiver:n
  CAN.baudConfig(BAUDRATE); //setasettaa baudratebaudraten 250kbit125kbit/s
  CAN.setMode(NORMAL); //set mode for CANClassasettaa CAN moden
 
  //datan nollaukset
  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); //initializesarjaväylän serial communicationalustus

  pinMode(ledPinsuuntaPin, OUTPUT); // pwm lähtö suunnalle outputiksi
  pinMode(ledPin2kauhaPin, OUTPUT);  // pwm lähtö kauhalle outputiksi
   
  //RS232 setup sarjaväylän alustus radio modeemeille
  pinMode(rx, INPUT);   
  pinMode(tx, OUTPUT);
  digitalWrite(tx,HIGH);
  _bitPeriodbitDelay = 1000000 / 9600;
  bitDelayDelay = _bitPeriodbitDelay - clockCyclesToMicroseconds(50);  
  delayMicroseconds(_bitPeriodbitDelay);
}



void loop()
{
  laskuri = 0;
 
  //Yritetään lukea moottorinohjaimen CAN-viestiä niin kauan että juuri
  //se viesti saadaan, TAI kunnes laskuri ylittää säädetyn arvon.
  //Laskuri tarvitaan, jottei muu toiminta jäisi jumiin jos viestiä
  //ei jostain syystä saada EI KÄYTÖSSÄ!!
  //do{
    CAN.readDATA_ff_1(&rx_len, rx_msg, &rx_id); // luetaan CAN-väylää
    laskuri++;
 // id_vertaa=}while(rx_id!=0x66 && rx_id, HEX;
    !=167248164 && laskuri<15); //kuuluuko olla && vai ||
    
    //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ä
      
      // lähetetään CAN-viestin tiedot moodeemilla
  }
    //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
      
    if(rx_id ==ID_GPS 167248164)
       {
             viesti7 viesti7= rx_msg[20];
             viesti8 viesti8= rx_msg[31];
             viesti9 viesti9= rx_msg[42];
             viesti10 viesti10= rx_msg[53];
    
      
    }*/
 
  delay(10);
  CAN_kaasu=SWread();
  PWM_suunta=SWread();
  PWM_kauha=SWread();
  MoottoriOnOff=SWread();

  Serial.println(viesti1, BYTE);
  Serial.println(viesti2, BYTE);
  Serial.println(viesti3}

        Serial.println(1, DEC);
        Serial.println(2, DEC);
    Serial.println(viesti1, DEC);
    Serial.println(viesti2, DEC);
    Serial.println(viesti3, DEC);
    Serial.println(viesti4, DEC);
    Serial.println(viesti5, DEC);
    Serial.println(viesti6, DEC);
    Serial.println(viesti7, DEC);
    Serial.println(viesti8, DEC);
    Serial.println(viesti9, DEC);
    Serial.println(viesti10, DEC);            

    //DEBUG
    //Serial.println(CAN_kaasu, BYTE);
     //Serial.println(viesti4PWM_suunta, BYTE);
     //Serial.println(viesti5PWM_kauha, BYTE);
     //Serial.println(viesti6MoottoriOnOff, BYTE);

     analogWrite(ledPin//tartteeko tätä?
    //delay(10);
        int Check1 = SWread();
    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
        int Check2 = SWread();

        if(Check1==2 && Check2==3)
        {
            // annetaan arvot pwm lähdöille
            analogWrite(suuntaPin, PWM_suunta);
            analogWrite analogWrite(ledPin2kauhaPin, PWM_kauha);
        
             //Pitääkö MoottoriOnOff-viestiä pommittaa koko ajan ettei moottori sammu???
            if if(MoottoriOnOff != MoottoriVanha)
             {
               if     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                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=                MoottoriVanha = MoottoriOnOff;
                 //Pitääkö CAN-viestien välillä olla viive?
  delay                delay(10);
             }
  Kaasu=}
            
            // lasketaan radiomoodemilta saatu kaasun arvo oikeaan muotoon
            // ja lähetetään se CAN-viestinä moottorille
            kaasu = 0x8000-(12*(CAN_kaasu*10));
            candata candata[0]=Kaasu>>8 = kaasu >> 8;
            candata candata[1] =Kaasu kaasu & 0xFF;
            candata candata[2] = 0x00;
            CAN CAN.load_ff_0(8,id_Kaasu,candata);
  CAN.send_0();
}

void SWprint(int data)
{
 
  byte mask;
  digitalWrite(tx,LOW);
  delayMicroseconds(bitDelay);
  for (mask = 0x01; mask>0; mask <<= 1) {
    if (data & mask){ // choose bit
     digitalWrite(tx,HIGH); // send 1
    }
    else{
     digitalWrite(tx,LOW); // send 0
    }
    delayMicroseconds(bitDelay);
  }
  //stop bit
  digitalWrite(tx, HIGH);
  delayMicroseconds(bitDelay);
}

 0x65, candata); //65 = MOOTTORIN ID
            CAN.send_0();

        }//CHECKIN LOPETUS
 }

// funktio radiomodeemin lukemiseen
int SWread()
{
    byte byte val = 0;
 
 // int bitDelay = _bitPeriod - clockCyclesToMicroseconds(50);
  while (    while (digitalRead(rx));
  //wait for start bit
  if
    if (digitalRead(rx) == LOW) {
       delayMicroseconds delayMicroseconds(bitDelayDelay / 2 - clockCyclesToMicroseconds(50));
       for  for(int offset = 0; offset < 8; offset++) {
     delayMicroseconds(bitDelay            delayMicroseconds(Delay);
     val            val |= digitalRead(rx) << offset;
        }
        //wait for stop bit + extra
       delayMicroseconds delayMicroseconds(_bitPeriodbitDelay);

    
    return return val;
     }
      //return -1;
}