main.c

Go to the documentation of this file.

#include "t89c51cc02.h"
#include "datatypes.h"
#include "adc.h"
#include "can.h"
#include "timer.h"
#include "sharp.h"
#include "fingersensors.h"
#include "photosensor.h"
#include "bumper.h"
#include "command.h"
#include "eeprom.h"

#define DEBUG 1

#define LENGTH_SENSORBUFFER 128

/* #define SAMPLEPOINTS BUMPERSENSORS_NR + PHOTOSENSORS_NR + FINGERSENSORS_NR + 1 */
#define SAMPLEPOINTS 18

#define BUFFER_LENGTH 6 * SAMPLEPOINTS

#define SERIALNUMBER 0x01

const char version[]="Sensor Control 07092007 #1";

WORD xdata sensorbuffer[BUFFER_LENGTH];

void main()
{
        BYTE i;
        BYTE bufferptr; /* index pointer into the sensorbuffer */
        WORD samplenr; /* counts number of sensor sampling runs */
        unsigned long read_shiftreg; /* a shift register which contains the bit pattern for all sensors with scheduled readings */

        P1=0; P3=0; P2=0;
        samplenr=0;
        bufferptr=0;
        for(i=0;i<BUFFER_LENGTH;i++)
                sensorbuffer[i]=0;

        /* init functions - prepare but don't enable interrupts */
        Command_ReadDefaultConfiguration();
        ADC_init();
        CAN_init();
        Timer_init();
        Bumper_init();
        Sharp_init();
        Photosensor_init();
        Fingersensors_init();

        EA=1;           /* enable all interrupts */

        /* send initial hello World */
        CAN_setchannel(1);
        CANCONCH = CH_DISABLE;                    /* reset channel 1 configuration */            
        CANMSG = 'S';
        CANMSG = 'C';
        CANMSG = '0'+SERIALNUMBER;      
        CANCONCH |= 3;              
        CANCONCH |= CH_TxENA;                     /* emission enabled */
        CAN_enablechannel(1);                       /* channel 1 enable */
        CANSTCH=0x00; 

        Command_TimecheckEnable();
        read_eeprom_config=0;

        /* main loop - process all tasks here */
        while(1)
        {
        
                /* pending measurement task? */
                if(measurement_task)
                {
                        measurement_task=0;     /* acknowledge measurement task */
                        /* sample upper photosensor of finger */
                        sensorbuffer[bufferptr]=Photosensor_read(1);
                        /* sample finger sensors */                     
                        Fingersensors_read();
                        for(i=0;i<FINGERSENSORS_NR;i++)
                                sensorbuffer[bufferptr+14+i]=fingersensors[i];
                        /* sample lower photosensor of finger */
                        sensorbuffer[bufferptr+1]=Photosensor_read(2);
                        Photosensor_PowerOff();
                        /* begin sampling Sharp sensor */
                        Sharp_PowerOn();
                        /* we have approximately 50ms until the Sharp is ready - sample the bumper sensors
                         * while we wait for the Sharp sensor to be ready
                         */
                        for(i=0;i<BUMPERSENSORS_NR;i++) 
                        {
                                sensorbuffer[bufferptr+6+i]=Bumper_read(i);
                                
                        }
                        /* read the Sharp sensor */
                        sensorbuffer[bufferptr+5]=Sharp_read();
                        Sharp_PowerOff();
        
                        /* sample middle photo sensor */        
                        sensorbuffer[bufferptr+2]=Photosensor_read(3);

                        /* handle communication tasks if requested */
                        if(reporting)
                        {
                                if(Command_ReportDue()) /* only report when due */
                                        for(i=0;i<SAMPLEPOINTS;i++)
                                        {
                                                ECAN=0; /* disable CAN interrupt to prevent corruption of message buffer */
                                                can_data[0]='S';
                                                can_data[1]=i;
                                                can_data[2]=(BYTE) ((sensorbuffer[bufferptr+i] & 0xff00) >> 8);
                                                can_data[3]=(BYTE) (sensorbuffer[bufferptr+i] & 0x00ff);
                                                CAN_SendMsg(4);
                                        }
                        } else {
                                /* read and watch requests are handled here */
                                read_shiftreg=readenable;
                                for(i=0;i<SAMPLEPOINTS;i++)
                                {                       
                                                /* read requests overrule watch requests */             
                                                if(read_shiftreg & 0x1)
                                                {
                                                        ECAN=0; /* disable CAN interrupt to prevent corruption of message buffer */
                                                        can_data[0]='S';
                                                        can_data[1]=i;
                                                        can_data[2]=(BYTE) ((sensorbuffer[bufferptr+i] & 0xff00) >> 8);
                                                        can_data[3]=(BYTE) (sensorbuffer[bufferptr+i] & 0x00ff);
                                                        CAN_SendMsg(4);
                                                } else {
                                                        /* check for monitored sensor value */
                                                        if(CheckMonitor(i,sensorbuffer[bufferptr+i]))
                                                        {
                                                                ECAN=0; /* disable CAN interrupt to prevent corruption of message buffer */
                                                                can_data[0]='M';
                                                                can_data[1]=i;
                                                                can_data[2]=(BYTE) ((sensorbuffer[bufferptr+i] & 0xff00) >> 8);
                                                                can_data[3]=(BYTE) (sensorbuffer[bufferptr+i] & 0x00ff);
                                                                CAN_SendMsg(4);

                                                        }
                                                }
                                                read_shiftreg=(read_shiftreg >> 1); /* cycle next bit */
                                }
                                readenable=0;   /* make sure read requests for single sensor occur once */

                        }

                        bufferptr += SAMPLEPOINTS;
                        /* loop bufferptr if needed */
                        if(bufferptr>BUFFER_LENGTH)
                                bufferptr=0;

                        samplenr++;     /* count the number of measurements taken */
                        /* report miss of time constraints if requested by the user */
                        if(measurement_task && Command_CheckTime())
                        {
                                /* error - time constraint for measurement task was not met */
                                ECAN=0; /* disable CAN interrupt to prevent corruption of message buffer */
                                can_data[0]='T';
                                can_data[1]=CAN_NAK;
                                CAN_SendMsg(2);
                        }
                        measurement_task=0;
                }
        
                /* pending task to reinitialize the monitor points from EEPROM data? */
                if(read_eeprom_config)
                {
                        EA=0;
                        Command_ReadDefaultConfiguration();
                        EA=1;
#ifdef DEBUG
                                ECAN=0;
                                can_data[0]='E';
                                can_data[1]='P';
                                can_data[2]='R';
                                CAN_SendMsg(3);
#endif
                        read_eeprom_config=0;
                        write_eeprom_config=0; /* it makes no sense to schedule both read and write in one timeframe, we therefor disable any accidentially scheduled write task */
                }

                /* pending task to write monitor settings to EEPROM? */
                if(write_eeprom_config)
                {
                        Command_WriteDefaultConfiguration();
#ifdef DEBUG
                        ECAN=0;
                        can_data[0]='E';
                        can_data[1]='P';
                        can_data[2]='R';
                        can_data[3]='w';
                        CAN_SendMsg(4);
#endif
                        write_eeprom_config=0;
                }

        }
}

---