photo.c

通过车载终端采集GPS数据

#include "typedef.h"
#include "photo.h"

#include "16c554.h"
#include <string.h>
#include <stdio.h>
#include "TRANS_PROCESS.h"
//定义窗口大小，该值应该与相片数据包每个包的大小有关系
#define PHOTO_WINDOWSIZE 5//包大小为518的时候8，256的时候为14
#define PHOTO_TIMEOUT 1


#define PHOTO_COMMANDPACKSIZE 6
Uint8 gnPhotoState;
Uint8 gnPhotoMode;
Uint16 gnPhotoSize;//每个包的大小
Uint8 gnPhotoRetry;
Byte gphoto_msgnum[4];
//照片的包数量
Uint16 gnPhotoPackNum;
Byte gPhotoSendBuf[PHOTO_COMMANDPACKSIZE];
Uint16 gnPhotoCurSeq;
Byte gnPhotoDataSending;//取值为PHOTO_DATASENDING和PHOTO_NODATASEND

//定义相片重传方面的变量
Byte gnPhotoRetryThrd;
Byte gnPhotoTimeout;

//下面定义每个包的状态
Byte gPhotoPacketstate[PHOTO_PACK_NUM];

code Byte gPhotoCommand[][PHOTO_COMMANDPACKSIZE] = 
{
    {0xaa, 0x0d, 0x00, 0x00, 0x00, 0x00},  /*PHOTO_SENDINIAL*/
    {0xaa, 0x01, 0x00, 0x07, 0x00, 0x07},  /*PHOTO_SETFORMAT*/
    {0xaa, 0x06, 0x08, 0x00, 0x20, 0x00},  /*PHOTO_SETPACKETSIZE*/
    {0xaa, 0x05, 0x00, 0x00, 0x00, 0x00},  /*PHOTO_QUICKSNAP*/
    {0xaa, 0x04, 0x01, 0x00, 0x00, 0x00},  /*PHOTO_GETPHOTODATA*/
    {0xaa, 0x0e, 0x00, 0x00, 0x00, 0x00},   /*PHOTO_PHOTODATAREQ*/
    {0xaa, 0x0e, 0x0d, 0x00, 0x00, 0x00}, /*PHOTO_RESPONSEINIAL*/
};

//定义相机返回的应答包
code Byte gPhotoResp[PHOTO_RESPONSE_NUM] = 
{0x0d, 0x01, 0x06, 0x05, 0x04};

//定义发送数据包的内容
void photo_init()
{
    Byte i;
    gnPhotoState = PHOTO_INIAL;
    gnPhotoMode = PHOTO_CIFMODE;
    gnPhotoSize = 456;//306106;
    gnPhotoRetry = 0;
    for (i=0; i<PHOTO_PACK_NUM; i++)
        gPhotoPacketstate[i] = PHOTO_PACK_NOUSE;
    gnPhotoPackNum = 0;
    gnPhotoTimeout = 0;
    memset(gphoto_msgnum, 0 ,4);
    gnPhotoDataSending = PHOTO_NODATASEND;
}
char testBuf[550];
//1s处理一次
void photo_1s_process()
{
    Byte i;
    //在几种状态的情况下，才有以下处理
    if ((PHOTO_RETRYDATA == gnPhotoState) || (PHOTO_RETRYDATATIMING == gnPhotoState) \
        || (PHOTO_RECIEVERETRYDATA == gnPhotoState) || (PHOTO_RECIEVETIMINGDATA == gnPhotoState))
    {
        for (i=0; i<gnPhotoPackNum; i++)
        {
            if (gPhotoPacketstate[i] == PHOTO_PACK_WAITACK)
                break;
        }
        if (i == gnPhotoPackNum)
        {
            //所有包都发送完毕
//            sprintf(testBuf, "everything11 is ok");
//            sioc_send(testBuf, strlen(testBuf));
            gnPhotoDataSending = PHOTO_NODATASEND;
            gnPhotoState = PHOTO_PHOTODATAOVER;
            return;
        }
    }
    
    if ((PHOTO_RETRYDATATIMING == gnPhotoState) && (gnPhotoTimeout > 0))
        gnPhotoTimeout--;
}


//每50ms处理一次
void photo_process()
{
 //   sprintf(testBuf, "%bu:%bu:%d\r\n", gnPhotoState, gnPhotoRetry, gnPhotoCurSeq);
 //   sioc_send(testBuf, strlen(testBuf));
    //处理等待状态的情况下，在收到
    if ((PHOTO_WAITCOMMAND == gnPhotoState) || (PHOTO_NOPHOTO == gnPhotoState))
        return;
    
    if (gnPhotoState > PHOTO_WAITCOMMAND)
    {
        //处于接收状态
        photo_recievepro();
    }
    else
    {
        //处于发送状态
        photo_sendpro();
    }
}

void photo_addretryThrd(Byte nValue)
{
    if (0 == nValue)
    {
        //初始设置
        if (gnPhotoPackNum < PHOTO_WINDOWSIZE)
            gnPhotoRetryThrd = gnPhotoPackNum;
        else
            gnPhotoRetryThrd = PHOTO_WINDOWSIZE;
    }
    else
    {
        if ((gnPhotoRetryThrd+nValue) >= PHOTO_WINDOWSIZE)
            gnPhotoRetryThrd = gnPhotoPackNum;
        else
            gnPhotoRetryThrd += nValue;
    }
}

