Interfacing of SHT11 with PIC24f16KA102

Hi jalpa,

I suppose that you are using MPLAB IDE plus XC16 complier, rigth?

In your code you:

#include "i2c.h",

but you never use it, you are using own function declared and coded in your main.c, right?

If you have chosen the PIC when create the project, you do not need to:

#include <p24Fxxxx.h>

After includes and defines, configuration bits are missing, (the configuration bits MPLAB utility is very usefull!!).

I recommend you using the functions in i2c.h, like OpenI2C1(), CloseI2C1(), MasterWriteI2C1(), StartI2C1(), StopI2C1(), etc... the function to use will depend on the configuration of the bus when OpenI2C.

I hope that helps,

Miguel

thanks for your reply. For configuration i have kept file so thats why is not included in this code. I will try the functions suggested by you, which are in built.  can u tell me what is the difference between hardware spi and software spi?

Normally, you use I2C by soft when you do not have a dedicated hardware for I2C, mainly when you use software to emulate such a dedicated hardware, the CPU has to deal with all the delay, timings, pooling, checking flags, whereas if you use dedicated hardware (with interruptions), CPU has just to configure the hardware just once, and let the hardware deals with most of this work, making lighter the workload of the CPU.

I see you try to use a the dedicated registers and flags, so better use the functions given by XC.

If you configure the hardware, and when write, you don't receive the slave ACK, check you have configured correctly the address mode and the SCL speed of the I2C, maybe the sensor is not receiving correctly what it is expecting.

Hope that helps,

Miguel

Probably you have a very usefull help file, path could look like this C:\Program Files (x86)\Microchip\xc16\v1.21\docs\periph_libs\Microchip PIC24F Peripheral Library.chm.

Where every function is explained.

Maybe it is obvios, but do not forget the pull-up resistor in both lines SCL and SDA.

hi,

i have tried the following code from example of library. but still i m not getting ACK as 0 in I2C1STAT register when i debug the code and watching status of I2C1STAT register. i m pasting here code as well as configuration file data. i m using PIC24F16KA102 related board that is Microstick 3.3V. Pic works at 32MHZ so its Fcy is 16MHz and according to 100KHZ of SCL i have kept baud rate generator count as 157(refereed from data sheet of pic). plz let me know where i m doing wrong. thanks

code:.........................

#include "p24F16KA102.h"

#include "spi.h"

//#include "i2c.h"

#include <timer.h>

#define USE_AND_OR /* To enable AND_OR mask setting */

#include<i2c.h>

UINT8 I2C_RECV[15],I2C_TRANS[] = "MICROCHIP";

//******************** Interrupt sevice rotuine for I2C1 Master ***************************

void __attribute__((interrupt,no_auto_psv)) _MI2C1Interrupt(void)

{

  MI2C1_Clear_Intr_Status_Bit;  //Clear Interrupt status of I2C1

}

int main(void)

{

   UINT config1 = 0,i=0;

   UINT config2 = 0;

   /* Turn off I2C modules */

   CloseI2C1();    //Disbale I2C1 mdolue if enabled previously

//************ I2C interrupt configuration ******************************************************

    ConfigIntI2C1(MI2C_INT_OFF);  //Disable I2C interrupt

//***************** I2C1 configuration **********************************************************

/**********************************************************************************************

*

*        I2C1 enabled

*        continue I2C module in Idle mode

*        IPMI mode not enabled

*        I2CADD is 7-bit address

*        Disable Slew Rate Control for 100KHz

*        Enable SM bus specification

*        Disable General call address

*        Baud @ 8MHz = 39 into I2CxBRG

**********************************************************************************************/

   config1 = (I2C_ON  | I2C_7BIT_ADD );

   //config2 = 39;

   config2 = 157;

   OpenI2C1(config1,config2);   //configure I2C1

   IdleI2C1();

   StartI2C1();

   while(I2C1CONbits.SEN );  //Wait till Start sequence is completed

   MI2C1_Clear_Intr_Status_Bit; //Clear interrupt flag

   MasterWriteI2C1(0x03);       //Write Slave address and set master for transmission

   while(I2C1STATbits.TBF);     //Wait till address is transmitted

   while(!IFS1bits.MI2C1IF);    //Wait for ninth clock cycle

   MI2C1_Clear_Intr_Status_Bit; //Clear interrupt flag

   while(I2C1STATbits.ACKSTAT);

    for(i=0;i<1000;i++);

}

configuration file data:............

#include "system_config.h"

// *****************************************************************************

// *****************************************************************************

// Section: Configuration Bits

// *****************************************************************************

// *****************************************************************************

// FBS

#pragma config BWRP = OFF               // Table Write Protect Boot (Boot segment may be written)

#pragma config BSS = OFF                // Boot segment Protect (No boot program Flash segment)

// FGS

#pragma config GWRP = OFF               // General Segment Code Flash Write Protection bit (General segment may be written)

#pragma config GCP = OFF                // General Segment Code Flash Code Protection bit (No protection)

// FOSCSEL

#pragma config FNOSC = FRCPLL           // Oscillator Select (Fast RC oscillator with divide-by-N with PLL module (FRCDIV+PLL))

#pragma config IESO = OFF               // Internal External Switch Over bit (Internal External Switchover mode disabled (Two-Speed Start-up disabled))

// FOSC

#pragma config POSCMOD = NONE           // Primary Oscillator Configuration bits (Primary oscillator disabled)

#pragma config OSCIOFNC = ON            // CLKO Enable Configuration bit (CLKO output disabled; pin functions as port I/O)

#pragma config POSCFREQ = HS            // Primary Oscillator Frequency Range Configuration bits (Primary oscillator/external clock input frequency greater than 8 MHz)

#pragma config SOSCSEL = SOSCHP         // SOSC Power Selection Configuration bits (Secondary oscillator configured for high-power operation)

#pragma config FCKSM = CSDCMD           // Clock Switching and Monitor Selection (Both Clock Switching and Fail-safe Clock Monitor are disabled)

// FWDT

#pragma config WDTPS = PS32768          // Watchdog Timer Postscale Select bits (1:32,768)

#pragma config FWPSA = PR128            // WDT Prescaler (WDT prescaler ratio of 1:128)

#pragma config WINDIS = OFF             // Windowed Watchdog Timer Disable bit (Standard WDT selected; windowed WDT disabled)

#pragma config FWDTEN = OFF             // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))

// FPOR

#pragma config BOREN = BOR2             // Brown-out Reset Enable bits (Brown-out Reset enabled only while device is active and disabled in Sleep; SBOREN bit disabled)

#pragma config PWRTEN = OFF             // Power-up Timer Enable bit (PWRT disabled)

#pragma config I2C1SEL = PRI            // Alternate I2C1 Pin Mapping bit (Default location for SCL1/SDA1 pins)

#pragma config BORV = V27               // Brown-out Reset Voltage bits (Brown-out Reset set to Highest Voltage (2.7V))

#pragma config MCLRE = ON               // MCLR Pin Enable bit (MCLR pin enabled; RA5 input pin disabled)

// FICD

#pragma config ICS = PGx1               // ICD Pin Placement Select bits (PGC1/PGD1 are used for programming and debugging the device)

// FDS

#pragma config DSWDTPS = DSWDTPSF       // Deep Sleep Watchdog Timer Postscale Select bits (1:2,147,483,648 (25.7 Days))

#pragma config DSWDTOSC = LPRC          // DSWDT Reference Clock Select bit (DSWDT uses LPRC as reference clock)

#pragma config RTCOSC = SOSC            // RTCC Reference Clock Select bit (RTCC uses SOSC as reference clock)

#pragma config DSBOREN = ON             // Deep Sleep Zero-Power BOR Enable bit (Deep Sleep BOR enabled in Deep Sleep)

#pragma config DSWDTEN = OFF            // Deep Sleep Watchdog Timer Enable bit (DSWDT disabled)

Hi,

About config bits... Not easy to ceck .

I think that if you select FRCDIV+PLL,you have Fosc = 8 MHz /2 (Postscaler default is /2) x4 (PLL) = 16 Mhz, so Fcy = 8 MHz.

About the clock config, try with this configuration with a simple program switching on and off (for example 250ms on, 750ms off), an output with an LED, and see the blinking speed (1s for the example).

Despite of this i do not think this is the problem of communication.

When want to write the command, try:

     IdleI2C();          //Wait to complete

     StartI2C1();     //Send start bit

     IdleI2C1();

     MasterWriteI2C1(0x03)          //Slave Adress 000, Command 00011 Measure temp

     IdleI2C1();               //In this case Idel waits until transmition is done (8 bit + ACK)

Just in this moiment you can check ACK status. Notice that it can be a little bit confusing:

while(I2C1STATbits.ACKSTAT) means while(I2C1STATbits.ACKSTAT ==1) and when I2C1STATbits.ACKSTAT ==1 means not ACK.

So, after MasterWrite...IdleI2C1(), if the sensor has received correctly the command, and send back the acknowledge, the I2C1STATbits.ACKSTAT must be '0'.

I hope my explanation is not more confusing...

Hope that helps,

Miguel

Hi, thanks

Actually i checked the the clock configuration earlier through as u said by LED blinking Code. and for FRCPLL and keeping CLKDIV=0x0000; i m getting Fcy=16MHz. I have checked it by putting different value of PR1 for Timer.

For ACK, u r correct that it should be 0, so what i understood is it will come out from the while loop only when the ACK is received. And for my code its not coming out of the while loop.

is it not required to check that stop sequence is completed or not?  if i want to read the data after writing command which sequence of functions of library i have to follow?

Hi, thanks

Actually i checked the the clock configuration earlier through as u said by LED blinking Code. and for FRCPLL and keeping CLKDIV=0x0000; i m getting Fcy=16MHz. I have checked it by putting different value of PR1 for Timer.

For ACK, u r correct that it should be 0, so what i understood is it will come out from the while loop only when the ACK is received. And for my code its not coming out of the while loop.

is it not required to check that stop sequence is completed or not?  if i want to read the data after writing command which sequence of functions of library i have to follow?

Hi,

What I would do:

-Previosly declare variable similar like this:

     (...)

     char data_high=0;

     char data_low=0;

     unsigned short data;

     (...)

When reading the sensor:

