コード例 #1
0
ファイル: ELB_I2C.c プロジェクト: kunal15595/pic
S8 I2C1_WRITE_String(U8 DevAdd, U8 RegAdd, U8 *RegValue, U8 len)
 {
	char ComRes;
	
	DevAdd = (DevAdd<<1)|M_I2C_Write;
	StartI2C1();                                    // Send the start bit
	IdleI2C1();                                     // Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	ComRes=MasterWriteI2C1(DevAdd);			// Adress with write mode
	IdleI2C1();                                     // Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	ComRes=MasterWriteI2C1(RegAdd);			// Write the chip ID register loaction for read
	IdleI2C1();                                     // Send the start bit
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	while(len--)
	{
		ComRes=MasterWriteI2C1(*RegValue);      // Write the chip ID register loaction for read
		IdleI2C1();                             // Wait to complete
		while(I2C1STATbits.ACKSTAT);            //wait for acknowledgement
		RegValue++;
	}
	StopI2C1();					// Stop the I2C communication
	IdleI2C1();					// Wait to complete
	return ComRes;
 }
コード例 #2
0
bool I2C1dev_writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
    // S
    IdleI2C1();
    StartI2C1();

    // Device write address
    IdleI2C1();
    WriteI2C1(devAddr << 1 | 0x00);

    // Register address
    IdleI2C1();
    WriteI2C1(regAddr);

    for (i_accel = 0; i_accel < length; i_accel++) {
        // Data byte
        IdleI2C1();
        WriteI2C1(data[i_accel]);
    }
    
    // P
    IdleI2C1();
    StopI2C1();

    return 1;
}
コード例 #3
0
void main(void) {
    unsigned char slave7bitAddr = 0x2A; //7-bit address of Slave.  MSB=Don't care.
    unsigned char slaveAddrWrite = (slave7bitAddr << 1); //LSB=0, Master Write request.
    signed char writeStat;
    unsigned char message[11] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};

    OSCCONbits.IRCF = 0b111; //Set internal oscillator to 16mHz

    //Must set SCL(pin RC3)and SDA(pin RC4) as inputs and enable digital buffers.
    TRISCbits.TRISC3 = 1; //set input
    TRISCbits.TRISC4 = 1;
    ANSELCbits.ANSC3 = 0; //enable digital buffer
    ANSELCbits.ANSC4 = 0;

    OpenI2C1(MASTER, SLEW_OFF); //If you switch to 400kHz (see below) set SLEW_ON
    /* You can ignore all I2C "unable to resolve identifier" errors assuming
    you didn't make any typos.  Don't forget the "1"'s. */

    /* Now set the I2C clock speed.  I2C Master always controls clock.
    For 400kHz use 1k pullup resistors and for 100kHz use 2.2k ohms */

    SSP1ADD = 0x27; //100Khz = FOSC/(4 * (SSPADD + 1)) = 16E6/((39 + 1) * 4)note:39=0x27
    //SSP1ADD = 0x09; //400Khz = FOSC/(4 * (SSPADD + 1)) = 16E6/((9 + 1) * 4)

    while (1) {
        IdleI2C1(); //Wait for bus to become idle.
        StartI2C1(); //Begin I2C communication
        IdleI2C1();

        //send slave address (w/write request bit) and wait for slave to reply.
        do {
            writeStat = WriteI2C1(slaveAddrWrite); //Send address with LSB=Write
            if (writeStat == -1) { //Detected bus collision - More than one master?
                unsigned char data = SSP1BUF; //clear the buffer by reading it.
                SSPCON1bits.WCOL = 0; //clear the bus collision status bit
            } else if (writeStat == -2) { //NACK (no acknowledge rx'd)
                //Is the slave on and ready?  Did we send the correct address?
            }
        } while (writeStat != 0); //Keep repeating until slave acknowledges.

        //Slave has Ack'd so we can send our Hello World message now.
        for (int x = 0; x <= 10; x++) {
            do {
                writeStat = (WriteI2C1(message[x]));
                if (writeStat == -2) { //NACK (no acknowledge rx'd)
                    //Is the slave on and ready?  Using the correct pullups?
                }
            } while (writeStat != 0); //Keep repeating until slave acknowledges.
        }

        IdleI2C1();
        StopI2C1();

        //Delay about 1 sec and then repeat.  1sec = ((10K*200*2)/(16E6/4)
        Delay10KTCYx(200);
        Delay10KTCYx(200);
    }
}
コード例 #4
0
ファイル: i2c_master.c プロジェクト: Kidrc/Mechatronics
int RcvData(unsigned int address) {
	StartI2C1();				//Send line start condition
	IdleI2C1();			        //Wait to complete
	MasterWriteI2C1((address << 1) | 1);	//Write out slave address OR 1 (read command)
	IdleI2C1();				//Wait to complete
	int rcv = MasterReadI2C1();		//Read in a value
	StopI2C1();				//Send line stop condition
	IdleI2C1();				//Wait co complete
	return rcv;				//Return read value
}
コード例 #5
0
ファイル: main.c プロジェクト: reebot/wins
void LDByteWriteI2C(unsigned char SlaveAddress, unsigned char reg, unsigned char data){
    StartI2C1();	//Send the Start Bit
    IdleI2C1();		//Wait to complete
    MasterWriteI2C1(SlaveAddress); //transmit write command
    IdleI2C1();		//Wait to complete
    MasterWriteI2C1(reg);
    IdleI2C1();
    MasterWriteI2C1(data);
    IdleI2C1();
    StopI2C1();
    IdleI2C1();
}
コード例 #6
0
ファイル: Display_I2C.c プロジェクト: OptecInc/FocusLynx_FW
void ClearAll(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(Clear);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}	
コード例 #7
0
ファイル: Display_I2C.c プロジェクト: OptecInc/FocusLynx_FW
void SecondLine(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(Line2);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}
コード例 #8
0
ファイル: Display_I2C.c プロジェクト: OptecInc/FocusLynx_FW
void FirstLine(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(0x80);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}
コード例 #9
0
/**
 *  @brief  Write to device using generic i2c protocol
 *  @param[in]  slave_addr - slave address
 *  @param[in]  reg_addr   - register address
 *  @param[in]  length     - number of bytes to read
 *  @param[in]  *data      - pointer to where register data is to be transfered
 *  @return     0 if sucessfull, 1 otherwise
 */
int i2c_read(unsigned char slave_addr, unsigned char reg_addr, unsigned char length, unsigned char *data) {

	BYTE i=2;

	StartI2C1();								//Send the Start Bit
	IdleI2C1();
        if (MasterWriteI2C1(((slave_addr<<1)|(0x00))))
            return 1;
	IdleI2C1();
        if (MasterWriteI2C1(reg_addr))
            return 1;
	IdleI2C1();
        StartI2C1();                        //Send the Start Bit
        IdleI2C1();                         //Wait to complete
        if (MasterWriteI2C1(((slave_addr<<1)|(0x01))))
            return 1;
	IdleI2C1();
	I2CReceiverEnable ( I2C1, TRUE);

	for(i=0;i<length;i++) {
            data[i] = MasterReadI2C1();
		if(i<(length-1)) {
                    I2CAcknowledgeByte(MPU_I2C, TRUE);
                    IdleI2C1();
		}
		else {
                    I2CAcknowledgeByte(MPU_I2C, FALSE);
                    IdleI2C1();
		}
	}
        StopI2C1();								//Send the Stop condition
        IdleI2C1();								//Wait to complete

	return 0;
}
コード例 #10
0
ファイル: ELB_I2C.c プロジェクト: kunal15595/pic
S8 I2C1_READ_String(U8 DevAdd, U8 RegAdd, U8 *RegValue, U8 len)
 {
	int DataWait = len*100;
	char ComRes,DevAddr;

	DevAddr = (DevAdd<<1)|M_I2C_Write;
	StartI2C1();					// Send the start bit
	IdleI2C1();					// Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	ComRes=MasterWriteI2C1(DevAddr);		// Adress with write mode
	IdleI2C1();					// Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	ComRes=MasterWriteI2C1(RegAdd);			// Write the chip ID register loaction for read
	IdleI2C1();					// Send the start bit
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	RestartI2C1();                                  // Send the start bit
	IdleI2C1();					// Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	DevAddr = (DevAdd<<1)|M_I2C_Read;
	MasterWriteI2C1(DevAddr);                       // Adress with write mode
	IdleI2C1();					// Wait to complete
	while(I2C1STATbits.ACKSTAT);			//wait for acknowledgement
	MastergetsI2C1(len, RegValue, DataWait);        // Read the Register value
	IdleI2C1();					// Wait to complete
	NotAckI2C1();                                   // Not Acknowledge I2C
	IdleI2C1();					// Wait to complete
	StopI2C1();					// Stop I2C communication
	IdleI2C1();					// Wait to complete;

	return ComRes;
}
コード例 #11
0
/***************************************************
 * SendData(int data, unsigned int address)        *
 *                                                 *
 * Sends a byte of data (DATA) over the I2C line   *
 *	to I2C address ADDRESS                         *
 *                                                 *
 * Returns: nothing                                *
 ***************************************************/
