logger.c

无线传感器网络操作系统源代码

/*
 * @(#)LOGGER.c
 *
 * "Copyright (c) 2001 and The Regents of the University 
 * of California.  All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 * Author:  Robert Szewczyk
 *
 * $\Id$
 */

#include "tos.h"
#include "LOGGER.h"
#include "dbg.h"
// Logger states.
#define PHASE       1
#define IDLE        0
#define SEND_CMD    1
#define READ_DATA   2
#define WRITE_DATA  4
#define READ_BUFFER 6
/* Parameters for configuring the logger: */
/* The log entry is of size 2 ^ LOG_2_SIZE */

#define LOG_2_SIZE 4

#define LOG_ENTRY_SIZE (1 << LOG_2_SIZE)

/* Maximum number of log entries: 32768 / 16 => 2048 lines*/
#define LOGGER_MAX_LINES (0x8000 >> LOG_2_SIZE)

#define APPEND_ADDR_START 16

#define TOS_FRAME_TYPE LOGGER_obj_frame
TOS_FRAME_BEGIN(LOGGER_obj_frame) {
    char bufpos;
    char state;
    unsigned char cmdbuf[8];
    char *data_buf;
    char data_ptr;
    char data_len;
    int last_line;
}
TOS_FRAME_END(LOGGER_obj_frame);

void push_address(int line, char * buf) {
    *buf++ = (line << LOG_2_SIZE) & 0xff; // byte address, there is 8bytes
					  //per page that cannot be
					  //accessed. Will use for CRC, etc. 
    *buf++ = (line >> (9 - LOG_2_SIZE)) & 0xfe; //page address
    *buf++ = (line >> (17 - LOG_2_SIZE)) & 0xff; // page address
}


char TOS_COMMAND(READ_LOG) (short line, char * data) {
    if (VAR(state) == IDLE) {
	VAR(data_buf) = data;
	VAR(state) = READ_DATA | SEND_CMD;
	VAR(data_len) = LOG_ENTRY_SIZE; 
	VAR(data_ptr) = 0;
	// padding, optional
	// VAR(cmdbuf)[0] = 0;
	// VAR(cmdbuf)[1] = 0;
	// VAR(cmdbuf)[2] = 0;
	// VAR(cmdbuf)[3] = 0;
	push_address(line, &(VAR(cmdbuf)[5]));
	VAR(bufpos) = 7;
	TOS_CALL_COMMAND(LOGGER_FLASH_ENABLE)();
	if (TOS_CALL_COMMAND(LOGGER_SPI_BYTE)(0xd2)) {
	    return 1;
	} else {
	    TOS_CALL_COMMAND(LOGGER_FLASH_DISABLE)();
	}
    }
    return 0;
}

char TOS_COMMAND(APPEND_LOG) (char *data) {
    return TOS_CALL_COMMAND(WRITE_LOG)(VAR(last_line)+1, data);
}

char exec_write() {
    push_address(VAR(last_line), &(VAR(cmdbuf)[0]));
    VAR(state) = WRITE_DATA | SEND_CMD;
    VAR(bufpos) = 2;
    if (TOS_CALL_COMMAND(LOGGER_SPI_BYTE)(0x82)) {
	return 1;
    }
    return 0;
}

char read_buffer() {
    push_address(VAR(last_line), &(VAR(cmdbuf)[0]));
    VAR(state) = READ_BUFFER | SEND_CMD;
    VAR(bufpos) = 2;
    if (TOS_CALL_COMMAND(LOGGER_SPI_BYTE)(0x53)) {
	return 1;
    }
    return 0;
}    

char TOS_COMMAND(WRITE_LOG) (short line, char * data) {
    char retval = 0;
    if (VAR(state)== IDLE) {
	VAR(state) = WRITE_DATA | SEND_CMD;
	VAR(data_buf) = data;
	VAR(data_ptr) = 0;
	VAR(data_len) = LOG_ENTRY_SIZE;
	VAR(last_line) = line;
	TOS_CALL_COMMAND(LOGGER_FLASH_ENABLE)();
	if ((line >> (8 - LOG_2_SIZE)) != (VAR(last_line) >> (8 - LOG_2_SIZE))) {
	
	    retval = read_buffer();
	} else {
	    retval = exec_write();
	}

	if (retval == 0) {
	    TOS_CALL_COMMAND(LOGGER_FLASH_DISABLE)();
	}
    }
    return retval;
}

char TOS_COMMAND(LOGGER_INIT) (void) {
    VAR(state) = IDLE;
    VAR(bufpos) = -1;
    VAR(last_line) = APPEND_ADDR_START;
    TOS_CALL_COMMAND(LOGGER_SUB_INIT)();
    dbg(DBG_BOOT, ("Logger initialized.\n"));
    return 1;
}

char TOS_EVENT(LOGGER_FLASH_DISABLED) (){
    switch (VAR(state)) {
    case IDLE:
	break;
    case READ_DATA:
	VAR(state) = IDLE;
	TOS_SIGNAL_EVENT(READ_LOG_DONE) (VAR(data_buf), 1);
	break;
    case WRITE_DATA:
	VAR(state) = IDLE;
	TOS_SIGNAL_EVENT(APPEND_LOG_DONE)(1);
	break;
    case READ_BUFFER:
	TOS_CALL_COMMAND(LOGGER_FLASH_ENABLE)();
	exec_write();
	break;
    default:
	VAR(state) = IDLE;
	break;
    }
    return 0;
}

char TOS_EVENT(LOGGER_SPI_BYTE_DONE) (unsigned char in) {
    dbg(DBG_LOG, ("LOGGER: byte received: %02x, STATE: %02x, CMD COUNT: %d, DATA COUNT: %d \n", in&0xff, VAR(state), VAR(bufpos), VAR(data_ptr)));
    
    if ((VAR(state) & PHASE) == SEND_CMD) {
	dbg(DBG_LOG, ( "LOGGER: Byte sent: %02x\n", VAR(cmdbuf)[VAR(bufpos)]));
	TOS_CALL_COMMAND(LOGGER_SPI_BYTE)(VAR(cmdbuf)[(int)VAR(bufpos)]);
	VAR(bufpos)--;
	if (VAR(bufpos) < 0) {
	    VAR(state) &= ~PHASE;
	}
    } else if (VAR(state) == READ_DATA) {
	VAR(data_buf)[(int)VAR(data_ptr)] = in;
	VAR(data_ptr)++;
	if (VAR(data_ptr) < VAR(data_len)) 
	    TOS_CALL_COMMAND(LOGGER_SPI_BYTE)(0);
	else {
	    TOS_CALL_COMMAND(LOGGER_FLASH_DISABLE)();
	}
    } else if (VAR(state) == WRITE_DATA) {
	dbg(DBG_LOG, ( "LOGGER: Byte sent: %02x\n", VAR(data_buf)[VAR(data_ptr)]));
	if (VAR(data_ptr) < VAR(data_len)) {
	    TOS_CALL_COMMAND(LOGGER_SPI_BYTE) (VAR(data_buf)[(int)VAR(data_ptr)]);
	} else {
	    TOS_CALL_COMMAND(LOGGER_FLASH_DISABLE)();
	}
	VAR(data_ptr)++;
    } else if (VAR(state) == READ_BUFFER) {
	TOS_CALL_COMMAND(LOGGER_FLASH_DISABLE)();
    }
    return 1;
}