Electronic – arduino – CAN Controller + PIC32

arduinocanpic

I have been trying to design a functional board which combines the hardware of the Elecrow Arduino Uno CAN bus shield with a microcontroller board, which functions like an Arduino except with different hardware. This design can be programmed, with the appropriate software drivers for the Arduino IDE, but it skips over all of the CAN stuff.

This picture shows the connections between the PIC32 and the MCP2515 CAN controller.

Ignore everything in the image except the connections that exist between the CAN controller and the PIC32. I have probed some of the serial lines between the two chips and found that there is no clock signal. As such, there is no way the SPI module can be working, except how does the Arduino code run?

void setup()
{
  Serial.begin(115200);
  while (CAN_OK != CAN.begin(CAN_500KBPS))
  {
    Serial.println("CAN BUS Shield init fail");
    Serial.println("Init CAN BUS Shield again");
    delay(100);
  }

  Serial.println("CAN BUS Shield init ok!");
}

Above is just a snippet of the code used to initialize the CAN bus in the Arduino IDE. When the CS bit is set to anything other than 10, the program will just loop through the while loop, wherein it complains that the CAN bus has failed to initialize. In the alternative case, it will simply skip over all the CAN commands as if they weren't in the code and everything else in the program runs fine.

So as mentioned, I found there was no serial communication between this chip and the controller. In fact, the program switches on globes connected to FET switch circuits when it senses ground at the analog ports. When this occurs, there is a sudden random surge on the clock line, but how can this be possible unless the chip is broken? I said to somebody before that if the SPI module was damaged, wouldn't the entire chip not work? Please note that the text "CAN bus init OK!" does not appear in the serial monitor, when the PCB is connected via USB.

My next line of reasoning was that perhaps I needed to change the baud rate to match that of the SPI module of the PIC32. It doesn't matter what I change it to, the CAN bus does not initialize. Another engineer looked at the design and noticed that by connecting the MCP2515 to 5 V would cause the crossover voltage on the ports to have a VIH too high for the chip to function. This pin was disconnected and connected to 3.3 V which should fix part of the problems I was having, but this serial communications problem remains unsolved.

If anyone has any useful hints or experience in this area and could shed some light on it, I'd appreciate it greatly.

Best Answer

You should have something more in the line of the following.

if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)

Surely you should also set up your interrupt pins and your SPI connection to the MCP2515.

Related Solutions

Electronic – Interrupt handling for a UART on PIC32 with C32 v2.00 compiler

Your example code doesn't show any of the initialization for the UART.

Are you enabling the receive interrupt for the UART? You need to do something like this:

#define BAUDRATE1       (115200)     // the desired BaudRate
#define BRATE1    (FPB/4/BAUDRATE1) 
#define UART1_CONFIG1   UART_EN|UART_BRGH_FOUR      // defaults to 8,N,1
#define UART1_CONFIG2   UART_RX_ENABLE|UART_TX_ENABLE|UART_INT_RX_CHAR              // only RX interrupts

void ConfigureUart1(void)
{
    OpenUART1(UART1_CONFIG1, UART1_CONFIG2, BRATE1); // approx 115200 baud
}

where FPB is defined as your peripheral bus frequency, e.g. 10000000L for 10 MHz.

Then in main or elsewhere:

ConfigureUart1();
INTEnableSystemMultiVectoredInt();         
INTEnableInterrupts();

PIC32 + RTC via SPI doesn’t work

So thanks to the help of all here here's an alternative solution using the RTCC of the pic.

This solution makes much more sense then reading the time from an external SPI module.

you can buy a 32.768 crystal like this one: http://www.sparkfun.com/products/540

and two 11pf or 12 pf crystals and align them as shown on this schematic (top right): http://www.sparkfun.com/datasheets/DevTools/PIC/UBW32_MX795_v262.pdf

What I've still not figured out is how to power the RTC with an additional battery. If someone knows how I'd enjoy a post!

Here's a working example code:

// Master header file for all peripheral library includes
#include <plib.h>

// configuration settings
#pragma config FNOSC = PRIPLL, POSCMOD = HS, FPLLMUL = MUL_18, FPLLIDIV = DIV_2, FPBDIV = DIV_2, FPLLODIV = DIV_1
#pragma config FWDTEN = OFF

int main(void) {

    rtccTime    tm;          // time structure
    rtccDate    dt;          // date structure

    // Configure the device for maximum performance.
    // This macro sets flash wait states, PBCLK divider and DRM wait states based on the specified
    // clock frequency. It also turns on the cache mode if avaialble.
    // Based on the current frequency, the PBCLK divider will be set at 1:2. This knoweldge
    // is required to correctly set UART baud rate, timer reload value and other time sensitive
    // setting.
    SYSTEMConfigPerformance(72000000L);

    RtccInit();   // init the RTCC

    while(RtccGetClkStat()!=RTCC_CLK_ON);   // wait for the SOSC to be actually running and RTCC to have its clock source
                                            // could wait here at most 32ms

    RtccOpen(0x10073000, 0x07011602, 0);    // set time and date (- actually i don't know what time is set, but for the moment it doesn't matter.)
                                            // time is MSb: hour, min, sec, rsvd. date is MSb: year, mon, mday, wday.
                                            // please note that the rsvd field has to be 0 in the time field!

    RtccGetTimeDate(&tm, &dt);              // get current time

    DDPCONbits.JTAGEN = 0; // disable JTAGport, free up PORTA
    TRISA = 0b0000000000000000;
    TRISB = 0b0000000000000000;

    while(1){

        RtccGetTimeDate(&tm, &dt);

        // test: minutes odd or even
        int minutes = tm.sec%2;
        switch(minutes){
            case 0:
                PORTA = 0b0000000000000000;
                PORTB = 0b1111111111111111;
                break;
            case 1:
                PORTA = 0b1111111111111111;
                PORTB = 0b0000000000000000;
                PORTA._RA0 = 0;

                break;
        }
    }
}

Best Answer

Related Solutions

Electronic – Interrupt handling for a UART on PIC32 with C32 v2.00 compiler

PIC32 + RTC via SPI doesn’t work

Related Topic