f53x_linsnooper_main.c

来自「8051试验程序 基础教材」· C语言 代码 · 共 805 行 · 第 1/3 页

//-----------------------------------------------------------------------------
// F53x_LINSnooper_Main.c
//-----------------------------------------------------------------------------
// Copyright 2006 Silicon Laboratories, Inc.
// http://www.silabs.com
//
// File Description:
//
// This is main LIN Snooper file that enables all the peripherals and
// outputs the snooped messages
//
// FID:
// Target:          C8051F53x
// Tool chain:      KEIL C51 7.20
// Command Line:    None
// Project Name:    LIN Snooper
//
// Release 1.0
//    -Initial Revision
//    -01 NOV 2006
//
// FIX Formatting

//-----------------------------------------------------------------------------
// Include Files
//-----------------------------------------------------------------------------
#include <ioc8051f530.h>                 // SFR declarations
#include "F53x_LINSnooper_Main.h"         // Include common specific definitions
#include "F53x_LINSnooper_UART.h"      // Include UARTs specific definitions
#include "F53x_LINSnooper_Timer.h"     // Include Timers specific definitions
#include "F53x_LINSnooper_LIN.h"       // Include LIN specific definitions
#include "F53x_LINSnooper_Flash.h"     // Include Flash specific definitions


//-----------------------------------------------------------------------------
// Constants Definitions
//-----------------------------------------------------------------------------
#define F53x_MAIN_SOURCE

//-----------------------------------------------------------------------------
// Global Variables
//-----------------------------------------------------------------------------
unsigned char LIN_STATUS;
unsigned char LIN_IDENTIFIER;
unsigned char LIN_DATA[8];
unsigned char LIN_ENABLE;                       // Enable LIN flag
unsigned char UART_ENABLE;                   	// Enable UART flag
unsigned char ADDR_OFFSET;                   	// Address offset of stored data
unsigned char UART_DATA;                     	// Receive Data via UART flag
unsigned char FLASH_ERROR;                   	// Error flag
unsigned char NUMBER_RCVD;                      // Number Received flag


//-----------------------------------------------------------------------------
// Main
//-----------------------------------------------------------------------------
void main(void)
{
   unsigned char i;
   unsigned char id;

   CPU_Initialize();                   // Initialize CPU
   Timer2_Initialize();                // Initialize Timer2
   UART0_Initialize();                 // Initialize UART0
   ENABLE_IRQ;                         // Enable Global Interrupts

   UART_Send_Word( "LIN Sniffer ver. 0.3", 20 );
   UART_Send_CRLF();
   UART_Send_CRLF();

   LIN_ENABLE = 0;                     // Disable LIN Sniffer
   UART_ENABLE = 1;                    // Enable UART
   UART_DATA = 0;                      // Disable receiving file
	NUMBER_RCVD = 0;							// Clear flag

   UART_Send_Word( "1. Load LIN data", 16 );
   UART_Send_CRLF();

   if ( Flash_Read ( 200 ) == 0xAA )   // Check if data is stored
   {
       UART_Send_Word( "2. Use stored LIN data", 22 );
       UART_Send_CRLF();
       UART_Send_CRLF();
   }
   else {
       UART_Send_CRLF(); }

   while(1)                            // Main loop
   {
        if (UART_ENABLE == 1)
        {
            /* Data has been received via UART0 */
            if ( UART_BUFFER_GET != UART_BUFFER_PUSH )
            {
                P1 ^= LED;
                if ( UART_DATA == 1 )
                {
                    /* Receiving new data */

                    // Check if '.' received, next singn should be a number or 'E' or 'C'
                    if ( (UART_BUFFER[UART_BUFFER_GET] == '.') & (FLASH_ERROR == 0) )
                    {
                        Inc_UART_BUFFER_GET();
                        if ( UART_BUFFER_GET != UART_BUFFER_PUSH )
                        {
                            // Check if next sign is a number
                            if ( (UART_BUFFER[UART_BUFFER_GET] > '0') & (UART_BUFFER[UART_BUFFER_GET] < '9') & (NUMBER_RCVD == 0) )
                            {
                                if ( ADDR_OFFSET < 64)
                                {
                                    TIMEOUT = 2;    // Set timeout to 2s
                                    Flash_Store ( (unsigned char __code *)ADDR+ADDR_OFFSET, UART_BUFFER[UART_BUFFER_GET]-0x30 );
                                    ADDR_OFFSET++;
												NUMBER_RCVD = 1;
                                }
                                else
                                    FLASH_ERROR = 1;
                            }
									 // Check if next sign is a 'E' or 'C'
                            else if ( ((UART_BUFFER[UART_BUFFER_GET] == 'E') | (UART_BUFFER[UART_BUFFER_GET] == 'C')) & (NUMBER_RCVD == 1) )
                            {
                                TIMEOUT = 2;    // Set timeout to 2s
                                Flash_Store ( (unsigned char __code *)ADDR+ADDR_OFFSET+65, UART_BUFFER[UART_BUFFER_GET] );
							    	     NUMBER_RCVD = 0;
                            }
                            else
                                FLASH_ERROR = 2;

							Inc_UART_BUFFER_GET();
                        }
                        else
                            Dec_UART_BUFFER_GET();
                    }
                    // Check if 'end' received, next singn should be a 'n'
                    else if ( UART_BUFFER[UART_BUFFER_GET] == 'e'  & (FLASH_ERROR == 0) )
                    {
                        Inc_UART_BUFFER_GET();
                        if ( UART_BUFFER_GET != UART_BUFFER_PUSH )
                        {
                            // Check if next sign is a 'n'
                            if ( (UART_BUFFER[UART_BUFFER_GET] == 'n') & (ADDR_OFFSET == 64) & (FLASH_ERROR == 0) )
                            {
                                UART_Send_CRLF();
                                UART_Send_Word( "Data has been stored:", 21 );
                                UART_Send_CRLF();
                                Display_Flash_Data();
                                Flash_Store ( (unsigned char __code *)ADDR+200, 0xAA );
                                UART_BUFFER_GET = UART_BUFFER_PUSH;
                                UART_DATA = 0;      // Disable receiving file
                                LIN_ENABLE = 1; 	 // Enable LIN Sniffer
                                LIN_Initialize();   // Initialize LIN
                                UART_ENABLE = 0;    // Disable UART
                            }
                            else
                                FLASH_ERROR = 3;
                            Inc_UART_BUFFER_GET();
                        }
                        else
                            Dec_UART_BUFFER_GET();
                    }
                    else
                        Inc_UART_BUFFER_GET();
                }
                else
                {
                    switch ( UART_BUFFER[UART_BUFFER_GET] )
                    {
                        case '1':
                                Inc_UART_BUFFER_GET();
                                /* Clearing memory before storing */
                                Flash_Erase( (unsigned char __code *) ADDR);

                                UART_Send_Word( "Data has been erased,", 21 );
                                UART_Send_Word( " please send new data", 21 );
                                UART_Send_CRLF();
                                ADDR_OFFSET = 0;    // Clear address offset
                                FLASH_ERROR = 0;    // Clear Error flag
                                UART_DATA = 1;      // Enable receiving file
                                TIMEOUT = 3;        // Set timeout to 3s
                                break;

                        case '2':
                                Inc_UART_BUFFER_GET();
                                if ( Flash_Read ( 200 ) == 0xAA )
                                {
                                    UART_Send_Word( "Stored data:", 12 );
                                    UART_Send_CRLF();
                                    Display_Flash_Data();
                                    LIN_ENABLE = 1;     // Enable LIN Sniffer
                                    LIN_Initialize();   // Initialize LIN
                                    UART_ENABLE = 0;    // Disable UART
                                }
                                break;

                        default:
                                Inc_UART_BUFFER_GET();
                                break;
                    }
                }
            }
        }

        if ( (TIMEOUT == 0) & (UART_DATA == 1) )    // if UART timeout
        {
            if ( FLASH_ERROR )
            {
                UART_Send_Word( " Error in line ", 15 );
                UART_Send_DEC( ADDR_OFFSET , 1 );
                UART_Send_Word( " - ", 3 );
                switch ( FLASH_ERROR )
                {
                    case 1:
                            UART_Send_Word( " too much data", 14 );
                            break;

                    case 2:
                            UART_Send_Word( " wrong length or CRC type", 25 );
                            break;

                    case 3:
                            UART_Send_Word( " not enough data", 16 );
                            break;
                }
            }
            UART_Send_CRLF();
            UART_BUFFER_GET = UART_BUFFER_PUSH;
            UART_DATA = 0;
            UART_BUFFER[UART_BUFFER_PUSH] = '1';
            Inc_UART_BUFFER_PUSH();
        }

        if (LIN_ENABLE == 1)
        {
        /* Data has been received via LIN */
        if ( LIN_BUFFER_GET != LIN_BUFFER_PUSH )
        {
                LIN_STATUS = LIN_BUFFER[LIN_BUFFER_GET];
                Inc_LIN_BUFFER_GET();

                switch ( LIN_STATUS )
                {
                 case   ID_RECEIVED:            // Received ID
                                LIN_IDENTIFIER = LIN_BUFFER[LIN_BUFFER_GET];
                                Inc_LIN_BUFFER_GET();
                                break;

                    case    LIN_MSG_RECEIVED_OK:// Reception completed OK
                                if (LIN_IDENTIFIER < 60)
                                    id = Flash_Read ( LIN_IDENTIFIER );
                                else
                                    id = LINLENGTH;
                                for ( i=0; i<id; i++)
                                {
                                    LIN_DATA[i] = LIN_BUFFER[LIN_BUFFER_GET];
                                    Inc_LIN_BUFFER_GET();
                                }
                                LIN_STATUS = PROCESSING;
                                Display_Identifier();
                                Display_Received_Data();
                                Analize_Received_Data();
                                LIN_STATUS = NO_MESSAGE;
                                break;

                    default:                    // Error found
                            Display_Sniffer_Status();
                            break;
              }

            }