log.c

myTemp is used to connect PalmOS PDAs to Dallas Microlan(tm) Devices. It currently supports DS1820

#include <PalmOS.h>
#include "com.h"
#include "log.h"

#define kLogDbName	"myTempLog-TemP"

typedef struct {

} MyTempAppInfoT;

typedef struct {
	UInt16	nextRecord;
	UInt16	numEntries;
} RecordInfoT;

void packBytes(UInt8*, UInt8*, UInt16);
void unpackBytes(UInt8*, UInt8*, UInt16);
Boolean	InitRecord(DmOpenRef, UInt16);
UInt16 LogEntriesGetInfo(DmOpenRef, UInt16, RecordInfoT*);
UInt16 LogGetActiveRecord(DmOpenRef);
UInt16 AddNewRecord(DmOpenRef, UInt16);

Boolean LogOpenOrCreateDatabase(DmOpenRef* logDb, UInt16 mode)
{
	Err	err;
	UInt16	recordNum = 0;
	
	*logDb = DmOpenDatabaseByTypeCreator(kLogType, kMyTempID, mode);
	
	if (!*logDb)
	{
		err = DmCreateDatabase(0, kLogDbName, kMyTempID, kLogType, false);
		if (err)
		{
			return true;
		}
		*logDb = DmOpenDatabaseByTypeCreator(kLogType, kMyTempID, dmModeReadWrite);

/*
	init the database: write recordInfo
*/
/*
	discard return value
*/
		DmNewRecord(*logDb, &recordNum, sizeof(RecordInfoT));
		err = DmReleaseRecord(*logDb, recordNum, false);
		ErrNonFatalDisplayIf(err == dmErrIndexOutOfRange, "index out of range while releasing record");
		InitRecord(*logDb, recordNum);

		err = DmCloseDatabase(*logDb);
		*logDb = DmOpenDatabaseByTypeCreator(kLogType, kMyTempID, mode);
		if (!*logDb)
		{
			ErrNonFatalDisplayIf(!logDb, "error creating database");
			return true;
		}
	}
	return false;
}

Boolean OpenDatabase(DmOpenRef* logDb, UInt16 mode)
{
	*logDb = DmOpenDatabaseByTypeCreator(kLogType, kMyTempID, mode);
	
	if (!logDb)
	{
		ErrDisplay("error opening database");
		return true;
	}
	return false;
}

Boolean LogCloseDatabase(DmOpenRef logDb)
{
	Err	err;

	err = DmCloseDatabase(logDb);
	ErrNonFatalDisplayIf(err, "Error closing Database");

	return false;
}

Boolean	InitRecord(DmOpenRef logDb, UInt16 record)
{
	Err		err;
	UInt8	packedInfo[sizeof(RecordInfoT)];
	RecordInfoT	recordInfo;
	MemHandle	logRecordHandle;
	MemPtr		logRecordPtr;
	
	recordInfo.nextRecord = 0;
	recordInfo.numEntries = 0;
	
	packBytes(packedInfo, (UInt8*)&recordInfo, sizeof(recordInfo));
	logRecordHandle = DmGetRecord(logDb, record);
	logRecordPtr = MemHandleLock(logRecordHandle);
	DmWrite(logRecordPtr, 0, packedInfo, sizeof(RecordInfoT));
	MemHandleUnlock(logRecordHandle);
	
	err = DmReleaseRecord(logDb, record, true);
	ErrNonFatalDisplayIf(err == dmErrIndexOutOfRange, "index out of range while releasing record");
	return false;
}

void packBytes(UInt8* bytes, UInt8* source, UInt16 num)
{
	UInt16	i;
	
	for (i = 0; i < num; i++)
	{
		bytes[i] = source[i];
	}
}

void unPackBytes(UInt8* target, UInt8* bytes, UInt16 num)
{
	UInt16	i;
	
	for (i = 0; i < num; i++)
	{
		target[i] = bytes[i];
	}
}

UInt16	LogEntriesGetInfo(DmOpenRef logDb, UInt16 record, RecordInfoT* recordInfoPtr)
{
	MemHandle	logRecordHandle;
	MemPtr	logRecordPtr;
	
	logRecordHandle = DmQueryRecord(logDb, record);
	logRecordPtr = MemHandleLock(logRecordHandle);
	unPackBytes((UInt8*)recordInfoPtr, logRecordPtr, sizeof(RecordInfoT));
	MemHandleUnlock(logRecordHandle);
	
	return recordInfoPtr->numEntries;
}

Boolean WriteLogEntry(DmOpenRef logDb, LogEntryT logEntry)
{
	Err		err;
	UInt8	packedEntry[sizeof(LogEntryT)];
	UInt8	packedInfo[sizeof(RecordInfoT)];
	UInt16	record = LogGetActiveRecord(logDb);
	MemHandle	logRecordHandle;
	MemPtr	logRecordPtr;
	RecordInfoT	recordInfo;
	
	ErrNonFatalDisplayIf(!logDb, "database not available");
	
	packBytes(packedEntry, (UInt8*)&logEntry, sizeof(logEntry));
	
	LogEntriesGetInfo(logDb, record, &recordInfo);
	if (recordInfo.numEntries >= 8000)
	{
		record = AddNewRecord(logDb, record);
		LogEntriesGetInfo(logDb, record, &recordInfo);
	}
	
	logRecordHandle = DmResizeRecord(logDb, record, (recordInfo.numEntries + 1) * sizeof(LogEntryT) + sizeof(RecordInfoT));
	ErrNonFatalDisplayIf(!logRecordHandle, "no space left in record");
	
	logRecordHandle = DmGetRecord(logDb, record);
	logRecordPtr = MemHandleLock(logRecordHandle);

	DmWrite(logRecordPtr, sizeof(RecordInfoT) + recordInfo.numEntries * sizeof(LogEntryT), packedEntry, sizeof(LogEntryT));

	recordInfo.numEntries++;
	packBytes(packedInfo, (UInt8*)&recordInfo, sizeof(recordInfo));
	DmWrite(logRecordPtr, 0, packedInfo, sizeof(RecordInfoT));
	
	MemHandleUnlock(logRecordHandle);
	
	err = DmReleaseRecord(logDb, record, true);
	ErrNonFatalDisplayIf(err == dmErrIndexOutOfRange, "index out of range while releasing record");
	return false;
}

Boolean LogData(UInt8 sensor, UInt32 time, Int16 temp)
{
	DmOpenRef	logDb;
	LogEntryT	logEntry;
	
	logEntry.sensorNum = sensor;
	logEntry.time = time;
	logEntry.temp = temp;
	
	OpenDatabase(&logDb, dmModeReadWrite);
	WriteLogEntry(logDb, logEntry);
	LogCloseDatabase(logDb);

	return true;
}

void LogGetEntry(DmOpenRef logDb, UInt16 record, UInt16 entryNum, LogEntryT* entry)
{
	MemHandle	logRecordHandle;
	MemPtr		logRecordPtr;
	volatile Err err;

	logRecordHandle = DmQueryRecord(logDb, record);
	if (logRecordHandle == NULL)
	{
		err = DmGetLastErr();
	}
	logRecordPtr = MemHandleLock(logRecordHandle);
	
	unPackBytes((UInt8*)entry, logRecordPtr + sizeof(RecordInfoT) + entryNum * sizeof(LogEntryT), sizeof(LogEntryT));
	MemHandleUnlock(logRecordHandle);
}

void LogGetLastEntry(DmOpenRef logDb, LogEntryT* entry)
{
	UInt16	record = LogGetActiveRecord(logDb);
	volatile UInt16	entryNum = LogGetNumEntries(logDb, record);
	
	if (entryNum < 1)	
		return;
	else
		LogGetEntry(logDb, record, entryNum - 1, entry);
}

UInt16 LogGetNumEntries(DmOpenRef logDb, UInt16 record)
{
	RecordInfoT	recordInfo;
	
	LogEntriesGetInfo(logDb, record, &recordInfo);
	return recordInfo.numEntries;
}

UInt16 LogGetMinMaxEntry(DmOpenRef logDb, LogEntryT* minEntry, LogEntryT* maxEntry)
{
	UInt16	numEntries;
	UInt16	i;
	UInt16	j;
	LogEntryT	entry;
	
	minEntry->time = -1;
	minEntry->temp = 13000;
	maxEntry->time = 0;
	maxEntry->temp = 0;
	
	for (j = 0; j < DmNumRecords(logDb); j++)
	{
		numEntries = LogGetNumEntries(logDb, j);
		for (i = 0; i < numEntries; i++)
		{
			LogGetEntry(logDb, j, i, &entry);
			if (entry.time < minEntry->time)
			{
				minEntry->time = entry.time;
			}
			if (entry.temp < minEntry->temp)
			{
				minEntry->temp = entry.temp;
			}
			if (entry.time > maxEntry->time)
			{
				maxEntry->time = entry.time;
			}
			if (entry.temp > maxEntry->temp)
			{
				maxEntry->temp = entry.temp;
			}
		}
	}
	return 0;
}

UInt16 LogGetNumRecords(DmOpenRef logDb)
{
	return DmNumRecords(logDb);
}

Boolean LogClearLog(void)
{
	Err			err;
	DmOpenRef	logDb;
	UInt16		recordNum = 0;
	
	OpenDatabase(&logDb, dmModeReadWrite);
	
	do
	{
		DmRemoveRecord(logDb, recordNum);
	} 
	while (DmNumRecords(logDb) != 0);
	
	recordNum = dmMaxRecordIndex;
	DmNewRecord(logDb, &recordNum, sizeof(RecordInfoT));
	err = DmReleaseRecord(logDb, recordNum, false);
	ErrNonFatalDisplayIf(err == dmErrIndexOutOfRange, "index out of range while releasing record");
	InitRecord(logDb, recordNum);
	LogCloseDatabase(logDb);
	return true;
}

UInt16 LogGetActiveRecord(DmOpenRef logDb)
{
	RecordInfoT	recordInfo;
	UInt16	record;
	recordInfo.nextRecord = 0;
	
	do
	{
		record = recordInfo.nextRecord;
		LogEntriesGetInfo(logDb, record, &recordInfo);
	} 
	while (recordInfo.nextRecord != 0);

	return record;
}

UInt16 AddNewRecord(DmOpenRef logDb, UInt16	oldRecord)
{
	Err	err;
	UInt16	newRecord = dmMaxRecordIndex;
	RecordInfoT	recordInfo;
	MemHandle	oldRecordHandle;
	MemPtr	oldRecordPtr;
	UInt8	packedInfo[sizeof(RecordInfoT)];
	
	LogEntriesGetInfo(logDb, oldRecord, &recordInfo);
	
	DmNewRecord(logDb, &newRecord, sizeof(RecordInfoT));
	err = DmReleaseRecord(logDb, newRecord, false);
	ErrNonFatalDisplayIf(err == dmErrIndexOutOfRange, "index out of range while releasing record");
	InitRecord(logDb, newRecord);
	recordInfo.nextRecord = newRecord;

	oldRecordHandle = DmGetRecord(logDb, oldRecord);
	oldRecordPtr = MemHandleLock(oldRecordHandle);
	packBytes(packedInfo, (UInt8*)&recordInfo, sizeof(recordInfo));
	DmWrite(oldRecordPtr, 0, packedInfo, sizeof(RecordInfoT));
	MemHandleUnlock(oldRecordHandle);
	DmReleaseRecord(logDb, oldRecord, true);
	
	return newRecord;
}