First Commit

Logger.cpp

@@ -0,0 +1,188 @@
+/*
+  Logger.cpp - Library for formatting and writing data to various outputs.
+  Created by Derek Chafin, December 5, 2011
+  Released into the public domain.
+*/
+
+#include "Arduino.h"
+#include "Logger.h"
+#include <LoggerSD.h>
+
+#define CS 4
+
+
+Logger::Logger(log_outputs output, data_formats format, boolean add_line_break)
+{
+  _output = output;
+  _format = format;
+  _add_line_break = add_line_break;
+  _filename = "LOGGER00.CSV";
+}
+
+int Logger::init()
+{
+  int result;
+
+  switch(_output)
+  {
+    case SD_OUTPUT:
+    result = initSD();
+    break;
+    case SERIAL_OUTPUT:
+    result = initSerial();
+    break;
+  }
+
+  return result;
+}
+
+int Logger::initSD()
+{
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+  //Hardware SS pin on the Arduino Mega is pin 53
+  pinMode(53, OUTPUT);
+#else
+  pinMode(10, OUTPUT);
+#endif
+
+  if (!SD.begin(CS)) {
+    return 1;
+  }
+
+    // create a new file  
+  for (uint8_t i = 0; i < 100; i++) {
+    _filename[6] = i/10 + '0';
+    _filename[7] = i%10 + '0';
+    if (!SD.exists(_filename)) { 
+      break;  // leave the loop!
+    }
+  }
+
+  _file = SD.open(_filename, FILE_WRITE);
+
+  return 0;
+}
+
+int Logger::initSerial()
+{
+  return 0;
+}
+
+void Logger::checkAddLineBreak()
+{
+  if (_format != BINARY)
+  {
+    if (_add_line_break)
+    {
+      switch(_output)
+      {
+        case SD_OUTPUT:
+        _file.println("");
+        break;
+        case SERIAL_OUTPUT:
+        Serial.println("");
+        break;
+      }
+    }
+    else
+    {
+      switch(_output)
+      {
+        case SD_OUTPUT:
+        _file.print(',');
+        break;
+        case SERIAL_OUTPUT:
+        Serial.print(',');
+        break;
+      }
+    }
+
+  }
+}
+
+void Logger::logAsciiByte(byte data)
+{  
+    switch(_output)
+    {
+      case SD_OUTPUT:      
+        _file.print(data, DEC);
+        break;
+      case SERIAL_OUTPUT:
+        Serial.print(data, DEC);
+        break;
+    }
+}
+
+void Logger::logBinary(byte data)
+{
+  switch(_output)
+  {
+    case SD_OUTPUT:      
+      _file.write(data);
+      break;
+    case SERIAL_OUTPUT:
+      Serial.write(data);
+      break;
+  }
+}
+
+void Logger::logAsciiBoolean(byte data)
+{
+  for (int i=0; i < 8; i++)
+  {
+    switch(_output)
+    {
+      case SD_OUTPUT:      
+        _file.print(bitRead(data, i), DEC);
+        break;
+      case SERIAL_OUTPUT:
+        Serial.print(bitRead(data, i), DEC);
+        break;
+    }
+  }
+}
+
+void Logger::logData(byte data)
+{
+  static int sync_counter = 0;
+
+  switch(_format)
+  {
+    case ASCII_BYTE:
+      logAsciiByte(data);
+    break;
+    case BINARY:
+      logBinary(data);
+    break;
+    case ASCII_BOOL:
+      logAsciiBoolean(data);
+    break;
+  }
+
+  checkAddLineBreak();
+
+  if (_output == SERIAL_OUTPUT)
+  {
+    Serial.flush();
+  }
+
+  if (_output == SD_OUTPUT)
+  {
+    sync_counter++;
+    if (sync_counter >= 2048)
+    {
+      _file.flush();
+      sync_counter = 0;
+    }
+  }
+}
+
+// void Logger::logData(int data)
+// {
+
+// }
+
+// void Logger::logData(long data)
+// {
+
+// }

Logger.h

