~shadowrobot/sr-ros-interface-ethercat/friction_comp_tests

#include "basics.h"

#include <p18f2580.h>

 

#define CAN_LISTEN_MODE     0b01100000

#define CAN_LOOPBACK_MODE   0b01000000

#define CAN_DISABLE_MODE    0b00100000

#define CFGS        6

#define GIE         7

 

//! These are the different commands the bootloader accepts.

//! 

typedef enum

    WRITE_FLASH_ADDRESS_COMMAND   = 0x05,

    MAGIC_PACKET                  = 0x0A

}BOOTLOADER_COMMAND;

{

    ECAN_RX_OVERFLOW     = 0b00001000,

    ECAN_RX_INVALID_MSG  = 0b00010000,

 

} ECAN_RX_MSG_FLAGS;

 

struct CANmsg 

{

        int16u messageID;

        } d;

        int8u length;

        ECAN_RX_MSG_FLAGS flags;

static int8u read_eeprom(int8u address)

{

    EECON1 = 0;

    return EEDATA;

}

 

//! This checks if we should boot (start the user application), or stay in bootloader mode. 

//! We check the last byte of EEPROM if it is 0xFF it means no firmware has been

//! written in user application memory and we need to stay in bootloader mode,

    CANTX_DRIVE_VDD           = 0b00100000,

    CANTX_DRIVE_TRI_STATE     = 0b00000000

}CANTX_DRIVE_VALUES;

 

// The following #defines are used to configure the CAN bus,

// Specifically the speed and timing, among other things

#define BAUD_RATE_PRESCALER                             1

#define SYNC_JUMP_WIDTH                SYNC_JUMP_WIDTH_2X

#define SEG2PHTS                            SEG2PHTS_FREE

#define RECEIVE_BUFFER_MODE     RECEIVE_STANDARD_MESSAGES

#define CANTX_DRIVE                       CANTX_DRIVE_VDD

 

//! This initializes the ECAN module of the PIC18F

//! It sets up the baud rate, filters, masks and CAN MODE.

//! 

static void can_init(void)

{

 

        CANCON = CAN_CONFIG_MODE;

 

    BRGCON1 = SYNC_JUMP_WIDTH | (BAUD_RATE_PRESCALER-1);                                        //0x41;

    BRGCON2 = SEG2PHTS | SAMPLE_TIMES | ((PHASE_SEGMENT_1-1)<<3) | (PROPAGATION_SEGMENT-1);     //0x0B;

    BRGCON3 = CAN_WAKE_DISABLE | (PHASE_SEGMENT_2-1);                                           //0x82;

 

    

    ECANCON = CAN_MODE;                    

    RXB1CON = RECEIVE_BUFFER_MODE;

    RXB0CON = RECEIVE_BUFFER_MODE;

    CIOCON  = CANTX_DRIVE;

 

 

        CANCON = CAN_NORMAL_MODE;

}

 

//! This is the "Send Can Message" function.

//! It sends the content of the CanMsgT struct over the CAN bus.

//!

//! @author Yann Sionneau

static void sendCanMsg(void)

{

    TXB0SIDH = ((CanMsgT.messageID >> 3) & 0xff);

    TXB0DLC  = CanMsgT.length;

    TXB0D0   = CanMsgT.d.byte[0];

    TXB0D6   = CanMsgT.d.byte[6];

    TXB0D7   = CanMsgT.d.byte[7];

 

}

 

//! This function erases the program memory (which is flash)

//! It only erases the user application

//! So it starts erasing after the bootloader and stops before the debugger code

//! @author Yann Sionneau

static void erase_flash(void)

{

 

                                        // 0x7dc0 is the start of debugger code

 

    {

        TBLPTR &= 0xFFFFE0;

        

        EECON1 |=128;                   // point to Flash program memory

        {

        }

 

    }   

}

 

 

 

//! This function acknowledges ( most of ) the commands.

//!

//! @author Yann Sionneau

static void acknowledge_packet(void)

{

}

 

 

//! @author Yann Sionneau

static void write_flash_address(void)

{

    TBLPTRU = CanMsgR.d.byte[2];

    TBLPTRH = CanMsgR.d.byte[1];

    TBLPTRL = CanMsgR.d.byte[0];

 

 

//! This function does the actual writting in program memory (which is FLASH).

//! 8 bytes of data in a CAN message, so we do the block writting in 4 CAN commands.

//! So this command writes 8 bytes, and is called several times (4 times in theory)

//! Each time it is called the "position" variable gets added 8.

//! When position gets equal to 32, it means we have buffered a block and we can start

//!

//! @author Yann Sionneau

static void write_flash_data(void)

 

    position += 8;                                      // We just buffered 8 more bytes

 

    {

        _asm

            TBLRDPOSTDEC                                // We do a TBLRDPOSTDEC in order for the TBLPTR addressing register to stay in the range of the 32 bytes

        EECON1 &= ~(1 << WREN);                         // disable write to memory

        position = 0;                                   // reset the position to 0, we just finished a 32 bytes block

    }

 

//! This function writes to the EEPROM memory

//! The only goal of this function is to write something different than 0xFF

    EECON2  = 0xaa;

    EECON1 |= (1 << WR);                                // do the write

 

 

    INTCON |=  (1 << GIE );                             // enable back interrupts

    EECON1 &= ~(1 << WREN);                             // disable write to memory

                write_eeprom();

                acknowledge_packet();

                _asm

                _endasm

                // no break needed because of the goto above

 

                CanMsgT.messageID = CanMsgR.messageID | 0x10;

                CanMsgT.d.byte[0] = 0x40;

                CanMsgT.d.byte[1] = 0x41;

                sendCanMsg();

                break;

 

                _asm

                    goto 0x0000

                _endasm

        }

    }

 

    {

        Nop();

}

 

void serious_error(void)

{

    while(1)

    {

    }

}

 

//! Main function

//! This is always executed at startup of the PIC18F regardless of whether there is

//! @author Yann Sionneau

void main(void)

{

    WDTCON = 0;                             // disables the watchdog

                                            // has no effect if the configuration bit WDTEN is enabled

 

    motor_id = read_eeprom(0x00);

 

    if (motor_id == 0xFF)

 

                                            // From here we are in boot loader mode

                                            // ------------------------------------

 

    position = 0;                           // Resets the position for the "write to flash" process

    can_init();                             // Initializes ECAN module

        handle_can_msg();                   // checks if we have received a CAN msg, and handles it

    }

}