can_tx.c

#include <includes.h>

CAN_TX_CHAN_CFG  can_tx_chan_cfgs[5];   //Five elements, index 1 to 4

extern unsigned long can_elapsed_ms;   // CAN module time variable

// CAN error global variables:
extern volatile unsigned long can_error_1;
extern volatile unsigned long can_error_2;
extern volatile unsigned long can_error_3;
extern volatile unsigned long can_error_4;

// CAN transmit frame count global variables:
volatile unsigned short can_tx_frame_count_1 = 0;
volatile unsigned short can_tx_frame_count_2 = 0;
volatile unsigned short can_tx_frame_count_3 = 0;
volatile unsigned short can_tx_frame_count_4 = 0;

unsigned short can_tx_get_frame_count_1(CAN_FRAME * frame)
{
  frame->payload.w.w1 = can_tx_frame_count_1;
  can_tx_frame_count_1 = 0;     //Reset frame counter - could lose a count here, but not critical
  frame->payload.w.w2 = can_elapsed_ms;
  return 0;
}

unsigned short can_tx_get_frame_count_2(CAN_FRAME * frame)
{
  frame->payload.w.w1 = can_tx_frame_count_2;
  can_tx_frame_count_2 = 0;     //Reset frame counter - could lose a count here, but not critical
  frame->payload.w.w2 = can_elapsed_ms;
  return 0;
}

unsigned short can_tx_get_frame_count_3(CAN_FRAME * frame)
{
  frame->payload.w.w1 = can_tx_frame_count_3;
  can_tx_frame_count_3 = 0;     //Reset frame counter - could lose a count here, but not critical
  frame->payload.w.w2 = can_elapsed_ms;
  return 0;
}

unsigned short can_tx_get_frame_count_4(CAN_FRAME * frame)
{
  frame->payload.w.w1 = can_tx_frame_count_4;
  can_tx_frame_count_4 = 0;     //Reset frame counter - could lose a count here, but not critical
  frame->payload.w.w2 = can_elapsed_ms;
  return 0;
}

// Set up CAN_TX_CHAN_CFG for channel chan; stalled is initialized to 1 to kickstart transmit process
void can_tx_set_chan_cfg(CAN_CHANNEL chan,volatile unsigned long * base_addr, CAN_RING * tx_ring){
  can_tx_chan_cfgs[chan].base_addr = base_addr;
  can_tx_chan_cfgs[chan].ring      = tx_ring;
  can_tx_chan_cfgs[chan].stalled   = 1;
}

// Basic can_transmit function, calls multi-argument can_transmit_alt
int can_transmit(CAN_FRAME_DESC * frame_desc){
  return can_transmit_alt(frame_desc,frame_desc->chan, frame_desc->rtr);
}