@@ -0,0 +1,47 @@
+/*
+  Logger.h - Library for formatting and writing data to various outputs.
+  Created by Derek Chafin, December 5, 2011
+  Released into the public domain.
+*/
+
+#ifndef Logger_h
+#define Logger_h
+
+#include "Arduino.h"
+#include <LoggerSD.h>
+
+enum log_outputs
+{
+  SERIAL_OUTPUT,
+  SD_OUTPUT
+};
+
+enum data_formats
+{
+  ASCII_BYTE,
+  BINARY,
+  ASCII_BOOL
+};
+
+class Logger
+{
+  public:
+    Logger(log_outputs output, data_formats format, boolean add_line_break);
+    void logData(byte data);
+    int init();
+//    void logData(int data);
+//    void logData(long data);
+  private:    
+    int initSD();
+    int initSerial();
+    void checkAddLineBreak();
+    void logAsciiByte(byte data);
+    void logBinary(byte data);
+    void logAsciiBoolean(byte data);
+    char* _filename;
+    File _file;
+    log_outputs _output;
+    data_formats _format;
+    boolean _add_line_break;
+};
+#endif

LoggerFile.cpp

@@ -0,0 +1,150 @@
+/*
+
+ SD - a slightly more friendly wrapper for sdfatlib
+
+ This library aims to expose a subset of SD card functionality
+ in the form of a higher level "wrapper" object.
+
+ License: GNU General Public License V3
+          (Because sdfatlib is licensed with this.)
+
+ (C) Copyright 2010 SparkFun Electronics
+
+ */
+
+#include <LoggerSD.h>
+
+/* for debugging file open/close leaks
+   uint8_t nfilecount=0;
+*/
+
+File::File(SdFile f, const char *n) {
+  // oh man you are kidding me, new() doesnt exist? Ok we do it by hand!
+  _file = (SdFile *)malloc(sizeof(SdFile)); 
+  if (_file) {
+    memcpy(_file, &f, sizeof(SdFile));
+
+    strncpy(_name, n, 12);
+    _name[12] = 0;
+
+    /* for debugging file open/close leaks
+       nfilecount++;
+       Serial.print("Created \"");
+       Serial.print(n);
+       Serial.print("\": ");
+       Serial.println(nfilecount, DEC);
+    */
+  }
+}
+
+File::File(void) {
+  _file = 0;
+  _name[0] = 0;
+  //Serial.print("Created empty file object");
+}
+
+File::~File(void) {
+  //  Serial.print("Deleted file object");
+}
+
+// returns a pointer to the file name
+char *File::name(void) {
+  return _name;
+}
+
+// a directory is a special type of file
+boolean File::isDirectory(void) {
+  return (_file && _file->isDir());
+}
+
+
+size_t File::write(uint8_t val) {
+  return write(&val, 1);
+}
+
+size_t File::write(const uint8_t *buf, size_t size) {
+  size_t t;
+  if (!_file) {
+    setWriteError();
+    return 0;
+  }
+  _file->clearWriteError();
+  t = _file->write(buf, size);
+  if (_file->getWriteError()) {
+    setWriteError();
+    return 0;
+  }
+  return t;
+}
+
+int File::peek() {
+  if (! _file) 
+    return 0;
+
+  int c = _file->read();
+  if (c != -1) _file->seekCur(-1);
+  return c;
+}
+
+int File::read() {
+  if (_file) 
+    return _file->read();
+  return -1;
+}
+
+// buffered read for more efficient, high speed reading
+int File::read(void *buf, uint16_t nbyte) {
+  if (_file) 
+    return _file->read(buf, nbyte);
+  return 0;
+}
+
+int File::available() {
+  if (! _file) return 0;
+
+  uint32_t n = size() - position();
+
+  return n > 0X7FFF ? 0X7FFF : n;
+}
+
+void File::flush() {
+  if (_file)
+    _file->sync();
+}
+
+boolean File::seek(uint32_t pos) {
+  if (! _file) return false;
+
+  return _file->seekSet(pos);
+}
+
+uint32_t File::position() {
+  if (! _file) return -1;
+  return _file->curPosition();
+}
+
+uint32_t File::size() {
+  if (! _file) return 0;
+  return _file->fileSize();
+}
+
+void File::close() {
+  if (_file) {
+    _file->close();
+    free(_file); 
+    _file = 0;
+
+    /* for debugging file open/close leaks
+    nfilecount--;
+    Serial.print("Deleted ");
+    Serial.println(nfilecount, DEC);
+    */
+  }
+}
+
+File::operator bool() {
+  if (_file) 
+    return  _file->isOpen();
+  return false;
+}
+