008 Sanguino logger

1. Forewords

Ok guys, the new year (2011.01.01) come with the logger application which is the second and the last target for this board using Arduino language. It is a functional application which loggs date, time, values of two potentiometers and a temperature sensor on a SD card at every hour. The file names are built from the current year and month: 2011 + 01 (January) = 201101.TXT  . I did this to be usable using FAT16 system (where you can't have too many files in the root folder). So, you will end up having 12 files per year. It is up to your PC application to deal with these files and the data on them.
The application is written to be user friendly as much as possible.
I had to finish this application to use the board with some PICs for other projects written in SDCC, JAL and Pic Micro Pascal (PMP) languages (maybe also Hi-Tech C18).

The board wired and ready to go, and in second image, board waiting data to be set and Run Button to be pressed:


2. Setup the board

When is about wiring the board, always look at the pinout of Sanguino board - you can see it on this page.

Wire  connections
   
 ATmega pins
Peripheral pins
 Assigned name
 Digital 0
One of the 8 LED's  from the board, at your choice (I chosed RED color) Boot LED
 Digital 13
 One of the 8 LED's  from the board, at your choice (I chosed GREEN color) Run LED
 Digital 14
 One of the 8 LED's  from the board, at your choice (I chosed RED color)
 Error LED
 Digital 15
One of the 8 LED's  from the board, at your choice (I chose RED color)
SD access LED
 Digital 12
 on S5 pin
 Run Button
 Digital 11
 on S4 pin
 Eject Button
 Digital 2
 At the DS18B20 pin
 OneWire
 Digital 4
 pin DAT3 on MMC/SD card peripheral
 None
 Digital 5
 pin DI on MMC/SD card peripheral None
 Digital 6
 pin DAT0 on MMC/SD card peripheral None
 Digital 7
 pin CLK on MMC/SD card peripheral None
 Digital 22
RS pin on LCD
None
Digital 23
E pin on LCD
 None
 Digital 24
D4 pin on LCD
 None
Digital 25
D5 pin on LCD
 None
Digital 26
 D6 pin on LCD  None
Digital 27
 D7 pin on LCD  None
Analog 0
 POT1 pin
 POT1
Analog 1
 POT2 pin
 POT2

3. The Sketch


/*****************************************************************************
 *  A logging application and the second target to achieve.
 *
 *  remember you can set the time by sending it YYMMDDhhmmss; from console.
 *  The semicolon on the end tells it you're done...
 *
 *  Author: Vasile Guta-Ciucur
 *  License: New BSD License.
 ******************************************************************************/
#include <Wire.h> // necessary, or the application won't build properly
#include <stdio.h>
#include <PCF8583.h>
#include <LiquidCrystal.h>
#include <SdFat.h> 
#include <SdFatUtil.h> // use functions to print strings from flash memory
#include <OneWire.h>
#include <DallasTemperature.h>
// Data wire is plugged into port 2 on the Arduino #define ONE_WIRE_BUS 2 Sd2Card card; SdVolume volume; SdFile root; SdFile file; // Setup a oneWire instance to communicate with any OneWire devices  //    (not just Maxim/Dallas temperature ICs) OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.  DallasTemperature sensors(&oneWire);
 
int correct_address = 0;
PCF8583 p (0xA2);// the device's I2C read address on our board LiquidCrystal lcd(22, 23, 24, 25, 26, 27);

int pot1, pot2;
char potbuf[10];
int b1, tmp, b2 = 1;
int runLED = 13;
int errorLED = 15;
int recordingLED = 14;
int runButton = 12;
int ejectButton = 11;
int oldHour = -1;

void clear_row1(){
  lcd.setCursor(0, 0);
  lcd.print(" ");
  lcd.setCursor(0, 0);
}

void clear_row2(){
  lcd.setCursor(0, 1);
  lcd.print(" ");
  lcd.setCursor(0, 1);
}

void blink_runLED(){
  tmp = digitalRead(runLED);
  if (tmp == LOW)
    digitalWrite(runLED,HIGH);
  else     digitalWrite(runLED,LOW);
}

void blink_errorLED(){
  tmp = digitalRead(errorLED);
  if (tmp == LOW)
    digitalWrite(errorLED,HIGH);
  else     digitalWrite(errorLED,LOW);
}

long previousMillis = 0;
unsigned long currentMillis;

void initCard(){
  digitalWrite(runLED, HIGH);
  previousMillis = 0;
  // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with   // breadboards. use SPI_FULL_SPEED for better performance.   if (!card.init(SPI_HALF_SPEED)){
    clear_row1();
    lcd.print("Error: SD card");
    clear_row2();
    lcd.print("initialization");
    while(1 == 1){
      currentMillis = millis();
      if(currentMillis - previousMillis > 100) {
        previousMillis = currentMillis;   
        blink_errorLED();
      }    
    }
  }

  // initialize a FAT volume   if (!volume.init(&card)){
    clear_row1();
    lcd.print("Error: SD card");
    clear_row2();
    lcd.print("FAT volume");
    while(1 == 1){
      currentMillis = millis();
      if(currentMillis - previousMillis > 100) {
        previousMillis = currentMillis;   
        blink_errorLED();
      }    
    }  
  }

  // open the root directory   if (!root.openRoot(&volume)){
    clear_row1();
    lcd.print("Error: SD card");
    clear_row2();
    lcd.print("open Root");
    while(1 == 1){
      currentMillis = millis();
      if(currentMillis - previousMillis > 100) {
        previousMillis = currentMillis;   
        blink_errorLED();
      }    
    }  
  }
}