void SendData (int data, unsigned int address){
	StartI2C1();	        //Send the Start Bit
	IdleI2C1();		//Wait to complete

	MasterWriteI2C1((address << 1));  //Sends the slave address over the I2C line.  This must happen first so the 
                                             //proper slave is selected to receive data.
	IdleI2C1();	        //Wait to complete

	MasterWriteI2C1(data);  //Sends data byte over I2C line
	IdleI2C1();		//Wait to complete
	StopI2C1();	        //Send the Stop condition
	IdleI2C1();	        //Wait to complete

} //end function
コード例 #12
0
ファイル: i2c_local.c プロジェクト: horsetailfiddlehead/ee478
/*
 * send data to a slave device
 * takes the slave address, writes the given data byte
 */
int sendSpeed(unsigned int *slaveAddr, unsigned int *speed) {
    // get the data from global variable
    char newSpeed[3] = {*speed, 'X', '\0'};

    // wait until idle - not actually needed for single-master bus
    IdleI2C1();
    StartI2C1(); // send start
    data = SSP1BUF;

    WriteI2C1(*slaveAddr & 0xFE);
    //    do { // send address until ack'd
    //        status = WriteI2C1(*slaveAddr || 0x00);
    //        if (!(0 == status)) { // write collision
    //            data = SSP1BUF;
    //            SSP1CON1bits.WCOL = 0;
    //        }
    //    } while (!(0 == status));

    // 	send bytes
    WriteI2C1(newSpeed[0]); // TODO: send multiple bytes

    StopI2C1(); // stop transmission

    return 1;
}
コード例 #13
0
ファイル: I2CdsPIC.c プロジェクト: FrauBluher/SALT
uint8_t I2C_WriteToReg(uint8_t I2CAddress, uint8_t deviceRegister, uint8_t data) {

    StartI2C1();
    while(I2CCONbits.SEN);
    IFS1bits.MI2C1IF = 0;

    MasterWriteI2C1(I2CAddress << 1);
    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag

    MasterWriteI2C1(deviceRegister);
    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag
    MasterWriteI2C1(data);

    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag

    StopI2C1();               // Write stop sequence.
    while(I2CCONbits.PEN);
    IdleI2C1();
    return(1);
}
コード例 #14
0
void Init_mcp(void)
{
    unsigned int config2, config1;
    config2 = 0x190; // Baud rate is set for 100 kHz
    config1 = 0b1000001000100000;
    /* 
     * (I2C_ON & I2C_IDLE_CON & I2C_CLK_HLD & I2C_IPMI_DIS & I2C_7BIT_ADD &
     * I2C_SLW_DIS & I2C_SM_DIS & I2C_GCALL_DIS & I2C_STR_DIS & I2C_NACK &
     * I2C_ACK_DIS & I2C_RCV_DIS & I2C_STOP_DIS &   I2C_RESTART_DIS &
     * I2C_START_DIS)
     */
    // Configure I2C for 7 bit address mode
    OpenI2C1(config1, config2);
    IdleI2C1();

    //Initialize MCP23017 i2c I/O expander
    Write23X08_17(IOCONA, 0b01111000, 0x00);
    Write23X08_17(GPPUA, 0x00, 0x00); // Set Pull-up resistors
    Write23X08_17(GPPUB, 0x1F, 0x00); // Set Pull-up resistors
    Write23X08_17(IPOLA, 0x00, 0x00); // I/O polarity normal
    Write23X08_17(IPOLB, 0x00, 0x00); // I/O polarity normal
    Write23X08_17(GPIOA, 0x00, 0x00); // Row is kept LOW while changing I/O
    Write23X08_17(GPIOB, 0x00, 0x00); // Row is kept LOW while changing I/O
    Write23X08_17(IODIRA, 0x00, 0x00); // Rows = inputs; Columns = outputs
    Write23X08_17(IODIRB, 0x1F, 0x00); // Rows = inputs; Columns = outputs
}
コード例 #15
0
void I2C_WriteToReg(uint8_t address, uint8_t deviceRegister, uint8_t data)
{

	// Assert the start condition
	StartI2C1();
	while (I2C1CONbits.SEN);
	IFS1bits.MI2C1IF = 0;

	// Send the 7-bit I2C device address
	MasterWriteI2C1(address << 1);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Send the register address
	MasterWriteI2C1(deviceRegister);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Send the data
	MasterWriteI2C1(data);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Assert the stop condition
	StopI2C1();
	while (I2C1CONbits.PEN);

	// Sit idle on the bus
	IdleI2C1();
}
コード例 #16
0
signed char WriteI2C1( unsigned char data_out )
{
  SSPBUF = data_out;           // write single byte to SSPBUF
  if ( SSPCON1bits.WCOL )      // test if write collision occurred
   return ( -1 );              // if WCOL bit is set return negative #
  else
  {
	if( ((SSPCON1&0x0F)!=0x08) && ((SSPCON1&0x0F)!=0x0B) )	//Slave mode only
	{
	      SSPCON1bits.CKP = 1;        // release clock line 
	      while ( !PIR1bits.SSPIF );  // wait until ninth clock pulse received

	      if ( ( !SSPSTATbits.R_W ) && ( !SSPSTATbits.BF ) )// if R/W=0 and BF=0, NOT ACK was received
	      {
	        return ( -2 );           //return NACK
	      }
		  else
		  {
			return ( 0 );				//return ACK
		  }	
	}
	else if( ((SSPCON1&0x0F)==0x08) || ((SSPCON1&0x0F)==0x0B) )	//master mode only
	{ 
	    while( SSPSTATbits.BF );   // wait until write cycle is complete   
	    IdleI2C1();                 // ensure module is idle
	    if ( SSPCON2bits.ACKSTAT ) // test for ACK condition received
	    	 return ( -2 );			// return NACK
		else return ( 0 );              //return ACK
	}
	
  }
}
コード例 #17
0
ファイル: I2CdsPIC.c プロジェクト: FrauBluher/SALT
uint8_t I2C_ReadFromReg(uint8_t I2CAddress, uint8_t deviceRegister) {
    uint8_t data = 0;
    StartI2C1();
    while(I2CCONbits.SEN);

    MasterWriteI2C1(I2CAddress << 1);
    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag

    MasterWriteI2C1(deviceRegister);
    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag

    RestartI2C1();            // Second start.
    while(I2CCONbits.RSEN);

    MasterWriteI2C1((I2CAddress << 1 )+ 1);
    while(I2CSTATbits.TBF);   // 8 clock cycles
    while(!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
    IFS1bits.MI2C1IF = 0;     // Clear interrupt flag

    data = MasterReadI2C1();

    NotAckI2C1();             // Read stop sequence.
    while(I2C1CONbits.ACKEN == 1);
    StopI2C1();
    while(I2CCONbits.PEN);
    IdleI2C1();

    return(data);
}
コード例 #18
0
void WaitI2C(I2cBus* i2cBus) {
    if (i2cBus == NULL) {
        IdleI2C1();
    }
    else {
        enum I2cPort portIndex = i2cBus->port;
        if (portIndex == I2C_BUS_PORT_1) {
            while(I2C1CONbits.SEN || I2C1CONbits.PEN || I2C1CONbits.RSEN || I2C1CONbits.RCEN || I2C1CONbits.ACKEN || I2C1STATbits.TRSTAT);
        }
    #if defined _I2C2
        else if (portIndex == I2C_BUS_PORT_2) {
            while(I2C2CONbits.SEN || I2C2CONbits.PEN || I2C2CONbits.RSEN || I2C2CONbits.RCEN || I2C2CONbits.ACKEN || I2C2STATbits.TRSTAT);
        }
    #endif
    #if defined _I2C3
        else if (portIndex == I2C_BUS_PORT_3) {
            while(I2C3CONbits.SEN || I2C3CONbits.PEN || I2C3CONbits.RSEN || I2C3CONbits.RCEN || I2C3CONbits.ACKEN || I2C3STATbits.TRSTAT);
        }
    #endif
    #if defined _I2C4
        else if (portIndex == I2C_BUS_PORT_4) {
            while(I2C4CONbits.SEN || I2C4CONbits.PEN || I2C4CONbits.RSEN || I2C4CONbits.RCEN || I2C4CONbits.ACKEN || I2C4STATbits.TRSTAT);
        }
    }
    #endif
}
コード例 #19
0
ファイル: i2c1.c プロジェクト: larics/assisi-casu-pic
/*
 * Function reads I2C device from slaveAdd
 * inputs:  slaveAdd
 *          registerAdd
 * returns: int recByte -> received byte from slave device
 *          -1 -> reading error
 */
unsigned char I2C1ReadByte1(UINT8 slaveAdd, UINT8 registerAdd)
{
    unsigned char recByte = 0;
    UINT8 address;

    StartI2C1();
    IdleI2C1(); //Wait to complete
    address = (slaveAdd<<1) & 0xFE;    //write
    MasterWriteI2C1(address);
    IdleI2C1();
    if(I2C1STATbits.ACKSTAT)
    {
        StopI2C1();
        IdleI2C1();
        return 0;
    }

    //Send register register location
    MasterWriteI2C1(registerAdd);
    IdleI2C1();
    if(I2C1STATbits.ACKSTAT)
    {
        StopI2C1();
        IdleI2C1();
        return 0;
    }

    RestartI2C1(); //Send start condition again
    IdleI2C1();
    address = (slaveAdd<<1) | 0x01;    //Read
    MasterWriteI2C1(address);
    IdleI2C1();
    if(I2C1STATbits.ACKSTAT)
    {
        StopI2C1();
        IdleI2C1();
        return 0;
    }
    recByte = MasterReadI2C1();
    //NotAckI2C1();
    IdleI2C1();
    StopI2C1();
    IdleI2C1();

    return recByte;
}
コード例 #20
0
ファイル: i2c_test.c プロジェクト: horsetailfiddlehead/ee478
/*
 * sends a start and writes a char
 */
int startAndWrite(char *c) {
    char data = 0x9A; //0b10011010;
    IdleI2C1();
    StartI2C1();
    WriteI2C1(*c); // just write a char
    WriteI2C1(data);
    StopI2C1();
}
コード例 #21
0
unsigned char Read23X08_17(unsigned char reg, unsigned char gAddrPins)
{
    unsigned char num;

    StartI2C1();
    // Wait till start sequence is completed
    while (I2C1CONbits.SEN);
    MasterWriteI2C1(gControlByte | WrtCmd | gAddrPins);
    WaitForACK();
    MasterWriteI2C1(reg);
    WaitForACK();
    RestartI2C1();
    IdleI2C1();
    MasterWriteI2C1(gControlByte | RdCmd | gAddrPins);
    WaitForACK();
    num = MasterReadI2C1();
    NotAckI2C1();
    StopI2C1();
    IdleI2C1();
    return (num);
}
コード例 #22
0
ファイル: init.c プロジェクト: rqou/imageproc-exynos
void SetupI2C(void)
{
    unsigned int I2C1CONvalue, I2C1BRGvalue;
    I2C1CONvalue = I2C1_ON & I2C1_IDLE_CON & I2C1_CLK_HLD &
                   I2C1_IPMI_DIS & I2C1_7BIT_ADD & I2C1_SLW_DIS &
                   I2C1_SM_DIS & I2C1_GCALL_DIS & I2C1_STR_DIS &
                   I2C1_NACK & I2C1_ACK_DIS & I2C1_RCV_DIS &
                   I2C1_STOP_DIS & I2C1_RESTART_DIS & I2C1_START_DIS;
    I2C1BRGvalue = 363; // Fcy(1/Fscl - 1/1111111)-1
    OpenI2C1(I2C1CONvalue, I2C1BRGvalue);
    IdleI2C1();
}
コード例 #23
0
ファイル: Display_I2C.c プロジェクト: OptecInc/FocusLynx_FW
void Show(unsigned char *text)
{
	// Assert a start condition
	StartI2C1();
	while(_SEN);
	// Write the address of the slave 
	MasterWriteI2C1(Slave);
	while(I2C1STATbits.TBF);     //Wait till address is transmitted
   	while(!IFS1bits.MI2C1IF);    //Wait for ninth clock cycle
   	IdleI2C1();
	MasterWriteI2C1(Datasend);
	IdleI2C1();
	while(*text)
	{
		MasterWriteI2C1(*text);
		IdleI2C1();
		++text;
	}
	StopI2C1();
	delay(2);
}
コード例 #24
0
int8_t I2C1dev_readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data) {
    count_accel = 0;

    // S
    IdleI2C1();
    StartI2C1();

    // Device write address
    IdleI2C1();
    WriteI2C1(devAddr << 1 | 0x00);

    // Register address
    IdleI2C1();
    WriteI2C1(regAddr);

    // R
    IdleI2C1();
    RestartI2C1();

    // Device read address
    IdleI2C1();
    WriteI2C1(devAddr << 1 | 0x01);

    for (count_accel = 0; count_accel < length; count_accel++) {
        // Data byte
        IdleI2C1();
        data[count_accel] = ReadI2C1();

        if (count_accel == length - 1) {
            // NACK
            IdleI2C1();
            NotAckI2C1();
        } else {
            // ACK
            IdleI2C1();
            AckI2C1();
        }
    }

    // P
    IdleI2C1();
    StopI2C1();

    return count_accel;
}
コード例 #25
0
void I2C_ReadFromReg_Burst(uint8_t address, uint8_t deviceRegister, uint8_t* data, uint8_t burstNum)
{
	// Assert the start condition
	StartI2C1();
	while (I2C1CONbits.SEN);

	// Send the 7-bit device address
	MasterWriteI2C1(address << 1);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Send the register address
	MasterWriteI2C1(deviceRegister);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Start a new I2C transaction
	RestartI2C1();
	while (I2C1CONbits.RSEN);

	// Send the second address
	MasterWriteI2C1((address << 1) + 1);
	while (I2C1STATbits.TBF); // 8 clock cycles
	while (!IFS1bits.MI2C1IF); // Wait for 9th clock cycle
	IFS1bits.MI2C1IF = 0; // Clear interrupt flag

	// Read the data
	data[0] = MasterReadI2C1();

	if (burstNum > 1) {
                uint8_t i;
		for (i = 1; i < burstNum; i++) {
			AckI2C1();
			while (I2C1CONbits.ACKEN == 1);

			data[i] = MasterReadI2C1();
		}
	}

	// No need to ack reception of this data
	NotAckI2C1();
	while (I2C1CONbits.ACKEN == 1);

	// Stop the I2C transaction
	StopI2C1();
	while (I2C1CONbits.PEN);

	// Go idle on the bus
	IdleI2C1();
}
コード例 #26
0
/**
 *  @brief  Write to device using generic i2c protocol
 *  @param[in]  slave_addr - slave address
 *  @param[in]  reg_addr   - register address
 *  @param[in]  length     - number of bytes to write
 *  @param[in]  *data      - pointer for data to write
 *  @return     0 if sucessfull, 1 otherwise
 */
