File content as of revision 6:e7c29e46ad6c:

// Motor Control Board Program
// This program operates the Tritium controller and also sends data
// over the separate car CAN.
 
#include "mbed.h"
 
// CAN base address and offsets (Tritium)
#define DC_BASE 0x220  // Driver controls base address
#define DC_DRIVE 0x01  // Offset for motor drive command
#define DC_POWER 0x02  // Offset for motor power command
#define DC_RESET 0x03  // Offset for reset command
#define DC_SWITCH 0x04 // Offset for phase current measurement
 
#define MC_BASE 0x240 // Motor controls base address
#define MC_BUS 0x02   // Bus measurement offset
#define MC_VEL 0x03   // Velocity measurement offset
#define MC_PHCUR 0x04 // Phase Current offset
#define MC_VOVEC 0x05 // Voltage Vector offset
#define MC_CUVEC 0x06 // current vector offset
#define MC_BEMF 0x07  // back emf offset
#define MC_TEMP 0x0B  // heat sink and motor temp offset
#define MC_AMPH 0x0E  // odometer and bus amp ohours measuremeant
#define MAX_VELOCITY 100 // motor velocity in m/s
#define MAX_CURRENT 1.0  // desired motor current as percentage of max current
 
#define DC_BUS_CURRENT 0x900
#define DC_BUS_VOLTAGE 0x901
#define PHASE_B_CURRENT 0x902
#define PHASE_C_CURRENT 0x903
#define VEHICLE_VELOCITY 0x904
#define MOTOR_VELOCITY 0x905
#define VD 0x906
#define VQ 0x907
#define ID 0x908
#define IQ 0x909
#define BEMFD 0x90A
#define BEMFQ 0x90B
#define HEAT_SINK_TEMPERATURE 0x90C
#define MOTOR_TEMPERATURE 0x90D
#define DC_BUS_AMP_HOURS 0x90E
#define ODOMETER 0x90F

#define DASH_Forward      0x580  // DASH Forward Motor ID 
#define DASH_Cruise_Set   0x581  // DASH Brake ID 
#define DASH_Cruise       0x582  // DASH Brake ID 
#define DASH_Regen        0x583  // DASH Regen ID 
 
CAN can1(PD_0,PD_1,125000); // can1 is car CAN  (Rx, Tx, speed)
CAN can2(PB_5,PB_6, 100000); // can2 is motor controller CAN  (Rx, Tx, speed)
Serial pc(USBTX, USBRX);
 
AnalogIn ain(PB_0);
 
DigitalOut LED8(PF_2);
DigitalOut LED7(PA_7);
DigitalOut LED6(PF_10);
DigitalOut LED5(PF_5);
DigitalOut LED4a(PF_3);
DigitalOut LED3a(PC_3);
DigitalOut LED2a(PC_0);
DigitalOut LED1a(PA_3);

  
    CANMessage msg;

    union {
      char rcvdata[4];
      float rxdata;
    } urxdata;

  char rdata2[8];
  float vehicleVel;
  float motorVel;
 
#define MAX_VELOCITY 100 // motor velocity in m/s
#define MAX_CURRENT 1.0 // desired motor current as percentage of max current
void speeed(){


    while(1){
           if(can2.read(msg) && msg.id == (MC_BASE+MC_VEL)) {
        for (int i = 0; i < msg.len; i++) {
          rdata2[i] = msg.data[i];
        }
        }

            if(msg.id == (MC_BASE+MC_VEL)) {
        for (int i = 0; i < msg.len; i++) {
          rdata2[i] = msg.data[i];
        }
        // sending value to CAR can
        if (!can1.write(CANMessage(0x243, (char*) rdata2, 8))) {
          pc.printf("Cannot write to CAN\n");
        }
        wait(0.001);
 
        urxdata.rcvdata[3] = rdata2[7];
        urxdata.rcvdata[2] = rdata2[6];
        urxdata.rcvdata[1] = rdata2[5];
        urxdata.rcvdata[0] = rdata2[4];
        vehicleVel = urxdata.rxdata;
        urxdata.rcvdata[3] = rdata2[3];
        urxdata.rcvdata[2] = rdata2[2];
        urxdata.rcvdata[1] = rdata2[1];
        urxdata.rcvdata[0] = rdata2[0];
        motorVel = urxdata.rxdata;
    }
        }
    
    }