(previosly open and configured I2C with OpenI2C1()

     (...)

     IdleI2C1();

     StarI2C1();

     IdleI2C1();

     MasterWriteI2C1(0x03);

     IdleI2C1();

     if (I2C1STATbits.ACKSTAT ==1){

          // here you can put code for ack error

     }else{

          __delay_ms(80);     // this delay to let the sensor make the conversation, see SHT11 datasheet

          data_high = MasterReadI2C1();

          IdleI2C1();

          AckI2C1();

          IdleI2C1();

          data_low = MasterReadI2C1();

          IdleI2C1();

          NotAckI2C1();     //here not ack because I discard using CRC

          IdleI2C1();

     }

     StopI2C1();

     (...)

Sorry for any syntax error.

Hope that helps,

Miguel

Hi, thanks

now i m getting acknowledge from slave after MasterWriteI2C1(0x03) but when it goes to delay function after checking ACKSTAT bit and confirming it is 0, i m getting the value of I2C1STAT register = 4009, which means transmit is in progress, so i have confusion about how come i can get ACKSTAT= 0 without completion of transfer. Can u tell me why we should use and at what place we should use IdleI2C1();  what is the actual purpose of it?  i have tried to understand from library but not able to get the exact picture of it.

when i m trying to read from the slave (SHT11) i m not able to proceed ahead from data_low = MasterReadI2C1();, it stops at this point and then it cant go further for debugging. plz let me know where i m doing wrong.

Hi,

About the IdleI2C1():

After a StartI2C1(); you can wait until start condition enable bit is clear.

After a StopI2C1(); you can wait until stop condition enable bit is clear.

After a MasterWriteI2C1(); you can wait until transmit status bit is clear.

And so on.

Or for all these functions I think you can use IdleI2C1() instead of checking their own flag.

So, it seems you can get the data_high but not the data_low....Have you tried changing AckI2C1 by NotAckI2C1 and viceversa?

Hope that helps,

hi,
i came to know from the SHT11 data sheet is ...

The sensor

cannot be addressed by I2C protocol; however, the sensor

can be connected to an I2C bus without interference with

other devices connected to the bus. The controller must

switch between the protocols.

i m getting error in the following code. I have taken this code from the one of the post of mikroelectronika (viewtopic.php?f=13&t=13803&start=15) and I have modified only the pins used for SDA and SCL and commented the code for LCD. But i m getting error when i interface PIC24F16KA102 with SHT11 click board. i m pasting my code here. plz help in debugging this problem. i am debugging the following code using MPLABX IDE, C16 compiler. i m getting error in main programme at the following point.



if(error!=0)
{
s_connectionreset(); //in case of an error: connection reset
}

/**************************************************************************************************
* Project name:
SHT11_driver
* Copyright:
(c) Mikroelektronika, 2011.
* Revision History:
20111122:
- initial release (DA and JK);
* Description:
This code contains functions for communication with SHT1x temperature and humidity sensor.
http://www.sensirion.com/en/pdf/product ... -SHT1x.pdf

* Test configuration:
SW: mikroC PRO for PIC
http://www.mikroe.com/eng/products/view ... o-for-pic/
**************************************************************************************************/

/*******************************************************************************************************************/
#include "p24F16KA102.h"
#include <timer.h>
#include <math.h>
typedef union
{ unsigned int i;
float f;
} value;


//------------------------------------------------------------------------------
// modul-var
//------------------------------------------------------------------------------
//enum {TEMP,HUMI};

//#include "initlcd.h"

#define TEMP 0
#define HUMI 1

#define PORT_COND TRISBbits.TRISB9 //data port condition: input/output
#define DATA PORTBbits.RB9 //SHT11 DATA pin
#define SCK PORTBbits.RB8 //STH11 SCK pin
#define noACK 0
#define ACK 1
//adr command r/w
#define STATUS_REG_W 0x06 //000 0011 0
#define STATUS_REG_R 0x07 //000 0011 1
#define MEASURE_TEMP 0x03 //000 0001 1
#define MEASURE_HUMI 0x05 //000 0010 1
#define RESET 0x1e //000 1111 0

#define MEMORY_ADDRESS 0xA0


// char* Out_temp()
// {
// char str[]="Temp:" absolute MEMORY_ADDRESS;
// return str;
// }
//
// char* Out_humi()
// {
// char str[]="Humi:" absolute MEMORY_ADDRESS;
// return str;
// }


//------------------------------------------------------------------------------
char s_write_byte(unsigned char value)
//------------------------------------------------------------------------------
// writes a byte on the Sensibus and checks the acknowledge
{
unsigned char i,error=0;

PORT_COND = 0; //SHT11 WRITE


for (i=0x80;i>0;i/=2) //shift bit for masking
{ if (i & value) DATA=1; //masking value with i , write to SENSI-BUS
else DATA=0;
SCK=1; //clk for SENSI-BUS
delay_us(5); //pulswith approx. 5 us
SCK=0;
}

DATA=1; //release DATA-line

PORT_COND = 1; //SHT11 READ


delay_us(2);

SCK=1; //clk #9 for ack
error=DATA; //check ack (DATA will be pulled down by SHT11)
SCK=0;
return error; //error=1 in case of no acknowledge
}


//----------------------------------------------------------------------------------
char s_read_byte(unsigned char ack)
//----------------------------------------------------------------------------------
// reads a byte form the Sensibus and gives an acknowledge in case of "ack=1"
{
unsigned char i,val=0;

PORT_COND = 1; //SHT11 READ


DATA=1; //release DATA-line

for (i=0x80;i>0;i/=2) //shift bit for masking
{ SCK=1; //clk for SENSI-BUS

if (DATA) val=(val | i); //read bit
SCK=0;
}

DATA=!ack; //in case of "ack==1" pull down DATA-Line
SCK=1; //clk #9 for ack
delay_us(5); //pulswith approx. 5 us
SCK=0;
DATA=1; //release DATA-line
return val;
}


//----------------------------------------------------------------------------------
void s_transstart(void)
//----------------------------------------------------------------------------------
// generates a transmission start
// _____ ________
// DATA: |_______|
// ___ ___
// SCK : ___| |___| |______
{
PORT_COND = 0; //SHT11 WRITE

DATA=1; SCK=0; //Initial state
delay_us(2);
SCK=1;
delay_us(2);
DATA=0;
delay_us(2);
SCK=0;
delay_us(5);
SCK=1;
delay_us(2);
DATA=1;
delay_us(2);
SCK=0;
}


//----------------------------------------------------------------------------------
void s_connectionreset(void)
//----------------------------------------------------------------------------------
// communication reset: DATA-line=1 and at least 9 SCK cycles followed by transstart
// _____________________________________________________ ________
// DATA: |_______|
// _ _ _ _ _ _ _ _ _ ___ ___
// SCK : __| |__| |__| |__| |__| |__| |__| |__| |__| |______| |___| |______
{
unsigned char i;

PORT_COND = 0; //SHT11 WRITE


DATA=1; SCK=0; //Initial state

for(i=0;i<9;i++) //9 SCK cycles
{ SCK=1;
SCK=0;
}

s_transstart(); //transmission start
}


//----------------------------------------------------------------------------------
char s_softreset(void)
//----------------------------------------------------------------------------------
// resets the sensor by a softreset
{
unsigned char error=0;

s_connectionreset(); //reset communication

error+=s_write_byte(RESET); //send RESET-command to sensor
return error; //error=1 in case of no response form the sensor
}


//----------------------------------------------------------------------------------
char s_read_statusreg(unsigned char *p_value, unsigned char *p_checksum)
//----------------------------------------------------------------------------------
// reads the status register with checksum (8-bit)
{
unsigned char error=0;

s_transstart(); //transmission start

error=s_write_byte(STATUS_REG_R); //send command to sensor

*p_value=s_read_byte(ACK); //read status register (8-bit)
*p_checksum=s_read_byte(noACK); //read checksum (8-bit)

return error; //error=1 in case of no response form the sensor
}


//----------------------------------------------------------------------------------
char s_write_statusreg(unsigned char *p_value)
//----------------------------------------------------------------------------------
// writes the status register with checksum (8-bit)
{
unsigned char error=0;

s_transstart(); //transmission start

error+=s_write_byte(STATUS_REG_W);//send command to sensor
error+=s_write_byte(*p_value); //send value of status register

return error; //error>=1 in case of no response form the sensor
}


//----------------------------------------------------------------------------------
char s_measure(unsigned char *p_value, unsigned char *p_checksum, unsigned char mode)
//----------------------------------------------------------------------------------
// makes a measurement (humidity/temperature) with checksum
{
unsigned error=0;
unsigned int i;

s_transstart(); //transmission start

switch(mode)
{ //send command to sensor
case TEMP : error+=s_write_byte(MEASURE_TEMP); break; //temp
case HUMI : error+=s_write_byte(MEASURE_HUMI); break; //humidity
default : break;
}

PORT_COND = 1; //SHT11 READ


for (i=0;i<65535;i++) if(DATA==0) break; //wait until sensor has finished the measurement

if(DATA) error+=1; // or timeout (~2 sec.) is reached

*(p_value+1)=s_read_byte(ACK); //read the second byte (LSB)
*(p_value) =s_read_byte(ACK); //read the first byte (MSB)



*p_checksum =s_read_byte(noACK); //read checksum

return error;
}

/*
//----------------------------------------------------------------------------------
void init_uart()
//----------------------------------------------------------------------------------
// Initializes the UART so the final data can be sent away, e.g. to a PC
//9600 bps @ 11.059 MHz
{ SCON = 0x52;
TMOD = 0x20;
TCON = 0x69;
TH1 = 0xfd;
}
*/

//----------------------------------------------------------------------------------------
void calc_sth11(float *p_humidity ,float *p_temperature)
//----------------------------------------------------------------------------------------
// calculates temperature [C] and humidity [%RH]
// input : humi [Ticks] (12 bit)
// temp [Ticks] (14 bit)
// output: humi [%RH]
// temp [C]
{ const float C1=-4.0; // for 12 Bit
const float C2= 0.0405; // for 12 Bit
const float C3=-0.0000028; // for 12 Bit
const float T1=0.01; // for 14 Bit @ 5V
const float T2=0.00008; // for 14 Bit @ 5V
float rh=*p_humidity; // rh: Humidity [Ticks] 12 Bit
float t=*p_temperature; // t: Temperature [Ticks] 14 Bit
float rh_lin; // rh_lin: Humidity linear
float rh_true; // rh_true: Temperature compensated humidity
float t_C; // t_C : Temperature [C]

t_C=t*0.01-40; //calc. Temperature from ticks to [C]

rh_lin=C3*rh*rh + C2*rh + C1; //calc. Humidity from ticks to [%RH]

rh_true=(t_C-25)*(T1+T2*rh)+rh_lin; //calc. Temperature compensated humidity [%RH]

if(rh_true>100)rh_true=100; //cut if the value is outside of

if(rh_true<0.1)rh_true=0.1; //the physical possible range

*p_temperature=t_C; //return temperature [C]
*p_humidity=rh_true; //return humidity[%RH]
}


//--------------------------------------------------------------------
float calc_dewpoint(float h,float t)
//--------------------------------------------------------------------
// calculates dew point
// input: humidity [%RH], temperature [C]
// output: dew point [C]
{ float k,dew_point ;

k = (log10(h)-2)/0.4343 + (17.62*t)/(243.12+t);

dew_point = 243.12*k/(17.62-k);

return dew_point;
}

//----------------------------------------------------------------------------------
void main()
//----------------------------------------------------------------------------------
// sample program that shows how to use SHT11 functions
// 1. connection reset
// 2. measure humidity [ticks](12 bit) and temperature [ticks](14 bit)
// 3. calculate humidity [%RH] and temperature [C]
// 4. calculate dew point [C]
// 5. print temperature, humidity, dew point


//AD1PCFGbits.PCFG0=1;
//AD1PCFGbits.PCFG1=1;
{
AD1PCFG =0XFFFF;
//AD1PCFGbits.PCFG10=1;



value humi_val,temp_val;

float dew_point;
unsigned char error,checksum;
//unsigned int i;

char temp[13];
char humi[13];


// Initlcd(); //Initialize LCD

s_connectionreset();
delay_ms(20);

while(1)
{

error=0;

error+=s_measure((unsigned char*) &humi_val.i,&checksum,HUMI);
//measure humidity

error+=s_measure((unsigned char*) &temp_val.i,&checksum,TEMP);
//measure temperature

if(error!=0)
{
s_connectionreset(); //in case of an error: connection reset
}
else
{
humi_val.f=(float)humi_val.i; //converts integer to float
temp_val.f=(float)temp_val.i; //converts integer to float

calc_sth11(&humi_val.f,&temp_val.f); //calculate humidity, temperature

dew_point=calc_dewpoint(humi_val.f,temp_val.f); //calculate dew point

//send final data to serial interface (UART)

// Lcd8_Out(1,1,Out_temp());
// Lcd8_Out(2,1,Out_humi());
//
// FloatToStr(temp_val.f, temp);
// Lcd8_Out(1,6,temp);
//
// FloatToStr(humi_val.f, humi);
// Lcd8_Out(2,6,humi);


}
//----------wait approx. 0.8s to avoid heating up SHTxx----------------------
//-----------------------------------------------------------------------------------
delay_ms(1000);

}

}

Sorry jalpa I did not either realize that the sensor is not I2C...

Check this:

- Put a break point in line:

      error=DATA; //check ack (DATA will be pulled down by SHT11)

Check Data value in the physical Line SDA,

     if 'low', sensor is responding, so put a break point in line

               if(DATA) error+=1; // or timeout (~2 sec.) is reached

               Check what was the reason of exit the previous loop, i gets 65536 or D==0, if i gets 65536 the sensor does not end the measurement (remember using Pull-up resistor)

     if 'high', sensor is not responding:

               - Can you debug your code step by step? (in MPLAB I recommend you using F7 step into, because it is the shortest step). If yes run again the code from the begining, and when start the transmission of the command:

for (i=0x80;i>0;i/=2) //shift bit for masking

{ if (i & value) DATA=1; //masking value with i , write to SENSI-BUS

else DATA=0;

SCK=1; //clk for SENSI-BUS

delay_us(5); //pulswith approx. 5 us

SCK=0;

}

check every time that the status of both lines SCK and SDA are what you are expecting. When the command is sent keep on stepping and check the status of SDA when you get to line

error=DATA; //check ack (DATA will be pulled down by SHT11),

If now SDA is low means that sensor works, so maybe it is timing problem,

Check this, and let us know what you get.

Sorry for not giving a more concise answer but without the board and the sensor is difficult to try the code...

Regards.

hi..

i am using the pic24f16ka102 and temperature sensore tmp75 i got the same problem that i got the acknowledge for address but did'nt get the acknowledgement for data