Revision 1:dbc44582f2f8, committed 2010-06-13

Comitter:

tecnosys

Date:

Sun Jun 13 09:52:03 2010 +0000

Parent:

0:d8f50b1e384f

Child:

2:b392dd75be80

Commit message:

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CAN3.cpp	Sun Jun 13 09:52:03 2010 +0000
@@ -0,0 +1,95 @@
+#include "CAN3.h"
+
+#include "mbed.h"
+#include "mcp2515.h"
+#include "mcp2515_can.h"
+#include "mcp2515_defs.h"
+
+
+CAN3::CAN3(SPI& _spi, PinName ncs, PinName itr)
+        : spi(_spi), _mcp(spi, ncs), _itr(itr) {
+    printf("\n\rcan = %d",this);
+
+}
+
+uint8_t CAN3::read(CANMessage *msg) {
+    uint8_t stat, res;
+
+    stat = _mcp.readStatus();
+
+    if ( stat & MCP_STAT_RX0IF ) {
+        // Msg in Buffer 0
+        _mcp.read_canMsg( MCP_RXBUF_0, msg);
+        _mcp.modifyRegister(MCP_CANINTF, MCP_RX0IF, 0);
+        res = CAN_OK;
+    } else if ( stat & MCP_STAT_RX1IF ) {
+        // Msg in Buffer 1
+        _mcp.read_canMsg( MCP_RXBUF_1, msg);
+        _mcp.modifyRegister(MCP_CANINTF, MCP_RX1IF, 0);
+        res = CAN_OK;
+    } else {
+        res = CAN_NOMSG;
+    }
+
+    return res;
+}
+
+uint8_t CAN3::checkReceive(void) {
+    uint8_t res;
+
+    res = _mcp.readStatus(); // RXnIF in Bit 1 and 0
+    if ( res & MCP_STAT_RXIF_MASK ) {
+        return CAN_MSGAVAIL;
+    } else {
+        return CAN_NOMSG;
+    }
+}
+
+void CAN3::write(CANMessage* test) {
+    uint8_t  txbuf_n;
+    _mcp.getNextFreeTXBuf(&txbuf_n);
+    _mcp.write_canMsg(txbuf_n,test);
+    _mcp.start_transmit( txbuf_n );
+}
+
+void CAN3::rise(void (*fptr)(void)) {
+    _itr.rise(fptr);
+}
+
+void CAN3::fall(void (*fptr2)(void)) {
+    _itr.fall(fptr2);
+}
+
+void CAN3::frequency(int canSpeed) {
+
+    uint8_t res;
+
+    res = _mcp.init(canSpeed); //CAN_500KBPS_8MHZ
+    wait(.001);
+    if (res == MCP2515_OK) {
+        printf("CAN Init OK\n\r");
+
+    } else {
+        printf("CAN Init FAIL\n\r");
+    }
+
+    _mcp.setRegister(MCP_CANINTE, 0x3);//0x3); //MCP_RX_INT);
+    _mcp.setRegister(MCP_CANINTF, 0x3);// 0xff);
+
+
+//RX0,1 as rx0,1 digital interrupt outputs
+//_mcp.setRegister(BFPCTRL, 0xf);
+
+//[Set TX0,1,2 as digital inputs
+//_mcp.setRegister(TXRTSCTRL, 0x0);
+
+    printf("Setting Normal-Mode - \n\r ");
+    if ( _mcp.setCANCTRL_Mode(MODE_NORMAL) == MCP2515_OK) { //MODE_NORMAL MODE_LOOPBACK
+        printf("OK\n\r");
+    } else {
+        printf("failed\n\r");
+    }
+
+    _mcp.dumpExtendedStatus();
+    wait(.001);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CAN3.h	Sun Jun 13 09:52:03 2010 +0000
@@ -0,0 +1,44 @@
+
+#ifndef _CAN3_H_
+#define _CAN3_H_
+
+#include "mbed.h"
+#include "mcp2515.h"
+#include "mcp2515_defs.h"
+#include "mcp2515_can.h"
+#include "SPI.h"
+
+#define BFPCTRL        0x0C
+#define TXRTSCTRL       0x0D
+
+
+class CAN3  {
+    SPI& spi;
+    InterruptIn _itr;
+    mcp2515 _mcp;
+public:
+    CAN3(SPI& _spi, PinName ncs, PinName itr);
+    
+    uint8_t read(CANMessage *msg); //    int read(CANMessage&    msg);
+    void write(CANMessage* test);   //int write(CANMessage     msg);
+    void frequency( int canSpeed); //Set the frequency of the CAN interface hz    The bus frequency in hertz
+
+
+    void reset(); //Reset CAN interface. To use after error overflow.
+    unsigned char rderror(); //Returns number of read errors to detect read overflow errors.
+    unsigned char tderror(); //Returns number of write errors to detect write overflow errors.
+
+    void rise(void (*fptr)(void));
+    void fall(void (*fptr2)(void));
+
+
+
+
+    // Private functions
+private :
+    uint8_t checkReceive(void);
+
+
+};
+
+#endif // _MCP2515_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sun Jun 13 09:52:03 2010 +0000
@@ -0,0 +1,189 @@
+//#define PROTOPLATFORM
+#define MBEDPLATFORM
+// Flip an LED every time we see the rising edge interrupt on a pin
+#include "mbed.h"
+#include "CAN3.h"
+#include "mcp2515.h"
+#include "mcp2515_can.h"
+#include <Includes/Platform.h>
+
+
+
+DigitalOut led_can(LED1);
+DigitalOut led_serial(LED2);
+DigitalOut led_analog(LED3);
+DigitalOut led_status(LED4);
+Serial console(CONSOLETX, CONSOLERX); // tx, rx
+//Serial console(USBTX, USBRX); // tx, rx
+
+
+SPI spi1(CAN_SPI_MOSI, CAN_SPI_MISO, CAN_SPI_SCK);
+//SPI spi1(p5,p6,p7);
+CAN3 can1(spi1, CAN1_CS, CAN1_NT);
+CAN3 can2(spi1, CAN2_CS, CAN2_NT);
+CAN3 can3(spi1, CAN3_CS, CAN3_NT);
+CAN3 can4(spi1, CAN4_CS, CAN4_NT);
+
+//CAN3 can1(spi1, p19, p11);
+//CAN3 can2(spi1, p20, p12);
+//CAN3 can5(spi1, p21, p23);
+//CAN can5(p30, p29);
+
+//CAN can5(CAN5_L, CAN5_H);
+
+
+Ticker mbed_can_ticker;
+Ticker mcp2515_s1_can_ticker;
+Ticker mcp2515_s2_can_ticker;
+Ticker mcp2515_s3_can_ticker;
+Ticker mcp2515_s4_can_ticker;
+
+char testbytes[] = { 0xA1, 0xA2, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0xF0 };
+
+void showMessage(CAN3 can) {
+    CANMessage msg;
+
+
+    while ( can.read(&msg) == CAN_OK ) {
+        console.printf(" \n \r CAN[]: rx -> id 0x%02x dlc %d  ",msg.id,msg.len);
+        for (int i=0;i<msg.len;i++) {
+            console.printf("%02x", msg.data[i]);
+            console.printf(" ");
+            led_serial=!led_serial;
+        }
+
+    }
+}
+
+void send() {
+   static char counter = 0;
+   //can5.write(CANMessage(0x200, &counter, 1));
+   counter++;
+
+}
+
+void sendSPICAN1() {
+
+
+    CANMessage test(0x100, testbytes, 8);
+    can1.write(&test);
+
+}
+
+void sendSPICAN2() {
+
+
+    CANMessage test(0x200, testbytes, 8);
+    can2.write(&test);
+
+}
+
+
+void sendSPICAN3() {
+
+
+    CANMessage test(0x300, testbytes, 8);
+  //  can5.write(test);
+
+}
+
+
+void sendSPICAN4() {
+
+
+    CANMessage test(0x400, testbytes, 8);
+    //can4.write(&test);
+
+}
+
+
+///////
+
+
+void getCANMessages() {
+
+showMessage(can1);
+showMessage(can2);
+//showMessage(can3);
+//showMessage(can4);
+
+}
+
+int main() {
+
+
+
+led_can=1;
+led_status=1;
+
+     console.baud(57600);
+    console.printf("\nStarting\n\n");
+
+   // freopen("/console", "w", stdout);
+  //  spi1.format(8,0);
+ //  spi1.frequency(5000000); // anything above 5000000 5MHZ works
+      //spi1.format(16,0);
+     spi1.frequency(10000000);
+    
+//   can5.frequency(125000);//(500000); 50KBPS 1250000
+
+    console.printf("\n\r\rCAN1 \n\r");
+   // can1.frequency(50000);
+   can1.frequency(50000);
+   
+    console.printf("\n\r\rCAN2 \n\r");
+ //   can2.frequency(5000);
+can1.frequency(125000);
+   
+    console.printf("\n\r\rCAN3 \n\r");
+    can1.frequency(250000);
+
+    console.printf("\n\r\rCAN4 \n\r");
+  can1.frequency(500000);
+
+    
+    wait(.1);
+    led_can=0;
+    led_serial=0;
+    led_analog=0;
+    led_status=1;
+
+
+    //can3._spi.frequency(5000000); // anything above 5000000 5MHZ works
+
+    can1.fall(&getCANMessages);
+    can2.fall(&getCANMessages);
+    //can5.fall(&canmsg2);
+
+
+    printf("\n\r\n\r\n\r\n\r\n\r");
+    wait(.1);
+    mbed_can_ticker.attach(&send, 3);
+    mcp2515_s1_can_ticker.attach(&sendSPICAN1, 2);
+    mcp2515_s2_can_ticker.attach(&sendSPICAN2, 3);
+    mcp2515_s3_can_ticker.attach(&sendSPICAN3, 2);
+    mcp2515_s4_can_ticker.attach(&sendSPICAN4, 5);
+    //mcp2515_s3_can_ticker.attach(&sendSPICAN5, 1);
+     console.printf("here");
+    while (1) {
+
+    console.printf("here2");
+        wait(1);
+
+        // canmsg1();
+        /*
+                //MODE_NORMAL
+                if ( ( can3.can_checkReceive() == CAN_MSGAVAIL ) ) {
+                    can3.process_CANMessages();
+                }
+                //MODE_NORMAL
+                if ( ( can4.can_checkReceive() == CAN_MSGAVAIL ) ) {
+                    can4.process_CANMessages();
+                }
+        */
+        //can3.dumpExtendedStatus();
+
+    }
+
+
+}
\ No newline at end of file

--- a/mbed.bld	Sat Jan 30 08:46:04 2010 +0000
+++ b/mbed.bld	Sun Jun 13 09:52:03 2010 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/mbed_official/code/mbed/builds/49a220cc26e0
+http://mbed.org/users/mbed_official/code/mbed/builds/029aa53d7323

--- a/mcp2515.cpp	Sat Jan 30 08:46:04 2010 +0000
+++ b/mcp2515.cpp	Sun Jun 13 09:52:03 2010 +0000
@@ -1,8 +1,8 @@
 /******************************************************************************
- * 
+ *
  * Controller Area Network (CAN) Demo-Application
- * Atmel AVR with Microchip MCP2515 
- * 
+ * Atmel AVR with Microchip MCP2515
+ *
  * Copyright (C) 2005 Martin THOMAS, Kaiserslautern, Germany
  * <eversmith@heizung-thomas.de>
  * http://www.siwawi.arubi.uni-kl.de/avr_projects
@@ -11,10 +11,10 @@
  *
  * File    : mcp2515.c
  * Version : 0.9
- * 
+ *
  * Summary : MCP2515 "low-level" driver
  *
- * Parts of this code are adapted from a MCP2510 sample-application 
+ * Parts of this code are adapted from a MCP2510 sample-application
  * by KVASER AB, http://www.kvaser.com (KVASER-code is marked as free)
  *
  * This code-module is free to use but you have to keep the copyright
@@ -26,7 +26,7 @@
  * File    : mcp2515.cpp (mbed LPC1768 version)
  * Version : 0.1
  *
- * All credits to the nerds above, this source has been adapted for the 
+ * All credits to the nerds above, this source has been adapted for the
  * LPC1768 platform by J.Engelman. And does'nt require and of the copyrighted
  * SPI or AVR controller code that Martin or co have excluded copyright.
  * This module remains free.
@@ -36,25 +36,36 @@
 
 #include "mcp2515.h"
 
-#include <mbed.h>
+#include "mbed.h"
 #include "mcp2515_can.h"
 #include "mcp2515_defs.h"
 #include "mcp2515_bittime.h"
 
 #define SPI_NULL (0x00)
 
-
+#define PHSEG11        4
+#define PHSEG21        1
+#define BTLMODE2        7
+//BTLMODE 0x80 (128)
+#define BRP2        2
+#define BRP1        1
+#define BRP0        0
 
-mcp2515::mcp2515(PinName mosi, PinName miso, PinName clk, PinName ncs)
-        : _spi(mosi, miso, clk), _ncs(ncs) {
+#define CNF2_BTLMODE  0x80
+#define CNF3          0x28
+#define CNF3_SOF      0x08
+#define CNF3_WAKFIL   0x04
+#define CNF3_PHSEG2_MASK 0x07
 
-     // _spi.format(8,0);
-     // _spi.frequency(10000000);
-    //_spi.frequency(5000000);
+mcp2515::mcp2515(SPI& _spi, PinName ncs)
+        : spi(_spi), _ncs(ncs) {
+    printf("\n\rmcp2515 = %d",this);
+    printf("\n\rpin = %d",ncs);
 
 }
 
 
+
 void mcp2515::_reset() {
 
     _select();
@@ -63,8 +74,7 @@
     wait(0.001);
 }
 
-void mcp2515::setRegister(const uint8_t address, const uint8_t value)
-{
+void mcp2515::setRegister(  uint8_t address,   uint8_t value) {
     _select();
     _spi_readwrite(MCP_WRITE);
     _spi_readwrite(address);
@@ -72,21 +82,28 @@
     _deselect();
 }
 
-uint8_t mcp2515::configRate(const uint8_t canSpeed)
-{
+uint8_t mcp2515::configRate(  uint8_t canSpeed) {
     uint8_t set, cfg1, cfg2, cfg3;
-    
+
     set = 0;
-    
+
     switch (canSpeed) {
+        case (CAN_500KBPS_8MHZ) :
+                        cfg1 = 0x04;
+            cfg2 = 0xA0;
+            cfg3 = 0x02;
+        case (CAN_50KBPS_8MHZ) :
+                        cfg1 = 0x04; //0x09;
+            cfg2 = 0xB8; //0x90;
+            cfg3 = 0x05; //0x02;
         case (CAN_125KBPS) :
-            cfg1 = MCP_4MHz_125kBPS_CFG1 ;
+                        cfg1 = MCP_4MHz_125kBPS_CFG1 ;
             cfg2 = MCP_4MHz_125kBPS_CFG2 ;
             cfg3 = MCP_4MHz_125kBPS_CFG3 ;
             set = 1;
             break;
         case (CAN_20KBPS) :
-            cfg1 = MCP_4MHz_20kBPS_CFG1 ;
+                        cfg1 = MCP_4MHz_20kBPS_CFG1 ;
             cfg2 = MCP_4MHz_20kBPS_CFG2 ;
             cfg3 = MCP_4MHz_20kBPS_CFG3 ;
             set = 1;
@@ -95,36 +112,98 @@
             set = 0;
             break;
     }
-    
+
     if (set) {
         setRegister(MCP_CNF1, cfg1);
         setRegister(MCP_CNF2, cfg2);
         setRegister(MCP_CNF3, cfg3);
         return MCP2515_OK;
-    }
-    else {
+    } else {
         return MCP2515_FAIL;
     }
-} 
+}
+
+int mcp2515::configRate2(int bit_rate)
+{
+    //struct spi_device *spi = to_spi_device(can->cdev.dev);
+    //struct mcp251x *chip = dev_get_drvdata(&spi->dev);
+    //struct mcp251x_platform_data *pdata = spi->dev.platform_data;
+    
+        printf("\n\rcanspeed=%d",bit_rate);
+    int f_osc = 8000000; //4000000; //4Mhz
+    int tqs; /* tbit/TQ */
+    int brp;
+    int ps1, ps2, propseg, sjw;
+
+    /* Determine the BRP value that gives the requested bit rate. */
+    for(brp = 0; brp < 8; brp++) {
+        tqs = f_osc / (2 * (brp + 1)) / bit_rate;
+        if (tqs >= 5 && tqs <= 25
+            && (f_osc / (2 * (brp + 1)) / tqs) == bit_rate)
+            break;
+    }
+    if (brp >= 8) printf("Spaztic BRP");
+   //     return -1;
 
-uint8_t mcp2515::readRegister(const uint8_t address)
-{
+    /* The CAN bus bit time (tbit) is determined by:
+     *   tbit = (SyncSeg + PropSeg + PS1 + PS2) * TQ
+     * with:
+     *     SyncSeg = 1
+     *     sample point (between PS1 and PS2) must be at 60%-70% of the bit time
+     *     PropSeg + PS1 >= PS2
+     *     PropSeg + PS1 >= Tdelay
+     *     PS2 > SJW
+     *     1 <= PropSeg <= 8, 1 <= PS1 <=8, 2 <= PS2 <= 8
+     * SJW = 1 is sufficient in most cases.
+     * Tdelay is usually 1 or 2 TQ.
+     */
+
+    propseg = ps1 = ps2 = (tqs - 1) / 3;
+    if (tqs - (1 + propseg + ps1 + ps2) == 2)
+        ps1++;
+    if (tqs - (1 + propseg + ps1 + ps2) == 1)
+        ps2++;
+    sjw = 1;
+
+    printf("\n\rbit rate: BRP = %d, Tbit = %d TQ, PropSeg = %d, PS1 = %d, PS2 = %d, SJW = %d\n",
+        brp, tqs, propseg, ps1, ps2, sjw);
+
+    /* Since we can only change the bit rate when the network device is
+     * down the chip must be in sleep mode. Wake it up and put it into
+     * config mode. */
+    //mcp251x_hw_wakeup(spi);
+    //mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_CONF);
+
+    //mcp251x_write_reg(spi, CNF1, ((sjw-1) << 6) | brp);
+    //mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE | ((ps1-1) << 3) | (propseg-1));
+    //mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK, (ps2-1));
+        setRegister(MCP_CNF1, ((sjw-1) << 6) | brp );
+        setRegister(MCP_CNF2, CNF2_BTLMODE | ((ps1-1) << 3) | (propseg-1) );
+        modifyRegister(MCP_CNF3, CNF3_PHSEG2_MASK, (ps2-1) );
+    //mcp251x_hw_sleep(spi);
+
+    /* Calculate actual bit rate. */
+    //chip->bit_rate = pdata->f_osc / (2 * (brp + 1)) / tqs;
+
+    return 0;
+}
+
+uint8_t mcp2515::readRegister(  uint8_t address) {
     uint8_t ret;
-    
+
     _select();
     _spi_readwrite(MCP_READ);
     _spi_readwrite(address);
     ret = _spi_read();
     _deselect();
-    
+
     return ret;
 }
 
-void mcp2515::readRegisterS(const uint8_t address, 
-    uint8_t values[], const uint8_t n)
-{
+void mcp2515::readRegisterS(  uint8_t address,
+                              uint8_t values[],   uint8_t n) {
     uint8_t i;
-    
+
     _select();
     _spi_readwrite(MCP_READ);
     _spi_readwrite(address);
@@ -135,9 +214,8 @@
     _deselect();
 }
 
-void mcp2515::modifyRegister(const uint8_t address, 
-    const uint8_t mask, const uint8_t data)
-{
+void mcp2515::modifyRegister(  uint8_t address,
+                               uint8_t mask,   uint8_t data) {
     _select();
     _spi_readwrite(MCP_BITMOD);
     _spi_readwrite(address);
@@ -147,55 +225,51 @@
 }
 
 
-uint8_t mcp2515::readXXStatus_helper(const uint8_t cmd)
-{
+uint8_t mcp2515::readXXStatus_helper(  uint8_t cmd) {
     uint8_t i;
-    
+
     _select();
     _spi_readwrite(cmd);
     i = _spi_read();
     _deselect();
-    
+
     return i;
 }
-    
-uint8_t mcp2515::readStatus(void)
-{
+
+uint8_t mcp2515::readStatus(void) {
     return readXXStatus_helper(MCP_READ_STATUS);
 }
 
-uint8_t mcp2515::RXStatus(void)
-{
+uint8_t mcp2515::RXStatus(void) {
     return readXXStatus_helper(MCP_RX_STATUS);
 }
 
 // read-modify-write - better: Bit Modify Instruction
-uint8_t mcp2515::setCANCTRL_Mode(uint8_t newmode)
-{
+uint8_t mcp2515::setCANCTRL_Mode(uint8_t newmode) {
+
     uint8_t i;
-    
+
     i = readRegister(MCP_CANCTRL);
     i &= ~(MODE_MASK);
     i |= newmode;
     setRegister(MCP_CANCTRL, i);
-    
+
     // verify as advised in datasheet
     i = readRegister(MCP_CANCTRL);
     i &= MODE_MASK;
     if ( i == newmode ) {
-        return MCP2515_OK; 
-    }
-    else {
+        return MCP2515_OK;
+    } else {
         return MCP2515_FAIL;
     }
+    
 }
 
 
-void mcp2515::setRegisterS(const uint8_t address, 
-    const uint8_t values[], const uint8_t n)
-{
+void mcp2515::setRegisterS(  uint8_t address,
+                             uint8_t values[],   uint8_t n) {
     uint8_t i;
-    
+
     _select();
     _spi_readwrite(MCP_WRITE);
     _spi_readwrite(address);
@@ -206,18 +280,17 @@
     _deselect();
 }
 
-void mcp2515::read_can_id( const uint8_t mcp_addr, 
-    uint8_t* ext, uint32_t* can_id )
-{
+void mcp2515::read_can_id(   uint8_t mcp_addr,
+                             uint8_t* ext, uint32_t* can_id ) {
     uint8_t tbufdata[4];
-    
+
     *ext = 0;
     *can_id = 0;
-    
+
     readRegisterS( mcp_addr, tbufdata, 4 );
-    
+
     *can_id = (tbufdata[MCP_SIDH]<<3) + (tbufdata[MCP_SIDL]>>5);
-    
+
     if ( (tbufdata[MCP_SIDL] & MCP_TXB_EXIDE_M) ==  MCP_TXB_EXIDE_M ) {
         // extended id
         *can_id = (*can_id<<2) + (tbufdata[MCP_SIDL] & 0x03);
@@ -228,42 +301,66 @@
 }
 
 
+void mcp2515::read_can_idN(   uint8_t mcp_addr,
+                              CANFormat* ext, unsigned int* can_id ) {
+    uint8_t tbufdata[4];
+
+    *ext = CANStandard;
+    *can_id = 0;
+
+    readRegisterS( mcp_addr, tbufdata, 4 );
+
+    *can_id = (tbufdata[MCP_SIDH]<<3) + (tbufdata[MCP_SIDL]>>5);
+
+    if ( (tbufdata[MCP_SIDL] & MCP_TXB_EXIDE_M) ==  MCP_TXB_EXIDE_M ) {
+        // extended id
+        *can_id = (*can_id<<2) + (tbufdata[MCP_SIDL] & 0x03);
+        *can_id <<= 16;
+        *can_id = *can_id +(tbufdata[MCP_EID8]<<8) + tbufdata[MCP_EID0];
+        *ext = CANExtended;//1;
+    }
+}
+
 // Buffer can be MCP_RXBUF_0 or MCP_RXBUF_1
-void mcp2515::read_canMsg( const uint8_t buffer_sidh_addr,
-    CANMessage* msg)
+void mcp2515::read_canMsg(   uint8_t buffer_sidh_addr, CANMessage* msg)
+//CANMessage mcp2515::read_canMsg(   uint8_t buffer_sidh_addr)
 {
-/*
-    uint8_t mcp_addr, ctrl;
+    uint8_t mcp_addr, ctrl,dlc;
+
+
 
     mcp_addr = buffer_sidh_addr;
-    
-    read_can_id( mcp_addr, &(msg->extended_identifier), 
-        &(msg->identifier) );
-    
+
+    read_can_idN( mcp_addr, &msg->format, &msg->id );
+
     ctrl = readRegister( mcp_addr-1 );
-    msg->dlc = readRegister( mcp_addr+4 );
-    
+    dlc = readRegister( mcp_addr+4 );
+
     //if ((*dlc & RTR_MASK) || (ctrl & 0x08)) {
     if ((ctrl & 0x08)) {
-        msg->rtr = 1;
+        msg->type = CANRemote;  //1 CANRemote
     } else {
-        msg->rtr = 0;
+        msg->type = CANData;  //0 CANData
     }
-    
-    msg->dlc &= MCP_DLC_MASK;
-    readRegisterS( mcp_addr+5, &(msg->dta[0]), msg->dlc );
-    */
+
+    dlc &= MCP_DLC_MASK;
+    readRegisterS( mcp_addr+5, &(msg->data[0]), dlc );
+    msg->len =dlc;
+
 }
 
+void mcp2515::setDebugConsole(Serial c){
+    //console=c;
+    debug=true;
+}   
 
-void mcp2515::write_can_id( const uint8_t mcp_addr, 
-    const uint8_t ext, const uint32_t can_id )
-{
+void mcp2515::write_can_id(   uint8_t mcp_addr,
+                              uint8_t ext,   uint32_t can_id ) {
     uint16_t canid;
     uint8_t tbufdata[4];
-    
+
     canid = (uint16_t)(can_id & 0x0FFFF);
-    
+
     if ( ext == 1) {
         tbufdata[MCP_EID0] = (uint8_t) (canid & 0xFF);
         tbufdata[MCP_EID8] = (uint8_t) (canid / 256);
@@ -272,8 +369,7 @@
         tbufdata[MCP_SIDL] += (uint8_t) ((canid & 0x1C )*8);
         tbufdata[MCP_SIDL] |= MCP_TXB_EXIDE_M;
         tbufdata[MCP_SIDH] = (uint8_t) (canid / 32 );
-    }
-    else {
+    } else {
         tbufdata[MCP_SIDH] = (uint8_t) (canid / 8 );
         tbufdata[MCP_SIDL] = (uint8_t) ((canid & 0x07 )*32);
         tbufdata[MCP_EID0] = 0;
@@ -283,67 +379,63 @@
 }
 
 // Buffer can be MCP_TXBUF_0 MCP_TXBUF_1 or MCP_TXBUF_2
-void mcp2515::write_canMsg( const uint8_t buffer_sidh_addr, 
-     CANMessage* msg)
-{
+void mcp2515::write_canMsg(   uint8_t buffer_sidh_addr,
+                              CANMessage* msg) {
     uint8_t mcp_addr, dlc;
 
     mcp_addr = buffer_sidh_addr;
     dlc = msg->len;
-    
+
     setRegisterS(mcp_addr+5, &(msg->data[0]), dlc );  // write data bytes
     write_can_id( mcp_addr, msg->format,
-        msg->id );  // write CAN id
+                  msg->id );  // write CAN id
     if ( msg->type == 1)  dlc |= MCP_RTR_MASK;  // if RTR set bit in byte
     setRegister( (mcp_addr+4), dlc );  // write the RTR and DLC
 }
 
-void mcp2515::start_transmit(const uint8_t buffer_sidh_addr)
-{
-	// TXBnCTRL_addr = TXBnSIDH_addr - 1
-   modifyRegister( buffer_sidh_addr-1 , MCP_TXB_TXREQ_M, 
-		MCP_TXB_TXREQ_M );
+void mcp2515::start_transmit(  uint8_t buffer_sidh_addr) {
+    // TXBnCTRL_addr = TXBnSIDH_addr - 1
+    modifyRegister( buffer_sidh_addr-1 , MCP_TXB_TXREQ_M,
+                    MCP_TXB_TXREQ_M );
 }
 
-uint8_t mcp2515::getNextFreeTXBuf(uint8_t *txbuf_n)
-{
-	uint8_t res, i, ctrlval;
-	uint8_t ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
-	
-	res = MCP_ALLTXBUSY;
-	*txbuf_n = 0x00;
-	
-	// check all 3 TX-Buffers
-	for (i=0; i<MCP_N_TXBUFFERS; i++) {
-		ctrlval = readRegister( ctrlregs[i] );
-		if ( (ctrlval & MCP_TXB_TXREQ_M) == 0 ) {
+uint8_t mcp2515::getNextFreeTXBuf(uint8_t *txbuf_n) {
+    uint8_t res, i, ctrlval;
+    uint8_t ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
+
+    res = MCP_ALLTXBUSY;
+    *txbuf_n = 0x00;
 
-			*txbuf_n = ctrlregs[i]+1; // return SIDH-address of Buffer
-			res = MCP2515_OK;
-			return res; /* ! function exit */
-		}
-	}
-	
-	return res;
+    // check all 3 TX-Buffers
+    for (i=0; i<MCP_N_TXBUFFERS; i++) {
+        ctrlval = readRegister( ctrlregs[i] );
+        if ( (ctrlval & MCP_TXB_TXREQ_M) == 0 ) {
+
+            *txbuf_n = ctrlregs[i]+1; // return SIDH-address of Buffer
+            res = MCP2515_OK;
+            return res; /* ! function exit */
+        }
+    }
+
+    return res;
 }
 
-void mcp2515::initCANBuffers(void)
-{
-    uint8_t i, a1, a2, a3;
-    
-    // TODO: check why this is needed to receive extended 
+void mcp2515::initCANBuffers(void) {
+//    uint8_t i, a1, a2, a3;
+
+    // TODO: check why this is needed to receive extended
     //   and standard frames
     // Mark all filter bits as don't care:
     write_can_id(MCP_RXM0SIDH, 0, 0);
     write_can_id(MCP_RXM1SIDH, 0, 0);
     // Anyway, set all filters to 0:
-    write_can_id(MCP_RXF0SIDH, 1, 0); // RXB0: extended 
+    write_can_id(MCP_RXF0SIDH, 1, 0); // RXB0: extended
     write_can_id(MCP_RXF1SIDH, 0, 0); //       AND standard
-    write_can_id(MCP_RXF2SIDH, 1, 0); // RXB1: extended 
+    write_can_id(MCP_RXF2SIDH, 1, 0); // RXB1: extended
     write_can_id(MCP_RXF3SIDH, 0, 0); //       AND standard
     write_can_id(MCP_RXF4SIDH, 0, 0);
     write_can_id(MCP_RXF5SIDH, 0, 0);
-    
+    /*
     // Clear, deactivate the three transmit buffers
     // TXBnCTRL -> TXBnD7
     a1 = MCP_TXB0CTRL;
@@ -357,51 +449,54 @@
         a2++;
         a3++;
     }
-    
+    */
     // and clear, deactivate the two receive buffers.
-    setRegister(MCP_RXB0CTRL, 0);
-    setRegister(MCP_RXB1CTRL, 0);
+    // setRegister(MCP_RXB0CTRL, 0);
+    //setRegister(MCP_RXB1CTRL, 0);
 }
 
-uint8_t mcp2515::init(const uint8_t canSpeed)
-{
+uint8_t mcp2515::init(  int canSpeed) {
     uint8_t res;
-    
+
     _deselect();
     //MCP_CS_DDR |= ( 1 << MCP_CS_BIT );
-    
+
     _reset();
+
     
     res = setCANCTRL_Mode(MODE_CONFIG);
-    
-    if ( res == MCP2515_FAIL ){
-     printf("FAIL here");
-     return res;  /* function exit on error */
+
+    if ( res == MCP2515_FAIL ) {
+        printf("\r\nCAN init failed %d\n\r",&_ncs);
+        return res;  /* function exit on error */
     }
-    res = configRate(canSpeed);
-    
+    res = configRate2(canSpeed);
+
     if ( res == MCP2515_OK ) {
         initCANBuffers();
-        
+
 
         // enable both receive-buffers to receive messages
         // with std. and ext. identifiers
         // and enable rollover
-        modifyRegister(MCP_RXB0CTRL, 
-            MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK, 
-            MCP_RXB_RX_STDEXT | MCP_RXB_BUKT_MASK );
-        modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK, 
-            MCP_RXB_RX_STDEXT);
+        modifyRegister(MCP_RXB0CTRL,
+                       MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
+                       MCP_RXB_RX_STDEXT | MCP_RXB_BUKT_MASK );
+        modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
+                       MCP_RXB_RX_STDEXT);
 
+        // Prescaler setting of the CLKOUT pin to zero 
+        // => Spending clock frequency of the CLKOUT pin MCP2515 
+        modifyRegister (MCP_CANCTRL, 0x07, CLKOUT_ENABLE);
     }
-    
+
     return res;
 }
 
 /*
  * Select function
  */
- 
+
 void mcp2515::_select() {
 //printf("{");
     _ncs = 0;
@@ -420,9 +515,9 @@
 int mcp2515::status() {
     int status = 0;
     _select();
-    _spi.write(0xd7);
-    status = (_spi.write(0x00) << 8 );
-    status |= _spi.write(0x00);
+    spi.write(0xd7);
+    status = (spi.write(0x00) << 8 );
+    status |= spi.write(0x00);
     _deselect();
     return status;
 }
@@ -438,15 +533,45 @@
 }
 
 
-uint8_t mcp2515::_spi_readwrite(uint8_t data)
-{
-     //printf("W0x%x ", data);
-      uint8_t ret = _spi.write(data);
-       //     printf("R0x%x,", ret);
+uint8_t mcp2515::_spi_readwrite(uint8_t data) {
+    //printf("W0x%x ", data);
+    uint8_t ret = spi.write(data);
+    //      printf("R0x%x,", ret);
     return ret;
 }
 
-uint8_t mcp2515::_spi_read(void)
-{
+uint8_t mcp2515::_spi_read(void) {
     return _spi_readwrite(SPI_NULL);
 }
+
+void mcp2515::dumpExtendedStatus(void) {
+    uint8_t tec, rec, eflg;
+
+    tec  = readRegister(MCP_TEC);
+    rec  = readRegister(MCP_REC);
+    eflg = readRegister(MCP_EFLG);
+
+    printf("MCP2515 Extended Status:\n\r");
+    printf("MCP Transmit Error Count %d \r\n", tec);
+    printf("MCP Receiver Error Count %d \n\r", rec);
+    printf("MCP Error Flag %d\n\r", eflg);
+
+    if ( (rec>127) || (tec>127) ) {
+        printf("Error-Passive or Bus-Off\n\r");
+    }
+
+    if (eflg & MCP_EFLG_RX1OVR)
+        printf("Receive Buffer 1 Overflow\r\n");
+    if (eflg & MCP_EFLG_RX0OVR)
+        printf("Receive Buffer 0 Overflow\n\r");
+    if (eflg & MCP_EFLG_TXBO)
+        printf("Bus-Off\n\r");
+    if (eflg & MCP_EFLG_TXEP)
+        printf("Receive Error Passive\n\r");
+    if (eflg & MCP_EFLG_TXWAR)
+        printf("Transmit Error Warning\n\r");
+    if (eflg & MCP_EFLG_RXWAR)
+        printf("Receive Error Warning\r\n");
+    if (eflg & MCP_EFLG_EWARN )
+        printf("Receive Error Warning\n\r");
+}

--- a/mcp2515.h	Sat Jan 30 08:46:04 2010 +0000
+++ b/mcp2515.h	Sun Jun 13 09:52:03 2010 +0000
@@ -45,7 +45,7 @@
 void can_init(short id);
 char can_peek_message();
 char can_rx_byte();
-void can_set_id(short id); 
+void can_set_id(short id);
 void can_init_buffer();
 void can_load_byte(char input);
 void can_tx_buffer();
@@ -54,53 +54,64 @@
 
 #include "mbed.h"
 #include "SPI.h"
-        class mcp2515  {
-        public:
-            mcp2515(PinName mosi, PinName miso, PinName clk, PinName ncs);
-           // float read (void);
-           // void setThigh (float);
-           // void setTlow (float);
-           // float getThigh (void);
-           // float getTlow (void);
-            virtual void _reset();
-            uint8_t configRate(const uint8_t canSpeed);
-            void    setRegister(const uint8_t address, const uint8_t value);
-            
-            uint8_t readRegister(const uint8_t address);
-            void    modifyRegister(const uint8_t address, const uint8_t mask, const uint8_t data);
-            uint8_t setCANCTRL_Mode(uint8_t newmode);
-            uint8_t init(const uint8_t canSpeed);
-            void    initCANBuffers(void);
-            void    setRegisterS(const uint8_t address, const uint8_t values[], const uint8_t n);
-            void    write_can_id( const uint8_t mcp_addr, const uint8_t ext, const uint32_t can_id );
-            //
-            
-            void    readRegisterS(const uint8_t address, uint8_t values[], const uint8_t n);
-            uint8_t readXXStatus_helper(const uint8_t cmd);
-            uint8_t readStatus(void);
-            uint8_t RXStatus(void);
+class mcp2515  {
+   SPI& spi;
+    DigitalOut _ncs;
+    //Serial&  console =0;
+    bool    debug;
+public:
+    //  mcp2515(PinName mosi, PinName miso, PinName clk, PinName ncs);
+    mcp2515(SPI& _spi, PinName ncs);
+    // void setInterface(SPI& spi);
+    // float read (void);
+    // void setThigh (float);
+    // void setTlow (float);
+    // float getThigh (void);
+    // float getTlow (void);
+     void _reset();
+    uint8_t configRate(  uint8_t canSpeed);
+    void    setRegister(  uint8_t address,   uint8_t value);
+    
+    uint8_t readRegister(  uint8_t address);
+    void    modifyRegister(  uint8_t address,   uint8_t mask,   uint8_t data);
+    uint8_t setCANCTRL_Mode(uint8_t newmode);
+    uint8_t init(  int canSpeed);
+    void    initCANBuffers(void);
+    void    setRegisterS(  uint8_t address,   uint8_t values[],   uint8_t n);
+    void    write_can_id(   uint8_t mcp_addr,   uint8_t ext,   uint32_t can_id );
+    //
 
-            void read_can_id( const uint8_t mcp_addr, uint8_t* ext, uint32_t* can_id );
-            void read_canMsg( const uint8_t buffer_sidh_addr, CANMessage* msg);
-            void write_canMsg( const uint8_t buffer_sidh_addr,  CANMessage* msg);
-    
-            uint8_t getNextFreeTXBuf(uint8_t *txbuf_n);
+    void    readRegisterS(  uint8_t address, uint8_t values[],   uint8_t n);
+    uint8_t readXXStatus_helper(  uint8_t cmd);
+    uint8_t readStatus(void);
+    uint8_t RXStatus(void);
+
+    void read_can_id(   uint8_t mcp_addr, uint8_t* ext, uint32_t* can_id );
+    void read_can_idN(   uint8_t mcp_addr, CANFormat* ext, unsigned int* can_id );
+    void read_canMsg(   uint8_t buffer_sidh_addr, CANMessage* msg);
+    void write_canMsg(   uint8_t buffer_sidh_addr,  CANMessage* msg);
+
+    uint8_t getNextFreeTXBuf(uint8_t *txbuf_n);
+
+    void start_transmit(  uint8_t buffer_sidh_addr);
+
+    void dumpExtendedStatus(void);
+
+    void setDebugConsole(Serial c);
     
-            void start_transmit(const uint8_t buffer_sidh_addr);
-            
-            SPI _spi;
-            DigitalOut _ncs;   
-        // Private functions
-        private :   
-            void _select (void);               
-            void _deselect (void);       
-            int status();
-           void _pollbusy() ;
-           
-            uint8_t _spi_readwrite(uint8_t data);
-            uint8_t _spi_read(void);
-         
-           
-        };
+    int configRate2(int bit_rate);
+ 
+    // Private functions
+private :
+    void _select (void);
+    void _deselect (void);
+    int status();
+    void _pollbusy() ;
+
+    uint8_t _spi_readwrite(uint8_t data);
+    uint8_t _spi_read(void);
+
+
+};
 
 #endif // _MCP2515_H_

--- a/mcp2515_bittime.h	Sat Jan 30 08:46:04 2010 +0000
+++ b/mcp2515_bittime.h	Sun Jun 13 09:52:03 2010 +0000
@@ -74,10 +74,8 @@
 
 
 #define MCP_4MHz_125kBPS_CFG1 (MCP_4MHz_125kBPS_SJW | MCP_4MHz_125kBPS_BRP)
-#define MCP_4MHz_125kBPS_CFG2 (MCP_4MHz_125kBPS_BLTMODE | MCP_4MHz_125kBPS_SAM | \
-                MCP_4MHz_125kBPS_PHSEG1 | MCP_4MHz_125kBPS_PRSEG)
-#define MCP_4MHz_125kBPS_CFG3 (MCP_GENERAL_SOF | MCP_GENERAL_WAKFIL | \
-                MCP_4MHz_125kBPS_PHSEG)
+#define MCP_4MHz_125kBPS_CFG2 (MCP_4MHz_125kBPS_BLTMODE | MCP_4MHz_125kBPS_SAM | MCP_4MHz_125kBPS_PHSEG1 | MCP_4MHz_125kBPS_PRSEG)
+#define MCP_4MHz_125kBPS_CFG3 (MCP_GENERAL_SOF | MCP_GENERAL_WAKFIL | MCP_4MHz_125kBPS_PHSEG)
 
 
 /*-----------------------*/
@@ -119,7 +117,5 @@
 
 
 #define MCP_4MHz_20kBPS_CFG1 (MCP_4MHz_20kBPS_SJW | MCP_4MHz_20kBPS_BRP)
-#define MCP_4MHz_20kBPS_CFG2 (MCP_4MHz_20kBPS_BLTMODE | MCP_4MHz_20kBPS_SAM | \
-                MCP_4MHz_20kBPS_PHSEG1 | MCP_4MHz_20kBPS_PRSEG)
-#define MCP_4MHz_20kBPS_CFG3 (MCP_GENERAL_SOF | MCP_GENERAL_WAKFIL | \
-                MCP_4MHz_20kBPS_PHSEG)
+#define MCP_4MHz_20kBPS_CFG2 (MCP_4MHz_20kBPS_BLTMODE | MCP_4MHz_20kBPS_SAM | MCP_4MHz_20kBPS_PHSEG1 | MCP_4MHz_20kBPS_PRSEG)
+#define MCP_4MHz_20kBPS_CFG3 (MCP_GENERAL_SOF | MCP_GENERAL_WAKFIL | MCP_4MHz_20kBPS_PHSEG)

--- a/mcp2515_can.h	Sat Jan 30 08:46:04 2010 +0000
+++ b/mcp2515_can.h	Sun Jun 13 09:52:03 2010 +0000
@@ -1,35 +1,44 @@
-#ifndef MCP2515_CAN_H_
-#define MCP2515_CAN_H_
-
-#define CANDEBUG   1
-
-#define CANUSELOOP 0
-
-#define CANSENDTIMEOUT (200) /* milliseconds */
-
-// initial value of gCANAutoProcess
-#define CANAUTOPROCESS (1)
-#define CANAUTOON  (1)
-#define CANAUTOOFF (0)
-
-#define CAN_STDID (0)
-#define CAN_EXTID (1)
-
-#define CANDEFAULTIDENT    (0x55CC)
-#define CANDEFAULTIDENTEXT (CAN_EXTID)
-
-#define CAN_20KBPS   (1)
-#define CAN_125KBPS  (CAN_20KBPS+1)
-
-#define CAN_OK         (0)
-#define CAN_FAILINIT   (1)
-#define CAN_FAILTX     (2)
-#define CAN_MSGAVAIL   (3)
-#define CAN_NOMSG      (4)
-#define CAN_CTRLERROR  (5)
-#define CAN_FAIL       (0xff)
-
-#define CAN_MAX_CHAR_IN_MESSAGE (8)
-
-
+#ifndef MCP2515_CAN_H_
+#define MCP2515_CAN_H_
+
+#define CANDEBUG   1
+
+#define CANUSELOOP 0
+
+#define CANSENDTIMEOUT (200) /* milliseconds */
+
+// initial value of gCANAutoProcess
+#define CANAUTOPROCESS (1)
+#define CANAUTOON  (1)
+#define CANAUTOOFF (0)
+
+#define CAN_STDID (0)
+#define CAN_EXTID (1)
+
+#define CANDEFAULTIDENT    (0x55CC)
+#define CANDEFAULTIDENTEXT (CAN_EXTID)
+
+#define CAN_20KBPS   (1)
+#define CAN_125KBPS  (CAN_20KBPS+1)
+
+#define CAN_1MBPS_8MHZ (58)
+#define CAN_500KBPS_8MHZ (57)
+#define CAN_250KBPS_8MHZ (56)
+#define CAN_125KBPS_8MHZ (55)
+#define CAN_100KBPS_8MHZ (54)
+#define CAN_50KBPS_8MHZ (53)
+#define CAN_20KBPS_8MHZ (52)
+#define CAN_10KBPS_8MHZ (51)
+
+#define CAN_OK         (0)
+#define CAN_FAILINIT   (1)
+#define CAN_FAILTX     (2)
+#define CAN_MSGAVAIL   (3)
+#define CAN_NOMSG      (4)
+#define CAN_CTRLERROR  (5)
+#define CAN_FAIL       (0xff)
+
+#define CAN_MAX_CHAR_IN_MESSAGE (8)
+
+
 #endif
\ No newline at end of file