sftdownload.cpp

通过串口发送接受文件

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <dos.h>
#include "SFTDownload.h"
#include "Download.h"
#include <stdio.h>
#include <errno.h>
#include <time.h>
#pragma package(smart_init)

extern char CommandDownloadFileName[];

static int SFT_ReceiveFiles(char *machinename,int numfiles,char *filenames[]);

//---------------------------------------------------------------------------
//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall SFTDownload::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------
__fastcall SFTDownload::SFTDownload(bool CreateSuspended)
        : TThread(CreateSuspended)
{
  strcpy( MachineID,"" );
}
//---------------------------------------------------------------------------
void __fastcall SFTDownload::Execute()
{
  //---- Place thread code here ----
  int r;
redownload:
  Suspend();
  Stop=false;
  if( DownloadPath[strlen(DownloadPath)-1]!='\\' )strcat( DownloadPath,"\\" );
  SFT_ReceiveFiles("",-1,NULL);
  goto redownload;
}
//---------------------------------------------------------------------------

#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 <string.h>
#include <stdio.h>

#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;

TComport *ComDownload;

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

static 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;
}

static int SFT_SerialOpen(void)
{
    return 0;
}

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

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

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

static int SFT_SerialRead(char *c,int timeout_ms)
{
    switch( ComDownload->ReadChar(c,timeout_ms) )
        {
        case 0:return SFT_OK;
        case -1:return SFT_TIMEOUT;
        case -2:return SFT_ERROR;
        }
    return SFT_ERROR;
/*
    long start;
    start = SFT_GetTimeInMs();
    while( SFT_GetTimeInMs()-start < timeout_ms )
        {
        if( com->Read(c)==0 )return SFT_OK;
        };
    return SFT_TIMEOUT;
*/
//    return USERBREAK;
}

// Functions of Display Message

static void SFT_SendOpenFileError(void)
{
    Application->MessageBox("打开文件失败","ERROR",MB_OK);
}

static void SFT_SendError(void)
{
    Application->MessageBox("发送失败","ERROR",MB_OK);
}

static void SFT_SendUserBreak(void)
{
    Application->MessageBox("用户中断","ERROR",MB_OK);
}

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

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

static void SFT_SendProgress(int filecount,long totalsize,long totalprogress,char *currentfile,long currentfilesize,long currentprogress)
{
    char buf[256];
    sprintf(buf,"Sending... fc:%d ts:%d tp:%d cf:%s cfs:%d cp:%d",filecount,totalsize,totalprogress,currentfile,currentfilesize,currentprogress);
//    Form1->Caption = buf;
//    Form1->Update();
}


static void SFT_ReceiveError(void)
{
    Application->MessageBox("接收失败","ERROR",MB_OK);
}

static void SFT_ReceiveUserBreak(void)
{
    Application->MessageBox("用户中断","ERROR",MB_OK);
}

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

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

static void SFT_ReceiveCreateFileError(void)
{
    Application->MessageBox("创建文件失败","ERROR",MB_OK);
}

static void SFT_ReceiveProgress(int filecount,long totalsize,long totalprogress,char *currentfile,long currentfilesize,long currentprogress)
{
    char buf[256];
    sprintf(buf,"Rcving... fc:%d ts:%d tp:%d cf:%s cfs:%d cp:%d",filecount,totalsize,totalprogress,currentfile,currentfilesize,currentprogress);
//    Form1->Caption = buf;
//    Form1->Update();    
}

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

static 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);
}

static 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 )
            {
            result=SFT_SerialRead(&r,2000);
            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;
            }
        retry++;
        }
        
    return SFT_ERROR;
}

static 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;