void setup(void){
  Serial.begin(9600);
  // set up the LCD's number of columns and rows:   lcd.begin(16, 2);
  pinMode(runLED, OUTPUT); // digital 13 LED   // Start up the dallas library   sensors.begin();
  // two button inputs   pinMode(ejectButton, INPUT);
  pinMode(runButton, INPUT);
  // set pull-ups on them   digitalWrite(ejectButton, HIGH);
  digitalWrite(runButton, HIGH);
  // another two LEDs   pinMode(recordingLED, OUTPUT);
  pinMode(errorLED, OUTPUT);
  digitalWrite(recordingLED, 1); // shut them off   digitalWrite(errorLED, 1);
  // ready to set timer and/or press OK button   digitalWrite(runLED, LOW);
  while(b2 == 1){
    //reading time setup from the serial console     if(Serial.available() > 0){
      Serial.println("receiving...");
      // Use of (byte) type casting and ascii math to achieve result.       p.year= (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48)) + 2000;
      p.month = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
      p.day = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
      p.hour  = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
      p.minute = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
      p.second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48));
      if(Serial.read() == ';'){
        Serial.println("setting date");
        p.set_time();
      }
    }
    // Blink runLED intermitently signaling that you must press the run button     currentMillis = millis();
    if(currentMillis - previousMillis > 250) {
      // save the last time you blinked the LED       previousMillis = currentMillis;          blink_runLED();     }     // read the real time clock     p.get_time();     // printing the date     char date[9];
    sprintf(date, "%04d/%02d/%02d",
  p.year, p.month, p.day);
    lcd.setCursor(0, 0);
    lcd.print(date);
    lcd.print(" SET");
    char time[9];
    sprintf(time, "%02d:%02d:%02d",
  p.hour, p.minute, p.second);
    //Serial.println(time);     lcd.setCursor(0, 1);
    lcd.print(time);
    lcd.print(" CLOCK");
    b2 = digitalRead(runButton);
  }
  initCard();
}

void loop(void){
  //clear_row1();   //clear_row2();   digitalWrite(runLED, LOW);
  //read potentiometers   pot1 = analogRead(0);
  pot2 = analogRead(1);
  sprintf(potbuf, "P1=%04d P2=%04d", pot1, pot2);
  clear_row1();
  lcd.print(potbuf);
  // printing the hour   p.get_time();     char time[9];
  sprintf(time, "%02d:%02d:%02d",
  p.hour, p.minute, p.second);
  //Serial.println(time);   lcd.setCursor(0, 1);
  lcd.print(time);
  lcd.print(" T:");
  // call sensors.requestTemperatures() to issue a global temperature   // request to all devices on the bus   sensors.requestTemperatures(); // Send the command to get temperatures   lcd.print(sensors.getTempCByIndex(0));
  // see if eject button was pressed   b1 = digitalRead(ejectButton);
  b2 = HIGH;
  if (b1 == LOW) {
    //clear_row1();     lcd.setCursor(0, 0);
    lcd.print("Exchange SD and");
    //clear_row2();     lcd.setCursor(0, 1);
    lcd.print("press RUN button");
    previousMillis = 0;
    while (b2 == HIGH){
      b2 = digitalRead(runButton);
      currentMillis = millis();
      if(currentMillis - previousMillis > 250) {
        previousMillis = currentMillis;   
        blink_runLED();
      }
      //     }    } // end b1 event      // let's logg the data on SD card at every hour   // here check to see if is a new hour   if(oldHour != p.hour){
    // Light the recording LED when access SD card     digitalWrite(recordingLED, LOW);
    // create or open the file (the name is year+month)     char fname[11];
    sprintf(fname, "%04d%02d.TXT", p.year, p.month);
    file.writeError = false;
    if (!file.open(&root, fname, O_CREAT | O_APPEND | O_WRITE)) {
      digitalWrite(runLED, HIGH);
      digitalWrite(recordingLED, HIGH);
      clear_row1();
      lcd.print("Error: SD card");
      clear_row2();
      lcd.print("create/open File");
      previousMillis = 0;
      while(1 == 1){
        currentMillis = millis();
        if(currentMillis - previousMillis > 100) {
          previousMillis = currentMillis;   
          blink_errorLED();
        }    
      }  
    }
  
    // write the sensors and voltage into the file     char date[9];
    sprintf(date, "%04d/%02d/%02d",
  p.year, p.month, p.day);
    file.print(date);
    file.print(" ");
    file.print(time);
    file.print(" P1=");
    file.print(pot1, DEC);
    file.print(" P2=");
    file.print(pot2, DEC);
    file.print(" T:");
    file.println(sensors.getTempCByIndex(0));
    if (file.writeError){
      digitalWrite(runLED, HIGH);
      digitalWrite(recordingLED, HIGH);
      clear_row1();
      lcd.print("Error: SD card");
      clear_row2();
      lcd.print("write to File");
      previousMillis = 0;
      while(1 == 1){
        currentMillis = millis();
        if(currentMillis - previousMillis > 100) {
          previousMillis = currentMillis;   
          blink_errorLED();
        }    
      }  
    }
  
    // close the file and reactualize the oldHour variable     if (!file.close()) {
      digitalWrite(runLED, HIGH);
      digitalWrite(recordingLED, HIGH);
      clear_row1();
      lcd.print("Error: SD card");
      clear_row2();
      lcd.print("close File");
      previousMillis = 0;
      while(1 == 1){
        currentMillis = millis();
        if(currentMillis - previousMillis > 100) {
          previousMillis = currentMillis;   
          blink_errorLED();
        }    
      }  
    }
    oldHour = p.hour;
    
    //switch OFF the recording LED     digitalWrite(recordingLED, HIGH);
   
  } // end check if is a new hour    }

4. How it works

Obligatory, you must have a battery to your RTC clock. The application permits setting the date and time via a serial terminal using the USB cable. You need to do this only once and then, every time you need to adjust the clock. Important! Remove the USB cable when you insert/remove the SD card to avoid reseting the board - in this case, you need an external Power supply. Otherwise, no problem if you get a reset. On the field, where it will be used your application, you always will have an external power supply

The application have an LCD dispaly, four LEDs and two buttons:
 - one 2x16 character LCD display - it will show error messages and any data it collects;
 - Boot LED (blue color) - will show bootloader behavior;
 - Run LED (green color) - will signal the status of program;
 - Recording LED (yellow color) - will signal when SD card access;
 - Error LED (red color) - will signal fatal errors. Usually, after such error, you must reset the board;
 - RUN button - it is some kind of OK button
 - EJECT button - it stops the program and permits safely removing the SD card.
Note: On my development board I have only two colors for LEDs.
 

When you power the board for the first time, it will show the clock and will offer you to change the date/time via a serial terminal (see the image above and, for details about setting the clock, see this page). The run LED will blink continuously. When you are done (or, if you don't need to make changes), press RUN button.  In this moment, the application will start reading the sensors and recording on the SD card:


When you need to temporary remove the SD card for reading it on a PC, press and keep pressed the eject button. A message will appear on LCD and run LED will blink, waiting you to press run button again . Then, you can release the button, remove the SD card, read it on PC (maybe also erase some files or entirely), insert it on your board again and press run button. If you formatted your SD card then, after inserting it into your board, reset the board.


All errors related to SD card are blocking errors (will stop reading and recording the sensors) and are signaled properly on LCD and Error LED. After such error, you need to reset your board (first, resolve the error cause). See them bellow:









A possible front panel can be this (only for illustration purposes - you can design a professional panel):


5. The Result

If you change the sketch to make it to record continuously (you will do this to test the program), then your file will look like this:

2011/01/01 09:25:14 P1=396 P2=835 T:23.50
2011/01/01 09:25:15 P1=396 P2=835 T:23.56
2011/01/01 09:25:16 P1=396 P2=835 T:23.56
2011/01/01 09:25:17 P1=396 P2=835 T:23.56
2011/01/01 09:25:17 P1=396 P2=835 T:23.56
2011/01/01 09:25:18 P1=396 P2=835 T:23.56
2011/01/01 09:25:19 P1=396 P2=835 T:23.56
2011/01/01 09:25:20 P1=396 P2=835 T:23.56
2011/01/01 09:25:21 P1=396 P2=835 T:23.56
2011/01/01 09:25:22 P1=396 P2=835 T:23.56
2011/01/01 09:25:22 P1=396 P2=835 T:23.56
2011/01/01 09:25:23 P1=396 P2=835 T:23.56
2011/01/01 09:25:24 P1=396 P2=835 T:23.62
2011/01/01 09:25:25 P1=396 P2=835 T:23.62

Bellow, you can see the movie (is split in many parts because I used the photo camera SD card on Sanguino logger so, I had only internal memory available for video recording).

Part 1 - setting the clock and waiting RUN button to continue the program:

Part 2 - pressing the RUN Button and... an error appears because I forgot to insert the SD card :-P  :

Part 3 - finally, running the program without other unexpected "accidents" :) . You will see that in this movie I forgot to set the date and the hour - well, it really does not matter when you just make tests. But, if you want to introduce some validations, you have enough space on ATmega644P. You also can get rid of Serial/USB clock setting and add two more buttons to set the clock from "keyboard" - the options are yours.  

So, the last target is achieved! Thanks God, relatives and friends for their help in finishing this.

ċ
logger.pde
(9k)
Vasile Guta Ciucur,
Jan 1, 2011, 2:39 AM
Comments