Temperature data logger using PIC18F46K22, SD card and DS18B20

This project shows how to build a temperature data logger using PIC18F46K22 microcontroller, SD card and DS18B20 digital temperature sensor.
The PIC18F46K22 MCU reads temperature values from the DS18B20 sensor and saves them to a text file stored in the SD card. DS1307 real time clock chip is used to get time and date information.
Time, date and temperature values are displayed on 20×4 LCD screen.
MikroC PRO for PIC compiler is used in this project.

FAT32 Library for mikroC compiler:
MikroElektronika provides a nice library for FAT32 file system (& SD card). This library can be downloaded from the following link:
FAT32 Library for mikroC compiler

The extension of the downloaded file is .mpkg, and in order to open and install the library we need a small software named: Package Manager, it’s also a free software provided by MikroElektronika, download link is below:
Package Manager download

To see how to interface PIC18F46K22 with SD card, visit the following post:
PIC18F46K22 Interface with SD card – Write & read files | mikroC Projects

Hardware Required:
This is a list of all components required to build this project.

PIC18F46K22 microcontroller —-> datasheet
FAT32 formatted SD card (MMC, SD, SDHC, microSD ….)
micro SD card module
USB-to-serial UART converter (like: FT232RL module)
20×4 LCD screen
DS18B20 temperature sensor —-> datasheet
DS1307 RTC —-> datasheet
32.768 kHz crystal oscillator
2 x 10k ohm resistor
4.7k ohm resistor
330 ohm resistor
2 x push button
10k ohm variable resistor or potentiometer
3V coin cell battery
Breadboard
5V source
Jumper wires

Temperature data logger using PIC18F46K22 circuit:
The following image shows project hardware circuit diagram.

As a small hint, it’s highly recommended to add a voltage level translator to MISO line in order to step up the 3.3V that comes from the SD card into 5V which goes to SDI1 pin (#23) of the PIC18F46K22 microcontroller, here we can use the integrated circuit 74HCT125.

In this project I used micro SD card module, this module is supplied from circuit 5V source, it contains the AMS1117-3V3 voltage regulator which is used to supply the SD card with 3.3V. Also this module contains an IC which is 74LVC125A and it is used as level translator (from 5V to 3.3V).

All the grounded terminals are connected together.

The PIC18F46K22 microcontroller does have 2 MSSP modules: MSSP1 and MSSP2 (MSSP: Master Synchronous Serial Port), each one of them may work as hardware SPI module or hardware I2C module. The SD card uses SPI protocol, it’s connected to MSSP1 module (used as SPI) hardware pins (SCK1, SDI1 and SDO1). So the micro SD card module is connected to the circuit as follows (from left to right):

The first pin of the micro SD card module (GND) is connected to circuit ground.
The second pin of the micro SD card module (VCC) is connected to circuit +5V.
The third pin of the micro SD card module (MISO) is connected to pin SDI1 (RC4) of the PIC18F46K22.
The fourth pin of the micro SD card module (MOSI) is connected to pin SDO1 (RC5) of the PIC18F46K22.
The fifth pin of the micro SD card module (SCK) is connected to pin SCK1 (RC3) of the PIC18F46K22.
The last pin of the micro SD card module (CS) is connected to pin RC2 of the PIC18F46K22.

The DS1307 RTC chip uses I2C protocol, its data pins (SCL and SDA) are connected to MSSP2 module which is configured to operate in I2C mode. So, the SCL and SDA pins of the DS1307 RTC are respectively connected to SCL2 (RD0) and SDA2 (RD1) of the PIC18F46K22 microcontroller.

In the circuit there are two push buttons: B1 and B2, they are connected to pins RB0 (#33) and RB1 (#34) respectively, these buttons are used to set time and date of the real time clock.

The DS18B20 temperature sensor has 3 pins (from left to right): GND, data and VCC where:
GND is connected to circuit ground (0V)
Data pin is connected to pin RB5 (#38) of the PIC18F46K22
VCC is connected to +5V.

The 20×4 LCD screen (4 rows and 20 columns) is used to display time, date and temperature where:
RS —> pin RD2
E —> pin RD3
D4 —> pin RD4
D5 —> pin RD5
D6 —> pin RD6
D7 —> pin RD7
VSS, RW, D0, D1, D2, D3 and K are connected to circuit ground
VEE to the variable resistor (or potentiometer) output
VDD to +5V and A to +5V through 330 ohm resistor.

VEE pin is used to control the contrast of the LCD. A (anode) and K (cathode) are the back light LED pins.

The FT232RL board (USB to serial converter) RX pin is connected to PIC18F46K22 TX1 pin (RC6) which is USART1 module transmission pin (the PIC18F46K22 has 2 hardware USART modules).

In this project the PIC18F46K22 microcontroller runs with its internal oscillator @ 16 MHz and MCLR pin is configured as input.

Temperature data logger using PIC18F46K22 C code:
The C code below is for mikroC PRO for PIC compiler, it was tested with version 7.2.0.

To be able to compile project C code with no error, a driver (library) for the DS1307 RTC is required, download link is below. After you download the driver file which named DS1307.c, add it to your project folder.
DS1307 mikroC library

For more details about the DS1307 library, visit the following post:
DS1307 RTC Library for mikroC Compiler | mikroC Projects

The SD card chip select pin (SS) is connected to pin RC2 of the PIC18F46K22, it’s defined in the C code as:

// SD card chip select pin connection
sbit Mmc_Chip_Select           at RC2_bit;
sbit Mmc_Chip_Select_Direction at TRISC2_bit;

// SD card chip select pin connection

sbit Mmc_Chip_Select at RC2_bit;

sbit Mmc_Chip_Select_Direction at TRISC2_bit;

The connection of the two push buttons are defined in the code as shown below:

// button definitions
#define button1      RB0_bit   // button B1 is connected to RB0 pin
#define button2      RB1_bit   // button B2 is connected to RB1 pin

// button definitions

#define button1 RB0_bit // button B1 is connected to RB0 pin

#define button2 RB1_bit // button B2 is connected to RB1 pin

The microcontroller reads temperature values from the DS18B20 sensor and saves it (with time and date) to the SD card every 10 seconds, for that I used the following if condition:

if( ((mytime->seconds % 10) == 0) && (mytime->seconds != p_second) )

1	if( ((mytime->seconds % 10) == 0) && (mytime->seconds != p_second) )

where the variable p_second is used to save only one value every 10 seconds.

Functions used in the code:
FAT32_Init(): this function initializes the FAT32 library as well as the SD card, it returns 0 if OK and non-zero if error.

FAT32_Open(“DS18B20Log.txt”, FILE_APPEND): this function creates (& opens) a new file named “DS18B20Log.txt” if it doesn’t already exists, if the file exists, it opens and moves the cursor to the end of the file, returns 0 if OK and non-zero if error (for example file exists).

FAT32_Write(fileHandle, “…”, 26): writes a text (for example “…” ) of length (for example 26 characters) to the file associated with fileHandler.

FAT32_Close(fileHandle): closes the file associated with fileHandler, returns 0 if OK and non-zero if error.

char debounce (): this function is for button B1 debounce, returns 1 if button is debounced.

void wait(): this function is just a delay of 500 ms except that it can be interrupted by the two push buttons (B1 and B2). In this function Timer0 module is used to count the 500 milliseconds, it is used as 16-bit timer with prescaler = 32 (==> 1 tick every 8 microseconds ==> 62500 x 8 = 500000 us = 500 ms).

char edit(char x_pos, char y_pos, char parameter): this function is for setting the real time clock, returns the edited parameter.

void dow_print(): displays day of the week (Monday, Tuesday …) on the LCD.

void rtc_print(): displays time and date on the LCD. This function calls the previous one for displaying day of the week.

unsigned int ds18b20_read(): this function reads temperature from the DS18B20 sensor, returns the value of the temperature as unsigned 16-bit number.

Rest of code is described through comments.

Full mikroC code:
Configuration words (for PIC18F46K22 MCU):
CONFIG1H = 0x0028
CONFIG2L = 0x0018
CONFIG2H = 0x003C
CONFIG3H = 0x0037
CONFIG4L = 0x0081
CONFIG5L = 0x000F
CONFIG5H = 0x00C0
CONFIG6L = 0x000F
CONFIG6H = 0x00E0
CONFIG7L = 0x000F
CONFIG7H = 0x0040

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

  Temperature logger using PIC18F46K22 microcontroller, DS1307 RTC
    and DS18B20 sensor.
  Time, date and temperature are displayed on 20x4 LCD.
  C Code for mikroC PRO for PIC compiler.
  Internal oscillator used @ 16MHz
  
  Configuration words: CONFIG1H = 0x0028
                       CONFIG2L = 0x0018
                       CONFIG2H = 0x003C
                       CONFIG3H = 0x0037
                       CONFIG4L = 0x0081
                       CONFIG5L = 0x000F
                       CONFIG5H = 0x00C0
                       CONFIG6L = 0x000F
                       CONFIG6H = 0x00E0
                       CONFIG7L = 0x000F
                       CONFIG7H = 0x0040
  
  This is a free software with NO WARRANTY.
  http://simple-circuit.com/

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


// SD card chip select pin connection
sbit Mmc_Chip_Select           at RC2_bit;
sbit Mmc_Chip_Select_Direction at TRISC2_bit;

// LCD module connections
sbit LCD_RS at RD2_bit;
sbit LCD_EN at RD3_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_D5 at RD5_bit;
sbit LCD_D6 at RD6_bit;
sbit LCD_D7 at RD7_bit;
sbit LCD_RS_Direction at TRISD2_bit;
sbit LCD_EN_Direction at TRISD3_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;
// end LCD module connections

// button definitions
#define button1      RB0_bit   // button B1 is connected to RB0 pin
#define button2      RB1_bit   // button B2 is connected to RB1 pin

#define DS1307_I2C2    // use hardware I2C2 moodule (MSSP2) for DS1307 RTC
#include <DS1307.c>    // include DS1307 RTC driver source file
RTC_Time *mytime;      // DS1307 library variable

// include __Lib_FAT32.h file (useful definitions)
#include "__Lib_FAT32.h"
__HANDLE fileHandle;     // only one file can be opened

// other variable
short fat_err;
short i, p_second = 1;

// a small function for button1 (B1) debounce
char debounce()
{
  char m, count = 0;
  for(m = 0; m < 5; m++)
  {
    if ( !button1 )
      count++;
    delay_ms(10);
  }

  if(count > 2)  return 1;
  else           return 0;
}

// interrupted delay
void wait()
{
  unsigned int TMR0_value = 0;
  TMR0L = TMR0H = 0;  // rest Timer0 low and high registers
  while( (TMR0_value < 62500L) && button1 && button2 )
    TMR0_value = (TMR0H << 8) | TMR0L;
}

char edit(char x_pos, char y_pos, char parameter)
{
  char buffer[3];
  while(debounce());  // call debounce function (wait for B1 to be released)
  sprinti(buffer, "%02u", (int)parameter);

  while(1)
  {
    while( !button2 )
    {
      parameter++;
      if(i == 0 && parameter > 23)   // if hours > 23 ==> hours = 0
        parameter = 0;
      if(i == 1 && parameter > 59)   // if minutes > 59 ==> minutes = 0
        parameter = 0;
      if(i == 2 && parameter > 31)   // if day > 31 ==> day = 1
        parameter = 1;
      if(i == 3 && parameter > 12)   // if month > 12 ==> month = 1
        parameter = 1;
      if(i == 4 && parameter > 99)   // if year > 99 ==> year = 0
        parameter = 0;

      sprinti(buffer, "%02u", (int)parameter);
      LCD_Out(y_pos, x_pos, buffer);
      delay_ms(200);
    }

    LCD_Out(y_pos, x_pos, "  ");
    wait();
    LCD_Out(y_pos, x_pos, buffer);
    wait();

    if(!button1) // if button B1 is pressed
    {
      i++;                // increment 'i' for the next parameter
      return parameter;   // return parameter value and exit
    }
  }
}

void dow_print()
{
  switch(mytime->dow)
  {
    case SUNDAY   :  LCD_Out(1, 5, " SUNDAY  ");  break;
    case MONDAY   :  LCD_Out(1, 5, " MONDAY  ");  break;
    case TUESDAY  :  LCD_Out(1, 5, " TUESDAY ");  break;
    case WEDNESDAY:  LCD_Out(1, 5, "WEDNESDAY");  break;
    case THURSDAY :  LCD_Out(1, 5, "THURSDAY ");  break;
    case FRIDAY   :  LCD_Out(1, 5, " FRIDAY  ");  break;
    default       :  LCD_Out(1, 5, "SATURDAY ");
  }
}

void rtc_print()
{
  char buffer[17];
  // print day of the week
  dow_print();
  // print time
  sprinti(buffer, "TIME: %02u:%02u:%02u", (int)mytime->hours, (int)mytime->minutes, (int)mytime->seconds);
  LCD_Out(2, 1, buffer);
  // print date
  sprinti(buffer, "DATE: %02u-%02u-20%02u", (int)mytime->day, (int)mytime->month, (int)mytime->year);
  LCD_Out(3, 1, buffer);
}

unsigned int ds18b20_read()
{
  unsigned int _temp;
  Ow_Reset(&PORTB, 5);         // onewire reset signal
  Ow_Write(&PORTB, 5, 0xCC);   // issue command SKIP_ROM
  Ow_Write(&PORTB, 5, 0x44);   // issue command CONVERT_T
  while (Ow_Read(&PORTB, 5) == 0) ;
  Ow_Reset(&PORTB, 5);        // onewire reset signal
  Ow_Write(&PORTB, 5, 0xCC);  // issue command SKIP_ROM
  Ow_Write(&PORTB, 5, 0xBE);  // issue command READ_SCRATCHPAD
  _temp  = Ow_Read(&PORTB, 5);         // read temperature LSB byte
  _temp |= (Ow_Read(&PORTB, 5) << 8);  // read temperature MSB byte
  return _temp;
}

// main function
void main()
{
  OSCCON = 0x70;      // set internal oscillator to 16MHz
  ANSELB = 0;         // configure all PORTB pins as digital
  ANSELC = 0;         // configure all PORTC pins as digital
  ANSELD = 0;         // configure all PORTD pins as digital
  T0CON  = 0x04;      // configure Timer0 module (16-bit timer & prescaler = 32)
  // enable RB0 and RB1 internal pull ups
  RBPU_bit  = 0;      // clear RBPU bit (INTCON2.7)
  WPUB      = 0x03;   // WPUB register = 0b00000011

  delay_ms(1000);           // wait a second
  Lcd_Init();               // initialize LCD module
  Lcd_Cmd(_LCD_CURSOR_OFF); // cursor off
  Lcd_Cmd(_LCD_CLEAR);      // clear LCD
  LCD_Out(4, 1, "TEMP:");
  
  // initialize I2C2 module with clock frequency of 100KHz
  I2C2_Init(100000);
  // intialize SPI1 module at lowest speed
  SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
  
  UART1_Init(9600);   // initialize UART1 module at 9600 baud
  UART1_Write_Text("\r\n\nInitialize FAT library ... ");
  
  fat_err = FAT32_Init();
  if(fat_err != 0)
  {  // if there was a problem while initializing the FAT32 library
    UART1_Write_Text("Error initializing FAT library!");
  }

  else
  {  // the FAT32 library (& SD card) was (were) initialized
    // re-initialize SPI1 module at highest speed
    SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);
    UART1_Write_Text("FAT Library initialized");
    // create (or open if already exists) a text file 'DS18B20Log.txt'
    UART1_Write_Text("\r\n\r\nCreate 'DS18B20Log.txt' file ... ");
    fileHandle = FAT32_Open("DS18B20Log.txt", FILE_APPEND);
    if(fileHandle == 0){
      UART1_Write_Text("OK");
      // write some texts to 'DS18B20Log.txt' file
      FAT32_Write(fileHandle, "    DATE    |    TIME  | TEMPERATURE\r\n", 38);
      FAT32_Write(fileHandle, "(dd-mm-yyyy)|(hh:mm:ss)|\r\n", 26);
      FAT32_Write(fileHandle, "            |          |\r\n", 26);
    }
    else
      UART1_Write_Text("error creating file or file already exists");
    
    // now close the file 'DS18B20Log.txt'
    FAT32_Close(fileHandle);
  }

  // enable RTC oscillator
  OSC_Enable();
  
  while(1)
  {
    // read current time and date from the RTC chip
    mytime = RTC_Get();
    // print all data
    rtc_print();
    
    if( !button1 )    // if button B1 is pressed
    if( debounce() )  // call debounce function (make sure if B1 is pressed)
    {
      i = 0;
      while( debounce() );  // call debounce function (wait for button B1 to be released)
      TMR0ON_bit = 1;  // enable Timer0 module

      while(1)
      {
        while( !button2 )  // if button B2 button is pressed
        {
          mytime->dow++;
          if(mytime->dow > SATURDAY)
            mytime->dow = SUNDAY;
          dow_print();     // print week day
          delay_ms(500);   // wait half a second
        }
        LCD_Out(1, 5, "         ");
        wait();         // call wait() function
        dow_print();    // print week day
        wait();         // call wait() function
        if( !button1 )  // if button B1 is pressed
          break;
      }

      mytime->hours   = edit(7,  2, mytime->hours);    // edit hours
      mytime->minutes = edit(10, 2, mytime->minutes);  // edit minutes
      mytime->day     = edit(7,  3, mytime->day);      // edit day (day of month)
      mytime->month   = edit(10, 3, mytime->month);    // edit month
      mytime->year    = edit(15, 3, mytime->year);     // edit year
      mytime->seconds = 0;                             // reset seconds

      TMR0ON_bit = 0;     // disable Timer0 module
      while(debounce());  // call debounce function (wait for button B1 to be released)
      // write data to the RTC chip
      RTC_Set(mytime);
    }  // end 'if( debounce() )'
    
    if( ((mytime->seconds % 10) == 0) && (mytime->seconds != p_second) )
    {   // read & print temperature value from sensor every 10 seconds
      char buffer[11];
      unsigned int ds18b20_temp;
      p_second = mytime->seconds;  // save current second
      
      ds18b20_temp = ds18b20_read();       // read temperature from DS18B20 sensor
      if (ds18b20_temp & 0x8000){          // if temperature is negative
        ds18b20_temp = ~ds18b20_temp + 1;  // change temperature value to positive form
        sprinti(buffer, "-%02u.%04u%cC", (ds18b20_temp/16) % 100, (ds18b20_temp & 0x0F) * 625, (int)223);
      }
      else
        sprinti(buffer, " %02u.%04u%cC", (ds18b20_temp/16) % 100, (ds18b20_temp & 0x0F) * 625, (int)223);
      LCD_Out(4, 6, buffer);

      if(fat_err == 0)
      { // if the FAT32 library was successfully initialized
        char buffer2[26];
        // open DS18B20Log.txt file with append permission
        FAT32_Open("DS18B20Log.txt", FILE_APPEND);
        sprinti(buffer2, " %02u-%02u-20%02u | %02u:%02u:%02u | ", (int)mytime->day, (int)mytime->month, (int)mytime->year,
                       (int)mytime->hours, (int)mytime->minutes, (int)mytime->seconds);
        FAT32_Write(fileHandle, buffer2, 25);
        buffer[8] = '°';   // put degree symbol
        FAT32_Write(fileHandle, buffer, 10);
        FAT32_Write(fileHandle, "\r\n", 2);     // start a new line
        // now close the file (DS18B20Log.txt)
        FAT32_Close(fileHandle);
      } // end 'if(fat_err == 0)'
      
    }  // end 'if( (mytime->seconds % 10) == 0)'
    
    delay_ms(100);    // wait 100 milliseconds
    
  } // end 'while(1)'

}  // end main function

// end of code.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

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

Temperature logger using PIC18F46K22 microcontroller, DS1307 RTC

and DS18B20 sensor.

Time, date and temperature are displayed on 20x4 LCD.

C Code for mikroC PRO for PIC compiler.

Internal oscillator used @ 16MHz

Configuration words: CONFIG1H = 0x0028

CONFIG2L = 0x0018

CONFIG2H = 0x003C

CONFIG3H = 0x0037

CONFIG4L = 0x0081

CONFIG5L = 0x000F

CONFIG5H = 0x00C0

CONFIG6L = 0x000F

CONFIG6H = 0x00E0

CONFIG7L = 0x000F

CONFIG7H = 0x0040

This is a free software with NO WARRANTY.

http://simple-circuit.com/

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

// SD card chip select pin connection

sbit Mmc_Chip_Select at RC2_bit;

sbit Mmc_Chip_Select_Direction at TRISC2_bit;

// LCD module connections

sbit LCD_RS at RD2_bit;

sbit LCD_EN at RD3_bit;

sbit LCD_D4 at RD4_bit;

sbit LCD_D5 at RD5_bit;

sbit LCD_D6 at RD6_bit;

sbit LCD_D7 at RD7_bit;

sbit LCD_RS_Direction at TRISD2_bit;

sbit LCD_EN_Direction at TRISD3_bit;

sbit LCD_D4_Direction at TRISD4_bit;

sbit LCD_D5_Direction at TRISD5_bit;

sbit LCD_D6_Direction at TRISD6_bit;

sbit LCD_D7_Direction at TRISD7_bit;

// end LCD module connections

// button definitions

#define button1 RB0_bit // button B1 is connected to RB0 pin

#define button2 RB1_bit // button B2 is connected to RB1 pin

#define DS1307_I2C2 // use hardware I2C2 moodule (MSSP2) for DS1307 RTC

#include <DS1307.c> // include DS1307 RTC driver source file

RTC_Time *mytime; // DS1307 library variable

// include __Lib_FAT32.h file (useful definitions)

#include "__Lib_FAT32.h"

__HANDLE fileHandle; // only one file can be opened

// other variable

short fat_err;

short i, p_second = 1;

// a small function for button1 (B1) debounce

char debounce()

{

char m, count = 0;

for(m = 0; m < 5; m++)

{

if ( !button1 )

count++;

delay_ms(10);

}

if(count > 2) return 1;

else return 0;

}

// interrupted delay

void wait()

{

unsigned int TMR0_value = 0;

TMR0L = TMR0H = 0; // rest Timer0 low and high registers

while( (TMR0_value < 62500L) && button1 && button2 )

TMR0_value = (TMR0H << 8) | TMR0L;

}

char edit(char x_pos, char y_pos, char parameter)

{

char buffer[3];

while(debounce()); // call debounce function (wait for B1 to be released)

sprinti(buffer, "%02u", (int)parameter);

while(1)

{

while( !button2 )

{

parameter++;

if(i == 0 && parameter > 23) // if hours > 23 ==> hours = 0

parameter = 0;

if(i == 1 && parameter > 59) // if minutes > 59 ==> minutes = 0

parameter = 0;

if(i == 2 && parameter > 31) // if day > 31 ==> day = 1

parameter = 1;

if(i == 3 && parameter > 12) // if month > 12 ==> month = 1

parameter = 1;

if(i == 4 && parameter > 99) // if year > 99 ==> year = 0

parameter = 0;

sprinti(buffer, "%02u", (int)parameter);

LCD_Out(y_pos, x_pos, buffer);

delay_ms(200);

}

LCD_Out(y_pos, x_pos, " ");

wait();

LCD_Out(y_pos, x_pos, buffer);

wait();

if(!button1) // if button B1 is pressed

{

i++; // increment 'i' for the next parameter

return parameter; // return parameter value and exit

}

void dow_print()

{

switch(mytime->dow)

{

case SUNDAY : LCD_Out(1, 5, " SUNDAY "); break;

case MONDAY : LCD_Out(1, 5, " MONDAY "); break;

case TUESDAY : LCD_Out(1, 5, " TUESDAY "); break;

case WEDNESDAY: LCD_Out(1, 5, "WEDNESDAY"); break;

case THURSDAY : LCD_Out(1, 5, "THURSDAY "); break;

case FRIDAY : LCD_Out(1, 5, " FRIDAY "); break;

default : LCD_Out(1, 5, "SATURDAY ");

}

void rtc_print()

{

char buffer[17];

// print day of the week

dow_print();

// print time

sprinti(buffer, "TIME: %02u:%02u:%02u", (int)mytime->hours, (int)mytime->minutes, (int)mytime->seconds);

LCD_Out(2, 1, buffer);

// print date

sprinti(buffer, "DATE: %02u-%02u-20%02u", (int)mytime->day, (int)mytime->month, (int)mytime->year);

LCD_Out(3, 1, buffer);

}

unsigned int ds18b20_read()

{

unsigned int _temp;

Ow_Reset(&PORTB, 5); // onewire reset signal

Ow_Write(&PORTB, 5, 0xCC); // issue command SKIP_ROM

Ow_Write(&PORTB, 5, 0x44); // issue command CONVERT_T

while (Ow_Read(&PORTB, 5) == 0) ;

Ow_Reset(&PORTB, 5); // onewire reset signal

Ow_Write(&PORTB, 5, 0xCC); // issue command SKIP_ROM

Ow_Write(&PORTB, 5, 0xBE); // issue command READ_SCRATCHPAD

_temp = Ow_Read(&PORTB, 5); // read temperature LSB byte

_temp |= (Ow_Read(&PORTB, 5) << 8); // read temperature MSB byte

return _temp;

}

// main function

void main()

{

OSCCON = 0x70; // set internal oscillator to 16MHz

ANSELB = 0; // configure all PORTB pins as digital

ANSELC = 0; // configure all PORTC pins as digital

ANSELD = 0; // configure all PORTD pins as digital

T0CON = 0x04; // configure Timer0 module (16-bit timer & prescaler = 32)

// enable RB0 and RB1 internal pull ups

RBPU_bit = 0; // clear RBPU bit (INTCON2.7)

WPUB = 0x03; // WPUB register = 0b00000011

delay_ms(1000); // wait a second

Lcd_Init(); // initialize LCD module

Lcd_Cmd(_LCD_CURSOR_OFF); // cursor off

Lcd_Cmd(_LCD_CLEAR); // clear LCD

LCD_Out(4, 1, "TEMP:");

// initialize I2C2 module with clock frequency of 100KHz

I2C2_Init(100000);

// intialize SPI1 module at lowest speed

SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);

UART1_Init(9600); // initialize UART1 module at 9600 baud

UART1_Write_Text("\r\n\nInitialize FAT library ... ");

fat_err = FAT32_Init();

if(fat_err != 0)

{ // if there was a problem while initializing the FAT32 library

UART1_Write_Text("Error initializing FAT library!");

}

else

{ // the FAT32 library (& SD card) was (were) initialized

// re-initialize SPI1 module at highest speed

SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);

UART1_Write_Text("FAT Library initialized");

// create (or open if already exists) a text file 'DS18B20Log.txt'

UART1_Write_Text("\r\n\r\nCreate 'DS18B20Log.txt' file ... ");

fileHandle = FAT32_Open("DS18B20Log.txt", FILE_APPEND);

if(fileHandle == 0){

UART1_Write_Text("OK");

// write some texts to 'DS18B20Log.txt' file

FAT32_Write(fileHandle, " DATE | TIME | TEMPERATURE\r\n", 38);

FAT32_Write(fileHandle, "(dd-mm-yyyy)|(hh:mm:ss)|\r\n", 26);

FAT32_Write(fileHandle, " | |\r\n", 26);

}

else

UART1_Write_Text("error creating file or file already exists");

// now close the file 'DS18B20Log.txt'

FAT32_Close(fileHandle);

}

// enable RTC oscillator

OSC_Enable();

while(1)

{

// read current time and date from the RTC chip

mytime = RTC_Get();

// print all data

rtc_print();

if( !button1 ) // if button B1 is pressed

if( debounce() ) // call debounce function (make sure if B1 is pressed)

{

i = 0;

while( debounce() ); // call debounce function (wait for button B1 to be released)

TMR0ON_bit = 1; // enable Timer0 module

while(1)

{

while( !button2 ) // if button B2 button is pressed

{

mytime->dow++;

if(mytime->dow > SATURDAY)

mytime->dow = SUNDAY;

dow_print(); // print week day

delay_ms(500); // wait half a second

}

LCD_Out(1, 5, " ");

wait(); // call wait() function

dow_print(); // print week day

wait(); // call wait() function

if( !button1 ) // if button B1 is pressed

break;

}

mytime->hours = edit(7, 2, mytime->hours); // edit hours

mytime->minutes = edit(10, 2, mytime->minutes); // edit minutes

mytime->day = edit(7, 3, mytime->day); // edit day (day of month)

mytime->month = edit(10, 3, mytime->month); // edit month

mytime->year = edit(15, 3, mytime->year); // edit year

mytime->seconds = 0; // reset seconds

TMR0ON_bit = 0; // disable Timer0 module

while(debounce()); // call debounce function (wait for button B1 to be released)

// write data to the RTC chip

RTC_Set(mytime);

} // end 'if( debounce() )'

if( ((mytime->seconds % 10) == 0) && (mytime->seconds != p_second) )

{ // read & print temperature value from sensor every 10 seconds

char buffer[11];

unsigned int ds18b20_temp;

p_second = mytime->seconds; // save current second

ds18b20_temp = ds18b20_read(); // read temperature from DS18B20 sensor

if (ds18b20_temp & 0x8000){ // if temperature is negative

ds18b20_temp = ~ds18b20_temp + 1; // change temperature value to positive form

sprinti(buffer, "-%02u.%04u%cC", (ds18b20_temp/16) % 100, (ds18b20_temp & 0x0F) * 625, (int)223);

}

else

sprinti(buffer, " %02u.%04u%cC", (ds18b20_temp/16) % 100, (ds18b20_temp & 0x0F) * 625, (int)223);

LCD_Out(4, 6, buffer);

if(fat_err == 0)

{ // if the FAT32 library was successfully initialized

char buffer2[26];

// open DS18B20Log.txt file with append permission

FAT32_Open("DS18B20Log.txt", FILE_APPEND);

sprinti(buffer2, " %02u-%02u-20%02u | %02u:%02u:%02u | ", (int)mytime->day, (int)mytime->month, (int)mytime->year,

(int)mytime->hours, (int)mytime->minutes, (int)mytime->seconds);

FAT32_Write(fileHandle, buffer2, 25);

buffer[8] = '°'; // put degree symbol

FAT32_Write(fileHandle, buffer, 10);

FAT32_Write(fileHandle, "\r\n", 2); // start a new line

// now close the file (DS18B20Log.txt)

FAT32_Close(fileHandle);

} // end 'if(fat_err == 0)'

} // end 'if( (mytime->seconds % 10) == 0)'

delay_ms(100); // wait 100 milliseconds

} // end 'while(1)'

} // end main function

// end of code.

This project was tested in real hardware circuit using original Samsung microSD card with capacity of 32GB. The following image shows data logger file (DS18B20Log.txt) created by the hardware circuit:

Proteus simulation:
This project could be simulated using Proteus software, the following video shows the result of the simulation.
Note that Proteus simulation circuit is not the same as real hardware circuit, project hardware circuit is shown above.

Proteus simulation file download link:
PIC18F46k22 SD card DS1307 DS18B20 datalogger

SD Card image file (FAT32_MBR.ima) download link:
SD Card FAT32 image

Related Posts

Leave a Comment Cancel Reply