반응형
지금까지 길게 했지만 오늘 하는것이 핵심이다.
오늘 하고 싶은것은
1초 마다 데이터를 취득해서 저장 할것이다.
물론 하드웨어가 허용하는 한도에서 시간을 줄여 0.5초 0.3초 마다 저장도 할 수 있을것 같다,
그런데 그것이 중요한것은 아니다.
1개 파일에 저장하고 그 파일의 용량이 어느정도, 정한 용량까지 기록하면
다음파일에 기록하고, 다시 다음파일에 기록하고 싶다.
물론 파일개수는 정해진 개수만큼 기록을 할 것이다.
여기소스에서는 1024 *1024 바이트, 즉 1메가 단위로 기록한다.
파일 개수는 1000개로 했다.
물론 소스코드에서 본인이 적당히 수정해도 된다.
일단은 클래스로 분리했고 오늘 부터 하나 하나씩 공부하기로 하자.
일단 소스코드 부터 보자.
|
#include "SystemLog.h"
#include <SPI.h>
#include <SD.h>
#define version 0x01
#define check 0xFF
typedef struct _Info
{
char ver;
float Temp[5];
char chk;
_Info()
{
ver = version;
chk = check;
memset(Temp, 0x00, sizeof(float)*5);
}
}Info;
void read_temp(Info& _info);
void print_temp(Info& _info);
Info adcinfo;
CSystemLog sdlog;
volatile int i =0 ;
volatile unsigned long previousMillis;
void setup()
{
Serial.begin(9600);
while (!Serial)
{
; // wait for serial port to connect. Needed for native USB port only
}
sdlog.initialize();
previousMillis = millis();
}
void loop()
{
unsigned long currentMillis = millis();
if ((currentMillis-previousMillis)> 1000*1)
{
read_temp(adcinfo);
if (1)
{
char buf[100];
print_temp(adcinfo, buf);
Serial.print(buf);
sdlog<<i<<buf;
previousMillis = currentMillis;
if(i > 1000) i = 0;
else i++;
}
else
{
Serial.println("error opening test.txt");
}
}
delay(100);
}
void read_temp(Info& _info)
{
for(int i =0; i<5;i++)
{
_info.Temp[i] = analogRead (A0+i); // A0의 값을 불러옵니다.
_info.Temp[i] *= 5.0 / 10.24; //온도값을 계산하는 공식입니다.
}
return ;
}
void print_temp(Info& _info, char* p)
{
p+= sprintf(p, "Temperature: ");
for(int i =0; i<5;i++)
{
p+= sprintf(p, "%s", String(_info.Temp[i],2).c_str());
p+= sprintf(p, "C, ");
}
p+= sprintf(p, "\n");
return ;
}
#ifndef SYSTEM_LOG_CLASS
#define SYSTEM_LOG_CLASS
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
#include <SPI.h>
#include <SD.h>
class CLogFileStream
{
public:
CLogFileStream();
~CLogFileStream();
private:
const int maxfile = 1000;
public:
operator bool();
int logindex;
public:
bool is_open();
void initialize();
void write(const char* out, int bytes);
void file_Initial();
void file_lotate();
friend CLogFileStream& operator << (CLogFileStream& o, const int v);
friend CLogFileStream& operator << (CLogFileStream& o, const String& v);
friend CLogFileStream& operator << (CLogFileStream& o, const char* v);
public:
// template <class T> friend CLogFileStream& operator<< (CLogFileStream& o,const T& v)
// {
// int len = sizeof(T);
// o.write(&v, len);
// return o;
// }
static bool file_check(char* pLogFile);
static void file_remove(char* pLogFile);
static bool file_limit(char* pLogFile);
static uint32_t filesize(char* pLogFile);
private:
bool b_open;
File myFile;
};
class CSystemLog
{
public:
CSystemLog();
~CSystemLog();
private:
CLogFileStream pLogFileStream;
public:
void initialize();
public:
friend CSystemLog& operator << (CSystemLog& o, const char* v);
friend CSystemLog& operator << (CSystemLog& o, const int v);
public:
// template <class T> friend CSystemLog& operator<< (CSystemLog& o,const T& v)
// {
// if (o.pLogFileStream)
// {
// o.file_Initial();
// o.pLogFileStream << v;
// }
// return o;
// }
};
#endif
#include "SystemLog.h"
#define LZG_ENDL "\r\n"
#define SYSTEM_LOG "text"
CLogFileStream::CLogFileStream()
{
logindex =-1;
b_open = false;
}
CLogFileStream::~CLogFileStream()
{
}
void CLogFileStream::initialize()
{
Serial.println("Initializing SD card...");
if (!SD.begin(10))
{
Serial.println("initialization failed!");
while (1);
}
Serial.println("initialization done.");
b_open = true;
}
bool CLogFileStream::is_open()
{
return b_open;
}
CLogFileStream::operator bool()
{
return is_open();
}
void CLogFileStream::write(const char* v, int bytes)
{
if(is_open())
{
char pLogFile[25];
sprintf(pLogFile, "%s.%03d",SYSTEM_LOG, logindex);
myFile = SD.open(pLogFile, FILE_WRITE);
myFile.print(v);
myFile.close();
}
}
bool CLogFileStream::file_limit(char* pLogFile)
{
uint32_t limit_size = (uint32_t)1024* (uint32_t)1024*1;
if( filesize(pLogFile) > limit_size)
{
return true;
}
return false;
}
void CLogFileStream::file_Initial()
{
file_lotate();
char pLogFile[25];
sprintf(pLogFile, "%s.%03d",SYSTEM_LOG, logindex);
if (CLogFileStream::file_limit(pLogFile)) CLogFileStream::file_remove(pLogFile);
return;
}
void CLogFileStream::file_lotate()
{
char pLogFile[25];
if(logindex < 0)
{
int i;
for(i=0; i < maxfile; i++)
{
sprintf(pLogFile, "%s.%03d", SYSTEM_LOG, i);
if (CLogFileStream::file_limit(pLogFile)) continue;
break;
}
if(i==maxfile) logindex = 0;
else logindex = i;
}
else
{
sprintf(pLogFile, "%s.%03d",SYSTEM_LOG, logindex);
if (CLogFileStream::file_limit(pLogFile)) logindex++;
}
return;
}
bool CLogFileStream::file_check(char* pLogFile)
{
if (SD.exists(pLogFile)) return true;
return false;
}
void CLogFileStream::file_remove(char* pLogFile)
{
if (SD.exists(pLogFile)) SD.remove(pLogFile);
return false;
}
uint32_t CLogFileStream::filesize(char* pLogFile)
{
if (SD.exists(pLogFile))
{
File _file = SD.open(pLogFile, FILE_READ);
uint32_t t = _file.size();
_file.close();
//Serial.println(t);
return t;
}
return 0;
}
CLogFileStream& operator << (CLogFileStream& o, const int v)
{
char buf[32];
int len = sprintf(buf, "%d ", v);
o.write(buf, len);
return o;
}
CLogFileStream& operator << (CLogFileStream& o, const String& v)
{
o.write(v.c_str(), v.length());
return o;
}
CLogFileStream& operator << (CLogFileStream& o, const char* v)
{
o.write(v, strlen(v));
return o;
}
/////////////////////////////////////////////////////////////////////////
CSystemLog::CSystemLog()
{
}
CSystemLog::~CSystemLog()
{
}
void CSystemLog::initialize()
{
pLogFileStream.initialize();
}
CSystemLog& operator << (CSystemLog& o, const char* v)
{
if (o.pLogFileStream)
{
o.pLogFileStream.file_Initial();
o.pLogFileStream <<v;
}
return o;
}
CSystemLog& operator << (CSystemLog& o, const int v)
{
if (o.pLogFileStream)
{
o.pLogFileStream.file_Initial();
o.pLogFileStream <<v;
}
return o;
}
|
댓글