📄 functions.c
字号:
char * pbDriveCyclicData;
pbDriveCyclicData = COMMAND_DATA(uDriveNbr);
memcpy(pbDriveCyclicData, (char*) psCommandData, sCommandDataLength);
}
DWORD Init_SHM(void)
{
HANDLE tmp_handle;
DWORD ret;
SERC_ARGS_t *pSMem;
rtl_printf("start the Init_SHM\n");
/* Shared-Memory fuer Semaphorennamen bilden */
(void*)ipc_handles.pSMemNames = mbuff_alloc("IPC_NAMES",sizeof(T_IPC_NAMES));
/* Namen der Shared-memorys eintragen */
strcpy( ipc_handles.pSMemNames->ACPH_CNL, "ACPH_CHANNEL");
strcpy( ipc_handles.pSMemNames->DIAG_CNL, "DIAGNOSE");
strcpy( ipc_handles.pSMemNames->CYCLE_DATA_AT, "CYCLE_DATA_AT");
strcpy( ipc_handles.pSMemNames->CYCLE_DATA_MDT,"CYCLE_DATA_MDT");
strcpy( ipc_handles.pSMemNames->SYST_CNL, "SYST_CHANNEL");
(void*)ipc_handles.ACPH_CNL = mbuff_alloc(ipc_handles.pSMemNames->ACPH_CNL,sizeof(SERC_ARGS_t));
(void*)ipc_handles.CYCLE_DATA_AT = mbuff_alloc(ipc_handles.pSMemNames->CYCLE_DATA_AT,256 * sizeof(T_CYC_DATA));
(void*)ipc_handles.CYCLE_DATA_MDT = mbuff_alloc(ipc_handles.pSMemNames->CYCLE_DATA_MDT,256 * sizeof(T_CYC_DATA));
(void*)ipc_handles.SYST_CNL = mbuff_alloc(ipc_handles.pSMemNames->SYST_CNL,sizeof(SYST_t));
(void*)ipc_handles.DIAG_CNL = mbuff_alloc(ipc_handles.pSMemNames->DIAG_CNL,sizeof(DIAGNOSE));//not used yet
sem_init(&ipc_handles.REAL_CNL, 0, 0);//released by SERCANS_ISR ;wait by NC
sem_init(&ipc_handles.SOFT_SYNC, 0, 0);//released by NC ;wait by SERCANS_ISR
sem_init(&ipc_handles.TERMINATE_FLAG, 0, 0);//released by NC ;wait by root.o
sem_init(&ipc_handles.ACPH_BUSY, 0, 1);//acph thread(exchange datas)
sem_init(&ipc_handles.ACPH_READY, 0, 0);
sem_init(&ipc_handles.ACPH_FLAG, 0, 0);
sem_init(&ipc_handles.SYST_BUSY, 0, 1);//syst thread(change phase)
sem_init(&ipc_handles.SYST_READY, 0, 0);
sem_init(&ipc_handles.SYST_FLAG, 0, 0);
sem_init(&ipc_handles.DIAG_FLAG, 0, 0);//diag thread ,not used yet
return(0);
}
void Free_SHM(void)
{
mbuff_free(ipc_handles.pSMemNames->ACPH_CNL, (void*)ipc_handles.ACPH_CNL);
mbuff_free(ipc_handles.pSMemNames->CYCLE_DATA_AT, (void*)ipc_handles.CYCLE_DATA_AT);
mbuff_free(ipc_handles.pSMemNames->CYCLE_DATA_MDT, (void*)ipc_handles.CYCLE_DATA_MDT);
mbuff_free(ipc_handles.pSMemNames->SYST_CNL, (void*)ipc_handles.SYST_CNL);
mbuff_free(ipc_handles.pSMemNames->DIAG_CNL, (void*)ipc_handles.DIAG_CNL);
}
ULONG create_parameter_handler_tasks( void )
{
HANDLE hThread;
DWORD threadId;
ULONG func_ret;
int ret;
func_ret = OK;
ret = pthread_create (&acph_thread, NULL, acph, (void *)"SUSPEND");
if ( ret == 0 )
{ /* Eintrag der Task in die CLC-Task-Struktur */
strncpy( SCS_Task[ACPH].Name, "ACPH", 5 );
SCS_Task[ACPH].Status = CREATED;
}
else
func_ret |= NOT_OK; /* ACHTUNG - Betriebssystemfehler */
ret = pthread_create (&syst_thread, NULL, syst, (void *)"SUSPEND");
if ( ret == 0 )
{ /* Eintrag der Task in die CLC-Task-Struktur */
strncpy( SCS_Task[SYST].Name, "SYST", 5 );
SCS_Task[SYST].Status = CREATED;
}
else
func_ret |= NOT_OK; /* ACHTUNG - Betriebssystemfehler */
return( func_ret );
}
ULONG start_parameter_handler_tasks(void)
{
ULONG ret;
ULONG func_ret;
func_ret = OK;
/****************************************************************/
/* Start der A-/C-Parameter-Handler Task */
/****************************************************************/
pthread_wakeup_np (acph_thread);
/****************************************************************/
/* Start System channel Handler Task */
/****************************************************************/
pthread_wakeup_np (svch_thread);
return( func_ret );
}
unsigned long acph( PVOID arg_ptr )
{
HANDLE acSHMhdl; /* Shared-Memory fuer A/C Parameter */
SERC_ARGS_t* ph_ptr; /* Pointer auf die Uebergabe-Struktur */
ULONG ret; /* Rueckgabewert fuer RTX-Funktionsaufrufe */
BOOL bret;
T_IPC_NAMES *pSMemNames; /* Namensliste aller named objects */
HANDLE hIPCNames;
////////
USHORT usFail,*uspData,iTimeCounter;
ULONG ulData=0,ulLength=0,ulErrorMessage=0;
/****************************************************************/
/* 1. Schritt: Die Prioritaet dieses Threads auf 123 setzen */
/****************************************************************/
if(!strcmp( "SUSPEND", (char *)arg_ptr )){
pthread_suspend_np(pthread_self());
}
SCS_Task[ACPH].Status = STARTED;
p.sched_priority = MIN_PRI+2;
pthread_setschedparam(pthread_self(),SCHED_FIFO,&p);
ph_ptr = ipc_handles.ACPH_CNL;
SCS_Task[ACPH].Status = READY; /* ACPH-Task ist 'ready to work' */
while( TRUE )
{
/* Warte auf eine Anforderung von einer anderen Task */
sem_wait(&ipc_handles.ACPH_FLAG);
ph_ptr->ret = 0;
iTimeCounter = 0;
switch (ph_ptr->NCsvch_HMIsvch){
case NC_SVCH:
switch ( ph_ptr->rd_wrt ){
case PAR_LESEN:
/* C- oder A-Parameter lesen */
// if(ph_ptr->bSinglePara)
// rtl_printf("ph_ptr->ident_nbr=0x%08x\n",ph_ptr->ident_nbr);
usFail=Request_ReadDriveParameter(ph_ptr->drv_nbr, ph_ptr->ident_nbr,
ph_ptr->element,ph_ptr->bSinglePara);
if (usFail != SVCH_OK){
ph_ptr->ret = usFail;
break;
}
do
{
Sleep(WAIT_TIME);
usFail=Response_ReadDriveParameter(ph_ptr->drv_nbr, &ulData,(USHORT*)(&ulLength));
iTimeCounter++;
// rtl_printf("ph_ptr->ident_nbr=0x%08x\n",ph_ptr->ident_nbr);
// rtl_printf("iTimeCounter=%d,usFail=0x%08x\n",iTimeCounter,usFail);
if(iTimeCounter>10){
ph_ptr->ret = ERR_ANF_UZL;
break;
}
// rtl_printf("Response_ReadDriveParameter Sleep(WAIT_TIME)\n");
}while(usFail == SVCH_IN_PROGRESS || usFail == SVCH_NO_READ);
if (usFail != SVCH_FINISHED){
if( ph_ptr->ret == ERR_ANF_UZL)
break;
if( usFail == SVCH_ERROR){
ph_ptr->ret = ulData;
break;
}
ph_ptr->ret = usFail;
break;
}
if(ph_ptr->bSinglePara)
{
ph_ptr->ldata = ulData;//非列表参数将操作数写到ph_ptr->ldata
}else{
memcpy(ph_ptr->vdata,(pbBaseAdress+0x200000)+ulData,ulLength+4);//列表参数，将SERCANSII卡内存首地址（list container #0）写入ph_ptr->vdata
}
break;
case PAR_SCHREIBEN:
/* C- oder A-Parameter schreiben (Standard) */
usFail = Request_WriteDriveParameter(ph_ptr->drv_nbr,ph_ptr->ident_nbr,
ph_ptr->element,ph_ptr,ph_ptr->size,ph_ptr->bSinglePara);
if (usFail != SVCH_OK){
ph_ptr->ret = usFail;
break;
}
do
{
Sleep(WAIT_TIME);
usFail=Response_WriteDriveParameter(ph_ptr->drv_nbr, &ulData);
if(iTimeCounter>10){
ph_ptr->ret = ERR_ANF_UZL;
break;
}
// rtl_printf("Response_WriteDriveParameter Sleep(WAIT_TIME)\n");
}while(usFail == SVCH_IN_PROGRESS || usFail == SVCH_NO_WRITE);
if (usFail != SVCH_FINISHED){
if( ph_ptr->ret == ERR_ANF_UZL)
break;
if( usFail == SVCH_ERROR){
ph_ptr->ret = ulData;
break;
}
ph_ptr->ret = usFail;
break;
}
break;
}
break;
case HMI_SVCH:
switch ( ph_ptr->rd_wrt ){
case PAR_LESEN:
/* C- oder A-Parameter lesen */
usFail=Request_HMIReadDriveParameter(ph_ptr->ident_nbr,
ph_ptr->element,ph_ptr->bSinglePara);
if (usFail != SVCH_OK){
ph_ptr->ret = usFail;
break;
}
do
{
Sleep(WAIT_TIME);
usFail=Response_HMIReaDriveParameter(&ulData,(USHORT*)(&ulLength));
if(iTimeCounter>10){
ph_ptr->ret = ERR_ANF_UZL;
break;
}
rtl_printf("Sleep(WAIT_TIME)\n");
}while(usFail == SVCH_IN_PROGRESS || usFail == SVCH_NO_READ);
if (usFail != SVCH_FINISHED){
if( ph_ptr->ret == ERR_ANF_UZL)
break;
if( usFail == SVCH_ERROR){
ph_ptr->ret = ulData;
break;
}
ph_ptr->ret = usFail;
break;
}
if(ph_ptr->bSinglePara)
{
ph_ptr->ldata = ulData;
}else{
memcpy(ph_ptr->vdata,(pbBaseAdress+0x28018)+ulData,ulLength+4);
}
break;
case PAR_SCHREIBEN:
/* C- oder A-Parameter schreiben (Standard) */
usFail = Request_HMIWriteDriveParameter(ph_ptr->ident_nbr,
ph_ptr->element,ph_ptr,ph_ptr->size,ph_ptr->bSinglePara);
if (usFail != SVCH_OK){
ph_ptr->ret = usFail;
break;
}
do
{
Sleep(WAIT_TIME);
usFail=Response_HMIWriteDriveParameter(&ulData);
if(iTimeCounter>10){
ph_ptr->ret = ERR_ANF_UZL;
break;
}
rtl_printf("Sleep(WAIT_TIME)\n");
}while(usFail == SVCH_IN_PROGRESS || usFail == SVCH_NO_WRITE);
if (usFail != SVCH_FINISHED){
if( ph_ptr->ret == ERR_ANF_UZL)
break;
if( usFail == SVCH_ERROR){
ph_ptr->ret = ulData;
break;
}
ph_ptr->ret = usFail;
break;
}
break;
}
break;
}
sem_post(&ipc_handles.ACPH_READY);
}
return(0);
}
unsigned long syst( PVOID arg_ptr )
{
HANDLE acSHMhdl; /* Shared-Memory fuer A/C Parameter */
SYST_t* syst_ptr; /* Pointer auf die Uebergabe-Struktur */
ULONG ret; /* Rueckgabewert fuer RTX-Funktionsaufrufe */
BOOL bret;
T_IPC_NAMES *pSMemNames; /* Namensliste aller named objects */
HANDLE hIPCNames;
////////
USHORT usFail;
ULONG ulData,ulLength,ulErrorMessage;
if(!strcmp( "SUSPEND", (char *)arg_ptr )){
// sem_wait(&syst_suspend_sem);
pthread_suspend_np(pthread_self());
}
SCS_Task[SYST].Status = STARTED;
p.sched_priority = MIN_PRI;
pthread_setschedparam(pthread_self(),SCHED_FIFO,&p);
syst_ptr = ipc_handles.SYST_CNL;
SCS_Task[SYST].Status = READY; /* ACPH-Task ist 'ready to work' */
while( TRUE )
{
/* Warte auf eine Anforderung von einer anderen Task */
sem_wait(&ipc_handles.SYST_FLAG);
switch (syst_ptr->SYST_TYPE){
case CLEAR_ERROR:
*(pbBaseAdress+0x20000)=3;
break;
case CHANGE_PHASE:
*(SHORT*)(pbBaseAdress+0x20004)=syst_ptr->usData;
rtl_printf("syst_ptr->usData=%d\n",syst_ptr->usData);
break;
case SAVE_SYSTEM_PARA:
*(pbBaseAdress+0x20008)=3;
break;
case CLEAR_ALL_ERRORS:
*(pbBaseAdress+0x2000C)=3;
break;
case SET_LIFECOUNTER_DIF:
*(USHORT*)(pbBaseAdress+0x20010)=syst_ptr->usData;
break;
case GET_PHASE:
syst_ptr->usData=*(pbBaseAdress+0x20024);
break;
case GET_DIAG_MESSAGE:
memcpy(syst_ptr->chData,pbBaseAdress+0x20048,64);
break;
}
sem_post(&ipc_handles.SYST_READY);
}
}
void synchronize_user_isr()
{
BOOL bret;
usCount_NC_SERCOS_TAKT_SYNC_USER--;
if( !usCount_NC_SERCOS_TAKT_SYNC_USER )
{
usCount_NC_SERCOS_TAKT_SYNC_USER=usNC_SERCOS_TAKT;
sem_post(&ipc_handles.REAL_CNL);
}
}/* End of synchronize_user_isr */
void get_nc_serc_cyc()
{
ULONG ulNcCycleTime,ulSERCANSCycleTime,ulNcAccessTime;
CRead_Y_Parameter(5,&ulNcCycleTime);
// rtl_printf("ulNcCycleTime= %d\n",ulNcCycleTime);
CRead_Y_Parameter(4,&ulNcCycleTime);
// rtl_printf("ulNcCycleTime= %d\n",ulNcCycleTime);
// ulNcCycleTime = 2500;
// ulSERCANSCycleTime = 1000;
usNC_SERCOS_TAKT = ulNcCycleTime/ulSERCANSCycleTime;
if(usNC_SERCOS_TAKT==0)
usNC_SERCOS_TAKT=1;
if(ulNcCycleTime % ulSERCANSCycleTime)
usNC_SERCOS_TAKT++;
rtl_printf("usNC_SERCOS_TAKT = %d\n",usNC_SERCOS_TAKT);
usCount_NC_SERCOS_TAKT_SYNC_USER=1;
usCount_NC_SERCOS_TAKT_USER_ACC =1;
CRead_Y_Parameter(13,&ulNcAccessTime);
rtl_printf("ulNcAccessTime= %d\n",ulNcAccessTime);
}
void get_exist_drives()
{
int i,ret,iLength,iIndex;
USHORT * uspData;
ULONG * ulData;
for(i=1;i<255;i++)
{
DriveExist[i] = FALSE;
}
ret = CRead_Y_Parameter(2,&ulData);
uspData=(USHORT*)ulData;
iLength = uspData[0]/2;//一个驱动器有两个字节
rtl_printf("get_exist_drives iLength =%d\n",iLength);
for (i=0;i<iLength;i++)
{
iIndex = uspData[i+2];
rtl_printf("get_exist_drives iIndex =%d\n",iIndex);
DriveExist[iIndex] = TRUE;
}
// HeapFree(GetProcessHeap(),0,(void*)ulData);
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -