_sft.cpp

通过串口发送接受文件

#include <vcl.h>
#include "time.h"
#include "dos.h"
#include "Comport.h"

#define U8 unsigned char
#define U16 unsigned short int
#define S16 short int

#include "_SFT.h"
#include <string.h>
#include <stdio.h>

extern TComport *Com;

extern char UploadShortFileNames[30][128];

extern char DownloadPath[128];

extern bool Downloading;
extern bool DownloadStop;
extern bool Uploading;
extern bool UploadStop;

char    MachineName[128];
int     FileCount;
long    TotalSize;
int     TotalProgress;
char    CurrentFile[128];
char    CurrentFileSaveAs[128];
long    CurrentSize;
int     CurrentProgress;

int      ReceiveResult;
char     ReceiveResultMsg[128];
int      SendResult;
char     SendResultMsg[128];

#define TRANSMIT_REQ        0x01
#define TRANSMIT_FILENAMES  0x02
#define TRANSMIT_ERROR      0x03
#define TRANSMIT_USERBREAK  0x04
#define TRANSMIT_FILEINFO   0x05
#define TRANSMIT_FILEDATA   0x06
#define TRANSMIT_FILEEOF    0x07

#define SFT_BOF 0xC0
#define SFT_EOF 0xC1
#define SFT_XCH 0xCE

#define SFT_OK              0
#define SFT_ERROR           -1
#define SFT_TIMEOUT         -2
#define SFT_USERBREAK       -3
#define SFT_RETRY           -4
#define SFT_FILEDISMATCH    -5
#define SFT_MACHINEDISMATCH -6
#define SFT_SENDFILEERROR   -7
#define SFT_RECEIVEFILEERROR -8

#define PACKAGE_MAX 1024

static char SFT_BUF[PACKAGE_MAX];
static char SFT_TX_BUF[PACKAGE_MAX*2+16];
static int  SFT_TX_BUF_LEN=0;
int port;

// Functions of I/O
void SFT_Delay(int ms)
{
//    Sleep(ms);
}

long SFT_GetTimeInMs(void)
{
    struct time t;
    gettime(&t);
    return (((unsigned long)t.ti_hour*60L+(unsigned long)t.ti_min)*60L+(unsigned long)t.ti_sec)*1000L+(unsigned long)t.ti_hund*10L;
}

int SFT_SerialOpen(void)
{
    int r;
    r=0;
//    r = com->Open(port);
//    com->SetBaudRate(115200);
    SFT_TX_BUF_LEN=0;
    return r;
}

void SFT_SerialClose(void)
{
//    com->Close();
}

void SFT_SerialWrite(char c)
{
    SFT_TX_BUF[SFT_TX_BUF_LEN++]=c;
}

void SFT_SerialWriteUpdate(void)
{
    Com->Write(SFT_TX_BUF,SFT_TX_BUF_LEN);
    SFT_TX_BUF_LEN=0;
}

int SFT_SerialRead(char *c,int timeout_ms)
{
    if( Uploading && UploadStop )return SFT_USERBREAK;
    if( Downloading && DownloadStop )return SFT_USERBREAK;
//    if( Stop==1 ){ Stop=0;return SFT_USERBREAK; }
    switch( Com->ReadChar(c,timeout_ms ) )
        {
        case 0:return SFT_OK;
        case -1:return SFT_TIMEOUT;
        default:return SFT_ERROR;
        }
//    long start;
//    start = SFT_GetTimeInMs();
//    while( SFT_GetTimeInMs()-start < timeout_ms )
//        {
//        if( com->ReadChar(c)==true )return SFT_OK;
//        };
//    return SFT_TIMEOUT;
//    return USERBREAK;
}

// Functions of Display Message