int main() {  

    can1.frequency(125000);  
    Thread V1(speeed);
    
  float current = MAX_CURRENT;
  float velocity = MAX_VELOCITY;
  float bus_current = MAX_CURRENT;
  float DCbuscur;
  float DCbusvolt;
  double pedal_position;
  float data[2];
  float data2[2];
  float meas;
  double avgval;
  int n;
  int dummy;
  int alive;
 
  // other ids we need to read
  float phaseBcurrent;
  float phaseCcurrent;


  float vd;
  float vq;
  float Id;
  float Iq;
  float BEMFd;
  float BEMFq;
  float heatSinkTemp;
  float motorTemp;
  float DCBusAmpHours;
  float odometerValue;
  int forward;
  int cruiseSet;
  int cruise;
  float regen;
 
  //char const * serial = "0002173";
  // can1.frequency(500000);
  int id;
  int id2;
  int id3;
  char rdata[8];

  char rdata3[8];
  char rdata4[8];
  char rdata5[8];
  char rdata6[8];
  char rdata7[8];
  char rdata8[8];
  char rdata9[8];
  
  char ddata[8];
  char ddata1[8];
  char ddata2[8];
  char ddata3[8];
  
  float zero = 0; 
 
  CANMessage msg;
  CANMessage msg2;
  
  dummy = 0;
  alive = 0;
 

 
  id = DC_BASE + DC_DRIVE;
  id2 = DC_BASE + DC_POWER;
  id3 = MC_BASE + DC_POWER;
 
  while (1) {
    n = 0;
    avgval = 0.0;
    while(n < 100) {
        meas = ain.read();
        avgval = avgval + meas;
        n++ ;
    }
    pedal_position = avgval/100.0;
 
    if(pedal_position > 0.005)
        LED1a = 1;
    else
        LED1a = 0;
    if(pedal_position > 0.01)
        LED2a = 1;
    else
        LED2a = 0;
    if(pedal_position > 0.015)
        LED3a = 1;
    else
        LED3a = 0;
    if(pedal_position > 0.02)
        LED4a = 1;
    else
        LED4a = 0;
    if(pedal_position > 0.025)
        LED5 = 1;
    else
        LED5 = 0;
    if(pedal_position > 0.03)
        LED6 = 1;
    else
        LED6 = 0;
    if(pedal_position > 0.035)
        LED7 = 1;
    else
        LED7 = 0;
 
    current = MAX_CURRENT * pedal_position;
    velocity = 9.0;
 
    data[1] = current;  // Flipped because of endianness
    data[0] = velocity;
 
    if (!can2.write(CANMessage(id, (char*)data, 8))) // send current and velocity to Tritum
        printf("Drive failed \n\r");
 
    data2[1] = bus_current;
    data2[0] = 0.0;
    if (!can2.write(CANMessage(id2, (char*)data2, 8)))
        dummy = 0;
 
   wait_ms(10);  // Need message every 250ms to maintain operation
 
   // WE ARE READING STUFFF HERE //
//   if(can2.read(msg) && msg.id == (MC_BASE+MC_VEL)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata2[i] = msg.data[i];
//        }
// 
        // sending value to CAR can

//       
//   }

    if(can1.read(msg2)) {
        if(msg2.id == DASH_Forward) {
          for(int i = 0; i < msg2.len; i++) {
          ddata[i] = msg2.data[i];
          }
          
          float ddatafloat = *((float*) &ddata);
          int ddatabit = ceil(ddatafloat);

          
          if(ddatabit == 2147483647) {
              forward = 1;
          } else forward = 0;
          
          pc.printf("ddatabit: %d", ddatabit);
          pc.printf("forward: %d \n", forward);

        
        }
        
        else if(msg2.id == DASH_Cruise_Set) {
            for(int i = 0; i < msg2.len; i++) {
                ddata1[i] = msg2.data[i];
            }
            
            float ddatafloat1 = *((float*) &ddata1);
            int ddatabit1 = ceil(ddatafloat1);

            if(ddatabit1 == 2147483647) {
                cruiseSet = 1;
            } else cruiseSet = 0;
            
            pc.printf("ddatabit1: %d", ddatabit1);
            pc.printf("cruise set: %d \n", cruiseSet);

            
        }
        
        else if(msg2.id == DASH_Cruise) {
            for(int i = 0; i < msg2.len; i++) {
                ddata2[i] = msg2.data[i];
            }
            
            float ddatafloat2 = *((float*) &ddata2);
            int ddatabit2 = ceil(ddatafloat2);
            
            if(ddatabit2 == 2147483647) {
                cruise = 1;
            } else cruise = 0;
            
            pc.printf("ddatabit2: %d", ddatabit2);
            pc.printf("cruise: %d \n", cruise);

        }
        
        else if(msg2.id == DASH_Regen) {
            for(int i = 0; i < msg2.len; i++) {
                ddata3[i] = msg2.data[i];
            }
            pc.printf("regen ddata: %f", ddata3);
            
            urxdata.rcvdata[3] = ddata3[3];
            urxdata.rcvdata[2] = ddata3[2];
            urxdata.rcvdata[1] = ddata3[1];
            urxdata.rcvdata[0] = ddata3[0];
            regen = urxdata.rxdata;
            
            pc.printf("here in regen \n");
            pc.printf("%f", regen);

        }
    }

    if(can2.read(msg)){
     if(msg.id == id3 ) { // Tritium Bus
        for(int i = 0; i < msg.len; i++) {
          rdata[i] = msg.data[i];
        }
 
        // sending value to CAR can
        if (!can1.write(CANMessage(0x242, (char*) rdata, 8))) {
          pc.printf("Cannot write to CAN\n");
        }
//        wait(0.001);
 
        urxdata.rcvdata[3] = rdata[7];
        urxdata.rcvdata[2] = rdata[6];
        urxdata.rcvdata[1] = rdata[5];
        urxdata.rcvdata[0] = rdata[4];
        DCbuscur = urxdata.rxdata;
        urxdata.rcvdata[3] = rdata[3];
        urxdata.rcvdata[2] = rdata[2];
        urxdata.rcvdata[1] = rdata[1];
        urxdata.rcvdata[0] = rdata[0];
        DCbusvolt = urxdata.rxdata;
        }
 
 
        // reading vehicle and motor velocity

 
//        // reading phase currents
//    else if(msg.id == (MC_BASE+MC_PHCUR)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata3[i] = msg.data[i];
//        }
// 
//        // sending value to CAR can
//        if (!can1.write(CANMessage(0x244, (char*) rdata3, 8))) {
//          pc.printf("Cannot write to CAN\n");
//        }
////        wait(0.001);
// 
//        urxdata.rcvdata[3] = rdata3[7];
//        urxdata.rcvdata[2] = rdata3[6];
//        urxdata.rcvdata[1] = rdata3[5];
//        urxdata.rcvdata[0] = rdata3[4];
//        phaseCcurrent = urxdata.rxdata;
//        urxdata.rcvdata[3] = rdata3[3];
//        urxdata.rcvdata[2] = rdata3[2];
//        urxdata.rcvdata[1] = rdata3[1];
//        urxdata.rcvdata[0] = rdata3[0];
//        phaseBcurrent = urxdata.rxdata;
//        }
 
//        // reading motor voltage vector
//    else if(msg.id == (MC_BASE+MC_VOVEC)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata4[i] = msg.data[i];
//        }
// 
//        // sending value to CAR can
//        if (!can1.write(CANMessage(0x245, (char*) rdata4, 8))) {
//          pc.printf("Cannot write to CAN\n");
//        }
////        wait(0.001);
// 
//        urxdata.rcvdata[3] = rdata4[7];
//        urxdata.rcvdata[2] = rdata4[6];
//        urxdata.rcvdata[1] = rdata4[5];
//        urxdata.rcvdata[0] = rdata4[4];
//        vd = urxdata.rxdata;
//        urxdata.rcvdata[3] = rdata4[3];
//        urxdata.rcvdata[2] = rdata4[2];
//        urxdata.rcvdata[1] = rdata4[1];
//        urxdata.rcvdata[0] = rdata4[0];
//        vq = urxdata.rxdata;
//    }
// 
 //       // reading current vector
//    else if(msg.id == (MC_BASE+MC_CUVEC)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata5[i] = msg.data[i];
//        }
// 
//        // sending value to CAR can
//        if (!can1.write(CANMessage(0x246, (char*) rdata5, 8))) {
//          pc.printf("Cannot write to CAN\n");
//        }
////        wait(0.001);
// 
//        urxdata.rcvdata[3] = rdata5[7];
//        urxdata.rcvdata[2] = rdata5[6];
//        urxdata.rcvdata[1] = rdata5[5];
//        urxdata.rcvdata[0] = rdata5[4];
//        Id = urxdata.rxdata;
//        urxdata.rcvdata[3] = rdata5[3];
//        urxdata.rcvdata[2] = rdata5[2];
//        urxdata.rcvdata[1] = rdata5[1];
//        urxdata.rcvdata[0] = rdata5[0];
//        Iq = urxdata.rxdata;
//    }
// 
//    // reading back emf
//    else if(msg.id == (MC_BASE+MC_BEMF)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata6[i] = msg.data[i];
//        }
// 
//        // sending value to CAR can
//        if (!can1.write(CANMessage(0x247, (char*) rdata6, 8))) {
//          pc.printf("Cannot write to CAN\n");
//        }
////        wait(0.001);
// 
//        urxdata.rcvdata[3] = rdata6[7];
//        urxdata.rcvdata[2] = rdata6[6];
//        urxdata.rcvdata[1] = rdata6[5];
//        urxdata.rcvdata[0] = rdata6[4];
//        BEMFd = urxdata.rxdata;
//        urxdata.rcvdata[3] = rdata6[3];
//        urxdata.rcvdata[2] = rdata6[2];
//        urxdata.rcvdata[1] = rdata6[1];
//        urxdata.rcvdata[0] = rdata6[0];
//        BEMFq = urxdata.rxdata;
//    }
 
    // reading heatsink and motor temp
    else if(msg.id == (MC_BASE+MC_TEMP)) {
        for (int i = 0; i < msg.len; i++) {
          rdata7[i] = msg.data[i];
        }
 
        // sending value to CAR can
        if (!can1.write(CANMessage(0x24B, (char*) rdata7, 8))) {
          pc.printf("Cannot write to CAN\n");
        }
//        wait(0.001);
 
        urxdata.rcvdata[3] = rdata7[7];
        urxdata.rcvdata[2] = rdata7[6];
        urxdata.rcvdata[1] = rdata7[5];
        urxdata.rcvdata[0] = rdata7[4];
        heatSinkTemp = urxdata.rxdata;
        urxdata.rcvdata[3] = rdata7[3];
        urxdata.rcvdata[2] = rdata7[2];
        urxdata.rcvdata[1] = rdata7[1];
        urxdata.rcvdata[0] = rdata7[0];
        motorTemp = urxdata.rxdata;
    }
 
//    // reading odometer and bus amp ohours measuremeant
//    else if(msg.id == (MC_BASE+MC_AMPH)) {
//        for (int i = 0; i < msg.len; i++) {
//          rdata8[i] = msg.data[i];
//        }
// 
//        // sending value to CAR can
//        if (!can1.write(CANMessage(0x24E, (char*) rdata8, 8))) {
//          pc.printf("Cannot write to CAN\n");
//        }
////        wait(0.001);
// 
//        urxdata.rcvdata[3] = rdata8[7];
//        urxdata.rcvdata[2] = rdata8[6];
//        urxdata.rcvdata[1] = rdata8[5];
//        urxdata.rcvdata[0] = rdata8[4];
//        DCBusAmpHours = urxdata.rxdata;
//        urxdata.rcvdata[3] = rdata8[3];
//        urxdata.rcvdata[2] = rdata8[2];
//        urxdata.rcvdata[1] = rdata8[1];
//        urxdata.rcvdata[0] = rdata8[0];
//        odometerValue = urxdata.rxdata;
//    }
    }
 
       if(alive % 100 == 0){
       printf("Motor board is running \n\r");
       printf(" Requested Motor Current: %f\n\r", current);
       printf(" Requested Motor Velocity: %f\n\r", velocity);
       printf(" DC Bus Current (A) = %f",DCbuscur);
       printf("\r\n");
       printf(" DC Bus Voltage (V) = %f",DCbusvolt);
       printf("\r\n");
 
       // Printing other values
         printf(" Vehicle Velocity (RPM) = %f",vehicleVel);
       printf("\r\n");
       printf(" Motor Velocity (V) = %f",motorVel);
       printf("\r\n");
      // printf(" Phase B Current (A-rms) = %f",phaseBcurrent);
//       printf("\r\n");
//       printf(" Phase C Current (A-rms) = %f",phaseCcurrent);
//       printf("\r\n");
//       printf(" Vd (V) = %f",vd);
//       printf("\r\n");
//       printf(" Vq (V) = %f",vq);
//       printf("\r\n");
// 
//       printf(" Id (A) = %f",Id);
//       printf("\r\n");
//       printf(" Iq (A) = %f",Iq);
//       printf("\r\n");
//       printf(" BEMFd (V) = %f",BEMFd);
//       printf("\r\n");
//       printf(" BEMFq (V) = %f",BEMFq);
//       printf("\r\n");
       printf(" Heat Sink Temperature (Celsius) = %f",heatSinkTemp);
       printf("\r\n");
       printf(" Motor Temperature (Celsius) = %f",motorTemp);
       printf("\r\n");
//       printf(" DC Bus (Ah) = %f",DCBusAmpHours);
//       printf("\r\n");
//       printf(" Odometer (Distance) (m) = %f",odometerValue);
//       printf("\r\n");
// 
 
       // blinking LED
       LED8 = !LED8;
       if (!can1.write(CANMessage(id, (char*)data, 8))) //send current and velocity over car CAN
              printf("Car CAN failed \n\r");
       }
       alive++;
  }
}