Electronic – I2C Raspberry Pi to PIC24F

i2cpicraspberry pi

I'm new to PIC's and PIC programming but I'm working on a little project to try get a PIC24F32KA301 to communicate with a Raspberry Pi using I2C. The Raspberry Pi is the master and the PIC is the slave. I have created a little Python program on the Raspberry Pi and tested that it works by successfully communicating with an Arduino, what I want to do now is replace the Arduino with a PIC.

Just for completeness I've included the python program below:

import smbus
import time

bus = smbus.SMBus(1)
address = 0x22

def writeNumber(value):
    bus.write_byte(address, value)
    return -1

def readNumber():
    number = bus.read_byte(address)
    return number

while True:
    var = input("Enter 1 - 9: ")
    if not var:
        continue
    writeNumber(var)
    print "RPI: Hi Arduino, I sent you ", var

    time.sleep(1)
    number = readNumber()
    print "Arduino: Hey RPI, I received a digit ", number
    print

I'm pretty sure I've connected the PIC and Raspberry Pi correctly:

GND <—> Vss (pin 19)
SCL <—> SCL1 (pin 12)
SDA <—> SDA1 (pin 13)

The Raspberry Pi is powered over USB (I think it's 5V, but it might be 3V) and the PIC is powered separately using a 3V battery. The Arduino didn't have any pull up resistors so I assume it's ok to not have any on the PIC (maybe this is wrong?).

I'm using C with the XC16 compiler and the i2c.h library to program the PIC but I'm not really sure what I'm doing, I've tried my best to piece things together from I2C examples and little bits I've read on various forums etc:

#define USE_AND_OR    // not sure what this is!
#include <p24Fxxxx.h>
#include <i2c.h>

unsigned char I2C_RECV[1]

void main(void) {
    unsigned int temp, i;
    for(i=0; i<1; i++)
        I2C_RECV[i]=0;

    TRISA = 0b0000000000000000;
    PORTA = 0b0000000000000001;

    /* INITIALISE I2C MODULE  */
    CloseI2C1();                            // close i2c if it was operating earlier

    while(1) {
        OpenI2C1((I2C_ON | I2C_7BIT_ADD | I2C_CLK_REL | I2C_STR_EN), 0);
        I2C1ADD = 0x22;                     // initialze slave address to 1E

        // receive data from master
        while(DataRdyI2C1() == 0);          // wait until data is transmitted from master
        temp = SlaveReadI2C1();             // read address to empty buffer

        SlavegetsI2C1(I2C_RECV, 1);         // receive data

        if(I2C_RECV[0] == 9) {
            PORTA = 0b0000000000000011;
        }

        CloseI2C1();
    }
}

The code is quite simple (but probably wrong!). Basically I initialise the I2C module and turn on an LED, then I enter a loop, open the I2C connection using address 0x22 and wait for the master to send some data. When data is received I check it's value, if it's 9 I turn on another LED.

On the Raspberry Pi I can confirm that the PIC is accessible by running i2cdetect -y 1. I can see the PIC at address 0x22, which gives me some confidence that I'm at least heading in the right direction! However, when I run the python program I receive an IO error, the error number is 5. I've looked around to find out what that means, but it's a very vague error, basically anything could have gone wrong!

I'm not sure if it's my circuit that's incorrect (i.e. do I need pull up resistors, if so how do I calculate what resistance they need to be?) or my PIC program. If anyone can check the program makes sense or has any advice I'd be very grateful.

Thanks.

Best Answer

Test this:

unsigned char I2C_RECV[1]

void main(void) {
  unsigned int temp=0,temp2=0, i;
  for(i=0; i<1; i++)
     I2C_RECV[i]=0;

  TRISA = 0b0000000000000000;
  PORTA = 0b0000000000000001;

  /* INITIALISE I2C MODULE  */
  CloseI2C1();        // close i2c if it was operating earlier

  while(1){

   config1 = (I2C_ON | I2C_7BIT_ADD | I2C_CLK_REL | I2C_STR_EN  );
   config2 = 0;                //This defines I2C to be slave
   OpenI2C1(config1,config2);  //configure I2C1
   I2C1ADD = 0x22;             //I2C address set to 1E  

    I2C1CONbits.I2CEN = 1;     // ENABLE I2C!!
    I2C1CONbits.DISSLW = 1;    // Disable slew rate control
    I2C1CONbits.GCEN = 1;      // Enable interrupt when a general call address is received (enable for reception)

    while(IFS1bits.SI2C1IF==0){asm ("clrwdt");}; //wait untill the data is transmitted from master

    temp = SlaveReadI2C1();     //Read address to empty buffer
    temp2 = SlaveReadI2C1();    //Read data to empty buffer

    SlavegetsI2C1(I2C_RECV,1);

    if(temp2 == 0x09) PORTA = 0b0000000000000011;
    else PORTA = 0b0000000000000000;        
    CloseI2C1();      //Disable I2C
  }  
}

Related Solutions

Problems with I2C on PIC18F25K22

Start simple, see if you can get an ack from the device, the proceed further. Here is some working code from a pic18f87j50.

void InitEEprom(void) {
    TRISDbits.TRISD6 = 0;
    TRISDbits.TRISD5 = 1;
    OpenI2C2(MASTER, SLEW_OFF);
    SSP2ADD = 0x36;
}

int FindDevice(unsigned char Control) {
    unsigned int ErrorCode;
    IdleI2C2(); //Ensure Module is Idle
    StartI2C2(); //Generate Start COndition
    SSP2BUF = Control;
    //WriteI2C2(Control); //Write Control byte
    IdleI2C2();
    ErrorCode = ACKStatus();
    StopI2C2();
    return ErrorCode; //Return ACK Status
}

Electronic – I2C Module Not Responding

There are several I/O connection features that are in use by different PICs. The PIC that you're using has the following features (as copied from the heading of the relevant chapters of the data sheet):

11.0 I/O PORTS

Each port has six standard registers for its operation. These registers are:

TRISx registers (data direction)

PORTx registers (reads the levels on the pins of the device)

LATx registers (output latch)

INLVLx (input level control)

ODCONx registers (open-drain)

SLRCONx registers (slew rate

Some ports may have one or more of the following additional registers. These registers are:

ANSELx (analog select)

WPUx (weak pull-up)

Ports that support analog inputs have an associated ANSELx register. When an ANSEL bit is set, the digital input buffer associated with that bit is disabled. Disabling the input buffer prevents analog signal levels on the pin between a logic high and low from causing excessive current in the logic input circuitry.

11.3.5 ANALOG CONTROL

The ANSELB register (Register 11-12) is used to configure the Input mode of an I/O pin to analog. Setting the appropriate ANSELB bit high will cause al digital reads on the pin to be read as ‘0’ and allow analog functions on the pin to operate correctly. The state of the ANSELB bits has no effect on digital out put functions. A pin with TRIS clear and ANSELB set wil still operate as a digital output, but the Input mode will be analog. This can cause unexpected behavior when exe- cuting read-modify-write instructions on the affected port.

Note: The ANSELB bits default to the Analog mode after Reset. To use any pins as digital general purpose or peripheral inputs, the corresponding ANSEL bits must be initialized to ‘0’ by user software.

12.0 PERIPHERAL PIN SELECT (PPS) MODULE

The Peripheral Pin Select (PPS) module connects peripheral inputs and outputs to the device I/O pins. Only digital signals are included in the selections. All analog inputs and outputs remain fixed to their assigned pins. Input and output selections are independent as shown in the simplified block diagram Figure 12-1.

12.2 PPS Outputs

Each I/O pin has a PPS register with which the pin output source is selected. With few exceptions, the port TRIS control associated with that pin retains control over the pin output driver. Peripherals that control the pin output driver as part of the peripheral operation will override the TRIS control as needed. These peripherals include:

EUSART (synchronous operation)

MSSP (I2C)

COG (auto-shutdown)

12.3 Bidirectional Pins

PPS selections for peripherals with bidirectional signals on a single pin must be made so that the PPS input and PPS output select the same pin. Peripherals that have bidirectional signals include:

EUSART (synchronous operation)

MSSP (I2C)

You should read the relevant parts of the data sheet, and set up all I/O configuration registers needed for your configuration. In this case, setting up ANSELB to enable the digital inputs, and setting up the PPS registers to route the input & output functions of the I2C module to the desired pins is missing. Also, the PPS registers are protected from undesired changes, so there is a locking mechanism you have to use before you could access the registers.

After making the changes above, the code should look something like this. Note that since the I2C messages aren't being properly acknowledged yet, the device may not be "visible" to the master, but you should at least see the light blink.

#include <xc.h>                 /* XC8 General Include File */
#include <pic16lf1709.h>        /* Definitions of I/O pins */

#pragma config WDTE = OFF

// I2C address is 7 bits: 1111110
#define I2C_ADDRESS 0x6E

typedef unsigned char byte;

void main(void) {

    /* configure ports */
    TRISBbits.TRISB4    = 1;    // set SDA to input
    TRISBbits.TRISB6    = 1;    // set SCL to input

    ANSELBbits.ANSB4    = 0;    // make sure SDA is set to digital

    TRISC               = 0x00; // set LEDs to output
    PORTC               = 0xFF; // initialize LEDs to OFF

    /* configure peripheral pin select */
    PPSLOCK             = 0x55;
    PPSLOCK             = 0xAA;
    PPSLOCK             = 0x00; // PPS is now unlocked
    SSPDATPPS           = 0x0C; // RB4 input is SDA (pg 140)
    SSPCLKPPS           = 0x0E; // RB6 input is SCL (pg 140)
    RB4PPS              = 0x11; // RB4 output is SDA (pg 141)
    RB6PPS              = 0x10; // RB6 output is SCL (pg 141)
    PPSLOCK             = 0x55;
    PPSLOCK             = 0xAA;
    PPSLOCK             = 0x01; // PPS is now locked

    /* configure MSSP module */
    SSPCON1bits.SSPEN   = 1;    // enable SSP module
    SSPCON1bits.SSPM    = 0x6;  // SSP is in I2C slave mode, 7-bit addressing
    SSP1ADD             = I2C_ADDRESS<<1;  // set the device address (left-aligned)
    SSPCON1bits.CKP     = 1;    // release clock

    while(1) {

        byte ssp_buf;

        if(SSPSTATbits.BF) {    // if the I2C buffer is not empty
            PORTC = 0x00;       // turn on LEDs for a moment
            for(int i=0; i<100; i++) _delay(250);
            PORTC = 0xFF;       // turn them back off
            ssp_buf = SSPBUF;   // read the buffer
                                // BF flag is cleared by hardware
        }

        SSPCON1bits.CKP = 1;    // finally, release clock

    }

}

Best Answer

Related Solutions

Problems with I2C on PIC18F25K22

Electronic – I2C Module Not Responding

Related Topic