void fs_inode_Free(FS_INODE * pstInode_inout)
{
FS_INODE_EXT * pstInode = (FS_INODE_EXT *)pstInode_inout;
if (0 == pstInode) {
return;
}
if (0 == pstInode->i_dev) {
Mem_Clr(pstInode, (sizeof(FS_INODE_EXT) - sizeof(DRV_LOCK)));
return;
}
if (pstInode->i_count > 1) {
drv_disp_Printf("[i-node][count][%d]\r\n", pstInode->i_count);
CPUExt_CorePanic("[fs_inode_Free][i-node count]");
}
if (pstInode->ind.i_nlinks) {
CPUExt_CorePanic("[fs_inode_Free][i-node links]");
}
fs_super_ClearBit(pstInode->i_dev, pstInode->i_num);
Mem_Clr(pstInode, (sizeof(FS_INODE_EXT) - sizeof(DRV_LOCK)));
return;
}
void BSP_Ser_Init (CPU_INT32U baud_rate)
{
GPIO_InitTypeDef gpio_init;
USART_InitTypeDef usart_init;
USART_ClockInitTypeDef usart_clk_init;
/* ------------------ INIT OS OBJECTS ----------------- */
BSP_OS_SemCreate(&BSP_SerTxWait, BSP_UART2_TX_BUFFER_SIZE, "Serial Tx Wait");
BSP_OS_SemCreate(&BSP_SerRxWait, 0, "Serial Rx Wait");
BSP_OS_SemCreate(&BSP_SerLock, 1, "Serial Lock");
/* ----------------- INIT USART STRUCT ---------------- */
usart_init.USART_BaudRate = baud_rate;
usart_init.USART_WordLength = USART_WordLength_8b;
usart_init.USART_StopBits = USART_StopBits_1;
usart_init.USART_Parity = USART_Parity_No ;
usart_init.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
usart_init.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
usart_clk_init.USART_Clock = USART_Clock_Disable;
usart_clk_init.USART_CPOL = USART_CPOL_Low;
usart_clk_init.USART_CPHA = USART_CPHA_2Edge;
usart_clk_init.USART_LastBit = USART_LastBit_Disable;
BSP_PeriphEn(BSP_PERIPH_ID_USART2);
BSP_PeriphEn(BSP_PERIPH_ID_IOPD);
BSP_PeriphEn(BSP_PERIPH_ID_AFIO);
GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
/* ----------------- SETUP USART2 GPIO ---------------- */
/* Configure GPIOD.5 as push-pull. */
gpio_init.GPIO_Pin = GPIO_Pin_5;
gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
gpio_init.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOD, &gpio_init);
/* Configure GPIOD.6 as input floating. */
gpio_init.GPIO_Pin = GPIO_Pin_6;
gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOD, &gpio_init);
/* ------------- CLEAN UP RX & TX BUFFERS ------------- */
Mem_Clr((void*)&BSP_SerialRxBuffer[0], BSP_UART2_RX_BUFFER_SIZE);
Mem_Clr((void*)&BSP_SerialTxBuffer[0], BSP_UART2_TX_BUFFER_SIZE);
BSP_TxBuffer_Head_ndx = 0;
BSP_TxBuffer_Tail_ndx = 0;
BSP_RxBuffer_Head_ndx = 0;
BSP_RxBuffer_Tail_ndx = 0;
/* ------------------ SETUP USART2 -------------------- */
USART_Init(USART2, &usart_init);
USART_ClockInit(USART2, &usart_clk_init);
USART_Cmd(USART2, ENABLE);
BSP_IntVectSet(BSP_INT_ID_USART2, BSP_Ser_ISR_Handler);
BSP_IntEn(BSP_INT_ID_USART2);
BSP_SerialInitilizated = DEF_TRUE;
}
/////////////////////////////////////////////////////////////////////
// 函数名称：
// 函数功能：
// 入口参数：
//
//
// 出口参数：下一次DMA地址
////////////////////////////////////////////////////////////////////
uint32 Sound_Input_Int(void)
{
uint8 *pbuf, *p;
uint32 i;
struct _pkst micst, dst;
struct SOUND_HEADER_TYPE shead;
NetP *pnet;
Sound_Contrl.play_contrl |= SOUND_DMA2_OK;
if ((Sound_Contrl.Input_contrl & SOUND_CONTRL_ACTIVE) == 0)
return 0;
pnet = (NetP *)Get_NetPort();
for (i = 0; i < SOUND_OPEN_SIZE; i++)
{
if (Sound_Contrl.Rec[i].contrl & SOUND_CONTRL_SEND)
{
if ((Sound_Contrl.Rec[i].contrl & SOUND_IP_ASK) != 0)
{
pbuf = (BYTE *)DMA_Get_MICaddress();
p = (uint8 *)(SOUND_BUFF_ADDRESS + SOUND_BUFF_MAX * SOUND_BUFF_SIZE);
mic_play_add(pbuf, p);
dst.DAPTR = pbuf;
}
else if ((Sound_Contrl.Rec[i].contrl & SOUND_IP_hASK) != 0)
{
pbuf = (BYTE *)DMA_Get_MICaddress();
dst.DAPTR = pbuf;
if ((Sound_Contrl.Rec[i].contrl & SOUND_CONTRL_ECHO) != 0)
{
//dst.DAPTR=(BYTE *)blank_buf;
Mem_Clr(pbuf, SOUND_BUFF_SIZE);
}
//else
}
else
dst.DAPTR = (BYTE *)DMA_Get_MICaddress();
dst.STPTR = NULL;
dst.length = SOUND_BUFF_SIZE;
shead.Flag = FLAG_SOUND_HEADER;
shead.Seat = 0;
//shead.OWIP=pnet->My_Ip;//IPByte_TO_Dword(pnet->My_Ip);
memcpy( &shead.OWIP, &pnet->My_Ip[0], 4 );
micst.STPTR = &dst;
micst.DAPTR = (BYTE *)&shead;
micst.length = sizeof( struct SOUND_HEADER_TYPE);
Udp_SendPacked(&micst, Sound_Contrl.Rec[i].play_ip, Sound_Contrl.Rec[i].snumber);
}
}
return 0;
}
static NET_SOCK_ID socket_open(void)
{
NET_SOCK_ID sock;
NET_SOCK_ADDR_IP sock_addr_ip;
NET_ERR err;
Mem_Clr(
(void *) &sock_addr_ip,
(CPU_SIZE_T) sizeof(sock_addr_ip)
);
sock_addr_ip.AddrFamily = NET_SOCK_ADDR_FAMILY_IP_V4;
sock_addr_ip.Addr = NET_UTIL_HOST_TO_NET_32(IP);
sock_addr_ip.Port = NET_UTIL_HOST_TO_NET_16(PORT);
sock = NetSock_Open(
NET_SOCK_ADDR_FAMILY_IP_V4,
NET_SOCK_TYPE_STREAM,
NET_SOCK_PROTOCOL_TCP,
&err
);
if (NET_SOCK_ERR_NONE != err)
{
return -1;
}
NetSock_CfgTimeoutConnReqSet(sock, 4000, &err);
if (NET_SOCK_ERR_NONE != err)
{
NetSock_Close(sock, &err);
return -1;
}
NetSock_Conn(
(NET_SOCK_ID) sock,
(NET_SOCK_ADDR *) &sock_addr_ip,
(NET_SOCK_ADDR_LEN) sizeof(sock_addr_ip),
(NET_ERR *) &err
);
if (NET_SOCK_ERR_NONE != err)
{
NetSock_Close(sock, &err);
return -1;
}
return sock;
}
INT32S Simu_BuildRamDisk()
{
INT32S re=0,nChDataSize;
INT8S *p;
// BuildSignalGroupTable(g_nSit);
for(re=0;re<_MAX_SIGNAL_CHANNEL_CNT;re++)
{
g_nLength[re]=g_nDatalth;
g_nChNo[re]=re;
}
//g_pChData=malloc(1024*1024*384);
Mem_Clr(g_pChData, sizeof(g_pChData));
nChDataSize=sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S);
Mem_Clr(g_pOutChData,sizeof(g_pOutChData));
//g_pOutChData=malloc(_MAX_SIGNAL_CHANNEL_CNT*nChDataSize);
g_pOutChDataArray[0]=g_pOutChData;
for(re=1;re<_MAX_SIGNAL_CHANNEL_CNT;re++)
{
p=(INT8S *)g_pOutChDataArray[re-1];
g_pOutChDataArray[re]=(struct tagChData2060 *)(p+nChDataSize);
}
return re;
}
FS_PRIVATE FS_INODE_EXT * fs_inode_GetEmpty(void)
{
static FS_INODE_EXT * s_pstLastInode = fs_inode_astTbl;
FS_INODE_EXT * pstInode = 0;
CPU_INT32U i = 0;
do {
pstInode = 0;
for (i = FS_INODE_EXT_MAX; i > 0 ; --i) {
if ((++s_pstLastInode) >= (fs_inode_astTbl + FS_INODE_EXT_MAX)) {
s_pstLastInode = fs_inode_astTbl;
}
if (!(s_pstLastInode->i_count)) {
pstInode = s_pstLastInode;
if (!(pstInode->i_dirt) && !(pstInode->i_lock)) {
break;
}
}
}
if (0 == pstInode) {
CPUExt_CorePanic("[fs_inode_GetEmpty][No free inodes in memory]");
}
fs_inode_WaitOn(pstInode);
while (pstInode->i_dirt) {
fs_inode_Write(pstInode);
fs_inode_WaitOn(pstInode);
}
} while (pstInode->i_count);
Mem_Clr(pstInode, (sizeof(FS_INODE_EXT) - sizeof(DRV_LOCK)));
pstInode->i_count = 1;
return (pstInode);
}
void AppSampleTask(void *p_arg)
{
(void)p_arg;
/* 监测MPU6050信息 */
while(SensorCheckCnt < 5)
{
if(i2c_CheckDevice(MPU6050_SLAVE_ADDRESS) == 0)
{
bsp_InitMPU6050(); //初始化MPU6050
MPU6050Flag |= NORMAL;
}
else
{
MPU6050Flag &= (~NORMAL);
}
/* 监测HMC5883L信息 */
if (i2c_CheckDevice(HMC5883L_SLAVE_ADDRESS) == 0)
{
bsp_InitHMC5883L(); /* 初始化HMC5883L */
HMC5883LFlag |= NORMAL;
}
else
{
HMC5883LFlag &= (~NORMAL);
}
SensorCheckCnt++;
}
if(SensorCheckCnt == 5)
{
}
while(1)
{
/* 传感器采集数据 */
MPU6050_ReadData();
HMC5883L_ReadData();
MPU6050_DataDeal(); //处理MPU6050获取的数据得到：MPU6050_H结构体
HMC5883L_DataDeal(); //处理HMC5883L获取的数得到：HMC5883L_H结构体
if(HMC5883LFlag & CALI_MODE)
{
}
if(MPU6050Flag & CALI_MODE)
{
if(!(MPU6050FlagOld & CALI_MODE)) //进入校验模式
{
CaliTime = 200;
MPU6050_H.Accel_X_Offset = g_tMPU6050.Accel_X;
MPU6050_H.Accel_Y_Offset = g_tMPU6050.Accel_Y;
MPU6050_H.Accel_Z_Offset = g_tMPU6050.Accel_Z - 65536 / 4;
MPU6050_H.GYRO_X_Offset = g_tMPU6050.GYRO_X;
MPU6050_H.GYRO_Y_Offset = g_tMPU6050.GYRO_Y;
MPU6050_H.GYRO_Z_Offset = g_tMPU6050.GYRO_Z;
}
if(CaliTime == 0)
{
MPU6050Flag &= ~(CALI_MODE);
}
MPU6050_H.Accel_X_Offset = (float)(g_tMPU6050.Accel_X + MPU6050_H.Accel_X_Offset) / 2;
MPU6050_H.Accel_Y_Offset = (float)(g_tMPU6050.Accel_Y + MPU6050_H.Accel_Y_Offset) / 2;
MPU6050_H.Accel_Z_Offset = (float)(g_tMPU6050.Accel_Z + MPU6050_H.Accel_Z_Offset - 65536 / 4) / 2;
MPU6050_H.GYRO_X_Offset = (float)(g_tMPU6050.GYRO_X + MPU6050_H.GYRO_X_Offset) / 2;
MPU6050_H.GYRO_Y_Offset = (float)(g_tMPU6050.GYRO_Y + MPU6050_H.GYRO_Y_Offset) / 2;
MPU6050_H.GYRO_Z_Offset = (float)(g_tMPU6050.GYRO_Z + MPU6050_H.GYRO_Z_Offset) / 2;
CaliTime--;
if(CaliTime > 200)
CaliTime = 200;
}
if((HMC5883LFlag & NORMAL) && (MPU6050Flag & NORMAL))
{
FlyMain();
}
if(WifiStatus == CONNECTING)
{
if((WIFI_Period++) % 5000 == 0)
{
Mem_Clr(send_data_buf, sizeof(send_data_buf));
sprintf(send_data_buf, "sy:s1:d:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%fd:%f",angleAx_temp, angleAy_temp, angleAz_temp,MPU6050_H.Accel_X,MPU6050_H.Accel_Y,MPU6050_H.Accel_Z, \
MPU6050_H.GYRO_X,MPU6050_H.GYRO_Y,MPU6050_H.GYRO_Z,HMC5883L_H.X,HMC5883L_H.Y,HMC5883L_H.Z,MPU6050_H.Accel_X_Offset,MPU6050_H.Accel_Y_Offset,MPU6050_H.Accel_Z_Offset, \
MPU6050_H.GYRO_X_Offset,MPU6050_H.GYRO_Y_Offset,MPU6050_H.GYRO_Z_Offset);
ESP8266_send_data(send_data_buf);
bsp_LedToggle(2);
}
// if(CurrentGeneralReinforce != SetGeneralReinforce)
// {
// if(SetGeneralReinforce > 100) //防止增益超出范围
// SetGeneralReinforce = 100;
//
// for(index=0; index<4; index++)
// {
// PwmTemp = (uint32_t)(CurrentPwmValue[index] * SetGeneralReinforce / 100); //计算出当前的PWM实际值
// if(PwmTemp > 100) //防止PWM占空比超出范围
// PwmTemp = 100;
//
// bsp_SetPWMDutyCycle(PwmTemp, index+1);
// }
//
// CurrentGeneralReinforce = SetGeneralReinforce; //增益赋值
// }
for(index=0; index<4; index++)
{
if(CurrentPwmValue[index] != SetPwmValue[index])
{
if(SetPwmValue[index] > 100) //防止增益超出范围
SetPwmValue[index] = 100;
bsp_SetPWMDutyCycle(SetPwmValue[index], index+1);
CurrentPwmValue[index] = SetPwmValue[index];
}
// if(SetPwmDirection[index] != CurrentPwmDirection[index])
// SetPwmDirection[index] = CurrentPwmDirection[index];
}
}
MPU6050FlagOld = MPU6050Flag;
BSP_OS_TimeDlyMs(2);
}
}
void Simu_Send_Data(void* ps)
{
INT32S re=0,i,j,k,l,m,nKeyNo;
INT32S nChDataSize=sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S);
float fSign=0;
char inf[256]={0};
float fv[50];
//void* p;
INT8S p[sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+_DEFAULT_DATA_LTH-1)*sizeof(INT32S)];
INT8S* pData=(INT8S *)g_pOutChData;
struct tagChData2060* pchData=0;
INT32S nCurSit[_MAX_JKEY_CHANNEL_CNT]={0};
INT32S nSpeed[_MAX_JKEY_CHANNEL_CNT];
INT32S nLth[_MAX_JKEY_CHANNEL_CNT];
PAlertNode pAlert=g_AlertNode;
struct tagChValue *pAv=g_pSimuAlertMeasureValue;
PTranNode pTran=g_TranNode;
struct tagChValue chValue;
INT32S nRpmFlag=0;
//p=malloc(sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S));
Mem_Clr(p, sizeof(p));
pchData=(struct tagChData2060*)p;
chValue.nTrigerTime=0;
chValue.nChNo=0;
chValue.nRPM=g_nBasicRPM;
chValue.nAlertFlag=0;
chValue.nAllMeasureValue=g_fNormalAlp;
chValue.nAllPhase=0;
chValue.n1xV=g_fLevel*g_fCof1x;
chValue.n1xP=0;
chValue.n2xV=g_fLevel*g_fCof2x;
chValue.n2xP=0;
chValue.n05xV=g_fLevel*g_fCofP5x;
chValue.n05xP=0;
chValue.nRpmFlag=0;
i=0;
do{
// _log("Start Send SimuData\n");
for(m=0;;m++)
{
INT32S nChIndex=0;
CheckSimuData();
// OSTimeDly(5);
if(g_nChValueFlag!=3||g_nChDataFlag!=3)
{
//OSTimeDly(g_SendTimeInterval/(1000/OS_TICKS_PER_SEC));
//OSTimeDly(1);
OSTimeDly(1 );
continue;
}
OSSchedLock( );//禁止任务切换
g_nChValueFlag=0;
g_nChDataFlag=0;
if(i==50)
i=i;
for(j=0;j<g_nChcnt;j++)
{
// nSign=20*sin(6.2832*(m/100.+nSit[j]/71.));
fSign=(g_nSit[j]*48.0/g_nChcnt-24.0)*(1+0.3*sin(6.2832*(m/10.)));
if(g_nChKeyNo[g_nSit[j]]>=_START_KEY_CH)
{
nKeyNo=g_nChKeyNo[g_nSit[j]]-_START_KEY_CH;
nSpeed[nKeyNo]=*g_nKeySpeed[nKeyNo][i];
g_nCaltKeySpeed[nKeyNo]=nSpeed[nKeyNo];
}
else
nSpeed[nKeyNo]=-1;
// if(nSpeed[nKeyNo]>3000)
// nSpeed[nKeyNo]=nSpeed[nKeyNo];
nRpmFlag=0;
for(k=0;k<g_TranNode[nKeyNo].nEventcnt;k++)
{
if(i>= g_TranNode[nKeyNo].nTigerTime[2*k]&&i<= g_TranNode[nKeyNo].nTigerTime[2*k+1])
{
nRpmFlag=1;
break;
}
}
// CheckSimuData();
if(i==0)
i=i;
if(i==pAlert->nTigerTime)//报警时间
{
pAv->nRPM=nSpeed[nKeyNo];
pAv->nRpmFlag=nRpmFlag;
//////输出报警通道测量值pAv
//g_pOutChValue=pAv;
Mem_Copy(g_pOutChValue+g_nSit[j],pAv,sizeof(struct tagChValue));
pAv++;
}
else//非报警通道
{
chValue.nTrigerTime=i;
chValue.nChNo=g_nSit[j];
chValue.nRPM=nSpeed[nKeyNo];
chValue.nRpmFlag=nRpmFlag;
//g_pOutChValue=&chValue;
Mem_Copy(g_pOutChValue+g_nSit[j],&chValue,sizeof(struct tagChValue));
g_pOutChValue[g_nSit[j]].nAllMeasureValue*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n1xV*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n2xV*=(100+fSign)/100.;
g_pOutChValue[g_nSit[j]].n05xV*=(100+fSign)/100.;
fv[g_nSit[j]]=g_pOutChValue[g_nSit[j]].nAllMeasureValue;
g_nChValueFlag=1;
///////输出正常通道测量值chValue
}
// CheckSimuData();
//读取转速为nSpeed[nKeyNo]下的通道原始数据
if(i==680)
i=i;
memcpy(pchData,((INT8S*)g_pSimuTranPiece)+nSpeed[nKeyNo]*nChDataSize,nChDataSize);
//Mem_Copy(pchData,((INT8S*)g_pSimuTranPiece)+nSpeed[nKeyNo]*nChDataSize,nChDataSize);
// CheckSimuData();
nLth[nKeyNo]=nChDataSize-(_MAX_KEY_PT_CNT-pchData->nKeycnt)*sizeof(INT32S);
pchData->nTrigerTime=i;
pchData->nChNo=g_nSit[j];
if(i==pAlert->nTigerTime&&g_nSit[j]==pAlert->nChNo[nChIndex])//报警通道
{
INT32S step;
INT32S* p32s=&pchData->nKeycnt+1;
p32s+=pchData->nKeycnt;
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
// p32s[step]=p32s[step]*pAlert->fCof[nChIndex]*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]=p32s[step]*pAlert->fCof[nChIndex];
}
nChIndex++;
}
else
{
INT32S step;
INT32S* p32s=(&pchData->nKeycnt)+1;
p32s+=pchData->nKeycnt;
if(i>600)
i=i;
if(g_nSit[j]/2*2==g_nSit[j])
{
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
//p32s[step]*=(100+fSign)/100.*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]*=(100+fSign)/100.;
}
}else
{
for(step=0;step<g_nDatalth;step++)//修改报警通道原始数据幅值
{
//p32s[step]*=(100-fSign)/100.*g_12Param.SignalChannel[g_nSit[j]].fSensority;
//czx
p32s[step]*=(100-fSign)/100.;
}
}
nChIndex++;
}
if(i==350)
i=i;
//g_pOutChData=pchData;
Mem_Clr(inf, 256);
// sprintf(inf,"Ouput %d Sit\n",g_nCurWriteSit);
// _log(inf);
Mem_Copy(g_pOutChDataArray[g_nSit[j]],pchData,nChDataSize);
}
if(i==50)
i=i;
//输出所有通道数据头
OutputChValue();//
//输出所有通道原始数据
Simu_Write_ChData(g_nLength,g_nChNo,_MAX_SIGNAL_CHANNEL_CNT,
g_nFpgaDynamicChDataOffset,g_nFpgaDynamicKeyDataOffset,g_nFpgaDynamicChDataSampleStep,
g_nFpgaTranDataOffset,g_nFpgaTranKeyDataOffset,g_nFpgaTranDataSampleStep);
for(l=0;l<_MAX_SIGNAL_CHANNEL_CNT/_FPGA_GROUP_CHANNEL_CNT;l++)
receive_channel_data();
g_nChValueFlag=3;
g_nChDataFlag=3;
//OSTimeDly(g_SendTimeInterval/(1000/OS_TICKS_PER_SEC)/(_MAX_SIGNAL_CHANNEL_CNT/_FPGA_GROUP_CHANNEL_CNT));
if(i>=pAlert->nTigerTime)
pAlert++;
// _log("Deal Speed Too Slow,Data Will lose\n");
g_bDataValid=1;
for(l=0;l<_MAX_JKEY_CHANNEL_CNT;l++)
{
if(i==g_nTigerTime[l][nCurSit[l]])
{
nCurSit[l]++;
}
}
i++;
if(i==g_nAllcnt)
{
i=0;
// break;
}
OSSchedUnlock( );//允许任务切换
CheckSimuData();
sleep_ms(100);
}
//_log("End Send SimuData\n");
}while(1);
//free(p);
}
INT32S Simu_Write_ChData(INT32S nLength[],INT32S nChNo[],INT32S nCnt,
INT32U nDynamicChDataOffset[],INT32U nDynamicKeyOffset[],INT32U nDynamicStep[],
INT32U nTranChDataOffset[],INT32U nTranKeyOffset[],INT32U nTranStep[])
{
INT32S re=0;
INT32S i=0,j,nLth,nSit;
INT8S* pData=(INT8S *)g_pOutChData;
INT32S nChDataSize=sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S);
INT32S noKey[]={0,0,0,0};
for(i=0;i<_MAX_SIGNAL_CHANNEL_CNT;i++)
{
if(nChNo[re]==i)
{
INT8S* p=(INT8S *)g_pOutChDataArray[i];
INT32S* pChData=(INT32S *)(p+sizeof(struct tagChData2060)+(_MAX_KEY_PT_CNT-1)*sizeof(INT32S));
Mem_Clr(g_nDynamicResult, sizeof(g_nDynamicResult));
nLth=(g_nDynamicStart[i]+_DEFAULT_DATA_LTH)/nDynamicStep[i];
g_nDynamicResult[0]=nLth;
nSit=g_nDynamicStart[i];
for(j=1;j<nLth+1;j++)
{
g_nDynamicResult[j]=pChData[nSit];
nSit+=nDynamicStep[i];
}
WriteRamDisk(nDynamicChDataOffset[i],g_nDynamicResult,nLth+1);
g_nDynamicStart[i]=(g_nDynamicStart[i]+_DEFAULT_DATA_LTH)%nDynamicStep[i];
Mem_Clr(g_nTranResult, sizeof(g_nTranResult));
nLth=(g_nTranStart[i]+_DEFAULT_DATA_LTH)/nTranStep[i];
g_nTranResult[0]=nLth;
nSit=g_nTranStart[i];
for(j=1;j<nLth+1;j++)
{
g_nTranResult[j]=pChData[nSit];
nSit+=nTranStep[i];
}
WriteRamDisk(nTranChDataOffset[i],g_nTranResult,nLth+1);
g_nTranStart[i]=(g_nTranStart[i]+_DEFAULT_DATA_LTH)%nTranStep[i];
re++;
if(re==nCnt)
break;
}
}
for(i=0;i<_MAX_JKEY_CHANNEL_CNT;i++)
{
if(g_pOutChDataArray[g_nKeyChannSit[i]]->nKeycnt)
{
nLth=g_pOutChDataArray[g_nKeyChannSit[i]]->nKeycnt;
g_nKeyResult[0]=nLth;
nSit=g_nDynamicStart[i];
Mem_Copy(g_nKeyResult+1,g_pOutChDataArray[g_nKeyChannSit[i]]->pData,nLth*sizeof(INT32S));
for(j=1;j<nLth+1;j++)
{
g_nKeyResult[j]/=nDynamicStep[i];
}
WriteRamDisk(nDynamicKeyOffset[i],g_nKeyResult,nLth+1);
Mem_Copy(g_nKeyResult+1,g_pOutChDataArray[g_nKeyChannSit[i]]->pData,nLth*sizeof(INT32S));
for(j=1;j<nLth+1;j++)
{
g_nKeyResult[j]/=nTranStep[i];
}
WriteRamDisk(nTranKeyOffset[i],g_nKeyResult,nLth+1);
}else
{
WriteRamDisk(nDynamicKeyOffset[i],noKey,sizeof(noKey)/sizeof(INT32S));
WriteRamDisk(nTranKeyOffset[i],noKey,sizeof(noKey)/sizeof(INT32S));
}
}
return re;
}
INT32S Simu_BulidTran()//为各个转速创建原始数据，原始数据长度固定
{
INT32S re=0;
INT32S nOldrpm;
INT32S l;
INT32S nDatalth=sizeof(struct tagChData2060)+((_MAX_KEY_PT_CNT+g_nDatalth-1)*sizeof(INT32S));
struct tagChData2060* p1;
INT32S len = 1000*1.2*(sizeof(struct tagChData2060)+((_MAX_KEY_PT_CNT+_DEFAULT_DATA_LTH-1)*sizeof(INT32S)));
INT8S p[(int)(1000*1.2*(sizeof(struct tagChData2060)+((_MAX_KEY_PT_CNT+_DEFAULT_DATA_LTH-1)*sizeof(INT32S))))];
INT8S* p8=NULL;
//_log("Start Build Tran SimuData\n");
g_nSimuTranPiecelth=g_nBasicRPM*g_fMaxRpmCof;
g_nSimuTranPiecelth*=nDatalth;
//if(g_pSimuTranPiece)
// free(g_pSimuTranPiece);
//g_pSimuTranPiece=0;
//p=malloc(g_nSimuTranPiecelth);
Mem_Clr(p,30638400);
//Mem_Clr(p,g_nSimuTranPiecelth);
g_pSimuTranPiece=(struct tagChData2060*)p;
p1=(struct tagChData2060 *)(((INT8S*)g_pSimuTranPiece)+g_nStartRpm*nDatalth);
nOldrpm=g_nStartRpm;
for(l=g_nStartRpm;l<g_nBasicRPM*g_fMaxRpmCof-1;l++)
{
INT32S k;
INT32S step;
INT32S* p32s=&p1->nKeycnt+1;
//p1->nKeycnt=l/60.0*g_nDatalth/g_fPickFrequency;
p1->nKeycnt=l*0.005208;
p1->nPiecelen=g_nDatalth;
p1->nFrequency=g_fPickFrequency;
for(k=0;k<p1->nKeycnt;k++)
{
//p32s[k]=k*g_nDatalth/p1->nKeycnt+g_nDatalth/8/p1->nKeycnt;
p32s[k]=k*g_nDatalth/p1->nKeycnt+781.25/p1->nKeycnt;
}
p32s+=p1->nKeycnt;
if(l>600)
l=l;
for(step=0;step<g_nDatalth;step++)
{
//FP32 v=6.2832*l/60.0*step/g_fPickFrequency;//2pi*f*dt
FP32 v=0.000005236*l*step;//2pi*f*dt
//p32s[step]=(sin(v)*g_fCof1x+sin(v*2)*g_fCof2x+sin(v*0.5)*g_fCofP5x)*g_fLevel;
p32s[step]=v;
p32s[step]>>=1;
}
if(l==804||l==2028||l==3000)
l=l;
if(p1->nKeycnt>10)
p1=p1;
p8=(INT8S *)p1;
p1=(struct tagChData2060 *)(p8+nDatalth);
}
//_log("End Build Tran SimuData\n");
return re;
}
static void tcp_ip_Thread_Method (void *p_arg)
{
NET_SOCK_ID sock;
NET_SOCK_ADDR_IP server_sock_addr_ip;
NET_SOCK_ADDR_LEN server_sock_addr_ip_size;
NET_SOCK_ADDR_IP client_sock_addr_ip;
NET_SOCK_ADDR_LEN client_sock_addr_ip_size;
NET_SOCK_RTN_CODE rx_size, tx_size;
CPU_BOOLEAN attempt_rx;
NET_ERR err;
dispatchMsg* dmPtr;
INT8U continueInt = 1;
sock = NetSock_Open( NET_SOCK_ADDR_FAMILY_IP_V4,
NET_SOCK_TYPE_DATAGRAM,
NET_SOCK_PROTOCOL_UDP,
&err);
if (err != NET_SOCK_ERR_NONE) {
err_printf("NetSock Open failed\n");
}
server_sock_addr_ip_size = sizeof(server_sock_addr_ip);
Mem_Clr((void *)&server_sock_addr_ip, (CPU_SIZE_T) server_sock_addr_ip_size);
server_sock_addr_ip.Family = NET_SOCK_ADDR_FAMILY_IP_V4;
server_sock_addr_ip.Addr = NET_UTIL_HOST_TO_NET_32(NET_SOCK_ADDR_IP_WILD_CARD);
server_sock_addr_ip.Port = NET_UTIL_HOST_TO_NET_16(UDP_SERVER_PORT);
#warning: " tobe debugged in method tcp_ip_Thread_Method ip.addr in server_sock_add_ip"
NetSock_Bind((NET_SOCK_ID ) sock,
(NET_SOCK_ADDR *)&server_sock_addr_ip,
(NET_SOCK_ADDR_LEN) NET_SOCK_ADDR_SIZE,
(NET_ERR *)&err);
if (err != NET_SOCK_ERR_NONE) {
NetSock_Close(sock, &err);
err_printf("Net sock Bind failed\n");
}
while (continueInt) {
do {
client_sock_addr_ip_size = sizeof(client_sock_addr_ip);
rx_size = NetSock_RxDataFrom((NET_SOCK_ID ) sock,
(void *) tcp_ip_RecvBuffer,
(CPU_INT16S ) sizeof(tcp_ip_RecvBuffer),
(CPU_INT16S ) NET_SOCK_FLAG_NONE,
(NET_SOCK_ADDR *)&client_sock_addr_ip,
(NET_SOCK_ADDR_LEN *)&client_sock_addr_ip_size,
(void *) 0,
(CPU_INT08U ) 0,
(CPU_INT08U *) 0,
(NET_ERR *)&err);
switch (err) {
case NET_SOCK_ERR_NONE:
attempt_rx = DEF_NO;
break;
case NET_SOCK_ERR_RX_Q_EMPTY:
case NET_OS_ERR_LOCK:
attempt_rx = DEF_YES;
break;
default:
attempt_rx = DEF_NO;
break;
}
} while (attempt_rx == DEF_YES);
info_printf("Net received %i bytes : %X\n",rx_size,tcp_ip_RecvBuffer);
dmPtr = OSMemGet(dispatchMsgMem,&err);
if (err != OS_NO_ERR) {
err_printf("error get memory in method tcp_ip_Thread_Method, err = %d\n ",err);
} else {
dmPtr->dispatchData = (INT32U) tcp_ip_RecvBuffer;
err = OSQPost(dispatchMsgQ,dmPtr);
if (err != OS_NO_ERR) {
err_printf("error OSQPost in method tcp_ip_Thread_Method, err = %d\n ",err);
}
}
snprintf((char*)&tcp_ip_SendBuffer,sizeof(tcp_ip_SendBuffer)," msg received");
tx_size = NetSock_TxDataTo((NET_SOCK_ID ) sock,
(void *) tcp_ip_SendBuffer,
(CPU_INT16S ) strlen((char*) tcp_ip_SendBuffer)+ 1,
(CPU_INT16S ) NET_SOCK_FLAG_NONE,
(NET_SOCK_ADDR *)&client_sock_addr_ip,
(NET_SOCK_ADDR_LEN) client_sock_addr_ip_size,
(NET_ERR *)&err);
info_printf("net sent (ret error code %i) %i bytes : &s\n",err,tx_size, tcp_ip_SendBuffer);
}
NetSock_Close(sock, &err);
if (err != NET_SOCK_ERR_NONE) {
err_printf("Net Sock Close error\n");
}
}
