command.c

Go to the documentation of this file.

/*
 * Command description and interfacing for Sensor Control
 * (c) 2007 by Matthias Arndt <matthias.arndt@tu-clausthal.de>
 *
 */
#include "t89c51cc02.h"
#include "datatypes.h"
#include "command.h"
#include "eeprom.h"

LONG readenable;

LONG monitor;

LONG monitor_direction;

volatile bit reporting;
volatile bit timecheck;

volatile bit read_eeprom_config;
volatile bit write_eeprom_config;

BYTE report,report_reload;

WORD idata monitor_boundary[NR_SENSORS];

const unsigned long code masks[] = { 0x00001,0x00002,0x00004,0x00008,0x00010,0x00020,
                                  0x00040,0x00080,0x00100,0x00200,0x00400,0x00800,
                                  0x01000,0x02000,0x04000,0x08000,0x10000,0x20000};

void Command_SetRead(BYTE marker)
{
        if((marker>=0)&&(marker<NR_SENSORS))
                readenable |= masks[marker]; /* set bit */
}

void Command_EnableReport(BYTE timeframes)
{
        reporting=1;
        report=timeframes;
        report_reload=timeframes;
}

BYTE Command_ReportDue()
{
        BYTE retval;
        retval=0;
        if(reporting)
        {
                /* reports can only be due when reporting has been enabled */
                if(report_reload==0)
                {
                        /* skip some code if there is a report request for every frame */
                        retval=0xff;
                } else {
                        /* else: count number of time frames elapsed */
                        report--;
                        if(report==0)
                        {
                                report=report_reload;   /* restart timeframe counter */
                                retval=0xff;
                        }
                }
        }
        return(retval);
}

void Command_EnableMonitor(BYTE marker,WORD boundary,bit direction)
{
        if((marker>=0)&&(marker<NR_SENSORS))
        {
                monitor |= masks[marker]; /* mark sensor as monitored */
                monitor_boundary[marker]=boundary; /* apply boundary */

                monitor_direction &= ~masks[marker];
                if(direction)
                        monitor_direction |= masks[marker];
        }
}

void Command_DisableMonitor(BYTE marker)
{
        if((marker>=0)&&(marker<NR_SENSORS))
                monitor &= ~masks[marker];
}

BYTE CheckMonitor(BYTE marker, WORD value)
{
        BYTE retval;
        retval=0;
        if((marker>=0)&&(marker<NR_SENSORS))
        {
                if(monitor & masks[marker])
                {
                        /* only check if monitor was set for the given marker */
                        if(monitor_direction & masks[marker])
                        {
                                /* report larger values */
                                if(value>=monitor_boundary[marker]) retval=0xff;
                        } else {
                                /* report lower values */
                                if(value<=monitor_boundary[marker]) retval=0xff;
                        }
                }
        }
        return(retval);
}

WORD Command_GetBoundary(BYTE marker)
{
        return(monitor_boundary[marker]);
}

void Command_SetBoundary(BYTE marker,WORD bound)
{
        monitor_boundary[marker]=bound;
}

void Command_ReadDefaultConfiguration()
{
        BYTE i,chksum;
        WORD sum;

        /* TODO: read CANID configuration from EEPROM */
        /* checksum the EEPROM contents - we only set the monitor if the checksum was correct */
        sum=CHECKSUM_FILLER;
        for(i=EEPROM_MONITOR;i<EEPROM_CHECKSUM;i++)
                sum += EEPROM_read(i);

        chksum = 0xff-((BYTE)((sum & 0x00ff)));
        

        if(chksum == EEPROM_read(EEPROM_CHECKSUM))
        {
                /* reading and setting the monitoring values */
                monitor=0;
                monitor= ((LONG) (EEPROM_read(EEPROM_MONITOR+0)) << 24)
                        |((LONG) (EEPROM_read(EEPROM_MONITOR+1)) << 16)
                        |((LONG) (EEPROM_read(EEPROM_MONITOR+2)) <<  8)
                        |((LONG) (EEPROM_read(EEPROM_MONITOR+3)));
                monitor_direction=0;
                monitor_direction= ((LONG) (EEPROM_read(EEPROM_DIRECTION+0)) << 24)
                                  |((LONG) (EEPROM_read(EEPROM_DIRECTION+1)) << 16)
                                  |((LONG) (EEPROM_read(EEPROM_DIRECTION+2)) <<  8)
                                  |((LONG) (EEPROM_read(EEPROM_DIRECTION+3)));
                for(i=0;i<18;i++)
                {
                        sum= (((WORD) (EEPROM_read(EEPROM_BOUNDARY+i*2+0)) << 8))
                            +(((WORD) (EEPROM_read(EEPROM_BOUNDARY+i*2+1))));
                        monitor_boundary[i]=sum;
                }

        }       
}

void Command_WriteDefaultConfiguration()
{
        BYTE i,chksum;
        WORD sum;

        EA=0; /* to ensure the values can't be altered, we disable interrupts*/
        /* checksum the EEPROM contents - we only set the monitor if the checksum was correct */
        sum=CHECKSUM_FILLER;
        sum = sum + ((BYTE) ((monitor & 0xff000000) >> 24))
                  + ((BYTE) ((monitor & 0x00ff0000) >> 16))
                  + ((BYTE) ((monitor & 0x0000ff00) >>  8)) 
                  + ((BYTE) ((monitor & 0x000000ff)));
        sum = sum + ((BYTE) ((monitor_direction & 0xff000000) >> 24))
                  + ((BYTE) ((monitor_direction & 0x00ff0000) >> 16))
                  + ((BYTE) ((monitor_direction & 0x0000ff00) >>  8)) 
                  + ((BYTE) ((monitor_direction & 0x000000ff)));
        for(i=0;i<18;i++)
        {
                sum = sum + ((BYTE) ((monitor_boundary[i] & 0xff00) >> 8))
                          + ((BYTE) ((monitor_boundary[i] & 0x00ff)));
        }

        chksum = 0xff-((BYTE)((sum & 0x00ff)));
        /* prepare EEPROM buffer */
        EEPROM_write((BYTE) ((monitor & 0xff000000) >> 24),EEPROM_MONITOR);     /* latch monitored sensors */
        EEPROM_write((BYTE) ((monitor & 0x00ff0000) >> 16),EEPROM_MONITOR+1);
        EEPROM_write((BYTE) ((monitor & 0x0000ff00) >>  8),EEPROM_MONITOR+2);
        EEPROM_write((BYTE) ((monitor & 0x000000ff)),EEPROM_MONITOR+3);

        EEPROM_write((BYTE) ((monitor_direction & 0xff000000) >> 24),EEPROM_DIRECTION); /* latch direction information */
        EEPROM_write((BYTE) ((monitor_direction & 0x00ff0000) >> 16),EEPROM_DIRECTION+1);
        EEPROM_write((BYTE) ((monitor_direction & 0x0000ff00) >>  8),EEPROM_DIRECTION+2);
        EEPROM_write((BYTE) ((monitor_direction & 0x000000ff)),EEPROM_DIRECTION+3);

        /* latch boundary values */
        for(i=0;i<18;i++)
        {
                EEPROM_write((BYTE) ((monitor_boundary[i] & 0xff00) >>  8),EEPROM_BOUNDARY+i*2);
                EEPROM_write((BYTE) ((monitor_boundary[i] & 0x00ff)),EEPROM_BOUNDARY+i*2+1);
        }
        /* latch checksum */
        EEPROM_write(chksum,EEPROM_CHECKSUM);
        /* write new EEPROM contents */
        EEPROM_flush();
        EA=1;   /* activate interrupts again */
}

---