int i2c_write(unsigned char slave_addr, unsigned char reg_addr, unsigned char length, unsigned char const *data) {

	BYTE i;

	StartI2C1();								//Send the Start Bit
	IdleI2C1();									//Wait to complete
        if (MasterWriteI2C1(((slave_addr<<1)|(0x00))))
            return 1;
	IdleI2C1();
        if (MasterWriteI2C1(reg_addr))
            return 1;
	IdleI2C1();

	for(i=0;i<length;i++){
            if (MasterWriteI2C1(data[i]))
                return 1;
	}
        StopI2C1();								//Send the Stop condition
        IdleI2C1();								//Wait to complete

	return 0;
}
コード例 #27
0
int RcvIRTemp(unsigned int address){
    rcv = 0;
    StartI2C2();				//Send line start condition
	IdleI2C2();			        //Wait to complete
	MasterWriteI2C2(0xb4);	//Write slave addr WRITE (OR 0)
    IdleI2C2();
    MasterWriteI2C2(0xf0); //command
//    //Command to read Tobj1 on ir sensor's ram: 000 = read ram; 0x07 = tobj1
	IdleI2C2();				//Wait to complete
    
//    StopI2C2();             //restart
//    IdleI2C2();
//    StartI2C2();
//    IdleI2C2();
//    
//    MasterWriteI2C2(0xb5); //Write the slave address, READ (OR 1)
//    IdleI2C2(); 
    
    MasterReadI2C2();		//Read in LSB
    IdleI2C2();	        
    AckI2C2();              //Acknowledge LSB
    IdleI2C2();
    
    MasterReadI2C2();		//Read in MSB
    IdleI2C1();	        
    AckI2C2();              //Acknowledge MSB
    IdleI2C2();
    
    MasterReadI2C2();		//Read in PEC
    IdleI2C1();             
    AckI2C2();              //Acknowledge MSB
    IdleI2C2();
   
	StopI2C2();				//Send line stop condition
	IdleI2C2();				//Wait co complete
	return rcv;				//Return read value    
}
コード例 #28
0
char MasterWriteI2C1(unsigned char data_out)
{
    I2C1TRN = data_out;

    if(I2C1STATbits.IWCOL)        /* If write collision occurs,return -1 */
        return -1;
    else
    {
        while(I2C1STATbits.TRSTAT);  // wait until write cycle is complete 
        IdleI2C1();                  // ensure module is idle
        if ( I2C1STATbits.ACKSTAT ) // test for ACK condition received
    	 return ( -2 );
	    else return ( 0 );               // if WCOL bit is not set return non-negative #
    }
}
コード例 #29
0
ファイル: main.c プロジェクト: reebot/wins
void LDByteReadI2C(unsigned char SlaveAddress, unsigned  char reg, unsigned char *data, int num){
                StartI2C1();	//Send the Start Bit
		IdleI2C1();		//Wait to complete
		MasterWriteI2C1(SlaveAddress); //transmit write command
		IdleI2C1();		//Wait to complete
                MasterWriteI2C1(reg);
                IdleI2C1();
                StopI2C1();
                IdleI2C1();
                StartI2C1();	//Send the Start Bit
		IdleI2C1();		//Wait to complete
		MasterWriteI2C1(SlaveAddress|0x01); //transmit read command
		IdleI2C1();		//Wait to complete
      		MastergetsI2C1(num, data, 30);
		StopI2C1();	//Send the Stop condition
		IdleI2C1();	//Wait to complete
}
コード例 #30
0
ファイル: ams-enc.c プロジェクト: briansudo/imageproc-lib
// Blocking encoder read. This will fail if the encoders are in a weird state
void amsEncoderBlockingRead(unsigned char num) {
    unsigned char enc_data[2];

    CRITICAL_SECTION_START
    i2cStartTx(ENC_I2C_CHAN); //Setup to burst read both registers, 0xFE and 0xFF
    i2cSendByte(ENC_I2C_CHAN, encAddr[2*num+1]);    //Write address
    i2cSendByte(ENC_I2C_CHAN, AMS_ENC_ANGLE_REG);
    i2cEndTx(ENC_I2C_CHAN);

    i2cStartTx(ENC_I2C_CHAN);
    i2cSendByte(ENC_I2C_CHAN, encAddr[2*num]);      //Read address
    i2cReadString(1,2,enc_data,10000);
    i2cEndTx(ENC_I2C_CHAN);
    IdleI2C1();
    _MI2C1IF = 0;
    CRITICAL_SECTION_END

    amsEncoderUpdatePos(num,((enc_data[1] << 6)+(enc_data[0] & 0x3F)));
}