Ejemplo n.º 1
0
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;
 }
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
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();
}
Ejemplo n.º 6
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;
}
Ejemplo n.º 7
0
Archivo: main.c Proyecto: 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();
}
Ejemplo n.º 8
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();
}
Ejemplo n.º 9
0
void ClearAll(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(Clear);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}	
Ejemplo n.º 10
0
void FirstLine(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(0x80);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}
Ejemplo n.º 11
0
void SecondLine(void)
{
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(Line2);
	IdleI2C1();
	StopI2C1();
	IdleI2C1();
}
Ejemplo n.º 12
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
Ejemplo n.º 13
0
void Write23X08_17(unsigned char reg, unsigned char data, unsigned char gAddrPins)
{
    StartI2C1();
    // Wait till start sequence is completed
    while (I2C1CONbits.SEN);
    MasterWriteI2C1(gControlByte | WrtCmd | gAddrPins);
    WaitForACK();
    MasterWriteI2C1(reg);
    WaitForACK();
    MasterWriteI2C1(data);
    WaitForACK();
    StopI2C1();
    // Wait till stop sequence is completed
    while (I2C1CONbits.PEN);
}
Ejemplo n.º 14
0
Archivo: main.c Proyecto: 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
}
Ejemplo n.º 15
0
/*
 * 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;
}
Ejemplo n.º 16
0
unsigned int portableMasterWriteI2C(I2cBusConnection* i2cBusConnection, unsigned char data) {
    I2cBus* i2cBus = i2cBusConnection->i2cBus;
    if (i2cBus == NULL) {
        return MasterWriteI2C1(data);
    }
    else {
        I2C_MODULE i2cModule = getI2C_MODULE(i2cBus->port);
        return I2CSendByte(i2cModule, data);
    }
}
Ejemplo n.º 17
0
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
}
Ejemplo n.º 18
0
void i2cSendByte(unsigned char channel, unsigned char byte) {
    if (channel == 1) {
        MasterWriteI2C1(byte);
        while(I2C1STATbits.TRSTAT);
        while(I2C1STATbits.ACKSTAT);
    } else {
        MasterWriteI2C2(byte);
        while(I2C2STATbits.TRSTAT);
        while(I2C2STATbits.ACKSTAT);
    }
}
Ejemplo n.º 19
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);
}
Ejemplo n.º 20
0
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);
}
Ejemplo n.º 21
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;
}
Ejemplo n.º 22
0
void InitDisplay()
{
	
	unsigned int config1 = I2C_ON | I2C_7BIT_ADD;
    //unsigned int config2 = 15;		// Works with no pll in use 
    unsigned int config2 = 24;
    
    delay(100); // THIS IS REQUIRED TO ALLOW THE VOLTAGE TO STABILIZE BEFORE INIT-ING THE DISPLAY

	ConfigIntI2C1(MI2C_INT_OFF);  //Disable I2C interrupt

	CloseI2C1();
	OpenI2C1( config1, config2);
	IdleI2C1();
	// 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

	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(0x38);
	IdleI2C1();
	delay(10);
	MasterWriteI2C1(0x39);
	IdleI2C1();
	delay(10);
	MasterWriteI2C1(0x14);
	IdleI2C1();
	MasterWriteI2C1(0x25);
	IdleI2C1();
	MasterWriteI2C1(0x5E);
	IdleI2C1();
	MasterWriteI2C1(0x6D);
	IdleI2C1();
	MasterWriteI2C1(0x0C);
	IdleI2C1();
	MasterWriteI2C1(0x01);
	IdleI2C1();
	MasterWriteI2C1(0x06);
	IdleI2C1();
	delay(10);
	StopI2C1();
	IdleI2C1();
	CGRAM();			//define CGRAM
	
	StartI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(0x39);	
	IdleI2C1();	
	MasterWriteI2C1(0x01);		//go back Home
	IdleI2C1();
	StopI2C1();
	delay(10);
}
Ejemplo n.º 23
0
void CGRAM (void)
{
 	StartI2C1();
 	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Comsend);
	IdleI2C1();
	MasterWriteI2C1(0x38);		//go to instructino table 0
	IdleI2C1();
	MasterWriteI2C1(0x40);		//Set CGRAM address to 0x00
	IdleI2C1();
	StopI2C1();
	delay(10);
	
	StartI2C1();
	IdleI2C1();
	MasterWriteI2C1(Slave);
	IdleI2C1();
	MasterWriteI2C1(Datasend);
	IdleI2C1();
	MasterWriteI2C1(0x00);		//write to first CGRAM address
	IdleI2C1();
	MasterWriteI2C1(0x1E);
	IdleI2C1();
	MasterWriteI2C1(0x18);
	IdleI2C1();
	MasterWriteI2C1(0x14);
	IdleI2C1();
	MasterWriteI2C1(0x12);
	IdleI2C1();
	MasterWriteI2C1(0x01);
	IdleI2C1();
	MasterWriteI2C1(0x00);
	IdleI2C1();
	MasterWriteI2C1(0x00);		//8 bytes per character
	IdleI2C1();
	//continue writing to remaining CGRAM if desired
	StopI2C1();
	IdleI2C1();
}