File content as of revision 25:1d0488a03905:

/*
 * An example showing how to use the CANnucleo library:
 *
 * Two affordable (less than $3 on ebay) STM32F103C8T6 boards (20kB SRAM, 64kB Flash), 
 * (see [https://developer.mbed.org/users/hudakz/code/STM32F103C8T6_Hello/] for more details) 
 * are connected to the same CAN bus via transceivers (MCP2551 or TJA1040, or etc.). 
 * CAN transceivers are not part of NUCLEO boards, therefore must be added by you. 
 * Remember also that CAN bus (even a short one) must be terminated with 120 Ohm resitors at both ends.
 *
 * For more details see the wiki page <https://developer.mbed.org/users/hudakz/code/CANnucleo_Hello/>
 *
 * NOTE: If you'd like to use an STM32F103C8T6 board uncomment line 23
 *
 * The same code is used for both NUCLEO boards, but:
 *      For board #1 compile the example without any change.
 *      For board #2 comment out line 23 before compiling 
 *
 * Once the binaries have been downloaded to the boards reset board #1.
 *
 */ 

#define BOARD1                1     // comment out this line when compiling for board #2
//#define TARGET_STM32F103C8T6  1     // uncomment this line when using STM32F103C8T6 boards!                                    

#if defined(TARGET_STM32F103C8T6)
    #include "stm32f103c8t6.h"
    #define LED_PIN PC_13
    const int OFF = 1;
    const int ON  = 0;
#else
    #define LED_PIN LED1
    const int OFF = 0;
    const int ON  = 1;
#endif

#if defined(BOARD1)
    const unsigned int RX_ID = 0x100;
    const unsigned int TX_ID = 0x101;
#else
    const unsigned int RX_ID = 0x101;
    const unsigned int TX_ID = 0x100;
#endif

#include "CANnucleo.h"
#include "mbed.h"

/* 
 * To avaoid name collision with the CAN and CANMessage classes built into the mbed library
 * the CANnucleo's CAN and CANMessage classes have been moved into the CANnucleo namespace.
 * Remember to qualify them with the CANnucleo namespace.
 */
CANnucleo::CAN*         can;
CANnucleo::CANMessage   rxMsg;
CANnucleo::CANMessage   txMsg;
DigitalOut              led(LED_PIN);
Timer                   timer;
uint8_t                 counter = 0;
AnalogIn                analogIn(A0);
float                   voltage;
volatile bool           msgAvailable = false;
Serial*                 pc;

/**
 * @brief   'CAN receive-complete' interrup handler.
 * @note    Called on arrival of new CAN message.
 *          Keep it as short as possible.
 * @param   
 * @retval  
 */
void onMsgReceived() {
    msgAvailable = true;
}

/**
 * @brief   Prints CAN msg to PC's serial terminal
 * @note}
 * @param   CANMessage to print
 * @retval  none
 */
void printMsg(CANnucleo::CANMessage& msg) {
    pc->printf("  ID      = 0x%.3x\r\n", msg.id);
    pc->printf("  Type    = %d\r\n", msg.type);
    pc->printf("  Format  = %d\r\n", msg.format);
    pc->printf("  Length  = %d\r\n", msg.len);
    pc->printf("  Data    =");            
    for(int i = 0; i < msg.len; i++)
        pc->printf(" %.2x", msg.data[i]);
    pc->printf("\r\n");
 }

/**
 * @brief   Main
 * @note
 * @param 
 * @retval
 */
int main() {
#if defined(TARGET_STM32F103C8T6)
    confSysClock();     //Configure system clock (72MHz HSE clock, 48MHz USB clock)
#endif
    pc = new Serial(PA_2, PA_3);
    can = new CANnucleo::CAN(PA_11, PA_12);      // CAN Rx pin name, CAN Tx pin name
    can->frequency(1000000);                     // set bit rate to 1Mbps
    can->attach(&onMsgReceived);                 // attach 'CAN receive-complete' interrupt handler
    
#if defined(BOARD1)
    led = ON;       // turn LED on
    timer.start();  // start timer
    pc->printf("CANnucleo_Hello board #1\r\n");
#else
    led = OFF;      // turn LED off
    pc->printf("CANnucleo_Hello board #2\r\n");
#endif

    while(1) {
        if(timer.read_ms() >= 1000) {           // check for timeout
            timer.stop();                       // stop timer
            timer.reset();                      // reset timer
            counter++;                          // increment counter
            txMsg.clear();                      // clear Tx message storage
            txMsg.id = TX_ID;                   // set ID
            voltage = (analogIn * 5)/4096.0f;   // small floating voltage at analog input
            txMsg << counter << voltage;        // append data (total data length must be <= 8 bytes!)
            led = OFF;                          // turn LED off
            if(can->write(txMsg)) {             // transmit message
                pc->printf("-----------------------------------\r\n");
                pc->printf("CAN message sent\r\n");
                printMsg(txMsg);
                pc->printf("  counter = %d\r\n", counter);
                pc->printf("  voltage = %e V\r\n", voltage);
             }
            else
                pc->printf("Transmission error\r\n");
        }
        if(msgAvailable) {
            msgAvailable = false;               // reset flag for next use
            can->read(rxMsg);                   // read message into Rx message storage
            pc->printf("CAN message received\r\n");
            printMsg(rxMsg);
            // Filtering performed by software:           
            if(rxMsg.id == RX_ID) {             // About filtering performed by hardware see comments in CANnucleo.cpp 
                rxMsg >> counter >> voltage;    // extract data
                pc->printf("  counter = %d\r\n", counter);
                pc->printf("  voltage = %e V\r\n", voltage);
                led = ON;                       // turn LED on
                timer.start();                  // transmission lag
            }
        }
    }
}