/****************************************************************************/ /* Copyright 1992 to 1996 MBARI */ /****************************************************************************/ /* Summary : Toolsled Dcon Ine Module for VxWorks */ /* Filename : toolsledDcon.c */ /* Author : Douglas Au */ /* Project : Tiburon */ /* Version : Version 1.0 */ /* Created : 01/24/97 */ /* Modified : 01/24/97 */ /* Archived : */ /****************************************************************************/ /* Modification History: */ /* $Header: * $Log: /****************************************************************************/ #include /* vxWorks system declarations */ #include /* vxWorks semaphore functions */ #include /* vxWorks task library functions */ #include /* vxWorks linked list library */ #include /* vxWorks watch dog timer functions */ #include /* vxWorks time and date functions */ #include /* vxWorks Message Queue Library */ #include /* MBARI style guide type declarations */ #include /* Miscellaneous constants */ #include /* MBARI Rov Application Priorities */ #include /* MBARI time and date functions */ #include /* Data Manager declarations */ #include /* Data Manager error declarations */ #include "powerAlloc.h" /* Device Power Requirements */ #include "powerDM.h" /* Power System Data Manager Items */ #include "powerTypes.h" /* Power management Data Types */ #include "console.h" /* Topside Console Data Manager Items */ #include "sio32.h" /* SIO32 hardware and driver information*/ #include "sio32Server.h" /* Sio32 server communication services */ #include "sio32Client.h" /* Sio32 client communication services */ #include "toolsledDcon.h" /* Toolsled Dcon Can Definitions */ #include "filter.h" /* median filter data structers */ #include "applic.h" /* Microcontroller applications */ #include "microcmd.h" /* Microcontroller commands */ #include "microDm.h" /* Micro Data Manager Items & Functions */ #define Boolean MBool /* Map microcontroller Boolean to MBool */ #include "timer.h" /* IBC Micro Timer Definitions */ #include "ibc_card.h" /* IBC Card Types */ #include "ibc_cmd.h" /* IBC Serial Commands */ #include "filter.h" /* IBC General IIR Filter Routines */ #include "gf_board.h" /* GF/5V Controller Board Definitions */ #include "low_pwr.h" /* Low Power Switch Board Definitions */ #include "vicor.h" /* Dual Vicor Board Definitions */ #include "toolsled.h" /* Toolsled Dcon Micro definitions */ #include "ibc.h" /* Function Prototypes for ibc.c */ #include "switch.h" /* IBC Function Libarary Definitions */ #include "ibcDm.h" /* IBC Data Manager Interface Functions */ #include "lpsDm.h" /* IBC LPS Board Interface Functions */ #include "gf_5vDm.h" /* IBC Ground Fault Board DMgr Functions*/ #include "gf_5v.h" /* IBC Ground Fault Board Definitions */ #include "hpsDm.h" /* IBC HPS Board Data Manager Functions */ #include "vicorDm.h" /* IBC Dual Vicor Board Interface Funcs */ #include "quadSerDm.h" /* Quad Serial Board Data Manager Funcs */ #include "vspDm.h" /* VSP Data Manager Interface Functions */ #include "vspCmd.h" /* VSP Function Prototypes */ #include "microTask.h" /* Microcontroller Task IO definitions */ /* Toolsled Dcon device Name */ MLocal char* const toolsledDconName = "Toolsled Dcon"; /* Toolsled Dcon Data Mgr Item Name Prefix*/ MLocal char* const toolsledIbcDmPrefix = TOOLSLED_IBC_DM_PREFIX; #define NUM_TASKS 3 /* Number of co-operating tasks */ #define GF5V_BOARD_ADDR (Word) GROUND_FAULT_0_ADDR #define SERIAL_BOARD_ADDR (Word) QUAD_SERIAL_0_ADDR #define VICOR_BOARD_ADDR (Word) DUAL_VICOR_0_ADDR #define ISOLATED_IO_BOARD_0_ADDR (Word) ISO_IO_0_ADDR #define ISOLATED_IO_BOARD_1_ADDR (Word) ISO_IO_1_ADDR #define HPS_BOARD_ADDR (Word) HIGH_PWR_SWITCH_0_ADDR #define LPS_BOARDS 2 /* Number of LPS Board in Toolsled Dcon */ #define ISO_IO_SWITCHES 8 /* Number of Isolated Io Switches */ MLocal Word lpsBoardAddr[LPS_BOARDS] = /* LPS Board Assignments */ { LOW_PWR_SWITCH_48V_0_ADDR, LOW_PWR_SWITCH_24V_0_ADDR }; MLocal ibcCardConfig ibcCardSet = { 9, /* Number of IBC Cards Expected */ { CPU196, GF5V_BOARD_ADDR, LOW_PWR_SWITCH_48V_0_ADDR, LOW_PWR_SWITCH_24V_0_ADDR, ISOLATED_IO_BOARD_0_ADDR, ISOLATED_IO_BOARD_1_ADDR, HPS_BOARD_ADDR, VICOR_BOARD_ADDR, SERIAL_BOARD_ADDR } }; #if 0 #define VSP_CHAN 1 #endif /* Isolated IO Board Assignments */ #define SWITCH_0_CHAN 0 /* Switch 0 On/Off channel */ #define SWITCH_1_CHAN 1 /* Switch 1 On/Off channel */ #define SWITCH_2_CHAN 2 /* Switch 2 On/Off channel */ #define SWITCH_3_CHAN 3 /* Switch 3 On/Off channel */ #define SWITCH_4_CHAN 4 /* Switch 4 On/Off channel */ #define SWITCH_5_CHAN 5 /* Switch 5 On/Off channel */ #define SWITCH_6_CHAN 6 /* Switch 6 On/Off channel */ #define SWITCH_7_CHAN 7 /* Switch 7 On/Off channel */ /* LPS Board Channel Assignments */ #define MANIPULATOR_SWITCH_CHAN 0 /* Schilling Power */ #define SPARE_48v_1_TOOLSLED_SWITCH_CHAN 1 /* Spare 48v Toolsled Power */ #define SPARE_48v_2_TOOLSLED_SWITCH_CHAN 2 /* Spare 48v Toolsled Power */ #define SPARE_48v_3_TOOLSLED_SWITCH_CHAN 3 /* Spare 48v Toolsled Power */ #define VALVE_PACK_SWITCH_CHAN 0 /* Valve Pack Toolsled Power */ #define HP_VALVE_1A_SWITCH_CHAN 1 /* High Pressure Valve 1a Power*/ #define HP_VALVE_1B_SWITCH_CHAN 2 /* High Pressure Valve 1b Power*/ #define SPARE_24v_3_TOOLSLED_SWITCH_CHAN 3 /* Spare 24v Toolsled Power */ #define TOOLSLED_DM_PERIOD 100000 /* Toolsled Data period 10 Hz */ #define HUMIDITY_DM_PERIOD 2000000 /* Humidity toolsled period .5Hz */ #define TOOLSLED_IBC_DM_PERIOD 500000 /* Toolsled Dcon Data period 2 Hz */ #define TOOLSLED_IBC_IN_STACKSIZE 3000 /* Toolsled Dcon Input Task size & TCB */ #define TOOLSLED_IBC_OUT_STACKSIZE 4000 /* Toolsled Dcon Output Task size & TCB*/ #define TOOLSLED_IBC_TASK_STACKSIZE 4000 typedef struct /* Toolsled Dcon Data Manager Item Handles*/ { DM_Item powerSwitch; /* Data Concentrator Power Switch */ DM_Item canWaterAlarm; /* Housing Water Alarm Detected */ DM_Item jboxWaterAlarm; /* J Box Water Alarm Detected */ DM_Item waterAlarmThresh; /* Water Alarm Threshold */ DM_Item HpValve1aSwitch; /* High Pressure Valve 1A Switch */ DM_Item HpValve1bSwitch; /* High Pressure Valve 1B Switch */ DM_Item isoIoSpareSwitch0; /* Isolated Io Switch 0 Output0 */ DM_Item isoIoSpareSwitch1; /* Isolated Io Switch 0 Output1 */ DM_Item valve1aSwitch; /* Isolated Io Switch 0 Output2 */ DM_Item valve1bSwitch; /* Isolated Io Switch 0 Output3 */ DM_Item valve2aSwitch; /* Isolated Io Switch 0 Output4 */ DM_Item valve2bSwitch; /* Isolated Io Switch 0 Output5 */ DM_Item valve3aSwitch; /* Isolated Io Switch 0 Output6 */ DM_Item valve3bSwitch; /* Isolated Io Switch 0 Output7 */ DM_Item valve4aSwitch; /* Isolated Io Switch 1 Output0 */ DM_Item valve4bSwitch; /* Isolated Io Switch 1 Output1 */ DM_Item valve5aSwitch; /* Isolated Io Switch 1 Output2 */ DM_Item valve5bSwitch; /* Isolated Io Switch 1 Output3 */ DM_Item valve6aSwitch; /* Isolated Io Switch 1 Output4 */ DM_Item valve6bSwitch; /* Isolated Io Switch 1 Output5 */ DM_Item valve7aSwitch; /* Isolated Io Switch 1 Output6 */ DM_Item valve7bSwitch; /* Isolated Io Switch 1 Output7 */ ibcCpuDmItems ibcDm; /* IBC CPU Data Manager Items */ ibcGf5vDmItems gf5vDm; /* GF/5V Board Data Manager Items */ ibcVicorDmItems vicorDm; /* Dual Vicor Board Data Manager Items */ ibcLpsDmItems lpsDm[LPS_BOARDS];/* LPS Board Data Manager Items */ ibcQuadSerDmItems quadSerDm; /* Quad Serial Board Data Manager Items */ ibcHpsDmItems hpsDm; /* HPS Board Data Manager Items */ #if 0 ibcVspDmItems vspDm; /* VSP Data Manager Items */ #endif } toolsledDconDmItems; /****************************************************************************/ Void toolsledDconInTask(Reg toolsledDconDmItems *dmItems, microIOControl *microIOCtrl); Void toolsledDconOutTask(Reg toolsledDconDmItems* dmItems, microIOControl *microIOCtrl); MLocal Word processToolsledDconSRQ( Reg toolsledDconDmItems* dmItems, microIOControl *microIOCtrl); MLocal Void initToolsledDconDmItems(toolsledDconDmItems* dmItems, sio32Chan* toolsledDconDataChan); /******************************************************************************/ /* Function : toolsledCanGetWaterAlarm */ /* Purpose : Read water alarm status from Toolsled Dcon microcontroller */ /* Inputs : Sio32 socket and pointer to water alarm status */ /* Outputs : Returns OK or ERROR */ /******************************************************************************/ LOCAL STATUS toolsledCanGetWaterAlarm( sio32Chan *IBC_SerialChan, Word *waterAlarmStatus ) { /* Send command to microcontroller */ return( microCommand(IBC_SerialChan, TOOLSLED_IBC_APP | GET_WATER_ALARM, waterAlarmStatus) ); } /* toolsledCanGetWaterAlarm() */ /****************************************************************************/ /* Function : toolsledGetWaterAlarmThresh */ /* Purpose : Reads water alarm threshold value from IBC CPU */ /* Inputs : Sio32 channel, pointer to water alarm threshold */ /* Outputs : Returns OK or ERROR */ /****************************************************************************/ LOCAL STATUS toolsledGetWaterAlarmThresh( sio32Chan *IBC_SerialChan, Int16 *waterAlarmThresh ) { /* Send command to microcontroller */ return (microCommand( IBC_SerialChan, TOOLSLED_IBC_APP | GET_WATER_ALARM_THRESH, waterAlarmThresh) ); } /* toolsledGetWaterAlarmThresh() */ /****************************************************************************/ /* Function : initWaterAlarmThreshDm */ /* Purpose : Read Water Alarm Threshold and update data manager item */ /* Inputs : Sio32 channel, water alarm threshold dm item handle */ /* Outputs : Returns OK or ERROR */ /****************************************************************************/ LOCAL STATUS initWaterAlarmThreshDm( sio32Chan *IBC_SerialChan, DM_Item waterAlarmThreshDm ) { Int16 waterAlarmThresh; /* Water Alarm Threshold from IBC */ /* Get Water Alarm Threshold */ if (toolsledGetWaterAlarmThresh( IBC_SerialChan, &waterAlarmThresh ) != OK) return (ERROR); /* We MUST use urgent open here as */ /* another task is normal provider */ return (urgentWriteDmItem(waterAlarmThreshDm, &waterAlarmThresh, sizeof(waterAlarmThresh)) ); } /* initWaterAlarmThreshDm() */ /****************************************************************************/ /* Function : writeWaterAlarmThresh */ /* Purpose : Get water alarm threshold value from dm and send to IBC */ /* Inputs : Sio32 channel, water threshold dm item handle */ /* Outputs : Returns OK or ERROR */ /****************************************************************************/ LOCAL STATUS writeWaterAlarmThresh( sio32Chan *sio32DataChan, DM_Item waterAlarmThreshDm ) { Errno status; /* Result of dm_read */ Int16 waterAlarmThresh; /* Water Alarm Threshold */ /* Read Water Alarm Thresh from dmgr*/ status = dm_read( waterAlarmThreshDm, (char *) &waterAlarmThresh, sizeof(waterAlarmThresh), (DM_Time *) NULL); /* Check for successful dm_read */ if ((status == SUCCESS) || (status == EDM_NOPROVIDER)) /* Send command to microcontroller */ if ( sendMicroCommand( sio32DataChan, &status, sizeof(status), 2, TOOLSLED_IBC_APP | SET_WATER_ALARM_THRESH, waterAlarmThresh ) != ERROR ) /* Check command result */ return (wordFromBuf(&status, 0) == CMD_OK ? OK : ERROR); return(ERROR); } /* writeWaterAlarmThresh() */ /****************************************************************************/ /* Function : updateWaterAlarmDm */ /* Purpose : Reads micro Water Alarm status & updates dmgr items */ /* Inputs : Sio32 chan & water alarm status data manager item handles */ /* Outputs : Returns OK or ERROR */ /****************************************************************************/ LOCAL STATUS updateWaterAlarmDm( sio32Chan *sio32DataChan, DM_Item canWaterAlarmDm, DM_Item jboxWaterAlarmDm ) { Word waterAlarmStatus; /* Microcontroller Water Alarm Status */ MBool status; /* Boolean state of Water Alarm */ /* Read Water Alarm Status */ if (toolsledCanGetWaterAlarm(sio32DataChan, &waterAlarmStatus) != OK) return(ERROR); status = ( (waterAlarmStatus & HOUSING_WATER_ALARM_BIT) ? TRUE : FALSE); writeDmItem(canWaterAlarmDm, &status, sizeof(status)); status = ( (waterAlarmStatus & JBOX_WATER_ALARM_BIT) ? TRUE : FALSE); /* Write water alarm status to Dmgr */ return ( writeDmItem(jboxWaterAlarmDm, &status, sizeof(status)) ); } /* updateWaterAlarmDm() */ /****************************************************************************/ /* Function : createToolsledDconAppDmItems */ /* Purpose : Create Data Mgr Items specific to Toolsled Dcon Application */ /* Inputs : Pointer to structure of DM item handles, Dcon DM prefix, */ /* Toolsled DM prefix, Toolsled Data Concentrator Name */ /* Outputs : Returns OK or ERROR */ /****************************************************************************/ LOCAL STATUS createToolsledDconAppDmItems( toolsledDconDmItems *toolsledDmItems, const char* toolsledDconDmPrefix, const char* toolsledIbcDmPrefix, const char* toolsledDconName ) { dmItemList toolsledDconDmInit[] = { { &toolsledDmItems->canWaterAlarm, "Housing Water Alarm", HOUSING_WATER_ALARM_DM, DM_MBOOL, 1 }, { &toolsledDmItems->jboxWaterAlarm, "J Box Water Alarm", JBOX_WATER_ALARM_DM, DM_MBOOL, 1 }, { &toolsledDmItems->waterAlarmThresh, "Water Alarm Threshold", WATER_ALARM_THRESH_DM, DM_NAT16, 1 }, { &toolsledDmItems->HpValve1aSwitch, "High Pressure Valve 1A Switch", HIGH_PRESSURE_VALVE_1A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->HpValve1bSwitch, "High Pressure Valve 1B Switch", HIGH_PRESSURE_VALVE_1B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->isoIoSpareSwitch0, "Spare Isolated Io Switch 0", ISO_IO_SPARE_SWITCH0_DM, DM_MBOOL, 1 }, { &toolsledDmItems->isoIoSpareSwitch1, "Spare Isolated Io Switch 1", ISO_IO_SPARE_SWITCH1_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve1aSwitch, "Valve 1a Switch", VALVE_1A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve1bSwitch, "Valve 1b Switch", VALVE_1B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve2aSwitch, "Valve 2a Switch", VALVE_2A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve2bSwitch, "Valve 2b Switch", VALVE_2B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve3aSwitch, "Valve 3a Switch", VALVE_3A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve3bSwitch, "Valve 3b Switch", VALVE_3B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve4aSwitch, "Valve 4a Switch", VALVE_4A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve4bSwitch, "Valve 4b Switch", VALVE_4B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve5aSwitch, "Valve 5a Switch", VALVE_5A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve5bSwitch, "Valve 5b Switch", VALVE_5B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve6aSwitch, "Valve 6a Switch", VALVE_6A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve6bSwitch, "Valve 6b Switch", VALVE_6B_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve7aSwitch, "Valve 7a Switch", VALVE_7A_SWITCH_DM, DM_MBOOL, 1 }, { &toolsledDmItems->valve7bSwitch, "Valve 7b Switch", VALVE_7B_SWITCH_DM, DM_MBOOL, 1 }, { NO_ITEM, NULL, NULL, DM_ENDT, 0 } }; /* Initialize Data Manager Items from table*/ if (initMicroDmItemList( toolsledDconDmInit, toolsledIbcDmPrefix, "Toolsled Dcon I/F" ) != OK) return(ERROR); if ( (toolsledDmItems->powerSwitch = initMicroDmItem( "", TOOLSLED_48V_SWITCH_STATUS_DM, DM_ENUM, 1)) == ERROR) { logMsg("Toolsled Dcon I/F: Error initializing Dcon Power Switch Item\n"); return (ERROR); } /* if */ /* Declare this task an item provider */ dm_start_provider(toolsledDmItems->canWaterAlarm, DM_STATIC); dm_start_provider(toolsledDmItems->jboxWaterAlarm, DM_STATIC); dm_start_consumer(toolsledDmItems->powerSwitch, DM_STATIC, SEM_NULL); return(OK); } /* createToolsledDconAppDmItems() */ /****************************************************************************/ /* Function : toolsledDconTask */ /* Purpose : Initializes communication with Toolsled Data Concentrator. */ /* Provides interface between Toolsled Data Concentrator and */ /* Data Manager items. */ /* Inputs : SIO32 serial channel number for Toolsled Data Concentrator */ /* Physically maps the Data Concentrators to a serial channel */ /* Outputs : Normally runs forever, but returns ERROR on fatal error */ /****************************************************************************/ STATUS toolsledDconTask( Nat16 toolsledDconSerialChan ) { toolsledDconDmItems toolsledDmItems; /* Toolsled Application Data Mgr handles */ microIOControl microIOCtrl; /* Microcontroller IO Task control */ Int16 lps; /* Low Power Switch Board Index */ /* Initialize serial channel and task */ /* synchronization resources */ if (initMicroTaskIO( µIOCtrl, NUM_TASKS, toolsledDconSerialChan, toolsledIbcDmPrefix, "/sio32/toolsledDcon", TOOLSLED_48V_SWITCH_STATUS_DM ) == ERROR) { logMsg("Error initializing IO for Toolsled DCon"); return(ERROR); } /* if */ bzero(&toolsledDmItems, sizeof(toolsledDmItems)); /* Create IBC CPU Data Manager Items */ if (createIbcCpuDmItems(&(toolsledDmItems.ibcDm), toolsledIbcDmPrefix, toolsledDconName) == ERROR) { /* Error occurred so print message & exit */ sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); return(ERROR); } /* if */ #if 0 /* Create Virtual Serial Port Data Manager Items */ if (createIbcVspDmItems(&toolsledDmItems.vspDm, toolsledIbcDmPrefix, toolsledDconName, 0 )== ERROR) { /* Error occured so print message & exit */ sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); return(ERROR); } /* if */ #endif /* Create Toolsled Dcon Application Items */ if (createToolsledDconAppDmItems(&toolsledDmItems, toolsledIbcDmPrefix, toolsledIbcDmPrefix, toolsledDconName) == ERROR) { /* Error occurred so print message & exit */ sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); return(ERROR); } /* if */ #if 0 initIbcVspProvider (&toolsledDmItems.vspDm); #endif /* Create GF/5V Board Data Manager Items */ createIbcGf5vDmItems( &toolsledDmItems.gf5vDm, toolsledIbcDmPrefix, toolsledDconName ); initIbcGf5vAlarmProvider( &toolsledDmItems.gf5vDm ); /* Create Quad Serial Board Data Mgr Items*/ createIbcQuadSerDmItems( &toolsledDmItems.quadSerDm, toolsledIbcDmPrefix, toolsledDconName, 0); initIbcQuadSerAlarmProvider( &toolsledDmItems.quadSerDm ); updateIbcQuadSerAlarmsDm( µIOCtrl.sio32DataChan, SERIAL_BOARD_ADDR, &toolsledDmItems.quadSerDm ); /* Create IBC Dual Vicor DMgr Items */ createIbcVicorDmItems( toolsledDmItems.vicorDm, toolsledIbcDmPrefix, toolsledDconName ); initIbcVicorAlarmProvider( toolsledDmItems.vicorDm ); /* Create IBC HPS Data Manager Items */ createIbcHpsDmItems( &toolsledDmItems.hpsDm, toolsledIbcDmPrefix, toolsledDconName, 0); initIbcHpsAlarmProvider( &toolsledDmItems.hpsDm ); for (lps = 0; lps < LPS_BOARDS; lps++) { /* Create IBC LPS Data Manager Items */ createIbcLpsDmItems( &toolsledDmItems.lpsDm[lps], toolsledIbcDmPrefix, toolsledDconName, lps ); initIbcLpsAlarmProvider( &toolsledDmItems.lpsDm[lps] ); updateIbcLpsAlarmsDm( µIOCtrl.sio32DataChan, lpsBoardAddr[lps], &toolsledDmItems.lpsDm[lps] ); } /* for */ /* Initialize Toolsled Dcon Data Out Task */ if ((microIOCtrl.childTasks[OUT_TASK].taskId = taskSpawn("toolsledDconOut", TOOLSLED_DCON_OUT_PRIORITY, 0, TOOLSLED_IBC_OUT_STACKSIZE, (FUNCPTR) toolsledDconOutTask, (int) &toolsledDmItems, (int) µIOCtrl, 0, 0, 0, 0, 0, 0, 0, 0)) == ERROR) { /* Close serial communication channel */ sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); logMsg("Toolsled Dcon: Error spawning data output task\n"); return(ERROR); } /* if */ /* Initialize Toolsled Dcon Data In Task */ if (( microIOCtrl.childTasks[IN_TASK].taskId = taskSpawn( "toolsledDconIn", TOOLSLED_DCON_IN_PRIORITY, 0, TOOLSLED_IBC_IN_STACKSIZE, (FUNCPTR) toolsledDconInTask, (int) &toolsledDmItems, (int) µIOCtrl, 0, 0, 0, 0, 0, 0, 0, 0) ) == ERROR) { /* Delete Toolsled Dcon Out Task */ taskDelete(microIOCtrl.childTasks[OUT_TASK].taskId); sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); logMsg("Toolsled Dcon: Error spawning data input task\n"); return(ERROR); } /* if */ FOREVER { /* Check if Dcon is switched on */ if ((microDevPowerSwitchState(µIOCtrl) != SWITCH_ON) || ((microDevPowerSwitchState(µIOCtrl) == SWITCH_ON) && (microIOCtrl.resetEventCount != 0))) /* Process SRQ's from micro */ while(processToolsledDconSRQ(&toolsledDmItems, µIOCtrl) != MICRO_RESET_SRQ); microIOCtrl.resetEventCount++; /* Count reset events ffrom micro */ /* Reset event received from Micro so */ /* Mark serial coms link as up */ setSerialLinkState(µIOCtrl, LINK_UP); /******* Re-initialize Data Manager items after reset received ***** */ /* Initialize IBC Static Data Mgr Items */ if(initIbcCpuDmItems( &toolsledDmItems.ibcDm, µIOCtrl.sio32DataChan, toolsledDconName, ibcCardSet )==OK) { /* Initialize Toolsled Dcon Applic Items */ initToolsledDconDmItems( &toolsledDmItems, µIOCtrl.sio32DataChan ); updateIbcGf5vAlarmsDm( µIOCtrl.sio32DataChan, GF5V_BOARD_ADDR, &toolsledDmItems.gf5vDm); updateIbcQuadSerAlarmsDm( µIOCtrl.sio32DataChan, SERIAL_BOARD_ADDR, &toolsledDmItems.quadSerDm ); updateIbcVicorAlarmsDm(µIOCtrl.sio32DataChan, VICOR_BOARD_ADDR, toolsledDmItems.vicorDm ); for (lps = 0; lps < LPS_BOARDS; lps++) updateIbcLpsAlarmsDm( µIOCtrl.sio32DataChan, lpsBoardAddr[lps], &toolsledDmItems.lpsDm[lps] ); updateIbcHpsAlarmsDm( µIOCtrl.sio32DataChan, HPS_BOARD_ADDR, &toolsledDmItems.hpsDm ); #if 0 updateIbcVspDmItems( µIOCtrl.sio32DataChan, SERIAL_BOARD_ADDR, VSP_CHAN, &toolsledDmItems.vspDm, toolsledDconName ); #endif /* Wake up output task to configure micro*/ semGive(microIOCtrl.childTasks[OUT_TASK].taskSyncSem); } /* if */ else setSerialLinkState(µIOCtrl, LINK_DOWN); } /* FOREVER */ /* Delete Child Tasks */ taskDelete(microIOCtrl.childTasks[IN_TASK].taskId); taskDelete(microIOCtrl.childTasks[OUT_TASK].taskId); /* Close serial communication channel */ sio32ChanDestroy( toolsledDconSerialChan, µIOCtrl.sio32DataChan ); /* dm_stop_provider, dm_stop_consumer, etc are NOT */ /* required when the task exits as the Data Manager */ /* does this automatically when the task is deleted */ /* via taskDeleteHookAdd() and dm_task_exit functions*/ return(OK); /* That's all folks */ } /* toolsledDconTask() */ /*****************************************************************************/ /* Function : initToolsledDconDmItems */ /* Purpose : Reads parameters from Toolsled Dcon & update Data Mgr items */ /* Inputs : Array of Data Manager Item handles & serial chan structure */ /* Outputs : None, but Data Manager Items change */ /*****************************************************************************/ LOCAL Void initToolsledDconDmItems( toolsledDconDmItems* dmItems, sio32Chan* toolsledDconDataChan ) { /* Set Micro Water Alarms initial value */ if (updateWaterAlarmDm(toolsledDconDataChan, dmItems->canWaterAlarm, dmItems->jboxWaterAlarm) == ERROR) logMsg("Toolsled Dcon: Error checking water alarm status\n"); } /* initToolsledDconDmItems() */ /*****************************************************************************/ /* Function : toolsledDconOutTask */ /* Purpose : Toolsled Dcon Out Task. Read DM items & write to Toolsled Dcon */ /* Inputs : Array of Data Manager Item handles & serial chan structure */ /* Outputs : Normally runs forever, but exits if error occurs */ /*****************************************************************************/ Void toolsledDconOutTask(Reg toolsledDconDmItems *dmItems, microIOControl *microIOCtrl) { DM_Group cpuGroup; /* CPU & Misc Item Data Manager Group */ DM_Group gf5vGroup; /* GF/5V Board Data Manager Group */ #if 0 DM_Group vspGroup; /* VSP Data Manager Group */ #endif DM_Group vicorGroup; /* Vicor Board Data Manager Group */ DM_Group lpsGroup[LPS_BOARDS]; /* LPS 12V Board Data Manager Group */ DM_Group hpsGroup; /* HPS Board Data Manager Group */ SEM_ID dmUpdateSem; /* Data Manager Item Change wakeup sem */ SEM_ID powerReqSem; /* Power Request Update Semaphore */ Int16 lpsBoard; /* Lps Board index */ cpuUpdateBits ibcCpuBits; /* CPU Board Parameter Update Bits */ gf5vUpdateBits gf5vBits; /* GF/5V Board Paramater Update Bits */ #if 0 vspUpdateBits vspBits; /* VSP Parameter Update Bits */ #endif vicorUpdateBits vicorBits; /* Vicor Board Paramater Update Bits */ lpsUpdateBits lpsBits[LPS_BOARDS];/* LPS Board Paramater Update Bits */ hpsUpdateBits hpsBits; /* HPS Board Parameter Update Bits */ DWord toolsledDconGroupBits; /* Holds dm_group_changes bit vector */ DWord waterAlarmThreshBit; /* Water alarm threshold item change bit */ DWord lps0EnableBit; /* LPS 0 Enable Request changed bit */ DWord lps1EnableBit; /* LPS 0 Enable Request changed bit */ DWord manipulatorSwitchBit; /* Schilling Switch bit */ DWord spare48vSwitch1Bit; /* Spare 48v switch 1 - 3 */ DWord spare48vSwitch2Bit; DWord spare48vSwitch3Bit; DWord valvePackSwitchBit; /* Valve 8 Switch bit */ DWord hpValve1aSwitchBit; /* High Pressure Valve 1a Switch Bit */ DWord hpValve1bSwitchBit; /* High Pressure Valve 1b Switch Bit */ DWord spare24vSwitch3Bit; /* Spare 24v switch 3 */ DWord isolatedIo0SwitchBit; /* Isolated IO switch 0 bit */ DWord isolatedIo1SwitchBit; /* Isolated IO switch 1 bit */ DWord incandLampSwitchBit; /* Incandescent Lamp Switch Bit */ DWord isoIoSwitch0Bit; /* Isolated IO switch 0 bit */ DWord isoIoSwitch1Bit; /* Isolated IO switch 1 bit */ DWord valve1aSwitchBit; /* Isolated IO switch 2 bit */ DWord valve1bSwitchBit; /* Isolated IO switch 3 bit */ DWord valve2aSwitchBit; /* Isolated IO switch 4 bit */ DWord valve2bSwitchBit; /* Isolated IO switch 5 bit */ DWord valve3aSwitchBit; /* Isolated IO switch 6 bit */ DWord valve3bSwitchBit; /* Isolated IO switch 7 bit */ DWord valve4aSwitchBit; /* Isolated IO switch 0 bit */ DWord valve4bSwitchBit; /* Isolated IO switch 1 bit */ DWord valve5aSwitchBit; /* Isolated IO switch 2 bit */ DWord valve5bSwitchBit; /* Isolated IO switch 3 bit */ DWord valve6aSwitchBit; /* Isolated IO switch 4 bit */ DWord valve6bSwitchBit; /* Isolated IO switch 5 bit */ DWord valve7aSwitchBit; /* Isolated IO switch 6 bit */ DWord valve7bSwitchBit; /* Isolated IO switch 7 bit */ DWord toolsledDconSwitchBit; /* ToolsledDcon Switch Request changed bit */ DWord toolsledDcon240VSwitchBit; /* Toolsled Dcon LPS Output Enable switches*/ switchEntry toolsledLps0EnableSwitch; switchEntry toolsledLps1EnableSwitch; switchEntry toolsledDconSwitch; /* Toolsled DCon Switch */ switchEntry toolsledDcon240VSwitch; switchEntry manipulatorSwitch; /* Schilling Manipulator Switch */ switchEntry valvePackSwitch; /* Toolsled Hydralic Valve Switch */ switchEntry hpValve1aSwitch; /* Hp Valve 1a Switch */ switchEntry hpValve1bSwitch; /* Hp Valve 1b Switch */ switchEntry incandLampSwitch; /* Incandescent Lamp Switch */ switchEntry isolatedIo0Switch; /* Isolated Io switch for valve pack */ switchEntry isolatedIo1Switch; /* Isolated Io switch for valve pack */ MBool hpValve2aSwitch; MBool hpValve2bSwitch; MBool isoIoSpareSwitch0; MBool isoIoSpareSwitch1; MBool valve1aSwitch; MBool valve1bSwitch; MBool valve2aSwitch; MBool valve2bSwitch; MBool valve3aSwitch; MBool valve3bSwitch; MBool valve4aSwitch; MBool valve4bSwitch; MBool valve5aSwitch; MBool valve5bSwitch; MBool valve6aSwitch; MBool valve6bSwitch; MBool valve7aSwitch; MBool valve7bSwitch; /*****************************************************************************/ /* The code is this task implements the following interconnected switches for the toolsled data concentrator Toolsled Dcon 48V LPS Enable LPS 0-4 48V Bus _____ \_____________ \______________ \__Schilling Manip LPS______| | | | | |_ \__Spare 48v LPS 1__________| | | | | |_ \__Spare 48v LPS 2__________| | | | | |_ \__Spare 48v LPS 3__________| | | | 24V LPS Enable LPS 0-4 | |________ \______________ \__Hydralic Valve LPS_______| | | |_ \__High Press Valve 1a LPS__| | | |_ \__High Press Valve 1b LPS__| | | |_ \__Spare 24v LPS 3__________| /******************************************************************************/ /* Create switch & power sync semaphores */ if ( ((dmUpdateSem = semBCreate(SEM_Q_FIFO, SEM_EMPTY)) == NULL) || ((powerReqSem = semBCreate(SEM_Q_FIFO, SEM_EMPTY)) == NULL) ) { logMsg("Toolsled Dcon: Error initializing Input Task Resources\n"); return; } /* if */ duplicateIbcSwitchEntry( &toolsledDconSwitch, TOOLSLED_48V_SWITCH_REQ_DM, TOOLSLED_48V_SWITCH_STATUS_DM, dmUpdateSem, toolsledDconName, "Toolsled DCon Switch"); duplicateIbcSwitchEntry( &toolsledDcon240VSwitch, TOOLSLED_240V_SWITCH_REQ_DM, TOOLSLED_240V_SWITCH_STATUS_DM, dmUpdateSem, toolsledDconName, "Toolsled DCon 240V Switch"); initIbcSwitchEntry( &incandLampSwitch, SERIAL_CHAN, INCAND_LAMP_POWER, B240, HOTEL, HIGH_POWER_SWITCH, HPS_BOARD_ADDR, 0, INCAND_LAMP_SWITCH_REQ_DM, INCAND_LAMP_SWITCH_STATUS_DM, dmUpdateSem, INCAND_LAMP_PWR_REQ_DM, INCAND_LAMP_PWR_OK_DM, powerReqSem, toolsledDconName, "Incandescent Lamp Power Switch"); initIbcSwitchEntry( &toolsledLps0EnableSwitch, SERIAL_CHAN, VICOR_STANDBY_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[0], LPS_VICOR_ENABLE, TOOLSLED_LPS0_48V_ENABLE_SWITCH_REQ_DM, TOOLSLED_LPS0_48V_ENABLE_STATUS_DM, dmUpdateSem, TOOLSLED_LPS0_48V_ENABLE_PWR_REQ_DM, TOOLSLED_LPS0_48V_ENABLE_PWR_OK_DM, powerReqSem, toolsledDconName, "LPS 0 Enable"); initIbcSwitchEntry( &manipulatorSwitch, SERIAL_CHAN, MANIPULATOR_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[0], MANIPULATOR_SWITCH_CHAN, MANIPULATOR_SWITCH_REQ_DM, MANIPULATOR_SWITCH_STATUS_DM, dmUpdateSem, MANIPULATOR_PWR_REQ_DM, MANIPULATOR_PWR_OK_DM, powerReqSem, toolsledDconName, "ManipulatorSwitch"); initIbcSwitchEntry( &toolsledLps1EnableSwitch, SERIAL_CHAN , VICOR_STANDBY_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[1], LPS_VICOR_ENABLE, TOOLSLED_LPS1_24V_ENABLE_SWITCH_REQ_DM, TOOLSLED_LPS1_24V_ENABLE_STATUS_DM, dmUpdateSem, TOOLSLED_LPS1_24V_ENABLE_PWR_REQ_DM, TOOLSLED_LPS1_24V_ENABLE_PWR_OK_DM, powerReqSem, toolsledDconName, "LPS 1 Enable"); initIbcSwitchEntry( &valvePackSwitch, SERIAL_CHAN, VALVE_PACK_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[1], VALVE_PACK_SWITCH_CHAN, VALVE_PACK_SWITCH_REQ_DM, VALVE_PACK_SWITCH_STATUS_DM, dmUpdateSem, VALVE_PACK_PWR_REQ_DM, VALVE_PACK_PWR_OK_DM, powerReqSem, toolsledDconName, "Valve Pack Toolsled Switch"); initIbcSwitchEntry( &hpValve1aSwitch, SERIAL_CHAN, HP_VALVE_1A_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[1], HP_VALVE_1A_SWITCH_CHAN, HP_VALVE_1A_SWITCH_REQ_DM, HP_VALVE_1A_SWITCH_STATUS_DM, dmUpdateSem, HP_VALVE_1A_PWR_REQ_DM, HP_VALVE_1A_PWR_OK_DM, powerReqSem, toolsledDconName, "High Press Valve 1A Switch"); initIbcSwitchEntry( &hpValve1bSwitch, SERIAL_CHAN, HP_VALVE_1B_POWER, B48, HOTEL, LOW_POWER_SWITCH, lpsBoardAddr[1], HP_VALVE_1B_SWITCH_CHAN, HP_VALVE_1B_SWITCH_REQ_DM, HP_VALVE_1B_SWITCH_STATUS_DM, dmUpdateSem, HP_VALVE_1B_PWR_REQ_DM, HP_VALVE_1B_PWR_OK_DM, powerReqSem, toolsledDconName, "High Press Valve 1B Switch"); initIbcSwitchEntry( &isolatedIo0Switch, SERIAL_CHAN, ISOLATED_IO_0_POWER, B48, HOTEL, DUAL_VICOR, VICOR_BOARD_ADDR, DUAL_VICOR_PSU0, ISOLATED_IO_0_SWITCH_REQ_DM, ISOLATED_IO_0_SWITCH_STATUS_DM, dmUpdateSem, ISOLATED_IO_0_PWR_REQ_DM, ISOLATED_IO_0_PWR_OK_DM, powerReqSem, toolsledDconName, "Isolated IO 0 Power Switch"); initIbcSwitchEntry( &isolatedIo1Switch, SERIAL_CHAN, ISOLATED_IO_1_POWER, B48, HOTEL, DUAL_VICOR, VICOR_BOARD_ADDR, DUAL_VICOR_PSU1, ISOLATED_IO_1_SWITCH_REQ_DM, ISOLATED_IO_1_SWITCH_STATUS_DM, dmUpdateSem, ISOLATED_IO_1_PWR_REQ_DM, ISOLATED_IO_1_PWR_OK_DM, powerReqSem, toolsledDconName, "Isolated IO 1 Power Switch"); ibcAddSwitchInSeries( &toolsledDconSwitch, &toolsledLps0EnableSwitch ); ibcAddSwitchInSeries( &toolsledDconSwitch, &toolsledLps1EnableSwitch ); ibcAddSwitchInSeries( &toolsledDconSwitch, &isolatedIo0Switch ); ibcAddSwitchInSeries( &toolsledDconSwitch, &isolatedIo1Switch ); /* Devices on Toolsled Can Low Power Switches*/ ibcAddSwitchInSeries( &toolsledLps0EnableSwitch, &manipulatorSwitch ); ibcAddSwitchInSeries( &toolsledLps1EnableSwitch, &valvePackSwitch ); ibcAddSwitchInSeries( &toolsledLps1EnableSwitch, &hpValve1aSwitch ); ibcAddSwitchInSeries( &toolsledLps1EnableSwitch, &hpValve1bSwitch ); ibcAddSwitchInSeries( &toolsledDcon240VSwitch, &incandLampSwitch ); ibcConnectVicorDmItems( dmItems->vicorDm, &isolatedIo0Switch, toolsledDconName, "Isolated IO 0", DUAL_VICOR_PSU0, ISOLATED_IO_0_TEMP_DM, ISOLATED_IO_0_TEMP_ALARM_DM, ISOLATED_IO_0_TEMP_WARN_THRESH_DM, ISOLATED_IO_0_TEMP_ALARM_THRESH_DM); ibcConnectVicorDmItems( dmItems->vicorDm, &isolatedIo1Switch, toolsledDconName, "Isolated IO 1", DUAL_VICOR_PSU1, ISOLATED_IO_1_TEMP_DM, ISOLATED_IO_1_TEMP_ALARM_DM, ISOLATED_IO_1_TEMP_WARN_THRESH_DM, ISOLATED_IO_1_TEMP_ALARM_THRESH_DM); ibcConnectLpsDmItems( &dmItems->lpsDm[0], &manipulatorSwitch, toolsledDconName, "Manipulator", MANIPULATOR_SWITCH_CHAN, MANIPULATOR_CURRENT_DM, MANIPULATOR_CURRENT_ALARM_DM, MANIPULATOR_CURRENT_WARN_THRESH_DM, MANIPULATOR_CURRENT_ALARM_THRESH_DM); ibcConnectLpsDmItems( &dmItems->lpsDm[1], &valvePackSwitch, toolsledDconName, "Valve Pack", VALVE_PACK_SWITCH_CHAN, VALVE_PACK_CURRENT_DM, VALVE_PACK_CURRENT_ALARM_DM, VALVE_PACK_CURRENT_WARN_THRESH_DM, VALVE_PACK_CURRENT_ALARM_THRESH_DM); ibcConnectLpsDmItems( &dmItems->lpsDm[1], &hpValve1aSwitch, toolsledDconName, "High Press Valve 1a", HP_VALVE_1A_SWITCH_CHAN, HP_VALVE_1A_CURRENT_DM, HP_VALVE_1A_CURRENT_ALARM_DM, HP_VALVE_1A_CURRENT_WARN_THRESH_DM, HP_VALVE_1A_CURRENT_ALARM_THRESH_DM); ibcConnectLpsDmItems( &dmItems->lpsDm[1], &hpValve1bSwitch, toolsledDconName, "High Press Valve 1b", HP_VALVE_1B_SWITCH_CHAN, HP_VALVE_1B_CURRENT_DM, HP_VALVE_1B_CURRENT_ALARM_DM, HP_VALVE_1B_CURRENT_WARN_THRESH_DM, HP_VALVE_1B_CURRENT_ALARM_THRESH_DM); ibcConnectHpsDmItems( &dmItems->hpsDm, &incandLampSwitch, toolsledDconName, "Incandescent Lamp", INCAND_LAMP_CURRENT_DM, INCAND_LAMP_CURRENT_ALARM_DM, INCAND_LAMP_CURRENT_WARN_THRESH_DM, INCAND_LAMP_CURRENT_ALARM_THRESH_DM, INCAND_LAMP_SWITCH_TRIP_DM ); /* Create Data Manager Group for items */ cpuGroup = initIbcCpuConsumer(&dmItems->ibcDm, &ibcCpuBits, dmUpdateSem); /* Use CPU Group for misc parameters */ dm_start_consumer(dmItems->waterAlarmThresh, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->isoIoSpareSwitch0, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->isoIoSpareSwitch1, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve1aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve1bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve2aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve2bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve3aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve3bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve4aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve4bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve5aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve5bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve6aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve6bSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve7aSwitch, DM_STATIC, dmUpdateSem); dm_start_consumer(dmItems->valve7bSwitch, DM_STATIC, dmUpdateSem); dm_group_add_item(cpuGroup, toolsledDconSwitch.switchStatusDm, &toolsledDconSwitchBit); dm_group_add_item(cpuGroup, toolsledDcon240VSwitch.switchRequestDm, &toolsledDcon240VSwitchBit); dm_group_add_item(cpuGroup, dmItems->waterAlarmThresh, &waterAlarmThreshBit); /* Isolated I/O Switches */ dm_group_add_item(cpuGroup, dmItems->isoIoSpareSwitch0, &isoIoSwitch0Bit); dm_group_add_item(cpuGroup, dmItems->isoIoSpareSwitch1, &isoIoSwitch1Bit); dm_group_add_item(cpuGroup, dmItems->valve1aSwitch, &valve1aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve1bSwitch, &valve1bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve2aSwitch, &valve2aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve2bSwitch, &valve2bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve3aSwitch, &valve3aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve3bSwitch, &valve3bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve4aSwitch, &valve4aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve4bSwitch, &valve4bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve5aSwitch, &valve5aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve5bSwitch, &valve5bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve6aSwitch, &valve6aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve6bSwitch, &valve6bSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve7aSwitch, &valve7aSwitchBit); dm_group_add_item(cpuGroup, dmItems->valve7bSwitch, &valve7bSwitchBit); /* Create GF/5V Data Manager Group */ gf5vGroup = initIbcGf5vConsumer( &dmItems->gf5vDm, &gf5vBits, dmUpdateSem ); #if 0 /* Create Virtual Serial Port Data Manager Group */ vspGroup = initIbcVspConsumer( &dmItems->vspDm, &vspBits, dmUpdateSem ); #endif /* Create LPS Data Manager Group */ for (lpsBoard = 0; lpsBoard < LPS_BOARDS; lpsBoard++) lpsGroup[lpsBoard] = initIbcLpsConsumer(&dmItems->lpsDm[lpsBoard], &lpsBits[lpsBoard], dmUpdateSem); hpsGroup = initIbcHpsConsumer(&dmItems->hpsDm, &hpsBits, dmUpdateSem); vicorGroup = /* Create Dual Vicor DM Group */ initIbcVicorConsumer( dmItems->vicorDm, &vicorBits, dmUpdateSem ); /* Add Switch Requests to DM Group */ dm_group_add_item(cpuGroup, toolsledLps0EnableSwitch.switchRequestDm, &lps0EnableBit); dm_group_add_item(cpuGroup, toolsledLps1EnableSwitch.switchRequestDm, &lps1EnableBit); dm_group_add_item(cpuGroup, manipulatorSwitch.switchRequestDm, &manipulatorSwitchBit); dm_group_add_item(cpuGroup, valvePackSwitch.switchRequestDm, &valvePackSwitchBit); dm_group_add_item(cpuGroup, hpValve1aSwitch.switchRequestDm, &hpValve1aSwitchBit); dm_group_add_item(cpuGroup, hpValve1bSwitch.switchRequestDm, &hpValve1bSwitchBit); dm_group_add_item(cpuGroup, incandLampSwitch.switchRequestDm, &incandLampSwitchBit); dm_group_add_item(cpuGroup, isolatedIo0Switch.switchRequestDm, &isolatedIo0SwitchBit); dm_group_add_item(cpuGroup, isolatedIo1Switch.switchRequestDm, &isolatedIo1SwitchBit); /* Clear Changed Bits before we Start */ toolsledDconGroupBits = dm_get_group_changes(cpuGroup); FOREVER { /* Mark micro configuration as invalid */ microIOCtrl->microConfigured = FALSE; /* Wait for micro reset via SRQ Task */ semTake(microIOCtrl->childTasks[OUT_TASK].taskSyncSem, WAIT_FOREVER); /* We need to initialize default state of Data manager Items here */ /* Initialize DM item values and default */ /* IBC Switch states */ ibcSetSwitchState (&manipulatorSwitch, SWITCH_OFF); ibcSetSwitchState (&valvePackSwitch, SWITCH_OFF); ibcSetSwitchState (&hpValve1aSwitch, SWITCH_OFF); ibcSetSwitchState (&hpValve1bSwitch, SWITCH_OFF); ibcSetSwitchState (&incandLampSwitch, SWITCH_OFF); ibcSetSwitchState (&isolatedIo0Switch, SWITCH_ON); ibcSetSwitchState (&isolatedIo1Switch, SWITCH_ON); ibcSetSwitchState (&toolsledLps0EnableSwitch, SWITCH_ON ); ibcSetSwitchState (&toolsledLps1EnableSwitch, SWITCH_ON ); initIbcHumidityThreshDm( SERIAL_CHAN, dmItems->ibcDm.humidityWarnThresh, dmItems->ibcDm.humidityAlarmThresh); initWaterAlarmThreshDm( SERIAL_CHAN, dmItems->waterAlarmThresh); updateIbcGf5vDmItems( SERIAL_CHAN, GF5V_BOARD_ADDR, &dmItems->gf5vDm, toolsledDconName ); setGf5vChargeTimes( &dmItems->gf5vDm, LOW_VOLTAGE_GF_CHARGE_TIME, LOW_VOLTAGE_GF_CHARGE_TIME, LOW_VOLTAGE_GF_CHARGE_TIME, LOW_VOLTAGE_GF_CHARGE_TIME ); enableGf5vMonitoring( SERIAL_CHAN, GF5V_BOARD_ADDR, &dmItems->gf5vDm, FALSE ); runGf5vBoardSelftest( SERIAL_CHAN, GF5V_BOARD_ADDR, &dmItems->gf5vDm ); #if 0 updateIbcVspDmItems( SERIAL_CHAN, SERIAL_BOARD_ADDR, VSP_CHAN, &dmItems->vspDm, toolsledDconName ); #endif updateIbcLpsDmItems( SERIAL_CHAN, lpsBoardAddr[0], &dmItems->lpsDm[0], toolsledDconName ); updateIbcLpsDmItems( SERIAL_CHAN, lpsBoardAddr[1], &dmItems->lpsDm[1], toolsledDconName ); updateIbcHpsDmItems( SERIAL_CHAN, HPS_BOARD_ADDR, &dmItems->hpsDm, toolsledDconName ); updateIbcVicorDmItems( SERIAL_CHAN, VICOR_BOARD_ADDR, dmItems->vicorDm, toolsledDconName ); /* Clear Changed Bits before we start */ toolsledDconGroupBits = dm_get_group_changes(cpuGroup); /* Flag that micro has been configured */ microIOCtrl->microConfigured = TRUE; /* Wake up input task to read from micro */ semGive(microIOCtrl->childTasks[IN_TASK].taskSyncSem); /* Clear changed item bits in DM */ toolsledDconGroupBits = dm_get_group_changes(cpuGroup); while (microIOCtrl->serialLinkState == LINK_UP) { /* Wait for any data items to change */ semTake(dmUpdateSem, WAIT_FOREVER); /* Ask Data Manager which items changed */ toolsledDconGroupBits = dm_get_group_changes(cpuGroup); /* Check if micro Reset Event occurred */ if (toolsledDconGroupBits & ibcCpuBits.resetEventBit) break; /* Exit loop and re-initialize DM items */ taskSafe(); /* Prevent task from being deleted during*/ /* serial IO and Data Manager updates */ /* Toolsled Dcon Power Switch Request */ if (toolsledDconGroupBits & toolsledDconSwitchBit) { ibcProcessDupSwitchRequest( &toolsledDconSwitch ); if (microDevPowerSwitchState(microIOCtrl) != SWITCH_ON) { /* DCon is switched off so link is down */ setSerialLinkState(microIOCtrl, LINK_DOWN); taskSafe(); break; } /* if */ } /* if */ /* Toolsled Dcon 240V Power Switch Request*/ if (toolsledDconGroupBits & toolsledDcon240VSwitchBit) { if (ibcSwitchRequestDmState(&toolsledDcon240VSwitch) == SWITCH_OFF) { ibcSetSwitchState (&incandLampSwitch, SWITCH_OFF); } /* if */ } /* if */ /* Isolated IO Power Switch Request */ if (toolsledDconGroupBits & isolatedIo0SwitchBit) ibcProcessSwitchRequest( &isolatedIo0Switch ); if (toolsledDconGroupBits & isolatedIo1SwitchBit) ibcProcessSwitchRequest( &isolatedIo1Switch ); /* Toolsled Can LPS Output Enable Request */ if (toolsledDconGroupBits & lps0EnableBit) ibcProcessSwitchRequest( &toolsledLps0EnableSwitch ); if (toolsledDconGroupBits & lps1EnableBit) ibcProcessSwitchRequest( &toolsledLps1EnableSwitch ); if (toolsledDconGroupBits & manipulatorSwitchBit) ibcProcessSwitchRequest( &manipulatorSwitch ); if (toolsledDconGroupBits & valvePackSwitchBit) ibcProcessSwitchRequest( &valvePackSwitch ); if (toolsledDconGroupBits & hpValve1aSwitchBit) ibcProcessSwitchRequest( &hpValve1aSwitch ); if (toolsledDconGroupBits & hpValve1bSwitchBit) ibcProcessSwitchRequest( &hpValve1bSwitch ); if (toolsledDconGroupBits & incandLampSwitchBit) ibcProcessSwitchRequest( &incandLampSwitch ); /* Isolated I/O Switch 0 Request */ if (toolsledDconGroupBits & isoIoSwitch0Bit) { dm_read( dmItems->isoIoSpareSwitch0, (char *) &isoIoSpareSwitch0, sizeof(isoIoSpareSwitch0), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_0_CHAN, isoIoSpareSwitch0 ? OFF : ON); } /* Isolated I/O Switch 1 Request */ if (toolsledDconGroupBits & isoIoSwitch1Bit) { dm_read( dmItems->isoIoSpareSwitch1, (char *) &isoIoSpareSwitch1, sizeof(isoIoSpareSwitch1), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_1_CHAN, isoIoSpareSwitch1 ? OFF: ON); } /* Isolated I/O Switch 2 Request */ if (toolsledDconGroupBits & valve1aSwitchBit) { dm_read( dmItems->valve1aSwitch, (char *) &valve1aSwitch, sizeof(valve1aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_2_CHAN, valve1aSwitch ? OFF : ON); } /* Isolated I/O Switch 3 Request */ if (toolsledDconGroupBits & valve1bSwitchBit) { dm_read( dmItems->valve1bSwitch, (char *) &valve1bSwitch, sizeof(valve1bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_3_CHAN, valve1bSwitch ? OFF : ON); } /* Isolated I/O Switch 4 Request */ if (toolsledDconGroupBits & valve2aSwitchBit) { dm_read( dmItems->valve2aSwitch, (char *) &valve2aSwitch, sizeof(valve2aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_4_CHAN, valve2aSwitch ? OFF : ON); } /* Isolated I/O Switch 5 Request */ if (toolsledDconGroupBits & valve2bSwitchBit) { dm_read( dmItems->valve2bSwitch, (char *) &valve2bSwitch, sizeof(valve2bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_5_CHAN, valve2bSwitch ? OFF : ON); } /* Isolated I/O Switch 6 Request */ if (toolsledDconGroupBits & valve3aSwitchBit) { dm_read( dmItems->valve3aSwitch, (char *) &valve3aSwitch, sizeof(valve3aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_6_CHAN, valve3aSwitch ? OFF : ON); } /* Isolated I/O Switch 7 Request */ if (toolsledDconGroupBits & valve3bSwitchBit) { dm_read( dmItems->valve3bSwitch, (char *) &valve3bSwitch, sizeof(valve3bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_7_CHAN, valve3bSwitch ? OFF : ON); } /* Isolated I/O Switch 0 Request */ if (toolsledDconGroupBits & valve4aSwitchBit) { dm_read( dmItems->valve4aSwitch, (char *) &valve4aSwitch, sizeof(valve4aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_0_CHAN, valve4aSwitch ? OFF : ON); } /* Isolated I/O Switch 1 Request */ if (toolsledDconGroupBits & valve4bSwitchBit) { dm_read( dmItems->valve4bSwitch, (char *) &valve4bSwitch, sizeof(valve4bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_1_CHAN, valve4bSwitch ? OFF : ON); } /* Isolated I/O Switch 2 Request */ if (toolsledDconGroupBits & valve5aSwitchBit) { dm_read( dmItems->valve5aSwitch, (char *) &valve5aSwitch, sizeof(valve5aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_2_CHAN, valve5aSwitch ? OFF : ON); } /* Isolated I/O Switch 3 Request */ if (toolsledDconGroupBits & valve5bSwitchBit) { dm_read( dmItems->valve5bSwitch, (char *) &valve5bSwitch, sizeof(valve5bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_3_CHAN, valve5bSwitch ? OFF : ON); } /* Isolated I/O Switch 4 Request */ if (toolsledDconGroupBits & valve6aSwitchBit) { dm_read( dmItems->valve6aSwitch, (char *) &valve6aSwitch, sizeof(valve6aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_4_CHAN, valve6aSwitch ? OFF : ON); } /* Isolated I/O Switch 5 Request */ if (toolsledDconGroupBits & valve6bSwitchBit) { dm_read( dmItems->valve6bSwitch, (char *) &valve6bSwitch, sizeof(valve6bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_5_CHAN, valve6bSwitch ? OFF : ON); } /* Isolated I/O Switch 6 Request */ if (toolsledDconGroupBits & valve7aSwitchBit) { dm_read( dmItems->valve7aSwitch, (char *) &valve7aSwitch, sizeof(valve7aSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_6_CHAN, valve7aSwitch ? OFF : ON); } /* Isolated I/O Switch 7 Request */ if (toolsledDconGroupBits & valve7bSwitchBit) { dm_read( dmItems->valve7bSwitch, (char *) &valve7bSwitch, sizeof(valve7bSwitch), (DM_Time *) NULL); ibcSwitchControl(SERIAL_CHAN, ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_7_CHAN, valve7bSwitch ? OFF : ON); } /* Check for GF/5V Board Parameter Update*/ ibcGf5vUpdateCheck( SERIAL_CHAN, GF5V_BOARD_ADDR, &dmItems->gf5vDm, &gf5vBits, gf5vGroup ); /* Check for Vicor Board Parameter Update */ ibcVicorUpdateCheck( SERIAL_CHAN, VICOR_BOARD_ADDR, dmItems->vicorDm, &vicorBits, vicorGroup ); #if 0 /* Check for Virtual Serial Port Parameter Update*/ ibcVspUpdateCheck( SERIAL_CHAN, SERIAL_BOARD_ADDR, VSP_CHAN, &dmItems->vspDm, &vspBits, vspGroup ); #endif /* Check for LPS Board Parameter Update */ for (lpsBoard = 0; lpsBoard < LPS_BOARDS; lpsBoard++) ibcLpsUpdateCheck( SERIAL_CHAN, lpsBoardAddr[lpsBoard], &dmItems->lpsDm[lpsBoard], &lpsBits[lpsBoard], lpsGroup[lpsBoard] ); ibcHpsUpdateCheck( SERIAL_CHAN, HPS_BOARD_ADDR, &dmItems->hpsDm, &hpsBits, hpsGroup ); /* Send Set Humidity Alarm Threshold cmd*/ if ((toolsledDconGroupBits & ibcCpuBits.humidityWarnThreshBit) || (toolsledDconGroupBits & ibcCpuBits.humidityAlarmThreshBit)) writeIbcHumidityThresh(SERIAL_CHAN, dmItems->ibcDm.humidityWarnThresh, dmItems->ibcDm.humidityAlarmThresh); /* Send Set Water Alarm Threshold cmd */ if (toolsledDconGroupBits & waterAlarmThreshBit) writeWaterAlarmThresh(SERIAL_CHAN, dmItems->waterAlarmThresh); /* If Reset Command request occurred */ if (toolsledDconGroupBits & ibcCpuBits.resetCmdBit) { /* Mark serial link as down */ setSerialLinkState(microIOCtrl, LINK_DOWN); /* Manual reset so ammounce it */ microIOCtrl->announceResets = TRUE; /* Send Reset Command to Microcontroller */ microResetCmd(SERIAL_CHAN); break; /* Exit loop and wait for RESET */ } /* if */ taskUnsafe(); /* Task may now be safely deleted */ } /* while (LINK_UP) */ } /* FOREVER */ /* dm_stop_provider, dm_stop_consumer, dm_delete_group*/ /* etc are NOT required when the task exits as the */ /* Data Manager does this automatically when the task */ /* is deleted via the taskDeleteHookAdd() and */ /* dm_task_exit functions. */ /* That's all folks ! */ } /* toolsledDconOutTask() */ /*****************************************************************************/ /* Function : toolsledDconInTask */ /* Purpose : Toolsled Dcon Input Task. Wakes up periodically, read data */ /* from the Toolsled Dcon and write Data Manager Items */ /* Inputs : Array of Data Manager Item handles & serial chan structure */ /* Outputs : Normally runs forever, but exits if error occurs */ /*****************************************************************************/ Void toolsledDconInTask(Reg toolsledDconDmItems* dmItems, microIOControl *microIOCtrl) { SEM_ID wakeupSem; /* Used by watch dog to wake up this task*/ Int32 updates = 0; /* Counts dm updates for rate calculation*/ /* Create wakeup semaphore for provider */ /* rate control */ if ((wakeupSem = semBCreate(SEM_Q_FIFO, SEM_EMPTY)) == NULL) { logMsg("Toolsled Dcon: Error initializing Input Task Resources\n"); return; } /* if */ /* Provider Task for non-static data items*/ initIbcCpuProvider (&dmItems->ibcDm, HUMIDITY_DM_PERIOD); initIbcGf5vProvider (&dmItems->gf5vDm, TOOLSLED_IBC_DM_PERIOD); initIbcLpsProvider (&dmItems->lpsDm[0], TOOLSLED_IBC_DM_PERIOD); initIbcLpsProvider (&dmItems->lpsDm[1], TOOLSLED_IBC_DM_PERIOD); initIbcHpsProvider (&dmItems->hpsDm, TOOLSLED_IBC_DM_PERIOD); initIbcVicorProvider (dmItems->vicorDm, TOOLSLED_IBC_DM_PERIOD); FOREVER { /* Wait for IBC Coms to be initialized */ semTake(microIOCtrl->childTasks[IN_TASK].taskSyncSem, WAIT_FOREVER); while (microIOCtrl->serialLinkState == LINK_UP) { taskSafe(); /* Prevent task from being deleted during*/ /* serial IO and Data Manager updates */ if ((updates % (HUMIDITY_DM_PERIOD / TOOLSLED_IBC_DM_PERIOD)) == 0) updateIbcHumidityDm( SERIAL_CHAN, dmItems->ibcDm.microHumidity ); updateNewIbcGf5vDm( SERIAL_CHAN, GF5V_BOARD_ADDR, &dmItems->gf5vDm ); updateIbcVicorDm(SERIAL_CHAN, VICOR_BOARD_ADDR, dmItems->vicorDm); updateIbcLpsDm( SERIAL_CHAN, lpsBoardAddr[0], &dmItems->lpsDm[0] ); updateIbcLpsDm( SERIAL_CHAN, lpsBoardAddr[1], &dmItems->lpsDm[1] ); updateIbcHpsDm( SERIAL_CHAN, HPS_BOARD_ADDR, &dmItems->hpsDm ); taskUnsafe(); /* task may now be deleted safely */ /* increment & range check update counter*/ if (++updates == 10000) updates = 0; semTake(wakeupSem, /* pend until sem timeout wakes us up */ sysClkRateGet() / ( USECS_PER_SEC / TOOLSLED_IBC_DM_PERIOD)); } /* while */ }/* FOREVER */ semDelete(wakeupSem); /* reclaim semaphore resource */ /* dm_stop_provider, dm_stop_consumer, dm_delete_group*/ /* etc are not required when the task exits as the */ /* data manager does this automatically when the task */ /* is deleted via the taskDeleteHookAdd() and */ /* dm_task_exit functions. */ /* that's all folks ! */ } /* toolsledDConInTask() */ /******************************************************************************/ /* Function : processToolsledDconSRQ */ /* Purpose : Decode Service Request and take appropriate action */ /* Inputs : SRQ code, array of DM items, serial channel */ /* Outputs : Returns Reset Status & many DM items are changed */ /******************************************************************************/ LOCAL Word processToolsledDconSRQ( Reg toolsledDconDmItems* dmItems, microIOControl *microIOCtrl ) { Word srqRequest; /* Service Request Value */ Byte buffer[SRQ_PACKET_LEN]; /* Buffer for micro communications data */ /* Block on Reading Service Request */ if (readSRQPacket(SERIAL_CHAN, buffer, SRQ_PACKET_LEN, WAIT_FOREVER) == ERROR) return (ERROR); /* Service Request received so process it */ srqRequest = wordFromBuf(buffer, 0); switch (srqRequest) /* Decode Service Request from micro */ { case MICRO_RESET_SRQ: /* Microcontroller Reset Occurred */ /* Post Reset Event DM Item */ if (microIOCtrl->announceResets) microResetEventDm(dmItems->ibcDm.microDm.resetEvent); break; case CAN_WATER_ALARM_ON_SRQ: /* Housing Water Alarm Active */ writeBooleanDmItem(dmItems->canWaterAlarm, TRUE); break; case CAN_WATER_ALARM_OFF_SRQ: /* Housing Water Alarm Inactive */ writeBooleanDmItem(dmItems->canWaterAlarm, FALSE); break; case JBOX_WATER_ALARM_ON_SRQ: /* J Box Water Alarm Active */ writeBooleanDmItem(dmItems->jboxWaterAlarm, TRUE); break; case JBOX_WATER_ALARM_OFF_SRQ: /* J Box Water Alarm Inactive */ writeBooleanDmItem(dmItems->jboxWaterAlarm, FALSE); break; default: if (processIbcCpuSRQ(srqRequest, buffer, &dmItems->ibcDm ) != TRUE) if (processIbcLpsSRQ(srqRequest, buffer, lpsBoardAddr[0], &dmItems->lpsDm[0] ) != TRUE) if (processIbcLpsSRQ(srqRequest, buffer, lpsBoardAddr[1], &dmItems->lpsDm[1] ) != TRUE) if (processIbcHpsSRQ(srqRequest, buffer, HPS_BOARD_ADDR, &dmItems->hpsDm ) != TRUE) if (processIbcGf5vSRQ(srqRequest, buffer, GF5V_BOARD_ADDR, &dmItems->gf5vDm ) != TRUE) if (processIbcVicorSRQ(srqRequest, buffer, VICOR_BOARD_ADDR, dmItems->vicorDm ) != TRUE) #if 0 if (processIbcVspSRQ(toolsledDconDataChan, srqRequest, buffer, SERIAL_BOARD_ADDR, VSP_CHAN, &dmItems->vspDm ) != TRUE) #endif if (processIbcQuadSerSRQ(srqRequest, buffer, SERIAL_BOARD_ADDR, &dmItems->quadSerDm ) != TRUE) printf("Toolsled Dcon: Unrecognized SRQ 0x%x\n", srqRequest); break; } /* switch */ return (srqRequest); /* Return SRQ Received To Caller */ } /* processToolsledDconSRQ() */