示例#1
0
文件: can.c 项目: gedare/rtems
rtems_status_code can_write(
  const lpc176x_can_number minor,
  const can_message *const message
)
{
  const can_driver_entry *const can_driver = &can_driver_table[ minor ];
  can_device *const             obj = can_driver->device;
  const uint32_t                CANStatus = obj->SR;

  const registers_can_message *const msg = &( message->registers );
  rtems_status_code                  sc = RTEMS_IO_ERROR;
  can_transmit_number                transmit_buffer;

  can_enable( can_driver );

  for ( transmit_buffer = CAN_TRANSMIT1;
        ( sc != RTEMS_SUCCESSFUL ) && ( transmit_buffer <
                                        CAN_NUMBER_OF_TRANSMIT_BUFFERS );
        ++transmit_buffer ) {
    if ( CANStatus & transmit_info[ transmit_buffer ].can_status_mask ) {
      sc = RTEMS_SUCCESSFUL;
      obj->transmit[ transmit_buffer ] = *msg;
      obj->CMR = transmit_info[ transmit_buffer ].not_cc_cmr_value;
    }    /*else can buffer busy, try with the next.*/
  }

  return sc;
}
示例#2
0
static void can_drivers_setup()
{
    // Configure the CAN PB12/13
    gpio_set_can_rx(GPIO_B, GPIO_PIN_12);
    gpio_set_can_tx(GPIO_B, GPIO_PIN_13);

    // Start it
    can_enable(CAN_2, 1000000);
}
示例#3
0
void can_monitor(can_t *obj, int silent) {
    uint32_t mod_mask = can_disable(obj);
    if (silent) {
        obj->dev->MOD |= (1 << 1);
    } else {
        obj->dev->MOD &= ~(1 << 1);
    }
    if (!(mod_mask & 1)) {
        can_enable(obj);
    }
}
示例#4
0
int can_write(can_t *obj, CAN_Message msg, int cc) {
    unsigned int CANStatus;
    CANMsg m;

    can_enable(obj);

    m.id   = msg.id ;
    m.dlc  = msg.len & 0xF;
    m.rtr  = msg.type;
    m.type = msg.format;
    memcpy(m.data, msg.data, msg.len);
    const unsigned int *buf = (const unsigned int *)&m;

    CANStatus = obj->dev->SR;
    if (CANStatus & 0x00000004) {
        obj->dev->TFI1 = buf[0] & 0xC00F0000;
        obj->dev->TID1 = buf[1];
        obj->dev->TDA1 = buf[2];
        obj->dev->TDB1 = buf[3];
        if(cc) {
            obj->dev->CMR = 0x30;
        } else {
            obj->dev->CMR = 0x21;
        }
        return 1;

    } else if (CANStatus & 0x00000400) {
        obj->dev->TFI2 = buf[0] & 0xC00F0000;
        obj->dev->TID2 = buf[1];
        obj->dev->TDA2 = buf[2];
        obj->dev->TDB2 = buf[3];
        if (cc) {
            obj->dev->CMR = 0x50;
        } else {
            obj->dev->CMR = 0x41;
        }
        return 1;

    } else if (CANStatus & 0x00040000) {
        obj->dev->TFI3 = buf[0] & 0xC00F0000;
        obj->dev->TID3 = buf[1];
        obj->dev->TDA3 = buf[2];
        obj->dev->TDB3 = buf[3];
        if (cc) {
            obj->dev->CMR = 0x90;
        } else {
            obj->dev->CMR = 0x81;
        }
        return 1;
    }

    return 0;
}
示例#5
0
文件: can.c 项目: gedare/rtems
/**
 * @brief Enables the interrupt type passed to the desired CAN device.
 *
 * @param number The CAN device to enable the interrupts.
 * @param type The type of interrupt to enable.
 */
static inline void can_enable_interrupt(
  const lpc176x_can_number number,
  const can_irq_type       type
)
{
  const can_driver_entry *const driver = &can_driver_table[ number ];
  const uint32_t                ier = 1 << type;

  can_disable( driver );
  driver->device->IER |= ier;
  can_enable( driver );
}
示例#6
0
文件: can.c 项目: gedare/rtems
rtems_status_code can_read(
  const lpc176x_can_number minor,
  can_message             *message
)
{
  rtems_status_code             sc = RTEMS_IO_ERROR;
  const can_driver_entry *const can_driver = &can_driver_table[ minor ];
  can_device *const             dev = can_driver->device;
  registers_can_message *const  msg = &( message->registers );

  can_enable( can_driver );

  if ( dev->GSR & CAN_GSR_RBS_MASK ) {
    sc = RTEMS_SUCCESSFUL;
    *msg = dev->receive;
    dev->CMR = CAN_CMR_RRB_MASK;      /* release receive buffer. */
  } /* else Message not received.*/

  return sc;
}
示例#7
0
文件: can_api.c 项目: pan-/mbed
int can_mode(can_t *obj, CanMode mode) {
    int success = 0;
    switch (mode) {
        case MODE_RESET:
            LPC_C_CAN0->CANCNTL &=~CANCNTL_TEST;
            can_disable(obj);
            success = 1;
            break;
        case MODE_NORMAL:
            LPC_C_CAN0->CANCNTL &=~CANCNTL_TEST;
            can_enable(obj);
            success = 1;
            break;
        case MODE_SILENT:
            LPC_C_CAN0->CANCNTL |= CANCNTL_TEST;
            LPC_C_CAN0->CANTEST |= CANTEST_SILENT;
            LPC_C_CAN0->CANTEST &=~ CANTEST_LBACK;
            success = 1;
            break;
        case MODE_TEST_LOCAL:
            LPC_C_CAN0->CANCNTL |= CANCNTL_TEST;
            LPC_C_CAN0->CANTEST &=~CANTEST_SILENT;
            LPC_C_CAN0->CANTEST |= CANTEST_LBACK;
            success = 1;
            break;
        case MODE_TEST_SILENT:
            LPC_C_CAN0->CANCNTL |= CANCNTL_TEST;
            LPC_C_CAN0->CANTEST |= (CANTEST_LBACK | CANTEST_SILENT);
            success = 1;
            break;
        case MODE_TEST_GLOBAL:
        default:
            success = 0;
            break;
    }
    
    return success;
}
示例#8
0
int can_read(can_t *obj, CAN_Message *msg, int handle) {
    CANMsg x;
    unsigned int *i = (unsigned int *)&x;

    can_enable(obj);

    if (obj->dev->GSR & 0x1) {
        *i++ = obj->dev->RFS;  // Frame
        *i++ = obj->dev->RID;  // ID
        *i++ = obj->dev->RDA;  // Data A
        *i++ = obj->dev->RDB;  // Data B
        obj->dev->CMR = 0x04;  // release receive buffer

        msg->id     = x.id;
        msg->len    = x.dlc;
        msg->format = (x.type)? CANExtended : CANStandard;
        msg->type   = (x.rtr)?  CANRemote:    CANData;
        memcpy(msg->data,x.data,x.dlc);
        return 1;
    }

    return 0;
}