/****************************************************************************
* 名 称：FS_Init
* 功 能：初始化系统配置,小车配置等信息
* 参 数：无
* 反 回：无
* 说 明：
****************************************************************************/
void FS_Init(void)
{
#if SPI_FLASH_DEBUG
u16 ChipID = 0;
#endif
SPI_Flash_Init();
#if SPI_FLASH_DEBUG
ChipID = SPI_Flash_ReadID();
if((ChipID & FLASH_ID) == FLASH_ID)
printf("Read SPI Flash Chip ID Success\r\n");
else
printf("Read SPI Flash Chip ID Error\r\n");
#endif
SPI_Flash_Read( CAR_CFG_OFFSET, (u8*)&Car_Save_Info, sizeof(Car_Save_Info));
if( strcmp( Car_Save_Info.CheckStr , CAR_CHECK_STR) != NULL )
{
#if SPI_FLASH_DEBUG
printf("Read CarPara Error,Write to Default Info\r\n");
#endif
memset( (char*)&Car_Save_Info, 0x00, sizeof(Car_Save_Info));
sprintf(Car_Save_Info.CheckStr,"%s",CAR_CHECK_STR);
Car_Save_Info.CarPara.RunMode = CAR_MODE_MANUAL;
Car_Save_Info.CarPara.SetSpeed = 15;
SPI_Flash_Write( CAR_CFG_OFFSET, (unsigned char *)&Car_Save_Info, sizeof(Car_Save_Info));
}
#if SPI_FLASH_DEBUG
printf("Read CarPara Success\r\n");
#endif
SPI_Flash_Read( ROUTE_CFG_OFFSET, (u8*)&Route_Save_Info, sizeof(Route_Save_Info));
if( strcmp( Route_Save_Info.CheckStr , ROUTE_CHECK_STR) != NULL )
{
#if SPI_FLASH_DEBUG
printf("Read Route Error,Write to Default Info\r\n");
#endif
memset( (char*)&Route_Save_Info, 0x00, sizeof(Route_Save_Info));
sprintf(Route_Save_Info.CheckStr,"%s",ROUTE_CHECK_STR);
SPI_Flash_Write( ROUTE_CFG_OFFSET, (unsigned char *)&Route_Save_Info, sizeof(Route_Save_Info));
}
#if SPI_FLASH_DEBUG
printf("Read Route Success\r\n");
#endif
}
DRESULT disk_write (
BYTE drv, /* Physical drive nmuber (0..) */
const BYTE *buff, /* Data to be written */
DWORD sector, /* Sector address (LBA) */
BYTE count /* Number of sectors to write (1..255) */
)
{
SD_Error Status = SD_OK;
#if 1
switch(drv)
{
case SD_CARD://SD卡
//SD卡开始----------------------------------------
while (count--)
{
Status = SD_WriteBlock((uint8_t *)buff, sector << 9 ,SECTOR_SIZE);
if (Status != SD_OK)
{
break;
}
}
//SD卡结束----------------------------------------
break;
case EX_FLASH://外部flash
for(;count>0;count--)
{
SPI_Flash_Write((u8*)buff,sector*SECTOR_SIZE,SECTOR_SIZE);
sector++;
buff+=SECTOR_SIZE;
}
Status=SD_OK;
break;
default:
Status=SD_ERROR;
}
#else /* SD_WriteMultiBlocks() 偶尔会执行出错 */
if (count == 1)
{
Status = SD_WriteBlock((uint8_t *)buff, sector << 9 ,SECTOR_SIZE);
}
else
{
Status = SD_WriteMultiBlocks((uint8_t *)buff, sector << 9 ,SECTOR_SIZE, count);
}
#endif
if (Status == SD_OK)
{
return RES_OK;
}
else
{
printf("Err: SD_WriteBlocks(,%d,%d)\r\n",sector,count);
return RES_ERROR;
}
}
/////////////////////////////////////////////////////////////////////////////
//----保存BT参数---------------------------------------------------------------
void save_para_BT_enable(u8 ch)
{
// u8 para;
// SPI_Flash_Read((u8*)¶, FILE_PARA_ADDR, sizeof(FILE_PARA_STRUCT));
// para.BT_use = ch;
//保存参数
SPI_Flash_Write(&ch, FILE_PARA_ADDR, 1);
}
//更新某一个
//fxpath:路径
//fx:更新的内容 0,ungbk;1 ,gbk16;
//返回值:0,成功;其他,失败.
u8 updata_fontx(u8 *fxpath,u8 fx)
{
u32 flashaddr=0;
u32 tempsys[2]; //临时记录文件起始位置和文件大小
FIL * fftemp;
u8 res;
u16 bread;
u32 offx=0;
fftemp=&gbkFile;
if(fftemp==NULL)return 1; //内存分配出错.
res=f_open(fftemp,(const TCHAR*)fxpath,FA_READ);
if(res)//打开文件失败
{
f_close(fftemp);
return 2;//文件丢失
}
if(fftemp==NULL)return 2;
if(fx==0)//更新UNI2GBK.SYS
{
tempsys[0]=ftinfo.ugbkaddr; //UNIGBK存放地址
tempsys[1]=fftemp->fsize; //UNIGBK 大小
SPI_Flash_Write((u8*)tempsys,FONTINFOADDR,8); //记录在地址FONTINFOADDR+1~8处
flashaddr=ftinfo.ugbkaddr;
} else//GBK16
{
SPI_Flash_Read((u8*)tempsys,FONTINFOADDR,8); //读出8个字节
flashaddr=tempsys[0]+tempsys[1];
tempsys[0]=flashaddr; //GBK16的起始地址
tempsys[1]=fftemp->fsize; //GBK16 大小
SPI_Flash_Write((u8*)tempsys,FONTINFOADDR+8,8); //记录在地址FONTINFOADDR+1~8+16处
}
while(res==FR_OK)//死循环执行
{
res=f_read(fftemp,temp,1024,(UINT *)&bread);
if(res!=FR_OK)break; //执行错误
SPI_Flash_Write(temp,offx+flashaddr,1024);//从0开始写入1024个数据
offx+=bread;
fupd_prog(fftemp->fsize,offx); //进度显示
if(bread!=1024)break; //读完了.
}
return res;
}
DRESULT disk_write (
BYTE drv, /* Physical drive nmuber (0..) */
const BYTE *buff, /* Data to be written */
DWORD sector, /* Sector address (LBA) */
BYTE count /* Number of sectors to write (1..255) */
)
{
u8 res=0;
if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误
switch(drv)
{
case SD_CARD://SD卡
if (count > 1)
{
SD_WriteMultiBlocks((uint8_t *)buff, sector*BLOCK_SIZE, BLOCK_SIZE, count);
/* Check if the Transfer is finished */
SD_WaitWriteOperation(); //等待dma传输结束
while(SD_GetStatus() != SD_TRANSFER_OK); //等待sdio到sd卡传输结束
}
else
{
SD_WriteBlock((uint8_t *)buff,sector*BLOCK_SIZE, BLOCK_SIZE);
/* Check if the Transfer is finished */
SD_WaitWriteOperation(); //等待dma传输结束
while(SD_GetStatus() != SD_TRANSFER_OK); //等待sdio到sd卡传输结束
}
break;
case EX_FLASH://外部flash
for(;count>0;count--)
{
SPI_Flash_Write((u8*)buff,sector*BLOCK_SIZE,BLOCK_SIZE);
sector++;
buff+=BLOCK_SIZE;
}
res=0;
break;
default:
res=1;
}
//处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
if(res == 0x00)return RES_OK;
else return RES_ERROR;
}
/*******************************************************************************
* Function Name : MAL_Write
* Description : Write sectors
* Input : None
* Output : None
* Return : 0,OK
1,FAIL
*******************************************************************************/
u16 MAL_Write(u8 lun, u32 Memory_Offset, u32 *Writebuff, u16 Transfer_Length)
{
u8 STA;
switch (lun)
{
case 0:
STA=SD_WriteDisk((u8*)Writebuff, Memory_Offset>>9, Transfer_Length>>9);
break;
case 1:
STA=0;
SPI_Flash_Write((u8*)Writebuff, Memory_Offset, Transfer_Length);
break;
default:
return MAL_FAIL;
}
if(STA!=0)return MAL_FAIL;
return MAL_OK;
}
void OneSecond_Handler(void) //1S中断函数，在SysTick_Handler()中调用
{
Ethernet_Time_Count++; //用于1小时内计时判断控制器没有接收以太网的次数
minute++;
if(minute==5) //分钟应用
{
minute=0;
if(UHRFID_Flag & 0x01)
{
MJ_Tim++; //上模具计时
}
if(Input_Flag & 0x01)
{
XT_ONTime++; //系统上电计时，5秒
}
}
if(Input_Flag & 0x02)
{
RL_ONTime++; //熔炉上电计时，秒
}
if(YGTM_Flag & 0x01)
{
YG_Tim++; //员工在岗计时，秒
}
if((YGTM_Flag != 0x01) && Ethernet_Reset_Count >=2)
{
CPU_Reset_Time++; //当以太网重启的次数大于等于2次，而且员工不在岗，CPU复位计时
}
SYS_Timer++;
SYS_OnTime++;
if(SYS_Timer % 3600==0)
{
u8 Buffer[4];
Buffer[0]=SYS_Timer>>24;
Buffer[1]=SYS_Timer>>16;
Buffer[2]=SYS_Timer>>8;
Buffer[3]=SYS_Timer;
SPI_Flash_Write(Buffer,SYS_Space,4);
}
//更新字体文件,UNIGBK,GBK16一起更新
//返回值:0,更新成功;
// 其他,错误代码.
u8 update_font()
{
u8 *gbk16_path;
u8 *unigbk_path;
u8 res;
unigbk_path=(u8*)UNIGBK_SDPATH;
gbk16_path=(u8*)GBK16_SDPATH;
POINT_COLOR=RED;
LCD_ShowString(60,90,"Updating UNI2GBK.SYS");
res=updata_fontx(unigbk_path,0);//更新UNIGBK.BIN
if(res)return 1;
LCD_ShowString(60,90,"Updating GBK16.FON ");
res=updata_fontx(gbk16_path,1);//更新GBK16.FON
if(res)return 2;
//全部更新好了
res=0XAA;
SPI_Flash_Write(&res,FONTINFOADDR+24,1);//写入字库存在标志 0XAA
return 0;//无错误.
}
/****************************************************************************
* 名 称：OutsideValidDataProcess
* 功 能：收到路径序列时的处理过程
* 参 数：data 为指向路径序列的首地址，len 为路径序列的数组长度
* 反 回：无
* 说 明：
****************************************************************************/
void OutsideValidDataProcess(uint8_t *buf,uint16_t len)
{
memcpy((u8*)&Route_Save_Info,buf,len);
Route_Save_Info.TotalNum = len / sizeof(ROUTE_SERIAL_INFO);
SPI_Flash_Write(ROUTE_CFG_OFFSET,(u8*)&Route_Save_Info,sizeof(Route_Save_Info));
}
/****************************************************************************
* 名 称：void CheckConfigChange(void)
* 功 能：检查配置是否发生改变
* 参 数：无
* 反 回：无
* 说 明：
****************************************************************************/
void CheckConfigChange(void)
{
uint8_t IsChanged=0;
//////////////////////////////////环境事件改变///////////////////////////////
if(CarData->AGVID != LastCarData.AGVID)
{
LastCarData.AGVID = CarData->AGVID;
Car_Save_Info.CarPara.AGVID = CarData->AGVID;
IsChanged = 1;
Change_Flag.Env.BITS.AGVID = 1;
}
if(CarData->SetSpeed != LastCarData.SetSpeed)
{
LastCarData.SetSpeed = CarData->SetSpeed;
Car_Save_Info.CarPara.SetSpeed = CarData->SetSpeed;
IsChanged = 1;
Change_Flag.Env.BITS.SetSpeed = 1;
}
if(CarData->RunMode != LastCarData.RunMode)
{
LastCarData.RunMode = CarData->RunMode;
Car_Save_Info.CarPara.RunMode = CarData->RunMode;
IsChanged = 1;
Change_Flag.Env.BITS.RunMode = 1;
}
if(CarData->StopTime != LastCarData.StopTime)
{
LastCarData.StopTime = CarData->StopTime;
Car_Save_Info.CarPara.StopTime = CarData->StopTime;
IsChanged = 1;
Change_Flag.Env.BITS.StopTime = 1;
}
if(CarData->PValue != LastCarData.PValue)
{
LastCarData.PValue = CarData->PValue;
Car_Save_Info.CarPara.PValue = CarData->PValue;
IsChanged = 1;
Change_Flag.Env.BITS.PValue = 1;
}
if(CarData->DValue != LastCarData.DValue)
{
LastCarData.DValue = CarData->DValue;
Car_Save_Info.CarPara.DValue = CarData->DValue;
IsChanged = 1;
Change_Flag.Env.BITS.DValue = 1;
}
if(CarData->VoltageAdjust != LastCarData.VoltageAdjust)
{
LastCarData.VoltageAdjust = CarData->VoltageAdjust;
Car_Save_Info.CarPara.VoltageAdjust = CarData->VoltageAdjust;
IsChanged = 1;
Change_Flag.Env.BITS.VoltageAdjust = 1;
}
if(CarData->UseLimit != LastCarData.UseLimit)
{
LastCarData.UseLimit = CarData->UseLimit;
Car_Save_Info.CarPara.UseLimit = CarData->UseLimit;
IsChanged = 1;
Change_Flag.Env.BITS.UseLimit = 1;
}
if(CarData->ManualCmd != LastCarData.ManualCmd)
{
LastCarData.ManualCmd = CarData->ManualCmd;
Change_Flag.Env.BITS.ManualCmd = 1;
}
if(CarData->NowSpeed != LastCarData.NowSpeed)
{
LastCarData.NowSpeed = CarData->NowSpeed;
Change_Flag.Env.BITS.NowSpeed = 1;
}
if(CarData->Voltage != LastCarData.Voltage)
{
LastCarData.Voltage = CarData->Voltage;
Change_Flag.Env.BITS.Voltage = 1;
}
if(CarData->NowStatus != LastCarData.NowStatus)
{
LastCarData.NowStatus = CarData->NowStatus;
Change_Flag.Env.BITS.NowStatus = 1;
}
if(CarData->LastStation != LastCarData.LastStation)
{
LastCarData.LastStation = CarData->LastStation;
Change_Flag.Env.BITS.LastStation = 1;
}
if(CarData->Distance != LastCarData.Distance)
{
LastCarData.Distance = CarData->Distance;
Change_Flag.Env.BITS.Distance = 1;
}
if(CarData->NextStation != LastCarData.NextStation)
{
LastCarData.NextStation = CarData->NextStation;
Change_Flag.Env.BITS.NextStation = 1;
}
if(CarData->Destination != LastCarData.Destination)
{
LastCarData.Destination = CarData->Destination;
Change_Flag.Env.BITS.Destination = 1;
}
//////////////////////////////////外部事件发生///////////////////////////////
if(!GPIO_ReadInputDataBit(IR_Far_PORT, IR_Far_PIN)) //红外远障碍
{
Change_Flag.Ext.BITS.IR_Far = 1;
}
if(!GPIO_ReadInputDataBit(IR_Near_PORT, IR_Near_PIN)) //红外近障碍
{
Change_Flag.Ext.BITS.IR_Near = 1;
}
if(INT_Event.BITS.LRS_Far_Flag)
{
INT_Event.BITS.LRS_Far_Flag = 0;
Change_Flag.Ext.BITS.LRS_Far = 1;
}
if(INT_Event.BITS.LRS_Near_Flag)
{
INT_Event.BITS.LRS_Near_Flag = 0;
Change_Flag.Ext.BITS.LRS_Near = 1;
}
if(INT_Event.BITS.STOP_Flag)
{
INT_Event.BITS.STOP_Flag = 0;
Change_Flag.Ext.BITS.STOP = 1;
}
if(INT_Event.BITS.LT_UP_Flag)
{
INT_Event.BITS.LT_UP_Flag = 0;
Change_Flag.Ext.BITS.LT_UP = 1;
}
if(INT_Event.BITS.LT_DOWN_Flag)
{
INT_Event.BITS.LT_DOWN_Flag = 0;
Change_Flag.Ext.BITS.LT_DOWN = 1;
}
if(INT_Event.BITS.KEY1_Flag)
{
INT_Event.BITS.KEY1_Flag = 0;
Change_Flag.Ext.BITS.KEY1 = 1;
}
if(INT_Event.BITS.KEY2_Flag)
{
INT_Event.BITS.KEY2_Flag = 0;
Change_Flag.Ext.BITS.KEY2 = 1;
}
if(INT_Event.BITS.KEY3_Flag)
{
INT_Event.BITS.KEY3_Flag = 0;
Change_Flag.Ext.BITS.KEY3 = 1;
}
if(INT_Event.BITS.KEY4_Flag)
{
INT_Event.BITS.KEY4_Flag = 0;
Change_Flag.Ext.BITS.KEY4 = 1;
}
if(IsChanged)
{
SPI_Flash_Write(CAR_CFG_OFFSET,(u8*)&Car_Save_Info,sizeof(Car_Save_Info));
}
}
u8 Update_Font(void)
{
u32 fcluster=0;
u32 i;
//u8 temp[512]; //零时空间 在这里定义,会内存溢出
u32 tempsys[2]; //临时记录文件起始位置和文件大小
float prog;
u8 t;
FileInfoStruct FileTemp;//零时文件夹
//得到根目录的簇号
if(FAT32_Enable)fcluster=FirstDirClust;
else fcluster=0;
FileTemp=F_Search(fcluster,(unsigned char *)folder[0],T_FILE);//查找system文件夹
if(FileTemp.F_StartCluster==0)return 1; //系统文件夹丢失
{
//先查找字体
FileTemp=F_Search(FileTemp.F_StartCluster,(unsigned char *)folder[1],T_FILE);//在system文件夹下查找FONT文件夹
if(FileTemp.F_StartCluster==0)return 2;//字体文件夹丢失
fcluster=FileTemp.F_StartCluster; //字体文件夹簇号
FileTemp=F_Search(fcluster,(unsigned char *)sysfile[2],T_SYS);//在system文件夹下查找SYS文件
if(FileTemp.F_StartCluster==0)return 3;//FONT12字体文件丢失
LCD_ShowString(20,90,"Write UNI2GBK to FLASH...");
LCD_ShowString(108,110,"%");
F_Open(&FileTemp);//打开该文件
i=0;
while(F_Read(&FileTemp,temp))//成功读出512个字节
{
if(i<FileTemp.F_Size)//不超过文件大小
{
SPI_Flash_Write(temp,i+100000,512);//从100K字节处开始写入512个数据
i+=512;//增加512个字节
}
prog=(float)i/FileTemp.F_Size;
prog*=100;
if(t!=prog)
{
t=prog;
if(t>100)t=100;
LCD_ShowNum(84,110,t,3,16);//显示数值
}
}
UNI2GBKADDR=100000;//UNI2GBKADDR从100K处开始写入.
tempsys[0]=UNI2GBKADDR;
tempsys[1]=FileTemp.F_Size; //UNI2GBKADDR 大小
SPI_Flash_Write((u8*)tempsys,0,8);//记录在地址0~7处
delay_ms(1000);
//printf("UNI2GBK写入FLASH完毕!\n");
//printf("写入数据长度:%d\n",FileTemp.F_Size);
//printf("UNI2GBKSADDR:%d\n\n",UNI2GBKADDR);
FONT16ADDR=FileTemp.F_Size+UNI2GBKADDR;//F16的首地址
FileTemp=F_Search(fcluster,(unsigned char *)sysfile[0],T_FON);//在system文件夹下查找FONT16字体文件
if(FileTemp.F_StartCluster==0)return 4;//FONT16字体文件丢失
LCD_ShowString(20,90,"Write FONT16 to FLASH... ");
//printf("开始FONT16写入FLASH...\n");
F_Open(&FileTemp);//打开该文件
i=0;
while(F_Read(&FileTemp,temp))//成功读出512个字节
{
if(i<FileTemp.F_Size)//不超过文件大小
{
SPI_Flash_Write(temp,i+FONT16ADDR,512);//从0开始写入512个数据
i+=512;//增加512个字节
}
prog=(float)i/FileTemp.F_Size;
prog*=100;
if(t!=prog)
{
t=prog;
if(t>100)t=100;
LCD_ShowNum(84,110,t,3,16);//显示数值
}
}
tempsys[0]=FONT16ADDR;
tempsys[1]=FileTemp.F_Size; //FONT16ADDR 大小
SPI_Flash_Write((u8*)tempsys,8,8);//记录在地址8~15处
delay_ms(1000);
//printf("FONT16写入FLASH完毕!\n");
//printf("写入数据长度:%d\n",FileTemp.F_Size);
FONT12ADDR=FileTemp.F_Size+FONT16ADDR;//F16的首地址
//printf("FONT16SADDR:%d\n\n",FONT16ADDR);
//LCD_ShowString(20,60,"Write FONT12 to FLASH... ");
//FONT12暂时不加入
/*
FileTemp=F_Search(fcluster,(unsigned char *)sysfile[1],T_FON);//在system文件夹下查找FONT12字体文件
if(FileTemp.F_StartCluster==0)return 5;//FONT12字体文件丢失
printf("开始FONT12写入FLASH...\n");
F_Open(&FileTemp);//打开该文件
i=0;
while(F_Read(&FileTemp,temp))//成功读出512个字节
{
if(i<FileTemp.F_Size)//不超过文件大小
{
SPI_Flash_Write(temp,i+FONT12ADDR,512);//从0开始写入512个数据
i+=512;//增加512个字节
}
prog=(float)i/FileTemp.F_Size;
prog*=100;
if(t!=prog)
{
t=prog;
if(t>100)t=100;
LCD_ShowNum(84,80,t,3,16);//显示数值
}
}
tempsys[0]=FONT12ADDR;
tempsys[1]=FileTemp.F_Size; //FONT16ADDR 大小
SPI_Flash_Write((u8*)tempsys,16,8);//记录在地址16~23处
printf("FONT12写入FLASH完毕!\n");
printf("写入数据长度:%d\n",FileTemp.F_Size);
printf("FONT12SADDR:%d\n\n",FONT12ADDR); */
}
t=0XAA;
SPI_Flash_Write(&t,24,1);//写入字库存在标志 0XAA
LCD_ShowString(20,90," Font Update Successed ");
delay_ms(1000);
delay_ms(1000);
return 0;//成功
}
int main(void)
{
u8 Data_PC[SIZE]; //从Flash中读取数据到Data_PC，并上传至上位机
u16 a,b=0;
delay_init(); //延时函数初始化
NVIC_Configuration();//设置NVIC中断分组2:2位抢占优先级，2位响应优先级
uart_init(9600); //串口初始化为9600
LED_Init(); //LED端口初始化
LCD_Init();
KEY_Init();
WORD_Init();
TIM2_Int_Init(999,7199);
TIM3_Int_Init(9,7199);
EXTIX_Init(); //外部中断初始化
Adc_Init(); //ADC初始化
SPI_Flash_Init(); //SPI FLASH 初始化
while(1)
{
//功能：开机状态显示
//说明：1.开机，绿灯亮（DS1）
// 2.使用temp是为了避免重复执行该if语句
if(flag2==1&&temp==0)
{
while(SPI_Flash_ReadID()!=W25Q64) //检测不到W25Q64
{
LCD_ShowString(40,150,200,16,16,"W25Q64 Check Failed!");
delay_ms(500);
LCD_ShowString(40,150,200,16,16,"Please Check! ");
delay_ms(500);
LED0=!LED0;//DS0闪烁
}
LCD_ShowString(60,130,200,16,16,"W25Q64 Ready!");
LED1=0;
temp=1;
}
//功能：数据采集并保存至Flash中
//说明：1.使用temp1是为了避免重复使能TIM3
// 2.使用temp2是为了避免在数据上传至上位机的过程中，与终止上传功能相冲突
// 3.flag1=1代表按键按下，并开始采集
// 4.flag2=1代表开机，flag2=0代表未开机
// 5.采集过程中，红灯（DS0）以一定频率闪烁
if(flag2==1&&temp2==0&&flag1==1)
{
if(temp1==0)
{
LCD_ShowString(20,150,200,16,16,"Data collection began...");
TIM_Cmd(TIM3, ENABLE); //使能TIM3中断
LED0=0;
}
temp1=1;
if(flag_cycle==0&&flag_cycle_1==0)
{
SPI_Flash_Write((u8*)TEXT_Buffer2,FLASH_SIZE+counter*SIZE,SIZE);
counter++;
flag_cycle_1=1;
}
if(flag_cycle==1&&flag_cycle_1==0)
{
SPI_Flash_Write((u8*)TEXT_Buffer1,FLASH_SIZE+counter*SIZE,SIZE);
counter++;
flag_cycle_1=1;
}
}
//功能：将Flash中采集到的数据上传至上位机
//说明：1.使用temp1是为了保证上传是在采集之后进行
// 2.使用temp3是为了避免由于按键误操作使得该程序重复被执行
// 3.flag1=0代表按键再次被按下，上传开始 ；若再次被按下，则上传被终止；之后再按就没有作用了
// 4.上传过程中，红灯（DS0）以一定频率闪烁
if(temp1==1&&temp3==0&&flag1==0)
{
TIM_Cmd(TIM3, DISABLE); //失能TIM3中断
//用于解决当采集时间不是42ms的倍数时，部分采集数据未写入FLash的问题
if((time_collect-1)%42!=0)
{
data_residue=(time_collect-1)%42*6;
if(flag_cycle==0)
{
SPI_Flash_Write((u8*)TEXT_Buffer2,FLASH_SIZE+(counter+1)*SIZE,SIZE);
}
if(flag_cycle==1)
{
SPI_Flash_Write((u8*)TEXT_Buffer1,FLASH_SIZE+(counter+1)*SIZE,SIZE);
}
}
LCD_ShowString(20,170,200,16,16,"Data collection complete!");
LCD_ShowString(20,190,200,16,16,"Data is being uploaded...");
temp2=1;
for(a=1;a<counter;a++)
{
LED0=!LED0;
SPI_Flash_Read(Data_PC,FLASH_SIZE+a*SIZE,SIZE);
for(b=0;b<SIZE;b++)
{
if(flag1==1) //上传中途使用按键停止传送
{
break;
}
USART_GetFlagStatus(USART1, USART_FLAG_TC);
USART_SendData(USART1,Data_PC[b]);
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
}
if(flag1==1) //上传中途使用按键停止传送
{
LCD_ShowString(20,210,200,16,16,"Data upload is terminated!");
break;
}
}
//用于解决当采集时间不是42ms的倍数时，部分采集数据未写入FLash的问题
if(flag1!=1&&(time_collect-1)%42!=0)
{
LED0=!LED0;
SPI_Flash_Read(Data_PC,FLASH_SIZE+(a+1)*SIZE,SIZE);
for(b=0;b<data_residue;b++)
{
if(flag1==1) //上传中途使用按键停止传送
{
break;
}
USART_GetFlagStatus(USART1, USART_FLAG_TC);
USART_SendData(USART1,Data_PC[b]);
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
}
if(flag1==1) //上传中途使用按键停止传送
{
LCD_ShowString(20,210,200,16,16,"Data upload is terminated!");
break;
}
}
if(flag1!=1) //要么显示数据上传完成，要么显示数据上传完成
{
LCD_ShowString(20,210,200,16,16,"Data upload is completed!");
}
temp3=1;
}
//功能：关机并擦除Flash
//说明：1.flag2=0代表关机，与上temp1,temp2是要保证前面的已被执行
// 2.关机过程中擦除Flash，完成之后红绿灯同时亮一秒后灭
if(temp1==1&&temp2==1&&flag2==0) //关机机状态显示
{
flag1=0;
flag2=0;
temp1=0;
temp2=0;
LED0=1;
LED1=1;
SPI_Flash_Erase_Chip();
LED0=0;
LED1=0;
delay_ms(1000);
LED0=1;
LED1=1;
LCD_ShowString(80,230,200,16,16,"Shutdown!");
}
}
}
/*
* 函数名：USART3_ReceiveDW()
* 描述： 串口3数据接收处理
* 输入： 无
* 输出： 无
* 返回： 无
*/
void USART3_ReceiveDW() //接收到的数据处理
{
if(USART3_Flag & 0x20)
{
u8 tem=(USART3_RxBuffer[1]-0x30)*10+USART3_RxBuffer[2]-0x30; //计算命令字
switch(USART3_RxBuffer[0])
{
case 'R':
{ //读命令
switch(tem)
{
case 1: //发送本机地址
{
Send_Address();
Clear_RxBuffer();
break;
}
case 2: //发送本机机器类型
{
Send_MACHINE_TYPE();
Clear_RxBuffer();
break;
}
case 3: //发送本机当前运行状态
{
USART3_TxBuffer[0]=RUN_STATE;
USART3_TxBuffer[1]=0x0D; //结束符
USART3_TxBuffer[2]=0x0A;
USART3_TxLen=3;
USART3_SendDW();
Clear_RxBuffer();
break;
}
case 4: //发送机器当前模具条码
{
SendMJCode();
Clear_RxBuffer();
break;
}
case 5: //发送当前员工条码
{
SendYGCode();
Clear_RxBuffer();
break;
}
case 6: //发送机器当前模具开模总数
{
Send_MMYY(MJ_Cnt);
Clear_RxBuffer();
break;
}
case 7: //发送机器当前模具安装时间
{
Send_MMYY(MJ_Tim);
Clear_RxBuffer();
break;
}
case 8: //发送机器当前员工开模计数
{
Send_MMYY(YG_Cnt);
Clear_RxBuffer();
break;
}
case 9: //发送机器当前员工在岗时间
{
Send_MMYY(YG_Tim);
Clear_RxBuffer();
break;
}
case 20: //返回指令字001命令
{
USART3_SendWorld=1;
Clear_RxBuffer();
break;
}
case 21: //返回指令字110命令
{
USART3_SendWorld=2;
Clear_RxBuffer();
break;
}
case 22: //返回指令字111命令
{
USART3_SendWorld=3;
Clear_RxBuffer();
break;
}
case 23: //返回指令字112命令
{
USART3_SendWorld=4;
Clear_RxBuffer();
break;
}
case 24: //返回指令字113命令
{
USART3_SendWorld=5;
Clear_RxBuffer();
break;
}
case 25: //返回指令字114命令
{
USART3_SendWorld=6;
Clear_RxBuffer();
break;
}
case 26: //返回指令字110命令
{
USART3_SendWorld=19;
Clear_RxBuffer();
break;
}
case 27: //返回指令字111命令
{
USART3_SendWorld=8;
Clear_RxBuffer();
break;
}
case 28: //返回指令字112命令
{
USART3_SendWorld=9;
Clear_RxBuffer();
break;
}
case 29: //返回指令字113命令
{
USART3_SendWorld=10;
Clear_RxBuffer();
break;
}
case 30: //返回指令字114命令
{
USART3_SendWorld=11;
Clear_RxBuffer();
break;
}
case 31: //返回指令字115命令
{
USART3_SendWorld=12;
Clear_RxBuffer();
break;
}
case 32: //返回指令字116命令
{
USART3_SendWorld=13;
Clear_RxBuffer();
break;
}
case 33: //返回指令字117命令
{
USART3_SendWorld=14;
Clear_RxBuffer();
break;
}
case 34: //返回系统上电信息
{
USART3_SendWorld=15;
Clear_RxBuffer();
break;
}
case 35: //返回员工上岗信息
{
USART3_SendWorld=16;
Clear_RxBuffer();
break;
}
case 36: //返回模具安装信息
{
USART3_SendWorld=17;
Clear_RxBuffer();
break;
}
case 37: //返回模具安装信息
{
USART3_SendWorld=19;
Clear_RxBuffer();
break;
}
default :
{ //命令错误
Send_Error();
Clear_RxBuffer();
break;
}
}
break;
}
case 'W':
{ //写命令
switch(tem)
{
case 1: //修改本机地址
{
SPI_Flash_Write(&USART3_RxBuffer[3],Flash_Base0,3); //修改本机站号
SPI_Flash_Read(ADDRESS,Flash_Base0,3); //读取地址
Send_Address(); //返回修改后的地址
Clear_RxBuffer();
break;
}
case 2: //修改本机机器类型
{
SPI_Flash_Write(&USART3_RxBuffer[3],Flash_Base1,2); //修改本机机器类型
SPI_Flash_Read(MACHINE_TYPE,Flash_Base1,2); //读取机器类型
Send_MACHINE_TYPE(); //返回修改后的机器类型
Clear_RxBuffer();
break;
}
case 3: //修改模具条码
{
Clear_RxBuffer();
break;
}
case 4: //修改员工条码
{
u8 i;
if(YGTM_Flag & 0x01)
{//当前有员工条码
if(YG_CodeLend == (USART3_RxCounter-5))
{ //新接收的员工条码与旧的员工条码长度相同
if(Char_Compare(YG_Code,&USART3_RxBuffer[3],YG_CodeLend)==1)
{//接收到相同的条码，认为员工结束上岗
YGTM_Flag =0; //清员工条码标志位
USART3_SendWorld=14; //发送员工上岗结束
}
else
{//接收到不同的条码
YGTM_Flag = 0;
YGTM_Flag |= 0x02; //清员工条码标志位
USART3_SendWorld=14; //发送员工上岗结束
for(i=0;i<USART3_RxCounter-5;i++)
New_YG_Code[i]=USART3_RxBuffer[i+3];
New_YG_CodeLend=USART3_RxCounter-5;
}
}
else
{//新接收的员工条码与旧的员工条码长度不相同，则认为接收到新条码
YGTM_Flag =0;
YGTM_Flag |=02; //清员工条码标志位
USART3_SendWorld=14; //发送员工上岗结束
for(i=0;i<USART3_RxCounter-5;i++)
New_YG_Code[i]=USART3_RxBuffer[i+3];
New_YG_CodeLend=USART3_RxCounter-5;
}
}
else
{//当前无员工条码，则认为接收到新条码
YGTM_Flag |=0X01; //标志当前有条码
for(i=0;i<USART3_RxCounter-5;i++)
YG_Code[i]=USART3_RxBuffer[i+3];
YG_CodeLend=USART3_RxCounter-5;
USART3_SendWorld=13; //发送新条员工码数据
}
Clear_RxBuffer();
break;
}
case 5:
{//订单生产完毕，指示灯闪烁
LED_ON();
Clear_RxBuffer();
break;
}
case 6:
{//指示灯停止闪烁
LED_OFF();
Clear_RxBuffer();
break;
}
case 7:
{//修改模具开模数量,:W07|1234
MJ_Cnt=(USART3_RxBuffer[5]-0x30)*1000+(USART3_RxBuffer[6]-0x30)*100+(USART3_RxBuffer[7]-0x30)*10+USART3_RxBuffer[8]-0x30; //计算命令字
YG_Cnt=MJ_Cnt;
Clear_RxBuffer();
break;
}
default :
{ //命令错误
Send_Error();
Clear_RxBuffer();
break;
}
}
break;
}
case 'S':
{ //系统相关命令
switch(tem)
{
case 1:
{ //系统软件复位
NVIC_SystemReset(); //系统软件复位
Clear_RxBuffer();
break;
}
case 2:
{ //读取系统当前运行时间
USART3_SendWorld=100;
Clear_RxBuffer();
break;
}
case 3:
{//用于接收上位机返回的信息，不处理
Clear_RxBuffer();
break;
}
default:
{ //错误，没此命令
Send_Error();
Clear_RxBuffer();
break;
}
}
break;
}
default:
{ //命令错误
// Send_Error();
break;
}
}
Communicate_Computer();
USART3_Flag &= 0x0F; //清标识位
USART3_RxCounter=0; //清零
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); //开中断
}
}