//组织发送包
void photo_sendpacket(Byte* pBuf, Byte type, Uint16 value)
{
    memcpy(pBuf, gPhotoCommand[type], PHOTO_COMMANDPACKSIZE);
    if (PHOTO_SETFORMAT == type)
        pBuf[5] = value;
    else if (PHOTO_SETPACKETSIZE == type)
    {
        pBuf[3] = LSB(value);
        pBuf[4] = MSB(value);
    }
    else if (PHOTO_PHOTODATAREQ == type)
    {
        pBuf[4] = LSB(value);
        pBuf[5] = MSB(value);
    }
    siob_send(pBuf, PHOTO_COMMANDPACKSIZE);
//    sioc_send(pBuf, PHOTO_COMMANDPACKSIZE);
}

//发送模块
void photo_sendpro()
{
    switch (gnPhotoState)
    {
        case PHOTO_INIAL:
            gnPhotoState = PHOTO_RECIEVEINIAL;
            photo_sendpacket(gPhotoSendBuf, PHOTO_SENDINIAL, 0);
            break;
        case PHOTO_SETFORMAT:
            gnPhotoState = PHOTO_RECIEVEFORMAT;
            photo_sendpacket(gPhotoSendBuf, PHOTO_SETFORMAT, gnPhotoMode);
            break;
        case PHOTO_SETPACKETSIZE:
            gnPhotoRetry++;
            if (gnPhotoRetry > 5)
            {
                gnPhotoState = PHOTO_RECIEVEPACKETSIZE;
                photo_sendpacket(gPhotoSendBuf, PHOTO_SETPACKETSIZE, gnPhotoSize);
            }
            break;
        case PHOTO_QUICKSNAP:
            gnPhotoState = PHOTO_RECIEVEQUICKSNAP;
            photo_sendpacket(gPhotoSendBuf, PHOTO_QUICKSNAP, 0);
            break;
        case PHOTO_GETPHOTODATA:
            gnPhotoState = PHOTO_RECIEVEGETPHOTODATA;
            photo_sendpacket(gPhotoSendBuf, PHOTO_GETPHOTODATA, 0);
            break;
        case PHOTO_FIRSTPHOTO:            
            if (gnPhotoRetry == 0)
            {
                if (VALID_DATA == photo_setnextPacket())
                {
                    photo_sendpacket(gPhotoSendBuf, PHOTO_PHOTODATAREQ, gnPhotoCurSeq);
                    gnPhotoState = PHOTO_PHOTOPACKET;
                }
            }
            else
                gnPhotoRetry--;                
            break;
        case PHOTO_RETRYDATA:   
            
            if (0 == gnPhotoRetry)
            {         
                if (VALID_DATA == photo_setnextPacket())
                {
                    photo_sendpacket(gPhotoSendBuf, PHOTO_PHOTODATAREQ, gnPhotoCurSeq);
                    gnPhotoState = PHOTO_RECIEVERETRYDATA;
                }
            }
            else
                gnPhotoRetry--;
            break;
        case PHOTO_RETRYDATATIMING:
            if (0 == gnPhotoTimeout)
            {                
                if (0 == gnPhotoRetry)
                {
                    if (VALID_DATA == photo_setnextPacket())    
                    {
                        photo_sendpacket(gPhotoSendBuf, PHOTO_PHOTODATAREQ, gnPhotoCurSeq);
                        gnPhotoState = PHOTO_RECIEVETIMINGDATA;
                    }
                }
                else
                    gnPhotoRetry--;
            }    
            break;
        case PHOTO_PHOTODATAOVER:
            if (PHOTO_DATASENDING == gnPhotoDataSending)
            {
                if (PHOTO_REPHOTOTIMEOUT ==gnPhotoRetry)
                    photo_sendpacket(gPhotoSendBuf, PHOTO_PHOTODATAREQ, 0xf0f0);    
                gnPhotoRetry--;
                if (0 == gnPhotoRetry)
                {
                    gnPhotoDataSending = PHOTO_NODATASEND;
                    gnPhotoState = PHOTO_QUICKSNAP;
                }
            }
            else
            {
                photo_sendpacket(gPhotoSendBuf, PHOTO_PHOTODATAREQ, 0xf0f0);
                gnPhotoState = PHOTO_WAITCOMMAND;
            }
            break;
    }
}

/***需要查询下一个，返回VALID_DATA
    不需要查询，返回INVALID_DATA***/

Byte photo_setnextPacket()
{
    Byte i;
    if (gnPhotoState == PHOTO_FIRSTPHOTO)
    {
        if (gnPhotoCurSeq >= (gnPhotoPackNum-1))
        {
            gnPhotoState = PHOTO_RETRYDATA;
            //设置与重传有关的变量
            photo_addretryThrd(0);
            gnPhotoCurSeq = 0xffff;
            return INVALID_DATA;
        }
        else
        {
            gnPhotoCurSeq++;
            return VALID_DATA;