void SFT_SendOpenFileError(void)
{
    strcpy( SendResultMsg,"打开文件错误，发送失败" );
//    Application->MessageBox("打开文件失败","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_SendError(void)
{
    strcpy( SendResultMsg,"发送失败" );
//    Application->MessageBox("发送失败","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_SendUserBreak(void)
{
    strcpy( SendResultMsg,"发送被取消" );
//    Application->MessageBox("发送被取消","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_SendMachineDismatch(void)
{
    strcpy( SendResultMsg,"接收方拒绝接收本机数据" );
//    Application->MessageBox("接收方拒绝接收本机的数据","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_SendFileDismatch(void)
{
    strcpy( SendResultMsg,"接收方拒绝接收这些文件" );
//    Application->MessageBox("接收方拒绝接收这些文件","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_SendProgress(int filecount,long totalsize,long totalprogress,char *currentfile,long currentfilesize,long currentprogress)
{
    FileCount = filecount;
    TotalSize = totalsize;
    TotalProgress = totalprogress;
    strcpy(CurrentFile,currentfile);
    CurrentSize = currentfilesize;
    CurrentProgress = currentprogress;
}


void SFT_ReceiveError(void)
{
    strcpy( ReceiveResultMsg,"接收失败" );
//    Application->MessageBox("接收失败","ERROR",MB_OK|MB_ICONERROR);
}

void SFT_ReceiveUserBreak(void)
{
    strcpy( ReceiveResultMsg,"接收被取消" );
//    Application->MessageBox("接收被取消","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_ReceiveFileDismatch(void)
{
    strcpy( ReceiveResultMsg,"文件不匹配，请发送指定的文件" );
//    Application->MessageBox("文件不匹配，请发送指定的文件","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_ReceiveMachineDismatch(void)
{
    strcpy( ReceiveResultMsg,"发送方机器不对，请用指定的机器传输" );
//    Application->MessageBox("发送方机器不对，请用指定的机器传输","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_ReceiveCreateFileError(void)
{
    strcpy( ReceiveResultMsg,"创建文件错误，接收失败" );
//    Application->MessageBox("创建文件失败","ERROR",MB_ICONERROR|MB_OK);
}

void SFT_ReceiveProgress(int filecount,long totalsize,long totalprogress,char *currentfile,long currentfilesize,long currentprogress)
{
    FileCount = filecount;
    TotalSize = totalsize;
    TotalProgress = totalprogress;
    strcpy(CurrentFile,currentfile);
    CurrentSize = currentfilesize;
    CurrentProgress = currentprogress;
}

// ****************************************

void SFT_SerialWriteXCH(unsigned char c)
{
    if( c==SFT_BOF || c==SFT_EOF || c==SFT_XCH || c==0x0d || c==0x11 || c==0x13){ SFT_SerialWrite(SFT_XCH);SFT_SerialWrite(c^0x20); }
    else SFT_SerialWrite(c);
}

int SFT_SendPackage(U8 serial,U8 packagetype,U8 *data,U16 datalen)
{
    U8 checksum;
    int i,result;
    int retry=0;
    signed char r;

    while( retry<10 )
        {
        SFT_SerialWrite(SFT_BOF);
        SFT_SerialWriteXCH(serial);
        SFT_SerialWriteXCH(packagetype);
        // make checksum
        checksum=0xFF^SFT_BOF^SFT_EOF^serial^packagetype;
        for( i=0;i<datalen;i++ )checksum^=data[i];
        SFT_SerialWriteXCH(checksum);
        // write data
        for( i=0;i<datalen;i++ )SFT_SerialWriteXCH(data[i]);
        SFT_SerialWrite(SFT_EOF);
        SFT_SerialWriteUpdate();
                
        if( packagetype!=TRANSMIT_ERROR && packagetype!=TRANSMIT_USERBREAK )
            {
            int j;
            for( j=0;j<10;j++ )
                {
                result=SFT_SerialRead(&r,100);
                if( result==SFT_OK )
                    {
                    switch( r )
                        {
                        case SFT_TIMEOUT            :break;
                        case SFT_RETRY              :break;
                        case SFT_OK                 :return SFT_OK;
                        case SFT_USERBREAK          :return SFT_USERBREAK;
                        case SFT_MACHINEDISMATCH    :return SFT_MACHINEDISMATCH;
                        case SFT_FILEDISMATCH       :return SFT_FILEDISMATCH;
                        default                     :return SFT_ERROR;
                        }
                    }
                else if( result==SFT_USERBREAK )
                    return SFT_USERBREAK;
                }
            }
        else
            {
            return SFT_OK;
            }
//        retry++;
        }
        
    return SFT_ERROR;
}

int SFT_WaitPackage(U8 serial,U8 *packagetype,U8 *data,U16 *datalen)
{
    U8 c,checksum;
    U8 serial1,checksum1;
    int status,k,result;
    int i;

wait:    
    status = -1;
    while(1)
        {
        result=SFT_SerialRead(&c,100);
        if( result==SFT_USERBREAK )return SFT_USERBREAK;
        if( result==SFT_TIMEOUT )continue;
        if( c==SFT_BOF ){ status=0;k=0;continue; }
        if( c==SFT_EOF&&status>=0 )break;
        if( c==SFT_XCH ){ status=1;continue; };
        if( status==1 ){ c=c^0x20;status=0; };

        if( k==0 )serial1=c;
        if( k==1 )*packagetype=c;
        if( k==2 )checksum1=c;
        if( k>2 )data[k-3]=c;
        k++;
        if( k-3>PACKAGE_MAX )return SFT_ERROR;
        }

    if( serial<serial1 )return SFT_ERROR;
    if( serial>serial1 && serial1==0 )return SFT_ERROR;
    if( serial==serial1+1 ){ SFT_SerialWrite(SFT_OK);goto wait; };

    k=k-3;
    checksum=0xFF^SFT_BOF^SFT_EOF^serial1^(*packagetype);
    for( i=0;i<k;i++ )checksum ^= data[i];

    if( checksum!=checksum1 )
        {
        SFT_SerialWrite(SFT_RETRY);
        goto wait;
        }

    *datalen = k;

    return SFT_OK;
}