📄 rs232down.c
字号:
DWORD buff_offset;
buff_offset = bDesDataPtr - orgwPtr; //&(rsFlashBuff[0]);
buff_offset &= 0x000007ff; // %2048
wDesDataPtr = /*&(rsFlashBuff[0])*/ orgwPtr + buff_offset;
if(num==0)
{
for(n=bufCount; n<2048; n++)
{
*wDesDataPtr = 0xff;
wDesDataPtr++;
}
// rsPtrFlashBuff = (BYTE*) &(rsFlashBuff[0]);
if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
{
for (j = 0; j < 3; j++)
{
if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;
}
if (j >= 3)
{
// printf("StartAddr=0x%x Flash-memory program error\n",rsFlashStartAddr);
return ERROR;
}
}
rsFlashStartAddr += 2048;
bufCount=0;
return OK;
}
else
{
for(n=0;n<num;n++)
{
*wDesDataPtr = *bSrcDataPtr;
wChkSum += *bSrcDataPtr;
wDesDataPtr++;
bSrcDataPtr++;
}
nDataNum += n;
bufCount += n;
if(bufCount>=2048)
{
// rsPtrFlashBuff = (BYTE*) &(rsFlashBuff[0]);
if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
{
for (j = 0; j < 3; j++)
{
if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;
}
if (j >= 3)
{
printf("StartAddr=0x%x Flash-memory program error\n",rsFlashStartAddr);
return ERROR;
}
}
rsFlashStartAddr += 2048;
if(bufCount>2048)
{
for (j=0;j<bufCount-2048;j++)
rsFlashBuff[j]= rsFlashBuff[j+2048];
bufCount -= 2048;
}
else
bufCount=0;
return OK;
}
}
}
#endif
#if 0
static BOOL ChannelClose( void )
{
return OK;
}
static BOOL ChannelOpen( void )
{
return OK;
}
static BOOL ChannelSet( BYTE data )
{
outbyte(data);
return OK;
}
static BOOL ChannelGet( BYTE *dataPtr )
{
*dataPtr = inbyte();
return OK;
}
#else
static BOOL ChannelClose( void )
{
#if 1
/* wait for the last transmission finished */
while (!((*(CSSR)) & TEND));
// delay(500);
*(CTDR) = '&';
*(CSSR) = *(CSSR) & ((~TEND)&(~TDRE));
/* wait for current transmission finished */
while (!((*(CSSR)) & TEND));
/* clear TEND bit */
*(CSSR) = *(CSSR) & (~TEND);
#endif
return OK;
}
static BOOL ChannelOpen( void )
{
/* Set flag TEND to fit to the function ChannelSet(Byte) */
*(CTDR) = '*';
*(CSSR) = *(CSSR) & ((~TEND)&(~TDRE));
return OK;
}
static BOOL ChannelSet( BYTE data )
{
#if 1
/* wait for the last transmission finished */
while (!((*(CSSR)) & TEND));
*(CTDR) = data;
*(CSSR) = *(CSSR) & ((~TEND)&(~TDRE));
#else
/* send character */
*(CTDR) = data;
*(CSSR) = *(CSSR) & (~TDRE); /* clear TDRE bit, start transmitting */
/* wait for transmission finished */
while (!(status & TEND))
{
status = *(CSSR);
}
*(CSSR) = *(CSSR) & (~TEND); /* clear TEND bit */
#endif
return OK;
}
static BOOL ChannelGet( BYTE *dataPtr )
{
if( dataPtr == NULL )
return ERROR;
/* wait for character to arrive */
while (1)
{
if ( (*(CSSR)) & RDRF )
{
/* receive character */
*dataPtr = (unsigned char) *(CRDR) & 0xFF;
*(CSSR) = *(CSSR) & (~(RDRF|ORER|FER|PER));
return OK;
}
}
return ERROR;
}
#endif
/******************************************************************************
* Function: Recsw
*
* Description: Kermit state machine for receiving file
*
* Inputs: None
*
* Outputs: None
*
* Returns: errCodeType - OK
* ERROR
*
* Note: (optional section giving special considerations about the function)
******************************************************************************/
//#include <allocate.h>
static BOOL Recsw(void)
{
BYTE tmp_uch;
while((rs_getbyte(&tmp_uch)==OK));
ChannelOpen();
rsInitFlashBuff();
state = 'R'; /* Receive-Init is the start state */
n = 0; /* Initialize message number */
numtry = 0; /* Say no tries yet */
image = TRUE; /* Default to no processing for */
debug = 0;
totalBytes = 0;
numFlashData = 0;
flashDataPtr = (UINT8*)&flashData;
// wPtr = &(rsFlashBuff[0]);
// orgwPtr = wPtr;
/* start kermit state machine */
while( 1 )
{
switch(state) /* Do until done */
{
case 'R': state = Rinit(); break; /* Receive-Init */
case 'F': state = Rfile(); break; /* Receive-File */
case 'D': state = Rdata(); break; /* Receive-Data */
case 'C': ChannelClose();
outbyte('&');
outbyte('&');
// if(DataFlush2Ram( (UINT8 *)wPtr, (UINT8 *)&flashData, 0)!=OK)
// if(rsData2FlashBuff((UINT8 *)&flashData, 0)!=OK)
if(rsFlushFlashBuff() != OK)
{
printf("\nFlash Program Failure.\n");
return FALSE;
}
return TRUE; /* Complete state */
case 'A': ChannelClose();
outbyte('A');
outbyte('b');
outbyte('o');
outbyte('r');
outbyte('t');
outbyte('!');
outbyte('\0');
return FALSE; /* "Abort" state */
}
}
}
/******************************************************************************
* Function: Rinit
*
* Description: Receive Initialization
*
* Inputs: None
*
* Outputs: None
*
* Returns: char - the new state of Kermit receive state machine
*
* Note: (optional section giving special considerations about the function)
******************************************************************************/
static char Rinit(void)
{
int len, num; /* Packet length, number */
if (numtry++ > MAXTRY) return('A'); /* If too many tries, "abort" */
switch(Rpack(&len,&num,packet)) /* Get a packet */
{
case 'S': /* Send-Init */
Rpar(packet); /* Get the other side's init data */
Spar(packet); /* Fill up packet with my init info */
Spack('Y',n,6,packet); /* ACK with my parameters */
oldtry = numtry; /* Save old try count */
numtry = 0; /* Start a new counter */
n = (n+1)%64; /* Bump packet number, mod 64 */
return('F'); /* Enter File-Receive state */
case 'E': /* Error packet received */
Prerrpkt(recpkt); /* Print it out and */
return('A'); /* abort */
case FALSE: /* Didn't get packet */
Spack('N',n,0,0); /* Return a NAK */
return(state); /* Keep trying */
default: return('A'); /* Some other packet type, "abort" */
}
}
/******************************************************************************
* Function: Rfile
*
* Description: Receive File Header
*
* Inputs: None
*
* Outputs: None
*
* Returns: char - the next state of Kermit receive state machine
*
* Note: (optional section giving special considerations about the function)
******************************************************************************/
static char Rfile(void)
{
int num, len; /* Packet number, length */
if (numtry++ > MAXTRY) return('A'); /* "abort" if too many tries */
switch(Rpack(&len,&num,packet)) /* Get a packet */
{
case 'S': /* Send-Init, maybe our ACK lost */
if (oldtry++ > MAXTRY) return('A'); /* If too many tries "abort" */
if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
{ /* Yes, ACK it again with */
Spar(packet); /* our Send-Init parameters */
Spack('Y',num,6,packet);
numtry = 0; /* Reset try counter */
return(state); /* Stay in this state */
}
else return('A'); /* Not previous packet, "abort" */
case 'Z': /* End-Of-File */
if (oldtry++ > MAXTRY) return('A');
if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
{ /* Yes, ACK it again. */
Spack('Y',num,0,0);
numtry = 0;
return(state); /* Stay in this state */
}
else return('A'); /* Not previous packet, "abort" */
case 'F': /* File Header (just what we want) */
if (num != n) return('A'); /* The packet number must be right */
Spack('Y',n,0,0); /* Acknowledge the file header */
oldtry = numtry; /* Reset try counters */
numtry = 0; /* ... */
n = (n+1)%64; /* Bump packet number, mod 64 */
return('D'); /* Switch to Data state */
case 'B': /* Break transmission (EOT) */
if (num != n) return ('A'); /* Need right packet number here */
Spack('Y',n,0,0); /* Say OK */
return('C'); /* Go to complete state */
case 'E': /* Error packet received */
Prerrpkt(recpkt); /* Print it out and */
return('A'); /* abort */
case FALSE: /* Didn't get packet */
Spack('N',n,0,0); /* Return a NAK */
return(state); /* Keep trying */
default: return ('A'); /* Some other packet, "abort" */
}
}
/******************************************************************************
* Function: Rdata
*
* Description: Receive Data
*
* Inputs: None
*
* Outputs: None
*
* Returns: char - the next state of Kermit receive state machine
*
* Note: (optional section giving special considerations about the function)
******************************************************************************/
static char Rdata(void)
{
int num, len;
/* Packet number, length */
if (numtry++ > MAXTRY) return('A'); /* "abort" if too many tries */
switch(Rpack(&len,&num,packet)) /* Get packet */
{
case 'D': /* Got Data packet */
if (num != n) /* Right packet? */
{ /* No */
if (oldtry++ > MAXTRY)
return('A'); /* If too many tries, abort */
if (num == ((n==0) ? 63:n-1)) /* Else check packet number */
{ /* Previous packet again? */
Spack('Y',num,6,packet); /* Yes, re-ACK it */
numtry = 0; /* Reset try counter */
return(state); /* Don't write out data! */
}
else return('A'); /* sorry, wrong number */
}
/* Got data with right packet number */
Bufemp(packet,len); /* Write the data to the file */
Spack('Y',n,0,0); /* Acknowledge the packet */
oldtry = numtry; /* Reset the try counters */
numtry = 0; /* ... */
n = (n+1)%64; /* Bump packet number, mod 64 */
return('D'); /* Remain in data state */
case 'F': /* Got a File Header */
if (oldtry++ > MAXTRY)
return('A'); /* If too many tries, "abort" */
if (num == ((n==0) ? 63:n-1)) /* Else check packet number */
{ /* It was the previous one */
Spack('Y',num,0,0); /* ACK it again */
numtry = 0; /* Reset try counter */
return(state); /* Stay in Data state */
}
else return('A'); /* Not previous packet, "abort" */
case 'Z': /* End-Of-File */
if (num != n) return('A'); /* Must have right packet number */
Spack('Y',n,0,0); /* OK, ACK it. */
if( numFlashData == 1 )
{
/* write the last byte into Flash */
flashDataPtr[ 1 ] = 0xff;
#if 1
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -