📄 functions.c
字号:
ULONG start_parameter_handler_tasks(void)
{
ULONG ret;
ULONG func_ret;
func_ret = OK;
/****************************************************************/
/* Start der A-/C-Parameter-Handler Task */
/****************************************************************/
ret = ResumeThread(SCS_Task[ACPH].TaskHandle);
if ( ret != 0xFFFFFFFF )
SCS_Task[ACPH].Status = STARTED;
else
func_ret |= NOT_OK; /* ACHTUNG - Betriebssystemfehler */
/****************************************************************/
/* Start System channel Handler Task */
/****************************************************************/
ret = ResumeThread(SCS_Task[SYST].TaskHandle);
if ( ret != 0xFFFFFFFF )
SCS_Task[SYST].Status = STARTED;
else
func_ret |= NOT_OK; /* ACHTUNG - Betriebssystemfehler */
return( func_ret );
}
unsigned long RTFCNDCL acph( PVOID pUnused )
{
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 */
/****************************************************************/
SCS_Task[ACPH].Status = STARTED;
bret = RtSetThreadPriority( GetCurrentThread(), RT_PRIORITY_MIN+2);
if( !bret )
ret = GetLastError();
/* Shared-Memory fuer die IPC-Namen oeffnen */
hIPCNames = RtOpenSharedMemory( SHM_MAP_READ,
0,
"IPC_NAMES",
(void **)&pSMemNames);
if( hIPCNames == NULL )
ret = GetLastError();
/* Shared-Memory fuer den ACPH IPC oeffnen */
acSHMhdl = RtOpenSharedMemory( SHM_MAP_WRITE, 0, pSMemNames->ACPH_CNL, (void **)&ph_ptr);
if( acSHMhdl == NULL )
ret = GetLastError();
/* Ab hier wird die IPC-Namensliste nicht mehr gebraucht */
bret = RtCloseHandle( hIPCNames );
if( !bret )
ret = GetLastError();
SCS_Task[ACPH].Status = READY; /* ACPH-Task ist 'ready to work' */
while( TRUE )
{
/* Warte auf eine Anforderung von einer anderen Task */
ret = RtWaitForSingleObject(ipc_handles.ACPH_FLAG,INFINITE);
if( ret == WAIT_FAILED ){
RtPrintf("acph RtWaitForSingleObject(ipc_handles.ACPH_FLAG,INFINITE) FAILED\n");
ret = GetLastError();
}
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)
RtPrintf("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++;
RtPrintf("ph_ptr->ident_nbr=0x%08x\n",ph_ptr->ident_nbr);
RtPrintf("iTimeCounter=%d,usFail=0x%08x\n",iTimeCounter,usFail);
if(iTimeCounter>10){
ph_ptr->ret = ERR_ANF_UZL;
break;
}
RtPrintf("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;
}else{
memcpy(ph_ptr->vdata,(pbBaseAdress+0x200000)+ulData,ulLength+4);
}
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;
}
RtPrintf("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;
}
RtPrintf("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;
}
RtPrintf("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;
}
bret = RtReleaseSemaphore( ipc_handles.ACPH_READY, 1, 0);
}
return(0);
}
unsigned long RTFCNDCL syst( PVOID pUnused )
{
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;
SCS_Task[SYST].Status = STARTED;
bret = RtSetThreadPriority( GetCurrentThread(), RT_PRIORITY_MIN+3);
if( !bret )
ret = GetLastError();
/* Shared-Memory fuer die IPC-Namen oeffnen */
hIPCNames = RtOpenSharedMemory( SHM_MAP_READ,
0,
"IPC_NAMES",
(void **)&pSMemNames);
if( hIPCNames == NULL )
ret = GetLastError();
/* Shared-Memory fuer den ACPH IPC oeffnen */
acSHMhdl = RtOpenSharedMemory( SHM_MAP_WRITE, 0, pSMemNames->SYST_CNL, (void **)&syst_ptr);
if( acSHMhdl == NULL )
ret = GetLastError();
/* Ab hier wird die IPC-Namensliste nicht mehr gebraucht */
bret = RtCloseHandle( hIPCNames );
if( !bret )
ret = GetLastError();
SCS_Task[SYST].Status = READY; /* ACPH-Task ist 'ready to work' */
while( TRUE )
{
/* Warte auf eine Anforderung von einer anderen Task */
ret = RtWaitForSingleObject(ipc_handles.SYST_FLAG,INFINITE);
if( ret == WAIT_FAILED ){
RtPrintf("syst RtWaitForSingleObject(ipc_handles.SYST_FLAG,INFINITE) FAILED ipc_handles.SYST_FLAG=%d\n",ipc_handles.SYST_FLAG);
ret = GetLastError();
}
switch (syst_ptr->SYST_TYPE){
case CLEAR_ERROR:
*(pbBaseAdress+0x20000)=3;
break;
case CHANGE_PHASE:
*(SHORT*)(pbBaseAdress+0x20004)=syst_ptr->usData;
RtPrintf("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;
}
bret = RtReleaseSemaphore( ipc_handles.SYST_READY, 1, 0);
}
}
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;
bret = RtReleaseSemaphore( ipc_handles.REAL_CNL, 1, NULL);
}
}/* End of synchronize_user_isr */
void get_nc_serc_cyc()
{
ULONG ulNcCycleTime,ulSERCANSCycleTime,ulNcAccessTime;
CRead_Y_Parameter(5,&ulNcCycleTime);
// RtPrintf("ulNcCycleTime= %d\n",ulNcCycleTime);
CRead_Y_Parameter(4,&ulNcCycleTime);
// RtPrintf("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++;
RtPrintf("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);
RtPrintf("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;
RtPrintf("get_exist_drives iLength =%d\n",iLength);
for (i=0;i<iLength;i++)
{
iIndex = uspData[i+2];
RtPrintf("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 + -