M U S T A N G - I N S I D E

Code: Alles auswählen

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <RTClib.h>
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
/*
   This sample code demonstrates the normal use of a TinyGPS++ (TinyGPSPlus) object.
   It requires the use of SoftwareSerial, and assumes that you have a
   57600-baud serial GPS device hooked up on pins 4(rx) and 5(tx).
*/

static const int RXPin = 4, TXPin = 5;
static const uint32_t GPSBaud = 9600;

// A simple data logger for the Arduino analog pins

// how many milliseconds between grabbing data and logging it. 1000 ms is once a second

#define LOG_INTERVAL  500 // mills between entries (reduce to take more/faster data)

// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to 
// the last 10 reads if power is lost but it uses less power and is much faster!

#define SYNC_INTERVAL 10*LOG_INTERVAL // mills between calls to flush() - to write data to the card
uint32_t syncTime = 0; // time of last sync()


#define ECHO_TO_SERIAL   1 // echo data to serial port
#define WAIT_TO_START    0 // Wait for serial input in setup()

// the digital pins that connect to the LEDs
#define redLEDpin 2
#define greenLEDpin 3

// The analog pins that connect to the sensors
const int afrpin=A3;

unsigned long Time;
char timestamp[30];

// The TinyGPS++ object
TinyGPSPlus gps;

// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);


RTC_DS1307 RTC; // define the Real Time Clock object

// for the data logging shield, we use digital pin 10 for the SD cs line
const int chipSelect = 10;

// the logging file
File logfile;

void error(char *str)
{
  Serial.print("error: ");
  Serial.println(str);
  
  // red LED indicates error
  digitalWrite(redLEDpin, HIGH);

  while(1);
}

//------------------------------------------------------------------------------
// call back for file timestamps
void dateTime(uint16_t* date, uint16_t* time) {
 DateTime now = RTC.now();
// sprintf(timestamp, "%02d:%02d:%02d %2d/%2d/%2d \n", now.hour(),now.minute(),now.second(),now.month(),now.day(),now.year()-2000);
// Serial.println("yy");
// Serial.println(timestamp);
 // return date using FAT_DATE macro to format fields
 *date = FAT_DATE(now.year(), now.month(), now.day());

 // return time using FAT_TIME macro to format fields
 *time = FAT_TIME(now.hour()-2, now.minute(), now.second());
}
//------------------------------------------------------------------------------


void setup(void)
{
  Serial.begin(115200);
  Serial.println();
  ss.begin(GPSBaud);
    
  // use debugging LEDs
  pinMode(redLEDpin, OUTPUT);
  pinMode(greenLEDpin, OUTPUT);
  
#if WAIT_TO_START
  Serial.println("Type any character to start");
  while (!Serial.available());
#endif //WAIT_TO_START

 // connect to RTC
  Wire.begin();  
  if (!RTC.begin()) {
    logfile.println("RTC failed");
#if ECHO_TO_SERIAL
    Serial.println("RTC failed");
#endif  //ECHO_TO_SERIAL
  }

// set date time callback function
 SdFile::dateTimeCallback(dateTime);

  // initialize the SD card
  Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    error("Card failed, or not present");
  }
  Serial.println("card initialized.");
  
  // create a new file
  char filename[] = "AFR00.CSV";
  for (uint8_t i = 0; i < 100; i++) {
    filename[3] = i/10 + '0';
    filename[4] = i%10 + '0';
    if (! SD.exists(filename)) {
      // only open a new file if it doesn't exist
      logfile = SD.open(filename, FILE_WRITE); 
      break;  // leave the loop!
    }
  }
  
  if (! logfile) {
    error("couldnt create file");
  }
  
  Serial.print("Logging to: ");
  Serial.println(filename);

 logfile.println("time;  afr; kmph");
      
#if ECHO_TO_SERIAL
    Serial.println("time;  afr;  kmph");
#endif //ECHO_TO_SERIAL
 
// If you want to set the aref to something other than 5v
//  analogReference(EXTERNAL);
}
int afr = 0;
int afr_alt = 0;

void loop(void)

{
  //GPS auslesen
  while (ss.available() > 0)
    gps.encode(ss.read());
 
  analogRead(afrpin);
  int afr = analogRead(afrpin);
  //glaetten
  afr = (afr + afr_alt)/2;
  
  // fetch the time
  Time=millis()/100;
  
  // log time if afr and GPS is valid
  if (afr>102 && afr<921 && gps.location.isUpdated())
  {
      digitalWrite(greenLEDpin, HIGH);
      logfile.print('"');
      logfile.print(Time);
      logfile.print('"');

      #if ECHO_TO_SERIAL
        Serial.print('"');
        Serial.print(Time);
        Serial.print('"');
      #endif //ECHO_TO_SERIAL
  }
    
smartDelay(500);  

//Umrechnungsformeln
  double afr_Volt = 5.0 / 1023.0 * (float)afr;
  double afr_Wert = (2.3750 * afr_Volt)+7.3125;
  afr_alt = afr;
  
  if (afr>102 && afr<921 && gps.location.isUpdated())
  {
      logfile.print("; ");    
      logfile.print(afr_Wert);
      logfile.print("; ");
           
    #if ECHO_TO_SERIAL
      Serial.print(";    ");
      Serial.print(afr_Wert);
      Serial.print(";    ");      
    #endif //ECHO_TO_SERIAL
  }
  
if (afr>102 && afr<921 && gps.location.isUpdated())
  { 
    logfile.println(gps.speed.kmph(), 0);

    #if ECHO_TO_SERIAL
        Serial.print(gps.speed.kmph(), 0);
        Serial.println();
    #endif //ECHO_TO_SERIAL
  }  
  digitalWrite(greenLEDpin, LOW);

  // Now we write data to disk! Don't sync too often - requires 2048 bytes of I/O to SD card
  // which uses a bunch of power and takes time
  if ((millis() - syncTime) < SYNC_INTERVAL) return;
  syncTime = millis();
  
  // blink LED to show we are syncing data to the card & updating FAT!
  digitalWrite(redLEDpin, HIGH);
  logfile.flush();
  digitalWrite(redLEDpin, LOW);


  if (millis() > 5000 && gps.charsProcessed() < 10)
  {
     Serial.println(F("No GPS data received: check wiring"));
     digitalWrite(greenLEDpin, LOW);
     digitalWrite(redLEDpin, LOW);
  }
   
}

// This custom version of delay() ensures that the gps object
// is being "fed".
static void smartDelay(unsigned long ms)
{
    unsigned long start = millis();
    do 
    {
        while (ss.available())
        gps.encode(ss.read());
    }   while (millis() - start < ms);
}