// CAN transmit function; has options for CAN channel and rtr (remote transmission request)
int can_transmit_alt(CAN_FRAME_DESC * frame_desc, CAN_CHANNEL chan, char rtr){
  CAN_LAYOUT  layout = frame_desc->frame_layout;
  CAN_FRAME   frame;
  int         dlc;

// Set data length code of transmitted frame, based on rtr bit or CAN_LAYOUT
  if(rtr){
    dlc = 0;
  }else{
    switch(layout){
      case CAN_LAYOUT_D:
      case CAN_LAYOUT_FF:
      case CAN_LAYOUT_II:
      case CAN_LAYOUT_FI:
      case CAN_LAYOUT_ISS:
        dlc = 8;
        break;
      default:
        //Unrecognized layout, throw error and abort.
        return 1;
    }
  }
 
  // Use getter functions to fill in payload data bytes of transmitted frame.
  // Function pointers are from the frame descriptor in the first argument
  if(rtr) {
    dlc = 0;
  } else {
    switch(layout){
      //WARNING!!! not for the faint of heart.  Here we are casting function pointers
      //to another type of function pointer, and then we call it.  If this doesn't
      //make sense, read about function pointers and casting.
      case CAN_LAYOUT_D:
        frame.payload.d.d1 = ((CAN_TX_GETTER_DOUBLE)frame_desc->ptr1)();
        dlc = 8;
        break;
      case CAN_LAYOUT_FF:
        frame.payload.f.f1 = ((CAN_TX_GETTER_FLOAT)frame_desc->ptr1)();
        frame.payload.f.f2 = ((CAN_TX_GETTER_FLOAT)frame_desc->ptr2)();
        dlc = 8;
        break;
      case CAN_LAYOUT_II:
        frame.payload.i.i1 = ((CAN_TX_GETTER_INT)frame_desc->ptr1)();
        frame.payload.i.i2 = ((CAN_TX_GETTER_INT)frame_desc->ptr2)();
        dlc = 8;
      break;
      case CAN_LAYOUT_FI:
        frame.payload.f.f1 = ((CAN_TX_GETTER_FLOAT)frame_desc->ptr1)();
        frame.payload.i.i2 = ((CAN_TX_GETTER_INT)frame_desc->ptr2)();
        dlc = 8;
      break;
      case CAN_LAYOUT_ISS:
        frame.payload.i.i1 = ((CAN_TX_GETTER_INT  )frame_desc->ptr1)();
        frame.payload.s.s3 = ((CAN_TX_GETTER_SHORT)frame_desc->ptr2)();
        frame.payload.s.s4 = ((CAN_TX_GETTER_SHORT)frame_desc->ptr3)();
        dlc = 8;
      break;
      default:
        //Unrecognized layout, throw error and abort.
        return 1;
    }
  }

  // Fill in the rest of the CAN_FRAME elements
  // Note that the channel number chan comes from the frame descriptor here, not the argument chan.
  // This may or may not be useful. ***************************************************************
  // So the chan argument does nothing at this point.
  frame.addr = frame_desc->addr;
  frame.chan = frame_desc->chan;
  frame.dlc  = dlc;
  frame.rtr  = rtr;
  
  //The frame is now fully populated with Address, Data Length, and Payload
  //and is therefore ready to be sent out.
  return can_transmit_frame(&frame);
}

/*
// Push CAN_FRAME onto related CAN ring buffer
int can_transmit_frame(CAN_FRAME * frame)
{
  CAN_CHANNEL   chan      = frame->chan;
  CAN_RING    * ring      = can_tx_chan_cfgs[chan].ring;
  volatile unsigned long * base = can_tx_chan_cfgs[chan].base_addr;
  int           ret = 1;
  
  //Temporarily disable CAN channel chan interrupts
  VICIntEnClr = 1<<(20 + chan - 1); 

  //Push frame onto ring buffer, if not full.
  ret = can_ring_push(ring,frame);

  //Is channel stalled? Set software interrupt to unstall it.
  if (CAN_REG(base,CAN_SR) & (1<<2)) //Is transmit buffer 1 available?
  {
    if (!(VICRawIntr & (1<<(20 + chan - 1))))  // Is raw VIC interrupt for channel chan off?
    {
      VICSoftInt = 1<<(20 + chan - 1); //Set software interrupt bit for channel chan
    }
  }

  //Enable CAN channel chan interrupts
  VICIntEnable = 1<<(20 + chan - 1);
  return ret; //Return 0 if successful ring buffer push, 1 if buffer full.
}

void can_tx_send_next_frame(CAN_CHANNEL chan){
  volatile unsigned long * base           = can_tx_chan_cfgs[chan].base_addr;
  CAN_RING               * ring           = can_tx_chan_cfgs[chan].ring;
  CAN_FRAME                frame;
  int                      ret;
  int temp = CAN_REG(base,CAN_ICR); // < clear the transmit and error interrupts @todo check for errors here 
  
  if (CAN_REG(base,CAN_SR) & (1<<2)) //Is transmit buffer 1 available?
  {
    // Pop CAN_FRAME from relevant ring buffer; returns 0 if successful, 1 if ring empty.
    ret = can_ring_pop(ring,&frame);
    if(ret) 
    {
      //The buffer was empty, put channel into stall mode - disable channel chan interrupts
       VICIntEnClr = 1<<(20 + chan - 1);
    } 
    else // frame successfully popped from ring buffer
    {
      //Put data into relevant CAN controller data registers
      CAN_REG(base,CAN_TFI1) = (frame.dlc&0xF)<<16 | (frame.rtr&0x1) << 30; // PRIO = 0, FF = 0
      CAN_REG(base,CAN_TID1) = frame.addr;
      CAN_REG(base,CAN_TDA1) = frame.payload.w.w1;
      CAN_REG(base,CAN_TDB1) = frame.payload.w.w2;
      CAN_REG(base,CAN_CMR ) = (1<<0) | (1<<5); //TR: Transmit Now; STB1: Select Tx Buffer 1 for transmission
    }
  } 
  
  VICSoftIntClr = 1<<(20 + chan - 1); //Clear software interrupt bit for channel chan
}
*/


// Push CAN_FRAME onto related CAN ring buffer
int can_transmit_frame(CAN_FRAME * frame){
  CAN_CHANNEL   chan      = frame->chan;
  CAN_RING    * ring      = can_tx_chan_cfgs[chan].ring;
  int         * p_stalled = &(can_tx_chan_cfgs[chan].stalled);
  int           ret;

  // Return 1 if ring buffer is full
  ret = can_ring_push(ring,frame);
  if(ret) {
    return 1;
  }

  // Is the relevant channel stalled? (Ring buffer not empty and interrupts off)
  if(*p_stalled) {
    can_tx_send_next_frame(chan);//Then unstall it
  }
  return 0; // frame was successfully pushed onto buffer
}

void can_tx_send_next_frame(CAN_CHANNEL chan){
  volatile unsigned long * base           = can_tx_chan_cfgs[chan].base_addr;
  CAN_RING               * ring           = can_tx_chan_cfgs[chan].ring;
  int                    * p_stalled      = &(can_tx_chan_cfgs[chan].stalled);
  CAN_FRAME                frame;
  int                      ret;

  // Pop CAN_FRAME from relevant ring buffer; returns 0 if successful, 1 if ring empty.
  ret = can_ring_pop(ring,&frame);

  if(ret) 
  {
    //The buffer was empty, put channel into stall mode
    *p_stalled             = 1;
  } 
  else // frame successfully popped from ring buffer
  {
    *p_stalled             = 0;
 
    if (chan == CHAN_CAN1) {can_tx_frame_count_1++;}
    else if (chan == CHAN_CAN2) {can_tx_frame_count_2++;}
    else if (chan == CHAN_CAN3) {can_tx_frame_count_3++;}
    else if (chan == CHAN_CAN4) {can_tx_frame_count_4++;}

    //Put data into relevant CAN controller data registers
    CAN_REG(base,CAN_TFI1) = (frame.dlc&0xF)<<16 | (frame.rtr&0x1) << 30; // PRIO = 0, FF = 0
    CAN_REG(base,CAN_TID1) = frame.addr;
    CAN_REG(base,CAN_TDA1) = frame.payload.w.w1;
    CAN_REG(base,CAN_TDB1) = frame.payload.w.w2;
    CAN_REG(base,CAN_CMR ) = (1<<0) | (1<<5); //TR: Transmit Now; STB1: Select Tx Buffer 1 for transmission
    
  }
}


// Use RTR (Remote Transmission Request) to subscribe to desired receive CAN IDs.
// Use this function with each RX CAN_FRAME_DESC
// Should be transmitted on the same channel you want to receive this ID on.
void can_subscribe(CAN_FRAME_DESC * fd){
  CAN_FRAME frame;
  frame.chan = fd->chan;
  frame.addr = fd->addr;
  frame.rtr  = 1;
  can_transmit_frame(&frame);
}