From 26478fa65170a64c9de9604ffec1ca005c842348 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Sun, 14 Apr 2019 14:35:03 +0300 Subject: Version 1.3.8.49 dispenser data request, added config params (support pending). improvements in heating control, automatic refill at the end of job --- .../Embedded/Modules/Heaters/Heaters_print.c | 2 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c | 20 ++++++++++++++++++++ .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 4 ++-- 3 files changed, 23 insertions(+), 3 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index b373f0670..c177b9b06 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -547,7 +547,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage - int band = 6; + int band = 8; /*if (HeaterControl[HeaterId].outputproportionalband) { band = HeaterControl[HeaterId].outputproportionalband; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c index 868ddca9c..13142ad5f 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c @@ -13,6 +13,7 @@ #include "drivers/valves/valve.h" #include "PMR/EmbeddedParameters/DispenserRunningData.pb-c.h" #include "PMR/EmbeddedParameters/DispenserData.pb-c.h" +#include "PMR/EmbeddedParameters/DispenserDataResponse.pb-c.h" #include "Common/SWUpdate/FileSystem.h" #include "drivers/Flash_Memory/fatfs/ff.h" @@ -323,4 +324,23 @@ void IDS_Dispenser_MovingDirection (char DispenserId, bool direction) } //Report("IDS_Dispenser_MovingDirection",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)direction,0); } +void DispenserDataRequestFunc(MessageContainer* requestContainer) +{ + MessageContainer responseContainer; + + //DisconnectRequest* request = disconnect_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); + DispenserDataResponse response = DISPENSER_DATA_RESPONSE__INIT; + + + response.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; + response.dispenserinfo = dispenserdata; + responseContainer = createContainer(MESSAGE_TYPE__DispenserDataResponse, requestContainer->token, true, &response, &dispenser_data_response__pack, &dispenser_data_response__get_packed_size); + + //------------------------------------------------------------------------------------------- + uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + my_free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + +} diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 729b2bfa0..e2ebcfcd9 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -502,9 +502,9 @@ c. Go to step 2.a x Segment.BrushStopsCount. //IDS_MapDispenserUsedinJob(JobDetails); for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++) { + IDS_StopHomeDispenser(i); if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers { - //IDS_StopHomeDispenser(i); DispenserReady[i] = false; IDS_Dispenser_Build_Pressure(i, IDS_PrepareReady); REPORT_MSG(i,"Dispenser prepare called"); @@ -1017,7 +1017,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); //MotorStop(HW_Motor_Id,Hard_Hiz); - //IDS_HomeDispenser (deviceID, 800 , NULL); + IDS_HomeDispenser (deviceID, 800 , NULL); return OK; } -- cgit v1.3.1 From aa5ba8c457c3722cf215c2992a0b03f310afd1c1 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Sun, 14 Apr 2019 16:09:28 +0300 Subject: WATCHDIG ENABLED!!! complete process parameters handling, but disable file support. parameters for IDS, power off, idle state, init sequence, ids presegment. --- Software/Embedded_SW/Embedded/Main.c | 4 +- .../Embedded/Modules/General/GeneralHardware.c | 54 ++++++++++++++++++++-- Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h | 3 ++ .../Embedded_SW/Embedded/Modules/IDS/IDS_maint.c | 3 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 28 ++++++++++- .../StateMachines/Initialization/InitSequence.c | 28 ++++++----- .../StateMachines/Initialization/InitSequence.h | 1 + .../StateMachines/Initialization/PowerIdle.c | 34 +++++++++----- .../StateMachines/Initialization/PowerIdle.h | 1 + .../Initialization/PowerOffSequence.c | 13 +++++- .../Initialization/PowerOffSequence.h | 1 + 11 files changed, 138 insertions(+), 32 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index ba2f049ad..60707f2ef 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -176,9 +176,9 @@ int main(void) Control_Dryer_Fan(STOP,0);//Preventing unwanted movement at power up, since the default from FPGA is "0" (= START) #endif -#ifdef WATCHDOG +//#ifdef WATCHDOG InitWatchdog(ui32SysClock); -#endif +//#endif CommunicationTaskInit(); utilsInit(ui32SysClock); diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index f5aec59f6..1483f2889 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -40,6 +40,8 @@ #include "StateMachines/Printing/PrintingSTM.h" #include "StateMachines/Initialization/InitSequence.h" +#include "StateMachines/Initialization/PowerIdle.h" +#include "StateMachines/Initialization/PowerOffSequence.h" uint32_t EmbeddedParametersInit(void); uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size); @@ -148,7 +150,43 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dcheatersupperoperationlimit = true; EmbeddedParameters.dcheatersupperoperationlimit = 1002; EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.5; + EmbeddedParameters.midtankpressurecorrection = 0.2; + EmbeddedParameters.has_dispenserpresegmentwfcf = true; + EmbeddedParameters.dispenserpresegmentwfcf = 80; + EmbeddedParameters.has_startheatingoninitsequence = true; + EmbeddedParameters.startheatingoninitsequence = false; +//size_t n_generalparameters; +// EmbeddedParameters.*generalparameters; + EmbeddedParameters.has_currentalarmlowlimit = true; + EmbeddedParameters.currentalarmlowlimit = 0.80; + EmbeddedParameters.has_currentalarmhighlimit = true; + EmbeddedParameters.currentalarmhighlimit= 1.07; + EmbeddedParameters.has_ids_segmentrefilltimeout = true; + EmbeddedParameters.ids_segmentrefilltimeout = 5000; + EmbeddedParameters.has_ids_presegmentbuilduptime = true; + EmbeddedParameters.ids_presegmentbuilduptime = 5000; + EmbeddedParameters.has_ids_cleaningspeed = true; + EmbeddedParameters.ids_cleaningspeed = 50; + EmbeddedParameters.has_ids_cleaningstopbeforesegmenttime = true; + EmbeddedParameters.ids_cleaningstopbeforesegmenttime = 3000; + EmbeddedParameters.has_ids_cleaningstartspraypresegmenttime = true; + EmbeddedParameters.ids_cleaningstartspraypresegmenttime = 1000; + EmbeddedParameters.has_ids_leftcleaningmotorspeed = true; + EmbeddedParameters.ids_leftcleaningmotorspeed = 30; + EmbeddedParameters.has_ids_rightcleaningmotorspeed = true; + EmbeddedParameters.ids_rightcleaningmotorspeed = 23; + EmbeddedParameters.has_switchtoidletimeinseconds = true; + EmbeddedParameters.switchtoidletimeinseconds = 3600; + EmbeddedParameters.has_idledriertemperature = true; + EmbeddedParameters.idledriertemperature = 80; + EmbeddedParameters.has_idleheadtemperature = true; + EmbeddedParameters.idleheadtemperature = 80; + EmbeddedParameters.has_idlemixertemperature = true; + EmbeddedParameters.idlemixertemperature = 0; + EmbeddedParameters.has_powerofftemperaturelimit = true; + EmbeddedParameters.powerofftemperaturelimit = 50; + EmbeddedParameters.has_ids_presegment_wfcf_timebeforesegment = true; + EmbeddedParameters.ids_presegment_wfcf_timebeforesegment = 1500; uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters)); size_t response_size = 0; if (response_buffer) @@ -169,32 +207,40 @@ uint32_t EmbeddedParametersInit(void) ConfigurationParameters *Params; Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer); - if (Fresult == FR_OK) + /*if (Fresult == FR_OK) { - Params = configuration_parameters__unpack(NULL, Bytes, buffer)/*(ConfigurationParameters *)buffer*/; + Params = configuration_parameters__unpack(NULL, Bytes, buffer); LoadConfigurationParameters(Params); DataUpdated=true; free (buffer); configuration_parameters__free_unpacked(Params,NULL); } - else + else*/ { LoadConfigurationParameters(0); } IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout); IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag); IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed, EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag); + IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters.dispenserpresegmentwfcf, EmbeddedParameters.ids_presegment_wfcf_timebeforesegment); + IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters.ids_cleaningspeed,EmbeddedParameters.ids_cleaningstartspraypresegmenttime ,EmbeddedParameters.ids_cleaningstopbeforesegmenttime,EmbeddedParameters.ids_leftcleaningmotorspeed,EmbeddedParameters.ids_rightcleaningmotorspeed); + Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit, EmbeddedParameters.underheatcountlimit); Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit); MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection); SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit); ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit); + PowerOffSetTemperatureThreshold(EmbeddedParameters.powerofftemperaturelimit); + + InitSequenceSetStartHeating (EmbeddedParameters.startheatingoninitsequence); bool a1,a2,a3; a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true; a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true; a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true; AlarmHandlingSetFlags(a1,a2,a3); + PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature); + return Fresult; } uint32_t GenHWControlId; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h index 350e553b6..c691e1e90 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h @@ -64,6 +64,8 @@ uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback); void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout); void IDS_Dispenser_SetBackLashValues(double initialdispenserpressure, uint32_t initialdispensertimeout, uint32_t initialdispensertimelag); void IDS_Dispenser_SetPrepareValues( uint32_t DispenserBuildPressureSpeed, double DispenserBuildPressureLimit, uint32_t DispenserBuildPressureTimeout, uint32_t DispenserBuildPressureLag); +void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double ids_presegment_wfcf_timebeforesegment); +void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed); uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback); uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback); @@ -76,5 +78,6 @@ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails); float CalculateDispenserPressure (int DispenserId); float GetDispenserPressure(int DispenserId); int32_t IdsGetMotorSpeed(uint32_t DispenserId); +void DispenserDataRequestFunc(MessageContainer* requestContainer); #endif /* MODULES_IDS_IDS_EX_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index 215fab544..74ae94fd4 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -159,7 +159,8 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr IDS_Dispenser_RefillStarted(DispenserId); MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0); - CurrentDispenserSpeed[DispenserId] = (-1*speed); + CurrentDispenserSpeed[DispenserId] = speed; + CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]); return OK; } return ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index e2ebcfcd9..c4c9085ea 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -71,9 +71,36 @@ int lInterSegmentLength = 0; uint32_t InterSegmentStartSprayCleaner; uint32_t InterSegmentStartRocking; uint32_t InterSegmentCenterRockers; + uint32_t LeftRockerSpeed = 20; + uint32_t RighttRockerSpeed = 20; + uint32_t CleaningDispenserSpeed = 40; uint32_t InterSegmentStartWFCFDispensers; + uint32_t WFCF = 80; bool EnableCleaning = true; + void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double ids_presegment_wfcf_timebeforesegment) + { + if (ids_presegment_wfcf_timebeforesegment) + InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment; + if (dispenserpresegmentwfcf) + WFCF = dispenserpresegmentwfcf; + } + void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed) + { + if ( ids_cleaningspeed) + CleaningDispenserSpeed = ids_cleaningspeed; + if ( ids_cleaningstartspraypresegmenttime ) + { + InterSegmentStartSprayCleaner = ids_cleaningstartspraypresegmenttime; + InterSegmentStartRocking = ids_cleaningstartspraypresegmenttime + 1000; + } + if ( ids_cleaningstopbeforesegmenttime) + InterSegmentCenterRockers = ids_cleaningstopbeforesegmenttime; + if ( ids_leftcleaningmotorspeed) + LeftRockerSpeed = ids_leftcleaningmotorspeed; + if ( ids_rightcleaningmotorspeed) + RighttRockerSpeed = ids_rightcleaningmotorspeed; + } uint32_t DispenserPreSegmentControlId = 0xFF; uint32_t BrushStopControlId = 0xFF; @@ -657,7 +684,6 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); } if ((int) segmentfirst_speed > 0) { -#define WFCF 80 segmentfirst_speed *= (100+WFCF); segmentfirst_speed /= 100; DispenserSegmentReady[DispenserId] = false; diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c index 64cb99918..f95fb01a0 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c @@ -261,22 +261,28 @@ uint32_t InitSequenceStartHeatingCallBackFunction(uint32_t IfIndex, uint32_t Bus } return OK; } +bool InitialHeating = false; +void InitSequenceSetStartHeating(bool StartHeating) +{ + InitialHeating = StartHeating; +} uint32_t InitSequenceStartHeating(void) { -#ifndef NO_INITIAL_HEATING - if (ProcessParamsInit() ==OK) + if (InitialHeating) { - MachineState = MACHINE_STATE_HEATING_STARTED; - HWControlId = AddControlCallback( InitSequenceStartHeatingCallBackFunction, 2*eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); - //start heaters with predefined / store process parameters + if (ProcessParamsInit() ==OK) + { + MachineState = MACHINE_STATE_HEATING_STARTED; + HWControlId = AddControlCallback( InitSequenceStartHeatingCallBackFunction, 2*eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); + //start heaters with predefined / store process parameters + } + else + { + MachineState = MACHINE_STATE_NO_PROCESS_PARAMS; + } } else - { - MachineState = MACHINE_STATE_NO_PROCESS_PARAMS; - } -#else - MachineState = MACHINE_STATE_MACHINE_READY_TO_DYE; -#endif + MachineState = MACHINE_STATE_MACHINE_READY_TO_DYE; return OK; } uint32_t InitSequenceMachineReadyToDye(void) diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h index d7dc5265f..e4df62eb8 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h @@ -31,6 +31,7 @@ uint32_t Start_InitSequence(void); MACHINE_STATE_STAGES_ENUM GetMachineState(void); void SetMachineState(MACHINE_STATE_STAGES_ENUM); +void InitSequenceSetStartHeating(bool StartHeating); #endif /* STATEMACHINES_INITIALIZATION_INITSEQUENCE_H_ */ diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c index 2db4474f7..d365aafe4 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c @@ -28,6 +28,10 @@ #define DEFAULT_IDLE_TIME_LIMIT 3600 int powerIdleSecondsCounter = 0; int powerIdleSecondsLimit = DEFAULT_IDLE_TIME_LIMIT; +uint32_t IdleDrierTemperature = 8000; +uint32_t IdleHeadTemperature = 8000; +uint32_t IdleMixerTemperature = 0; + bool powerIdleState = false; bool machineActive = false; uint32_t IdleControlId = 0xFF; @@ -36,17 +40,17 @@ void PowerIdleSetIdle(void) { memcpy (&ActiveProcessParameters,&ProcessParametersKeep,sizeof(ProcessParameters)); ProcessParameters ProcessParametersClear; - ProcessParametersClear.dryerzone1temp = (ActiveProcessParameters.dryerzone1temp<80)? ActiveProcessParameters.dryerzone1temp:80; - ProcessParametersClear.dryerzone2temp = (ActiveProcessParameters.dryerzone2temp<80)? ActiveProcessParameters.dryerzone2temp:80; - ProcessParametersClear.dryerzone3temp = (ActiveProcessParameters.dryerzone3temp<80)? ActiveProcessParameters.dryerzone3temp:80; - ProcessParametersClear.mixertemp = (ActiveProcessParameters.mixertemp <80)? ActiveProcessParameters.mixertemp :80; - ProcessParametersClear.headzone1temp = (ActiveProcessParameters.headzone1temp <80)? ActiveProcessParameters.headzone1temp :80; - ProcessParametersClear.headzone2temp = (ActiveProcessParameters.headzone2temp <80)? ActiveProcessParameters.headzone2temp :80; - ProcessParametersClear.headzone3temp = (ActiveProcessParameters.headzone3temp <80)? ActiveProcessParameters.headzone3temp :80; - ProcessParametersClear.headzone4temp = (ActiveProcessParameters.headzone4temp <80)? ActiveProcessParameters.headzone4temp :80; - ProcessParametersClear.headzone5temp = (ActiveProcessParameters.headzone5temp <80)? ActiveProcessParameters.headzone5temp :80; - ProcessParametersClear.headzone6temp = (ActiveProcessParameters.headzone6temp <80)? ActiveProcessParameters.headzone6temp :80; - ProcessParametersClear.dyeingspeed = (ActiveProcessParameters.dyeingspeed <40)? ActiveProcessParameters.dyeingspeed :40; + ProcessParametersClear.dryerzone1temp = (ActiveProcessParameters.dryerzone1temp<80)? ActiveProcessParameters.dryerzone1temp:IdleDrierTemperature; + ProcessParametersClear.dryerzone2temp = (ActiveProcessParameters.dryerzone2temp<80)? ActiveProcessParameters.dryerzone2temp:IdleDrierTemperature; + ProcessParametersClear.dryerzone3temp = (ActiveProcessParameters.dryerzone3temp<80)? ActiveProcessParameters.dryerzone3temp:IdleDrierTemperature; + ProcessParametersClear.mixertemp = (ActiveProcessParameters.mixertemp <80)? ActiveProcessParameters.mixertemp :IdleMixerTemperature; + ProcessParametersClear.headzone1temp = (ActiveProcessParameters.headzone1temp <80)? ActiveProcessParameters.headzone1temp :IdleHeadTemperature; + ProcessParametersClear.headzone2temp = (ActiveProcessParameters.headzone2temp <80)? ActiveProcessParameters.headzone2temp :IdleHeadTemperature; + ProcessParametersClear.headzone3temp = (ActiveProcessParameters.headzone3temp <80)? ActiveProcessParameters.headzone3temp :IdleHeadTemperature; + ProcessParametersClear.headzone4temp = (ActiveProcessParameters.headzone4temp <80)? ActiveProcessParameters.headzone4temp :IdleHeadTemperature; + ProcessParametersClear.headzone5temp = (ActiveProcessParameters.headzone5temp <80)? ActiveProcessParameters.headzone5temp :IdleHeadTemperature; + ProcessParametersClear.headzone6temp = (ActiveProcessParameters.headzone6temp <80)? ActiveProcessParameters.headzone6temp :IdleHeadTemperature; + ProcessParametersClear.dyeingspeed = (ActiveProcessParameters.dyeingspeed <40)? ActiveProcessParameters.dyeingspeed :IdleHeadTemperature; if (HandleProcessParameters(&ProcessParametersClear)!= OK) { LOG_ERROR (1, "Turn Heaters idle failed"); @@ -89,6 +93,14 @@ void PowerIdleInit(void) Report("AddControlCallback failed",__FILE__,__LINE__,(int)IdleControlId,RpWarning,(int)0,0); Report("PowerIdleInit ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)0,0); +} +void PowerIdleSetParameters(uint32_t switchtoidletimeinseconds,uint32_t idledriertemperature,uint32_t idleheadtemperature,uint32_t idlemixertemperature) +{ + powerIdleSecondsLimit = switchtoidletimeinseconds; + IdleDrierTemperature = idledriertemperature*100; + IdleHeadTemperature = idleheadtemperature*100; + IdleMixerTemperature = idlemixertemperature*100; + } int getIdleCounter (void) {return powerIdleSecondsCounter;} void setIdleLimit (int Limit) {powerIdleSecondsLimit = Limit;} diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.h b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.h index efe0e7cb4..71597d026 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.h +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.h @@ -21,6 +21,7 @@ void PowerIdleActivateIdleState(void); void setmachineActive(bool Active); void PowerIdleInit(void); +void PowerIdleSetParameters(uint32_t switchtoidletimeinseconds,uint32_t idledriertemperature,uint32_t idleheadtemperature,uint32_t idlemixertemperature); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c index 454204229..fcb7b337a 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c @@ -56,6 +56,16 @@ uint32_t PowerOffControlId = 0xFF; uint32_t WaitForProcessControlId = 0xFF; uint32_t PowerOffSequenceStateMachine( POWER_OFF_STAGES_ENUM ReadValue); +#define POWER_OFF_TEMP_THRESHOLD 5000 //50 celsious +int32_t PowerOffTemperatureThreshold = POWER_OFF_TEMP_THRESHOLD; + +void PowerOffSetTemperatureThreshold (int32_t temperature) +{ + if (temperature) + { + PowerOffTemperatureThreshold = temperature*100; + } +} /*******************************************************************************************************/ uint32_t PowerOffScheduler(uint32_t IfIndex, uint32_t BusyFlag) { @@ -221,9 +231,8 @@ uint32_t PowerOffWaitForTemperatureCallback(uint32_t IfIndex, uint32_t BusyFlag) if ((readTemp>= MaxTemp)&&(readTemp < 28000)) MaxTemp = readTemp; -#define POWER_OFF_TEMP_THRESHOLD 10000 - if ((MaxTemp>POWER_OFF_TEMP_THRESHOLD)&&(WaitForProcessCounter++<1800)) + if ((MaxTemp>PowerOffTemperatureThreshold)&&(WaitForProcessCounter++<1800)) { Report("On going cooling down, wait for end of cooling",__FILE__,__LINE__,(int)MaxTemp,RpWarning,(int)WaitForProcessCounter,0); resetIdleCounter(); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h index af4d4230d..fd3014d95 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h @@ -31,6 +31,7 @@ uint32_t PowerOffInit(void); uint32_t PowerOffCancel(void);//POWER_OFF_CANCELLED +void PowerOffSetTemperatureThreshold (int32_t temperature); //celsius temperature #endif /* STATEMACHINES_INITIALIZATION_POWEROFFSEQUENCE_H_ */ -- cgit v1.3.1 From af171144af42c380f5df1569466af6487990977b Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 15 Apr 2019 15:51:21 +0300 Subject: Version 1.3.8.5 pre Itma1:waste and buttons improved --- .../Embedded/Common/SWUpdate/FirmwareUpgrade.c | 3 +- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../PMR/Debugging/DebugDistributor.pb-c.c | 61 ++++++++++ .../PMR/Debugging/DebugDistributor.pb-c.h | 55 +++++++++ .../Debugging/SetupDebugDisributorsRequest.pb-c.c | 92 ++++++++++++++ .../Debugging/SetupDebugDisributorsRequest.pb-c.h | 72 +++++++++++ .../Debugging/SetupDebugDisributorsResponse.pb-c.c | 72 +++++++++++ .../Debugging/SetupDebugDisributorsResponse.pb-c.h | 70 +++++++++++ Software/Embedded_SW/Embedded/Main.c | 8 +- .../Modules/Diagnostics/DiagnosticActions.c | 6 + .../Embedded/Modules/Diagnostics/Diagnostics.c | 21 +++- .../Embedded_SW/Embedded/Modules/General/buttons.c | 133 +++++++-------------- .../Embedded_SW/Embedded/Modules/General/buttons.h | 4 +- .../Embedded_SW/Embedded/Modules/Waste/Waste.h | 17 ++- .../Embedded_SW/Embedded/Modules/Waste/Waste_ex.h | 1 + .../Embedded/Modules/Waste/Waste_init.c | 131 ++++++++++++++++---- 16 files changed, 623 insertions(+), 125 deletions(-) create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.c create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.h create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.c create mode 100644 Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.h (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c index d54280fee..01a30c21a 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c @@ -77,6 +77,7 @@ uint32_t ActivateVersionCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) } */ } +int File_i = 0; uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) { @@ -90,7 +91,6 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) fno = my_malloc(sizeof(FILINFO)); if (fno == 0) return ERROR; - int File_i; MessageContainer responseContainer; ActivateVersionRequest* request = activate_version_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); @@ -113,6 +113,7 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) if (NumberOfFiles) { CurrentRunningFile = 0; + File_i = 0; //add control 1 second ActivateVersionControlId = AddControlCallback( ActivateVersionCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); } diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 1be48737d..075f0c5d9 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,8,49}; +TangoVersion_t _gTangoVersion = {1,3,8,5}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.c new file mode 100644 index 000000000..df9728c6c --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.c @@ -0,0 +1,61 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DebugDistributor.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "DebugDistributor.pb-c.h" +static const ProtobufCEnumValue debug_distributor__enum_values_by_number[14] = +{ + { "ControlFilter", "DEBUG_DISTRIBUTOR__ControlFilter", 0 }, + { "HeatersFilter", "DEBUG_DISTRIBUTOR__HeatersFilter", 1 }, + { "JobFilter", "DEBUG_DISTRIBUTOR__JobFilter", 2 }, + { "WasteFilter", "DEBUG_DISTRIBUTOR__WasteFilter", 3 }, + { "AlarmFilter", "DEBUG_DISTRIBUTOR__AlarmFilter", 4 }, + { "DiagnosticsFilter", "DEBUG_DISTRIBUTOR__DiagnosticsFilter", 5 }, + { "IDSFilter", "DEBUG_DISTRIBUTOR__IDSFilter", 6 }, + { "ThreadFilter", "DEBUG_DISTRIBUTOR__ThreadFilter", 7 }, + { "GeneralFilter", "DEBUG_DISTRIBUTOR__GeneralFilter", 8 }, + { "CommFilter", "DEBUG_DISTRIBUTOR__CommFilter", 9 }, + { "FPGAFilter", "DEBUG_DISTRIBUTOR__FPGAFilter", 10 }, + { "LoadFilter", "DEBUG_DISTRIBUTOR__LoadFilter", 11 }, + { "InitFilter", "DEBUG_DISTRIBUTOR__InitFilter", 12 }, + { "MaintFilter", "DEBUG_DISTRIBUTOR__MaintFilter", 13 }, +}; +static const ProtobufCIntRange debug_distributor__value_ranges[] = { +{0, 0},{0, 14} +}; +static const ProtobufCEnumValueIndex debug_distributor__enum_values_by_name[14] = +{ + { "AlarmFilter", 4 }, + { "CommFilter", 9 }, + { "ControlFilter", 0 }, + { "DiagnosticsFilter", 5 }, + { "FPGAFilter", 10 }, + { "GeneralFilter", 8 }, + { "HeatersFilter", 1 }, + { "IDSFilter", 6 }, + { "InitFilter", 12 }, + { "JobFilter", 2 }, + { "LoadFilter", 11 }, + { "MaintFilter", 13 }, + { "ThreadFilter", 7 }, + { "WasteFilter", 3 }, +}; +const ProtobufCEnumDescriptor debug_distributor__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "DebugDistributor", + "DebugDistributor", + "DebugDistributor", + "", + 14, + debug_distributor__enum_values_by_number, + 14, + debug_distributor__enum_values_by_name, + 1, + debug_distributor__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.h new file mode 100644 index 000000000..c4385cf7e --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/DebugDistributor.pb-c.h @@ -0,0 +1,55 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: DebugDistributor.proto */ + +#ifndef PROTOBUF_C_DebugDistributor_2eproto__INCLUDED +#define PROTOBUF_C_DebugDistributor_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + + + +/* --- enums --- */ + +typedef enum _DebugDistributor { + DEBUG_DISTRIBUTOR__ControlFilter = 0, + DEBUG_DISTRIBUTOR__HeatersFilter = 1, + DEBUG_DISTRIBUTOR__JobFilter = 2, + DEBUG_DISTRIBUTOR__WasteFilter = 3, + DEBUG_DISTRIBUTOR__AlarmFilter = 4, + DEBUG_DISTRIBUTOR__DiagnosticsFilter = 5, + DEBUG_DISTRIBUTOR__IDSFilter = 6, + DEBUG_DISTRIBUTOR__ThreadFilter = 7, + DEBUG_DISTRIBUTOR__GeneralFilter = 8, + DEBUG_DISTRIBUTOR__CommFilter = 9, + DEBUG_DISTRIBUTOR__FPGAFilter = 10, + DEBUG_DISTRIBUTOR__LoadFilter = 11, + DEBUG_DISTRIBUTOR__InitFilter = 12, + DEBUG_DISTRIBUTOR__MaintFilter = 13 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(DEBUG_DISTRIBUTOR) +} DebugDistributor; + +/* --- messages --- */ + +/* --- per-message closures --- */ + + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor debug_distributor__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_DebugDistributor_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c new file mode 100644 index 000000000..ebdad2054 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c @@ -0,0 +1,92 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SetupDebugDisributorsRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "SetupDebugDisributorsRequest.pb-c.h" +void setup_debug_disributors_request__init + (SetupDebugDisributorsRequest *message) +{ + static const SetupDebugDisributorsRequest init_value = SETUP_DEBUG_DISRIBUTORS_REQUEST__INIT; + *message = init_value; +} +size_t setup_debug_disributors_request__get_packed_size + (const SetupDebugDisributorsRequest *message) +{ + assert(message->base.descriptor == &setup_debug_disributors_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t setup_debug_disributors_request__pack + (const SetupDebugDisributorsRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &setup_debug_disributors_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t setup_debug_disributors_request__pack_to_buffer + (const SetupDebugDisributorsRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &setup_debug_disributors_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +SetupDebugDisributorsRequest * + setup_debug_disributors_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (SetupDebugDisributorsRequest *) + protobuf_c_message_unpack (&setup_debug_disributors_request__descriptor, + allocator, len, data); +} +void setup_debug_disributors_request__free_unpacked + (SetupDebugDisributorsRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &setup_debug_disributors_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor setup_debug_disributors_request__field_descriptors[1] = +{ + { + "DistributorActive", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_BOOL, + offsetof(SetupDebugDisributorsRequest, n_distributoractive), + offsetof(SetupDebugDisributorsRequest, distributoractive), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned setup_debug_disributors_request__field_indices_by_name[] = { + 0, /* field[0] = DistributorActive */ +}; +static const ProtobufCIntRange setup_debug_disributors_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor setup_debug_disributors_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "SetupDebugDisributorsRequest", + "SetupDebugDisributorsRequest", + "SetupDebugDisributorsRequest", + "", + sizeof(SetupDebugDisributorsRequest), + 1, + setup_debug_disributors_request__field_descriptors, + setup_debug_disributors_request__field_indices_by_name, + 1, setup_debug_disributors_request__number_ranges, + (ProtobufCMessageInit) setup_debug_disributors_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h new file mode 100644 index 000000000..65a5091ac --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SetupDebugDisributorsRequest.proto */ + +#ifndef PROTOBUF_C_SetupDebugDisributorsRequest_2eproto__INCLUDED +#define PROTOBUF_C_SetupDebugDisributorsRequest_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _SetupDebugDisributorsRequest SetupDebugDisributorsRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _SetupDebugDisributorsRequest +{ + ProtobufCMessage base; + size_t n_distributoractive; + protobuf_c_boolean *distributoractive; +}; +#define SETUP_DEBUG_DISRIBUTORS_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&setup_debug_disributors_request__descriptor) \ + , 0,NULL } + + +/* SetupDebugDisributorsRequest methods */ +void setup_debug_disributors_request__init + (SetupDebugDisributorsRequest *message); +size_t setup_debug_disributors_request__get_packed_size + (const SetupDebugDisributorsRequest *message); +size_t setup_debug_disributors_request__pack + (const SetupDebugDisributorsRequest *message, + uint8_t *out); +size_t setup_debug_disributors_request__pack_to_buffer + (const SetupDebugDisributorsRequest *message, + ProtobufCBuffer *buffer); +SetupDebugDisributorsRequest * + setup_debug_disributors_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void setup_debug_disributors_request__free_unpacked + (SetupDebugDisributorsRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*SetupDebugDisributorsRequest_Closure) + (const SetupDebugDisributorsRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor setup_debug_disributors_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_SetupDebugDisributorsRequest_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.c new file mode 100644 index 000000000..514e7c05b --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SetupDebugDisributorsResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "SetupDebugDisributorsResponse.pb-c.h" +void setup_debug_disributors_response__init + (SetupDebugDisributorsResponse *message) +{ + static const SetupDebugDisributorsResponse init_value = SETUP_DEBUG_DISRIBUTORS_RESPONSE__INIT; + *message = init_value; +} +size_t setup_debug_disributors_response__get_packed_size + (const SetupDebugDisributorsResponse *message) +{ + assert(message->base.descriptor == &setup_debug_disributors_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t setup_debug_disributors_response__pack + (const SetupDebugDisributorsResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &setup_debug_disributors_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t setup_debug_disributors_response__pack_to_buffer + (const SetupDebugDisributorsResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &setup_debug_disributors_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +SetupDebugDisributorsResponse * + setup_debug_disributors_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (SetupDebugDisributorsResponse *) + protobuf_c_message_unpack (&setup_debug_disributors_response__descriptor, + allocator, len, data); +} +void setup_debug_disributors_response__free_unpacked + (SetupDebugDisributorsResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &setup_debug_disributors_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define setup_debug_disributors_response__field_descriptors NULL +#define setup_debug_disributors_response__field_indices_by_name NULL +#define setup_debug_disributors_response__number_ranges NULL +const ProtobufCMessageDescriptor setup_debug_disributors_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "SetupDebugDisributorsResponse", + "SetupDebugDisributorsResponse", + "SetupDebugDisributorsResponse", + "", + sizeof(SetupDebugDisributorsResponse), + 0, + setup_debug_disributors_response__field_descriptors, + setup_debug_disributors_response__field_indices_by_name, + 0, setup_debug_disributors_response__number_ranges, + (ProtobufCMessageInit) setup_debug_disributors_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.h new file mode 100644 index 000000000..a3ecfb1d7 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: SetupDebugDisributorsResponse.proto */ + +#ifndef PROTOBUF_C_SetupDebugDisributorsResponse_2eproto__INCLUDED +#define PROTOBUF_C_SetupDebugDisributorsResponse_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _SetupDebugDisributorsResponse SetupDebugDisributorsResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _SetupDebugDisributorsResponse +{ + ProtobufCMessage base; +}; +#define SETUP_DEBUG_DISRIBUTORS_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&setup_debug_disributors_response__descriptor) \ + } + + +/* SetupDebugDisributorsResponse methods */ +void setup_debug_disributors_response__init + (SetupDebugDisributorsResponse *message); +size_t setup_debug_disributors_response__get_packed_size + (const SetupDebugDisributorsResponse *message); +size_t setup_debug_disributors_response__pack + (const SetupDebugDisributorsResponse *message, + uint8_t *out); +size_t setup_debug_disributors_response__pack_to_buffer + (const SetupDebugDisributorsResponse *message, + ProtobufCBuffer *buffer); +SetupDebugDisributorsResponse * + setup_debug_disributors_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void setup_debug_disributors_response__free_unpacked + (SetupDebugDisributorsResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*SetupDebugDisributorsResponse_Closure) + (const SetupDebugDisributorsResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor setup_debug_disributors_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_SetupDebugDisributorsResponse_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 60707f2ef..a125ef10c 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -176,9 +176,9 @@ int main(void) Control_Dryer_Fan(STOP,0);//Preventing unwanted movement at power up, since the default from FPGA is "0" (= START) #endif -//#ifdef WATCHDOG +#ifdef WATCHDOG InitWatchdog(ui32SysClock); -//#endif +#endif CommunicationTaskInit(); utilsInit(ui32SysClock); @@ -196,8 +196,8 @@ int main(void) Heaters_Init(); MotorsInit(); //Shai WHS_HW_test(); // for WHS sensor test -// WHS_init(); -// Buttons_Init(); + WHS_init(); + Buttons_Init(); //IDS_ModuleInit(); Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index c9bbe2df6..97489f431 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -255,6 +255,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) else Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%(); break; + case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve + Valve_Set(VALVE_WASTE_TANK, request->value); + break; + case INTERFACE_IOS__GPO_WHS_WTANKPUMP2: + SetWastePump( request->value); + break; default: responseContainer.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index d39c97621..5ef216264 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -29,6 +29,7 @@ #include "Modules/AlarmHandling/AlarmHandling.h" #include "Modules/heaters/heaters_ex.h" #include "modules/thread/thread_ex.h" +#include "modules/waste/waste.h" #include "PMR/Hardware/HardwareDancerType.pb-c.h" #include @@ -104,7 +105,7 @@ DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS]; HeaterState **heatersstates; HeaterState HeaterInfo[HEATER_TYPE__MixerHeater+1]; DigitalInterfaceState **digitalinterfacestates; -DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+2]; +DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+8]; /*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1]; double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1]; double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1]; @@ -168,8 +169,8 @@ void DiagnosticsInit(void) heater_state__init(&HeaterInfo[i]); heatersstates[i] = &HeaterInfo[i]; } - digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*MAX_HEATERS_NUM); - for (i = 0;i #include @@ -24,33 +23,13 @@ #include "Modules/General/buttons.h" #include "StateMachines/Initialization/PowerOffSequence.h" +#include "StateMachines/Initialization/PowerIdle.h" -//int MachineOnOff(); int PowerDown(); int PowerUp(); int thredJog(); -/* -typedef enum -{ - OFFPB = 0, - COUNTPB , - SHORTPB , - LONGPB , - REPLONGPB //repeat long PB -}PBstat; -*/ -typedef enum -{ - MSEC = 0, - lESS200 , - LESS500 , - LESS5000 , - MORE5000 -}timems; - - //enum PBstat OnOffPBstate = OFFPB; //enum PBstat ret @@ -68,7 +47,7 @@ uint32_t StateMachine( button *pBtn); uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue); uint8_t thraedJogging(uint8_t off); -uint32_t setJoggingEnableCondition( button *pBtn); +//uint32_t setJoggingEnableCondition( button *pBtn); uint32_t joggingMachine( button *pBtn); //uint8_t OnOffPB, @@ -87,8 +66,8 @@ bool Read_PWR_Button();//TODO move to GPIO folder int PowerDown() { - bool ret = OK; - PowerOffInit(); + bool ret = !OK; + ret = PowerOffInit(); return ret; } @@ -100,42 +79,25 @@ int PowerUp() return ret; } - bool SetPowerMachineState(PBmachineState state) { bool ret = OK; switch ( state ) { case sttOFF: - power.state = state; - break; case sttON: + case sttIDLE: power.state = state; - break; + break; case sttDISABLE: - jog.state = state; - break; case sttENABLE: - jog.state = state; - break; - case sttIDLE: - power.state = state; - break; case sttJOGGING: jog.state = state; break; case sttRDY: - load.state = state; - break; case sttPRELOAD: - load.state = state; - break; case sttLOADING: - load.state = state; - break; case sttLOADSUCSESS: - load.state = state; - break; case sttLOADFAIL: load.state = state; break; @@ -190,9 +152,7 @@ uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t Buttons_Init(void) { - -// power.bttn_status = 0 ; -// power.bttn_name = "power"; //option + strcpy(power.bttn_name, "power"); power.bttn_status = release; // 0=release 1=press power.Action = OFFPB ; //off,short,long,count,replong power.color = BLUE; //off, blue, blink, bithing @@ -201,8 +161,7 @@ uint32_t Buttons_Init(void) AddControlCallback( ButtonPowerCBFunction, BUTTOMS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond -// jog.bttn_status = 0 ; -// jog.bttn_name = "jog"; //option + strcpy(jog.bttn_name, "jog"); jog.bttn_status = release; // 0=release 1=press jog.Action = OFFPB ; //OFFPB,short,long,count,replong jog.color = colorOFF; //colorOFF, BLUE, BLINK, @@ -210,12 +169,11 @@ uint32_t Buttons_Init(void) jog.count = 0; AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); // -// load.bttn_status = 0 ; -// load.bttn_name = "load"; //option + strcpy(load.bttn_name, "load"); load.bttn_status = release; // 0=release 1=press load.Action = OFFPB ; //OFFPB,short,long,count,replong load.color = colorOFF; //colorOFF, BLUE, BLINK, - load.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING + load.state = sttRDY; // load.count = 0; AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); // @@ -232,15 +190,12 @@ uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue) { - jog.bttn_status = ReadValue; //if (ReadValue == press) { - setJoggingEnableCondition(&jog); + //setJoggingEnableCondition(&jog); joggingMachine(&jog); } - - return 0; } @@ -452,36 +407,36 @@ return 0; -uint32_t setJoggingEnableCondition( button *pBtn) -{ - uint8_t parameter = 3; - - if (0 -// to do : what are the conditions for enable / disable -// 1. -// 2. -// 3. -// ... - ) - { - pBtn->state = sttDISABLE; - REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttDISABLE ----------------- "); - pBtn->color = colorOFF; - Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+ - // ThreadAbortJoggingFunc(); - } - - else - { - pBtn->state = sttENABLE; -// REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttENABLE ----------------- "); - pBtn->color = BLUE; - Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+ - //ThreadJoggingFunc(40); - } - -return 0; -} +//uint32_t setJoggingEnableCondition( button *pBtn) +//{ +// uint8_t parameter = 3; +// +// if (0 +//// to do : what are the conditions for enable / disable +//// 1. +//// 2. +//// 3. +//// ... +// ) +// { +// pBtn->state = sttDISABLE; +// REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttDISABLE ----------------- "); +// pBtn->color = colorOFF; +// Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+ +// // ThreadAbortJoggingFunc(); +// } +// +// else +// { +// pBtn->state = sttENABLE; +//// REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttENABLE ----------------- "); +// pBtn->color = BLUE; +// Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+ +// //ThreadJoggingFunc(40); +// } +// +//return 0; +//} @@ -575,13 +530,14 @@ return 0; uint32_t LoadStatMachine( button *pBtn) { - //uint8_t parameter = 5; + uint8_t parameter = 5; //REPORT_MSG(parameter," ------------ start loading ----------------- "); Report(" ------------ start loading ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->color,0); switch (pBtn->state) { case sttRDY : + REPORT_MSG(parameter," ------------ load.state = sttRDY ----------------- "); switch (pBtn->Action) { case (SHORTPB): @@ -607,6 +563,7 @@ uint32_t LoadStatMachine( button *pBtn) } break; case sttPRELOAD: + REPORT_MSG(parameter," ------------ load.state = sttPRELOAD ----------------- "); switch (pBtn->Action) { case (SHORTPB): @@ -632,6 +589,7 @@ uint32_t LoadStatMachine( button *pBtn) } break; case sttLOADING: + REPORT_MSG(parameter," ------------ load.state = sttLOADING ----------------- "); break; // case sttLOADSUCSESS ????? // break; @@ -639,6 +597,7 @@ uint32_t LoadStatMachine( button *pBtn) // break; default: //sttDISABLE + REPORT_MSG(parameter," ------------ load.state = default ----------------- "); pBtn->color = colorOFF; Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+ break; diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index 8b064bbcc..2ec6d32a0 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -29,10 +29,12 @@ typedef enum { sttOFF = 0, sttON, + sttIDLE, + sttDISABLE, sttENABLE, - sttIDLE, sttJOGGING, + sttRDY, sttPRELOAD, sttLOADING, diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h index bda01564f..74f7b40ef 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h @@ -38,14 +38,14 @@ typedef enum typedef enum { - SENSORnotFULL = 0, - SENSORFULL + SENSORFULL = 0, + SENSORnotFULL } WHS_FullSensorStatus; typedef enum { - SENSOREMPTY = 0, - SENSORnotEMPTY + SENSORnotEMPTY = 0, + SENSOREMPTY } WHS_EmptySensorStatus; typedef enum @@ -99,6 +99,15 @@ U8 WHS_init(void); U8 WHS_HW_test(void); bool WHS_IsEmptying(); +bool WHS_IsContainerFull(); +bool WHS_IsContainerOverflow(); +bool WHS_WasteCartridgeLowerPresent(); +bool WHS_WasteCartridgeMiddlePresent(); +bool WHS_IsPumpActive(); +bool WHS_IsValveOpen(); + +bool SetWastePump( bool power); + #endif diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h index e69de29bb..8b1378917 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h @@ -0,0 +1 @@ + diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c index 9531b67d6..8aa358e32 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c @@ -19,7 +19,7 @@ #define CartridgeWaste2CallBackTime eOneSecond #define STARTCOUNT 1 #define STOPCOUNT 0 -#define PumpTimeout 60 // minutes +#define PumpTimeout 1200 // seconds; 20 minutes, per Moty, 15/4/19 /*------------Waste Tank function-----------------------*/ @@ -98,6 +98,14 @@ struct WHS_information struct WHS_information WHS_info; +bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;} +bool WHS_IsContainerOverflow(){return WHS_info.WHS_sensors.waste_tank_over_flow_sensor;} +bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;} +bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;} +bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;} +bool WHS_IsValveOpen(){return WHS_info.WHS_valve;} + + bool WHS_IsEmptying() { @@ -141,13 +149,17 @@ bool CartridgeAuthentication(cartridge_name cart_name) { case waste_cartridge1: WHS_info.cartridge_1.autheticate = PASSED; + //Pannel_Leds(CART_2, MODE_ON); break; case waste_cartridge2: WHS_info.cartridge_2.autheticate = PASSED; + //Pannel_Leds(CART_3, MODE_ON); break; default: WHS_info.cartridge_1.autheticate = FAILED; WHS_info.cartridge_2.autheticate = FAILED; + //Pannel_Leds(CART_2, MODE_OFF); + //Pannel_Leds(CART_3, MODE_OFF); break; } ret = OK; @@ -231,7 +243,9 @@ bool SetValveDirection() * * */ bool ret = notOK; - if (WHS_info.WHS_valve != no_waste_cartridge) + //if (WHS_info.WHS_valve != no_waste_cartridge) + if (WHS_info.active_cartridge == waste_cartridge1) WHS_info.WHS_valve = 1; + else WHS_info.WHS_valve = 2; { Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve); ret = OK; @@ -258,6 +272,7 @@ U8 CartridgeWasteFilling(bool status) SetWastePump(OPEN); //WHS_info.WHS_pump.time = 0; REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- "); + ret=OK; } else // stop Waste cartridge filling { @@ -352,7 +367,7 @@ WHS_sttMachin UpdateStateMachine() bool initWHS_WasteTank() { WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor(); - WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;//RdWasteTankFullSensor(); + WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;//;RdWasteTankFullSensor() UpdateStateMachine(); AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute return OK; @@ -392,7 +407,7 @@ WHS_sensor FullSensorEvent() { WHS_info.event = WHS_full_sensor; ret = WHS_full_sensor; - WHS_info.WHS_sensors.waste_tank_full_sensor = !WHS_info.WHS_sensors.waste_tank_full_sensor; + WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor; } return ret; } @@ -446,7 +461,10 @@ bool WasteTankCBFunction() if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY) { if (WHS_info.sttMachine == WHS_empty) + { WHS_info.sttMachine = WHS_filling; + REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- "); + } else { REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- "); @@ -457,9 +475,10 @@ bool WasteTankCBFunction() if (WHS_info.sttMachine == WHS_emptying) { WHS_info.sttMachine = WHS_empty; + REPORT_MSG(WHS_filling," ------------ WHS_empty ----------------- "); ret = CartridgeWasteFilling(OFF); WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction ); - WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond + WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond //SafeRemoveControlCallback(Cartridge_Cover_device_Id, CartridgeCoverCBFunction ); } else @@ -471,24 +490,25 @@ bool WasteTankCBFunction() case WHS_full_sensor: if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL) { - if (WHS_info.sttMachine == WHS_filling) - { - WHS_info.sttMachine = WHS_full; - WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction ); - WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond - ret = CartridgeWasteFilling(ON); - // cant start a new Job - } - else + WHS_info.sttMachine = WHS_full; + REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- "); + WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction ); + WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond + ret = CartridgeWasteFilling(ON); + if (ret != OK) { - REPORT_MSG(WHS_filling," ------------ WHS FULL sensor failed !!!!!!! ----------------- "); + //recreate the full event until cartridge is inserted + WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor; } + + // cant start a new Job } else { if (WHS_info.sttMachine == WHS_full) { WHS_info.sttMachine = WHS_emptying; + REPORT_MSG(WHS_emptying," ------------ WHS_emptying ----------------- "); // can start a new JOB } else @@ -548,13 +568,15 @@ bool WasteTankCBFunction() case WHS_waste1_presence_sensor : if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge 1 is inserted . { - SetCartridgeLED(waste_cartridge1, led_on); + //SetCartridgeLED(waste_cartridge1, led_on); + Pannel_Leds(CART_2, MODE_ON); RdWasteCartridgeParam(waste_cartridge1); + SetActiveWastCartridge(); + SetValveDirection(); if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication { //WHS_info.cartridge_1.autheticate = PASSED; //='0' //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping???? - //???SetValveDirection(); // or we should do it only before pumping???? } else { @@ -564,6 +586,7 @@ bool WasteTankCBFunction() } else // waste cartridge 1 take out { + Pannel_Leds(CART_2, MODE_OFF); WHS_info.cartridge_1.autheticate = FAILED; //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? //???{ @@ -582,7 +605,7 @@ bool WasteTankCBFunction() case WHS_waste2_presence_sensor : if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge is inserted . { - SetCartridgeLED(waste_cartridge2, led_on); + Pannel_Leds(CART_3, MODE_ON);//SetCartridgeLED(waste_cartridge2, led_on); RdWasteCartridgeParam(waste_cartridge2); if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication { @@ -598,6 +621,7 @@ bool WasteTankCBFunction() } else // waste cartridge 2 take out { + Pannel_Leds(CART_3, MODE_OFF); WHS_info.cartridge_2.autheticate = FAILED; /* if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? @@ -616,6 +640,7 @@ bool WasteTankCBFunction() //SetActiveWastCartridge(); break; case WHS_Timeout: + REPORT_MSG(WHS_emptying," ------------ WHS_Timeout ----------------- "); AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT, true); CartridgeWasteFilling(OFF); break; @@ -633,11 +658,16 @@ bool WasteTankCBFunction() bool RdCartridgeCoverSensor() { + uint32_t parameter = 6 ; + + //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor ----------------- "); bool ret = notOK; WHS_Read_GPI_Registers(); // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor); // ret = WHS_info.WHS_sensors.cartridge_cover; ret = Get_COVER_1_State(CartridgesDoor); + if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1) ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0); + if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0) ----------------- "); return ret; } @@ -646,10 +676,14 @@ bool RdCartridgeCoverSensor() WHS_sensor CartridgeCoverCallBackFunction() { + uint32_t parameter = 6 ; + + WHS_sensor ret = WHS_no_event; //ret = RdCartridgeCoverSensor(); if (WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor()) { + REPORT_MSG(parameter," ------------ find : WHS_cartridge_cover_sensor event ----------------- "); WHS_info.event = WHS_cartridge_cover_sensor; WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover; ret = WHS_cartridge_cover_sensor; @@ -659,10 +693,13 @@ WHS_sensor CartridgeCoverCallBackFunction() WHS_sensor CartridgeWaste1CallBackFunction() { + uint32_t parameter = 6 ; + WHS_sensor ret = WHS_no_event; //ret = RdCartridgeCoverSensor(); if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor()) { + REPORT_MSG(parameter," ------------ find : WHS_waste1_presence_sensor event ----------------- "); WHS_info.event = WHS_waste1_presence_sensor; WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor; ret = WHS_waste1_presence_sensor; @@ -672,10 +709,13 @@ WHS_sensor CartridgeWaste1CallBackFunction() WHS_sensor CartridgeWaste2CallBackFunction() { + uint32_t parameter = 6 ; + WHS_sensor ret = WHS_no_event; //ret = RdCartridgeCoverSensor(); if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor()) { + REPORT_MSG(parameter," ------------ find : WHS_waste2_presence_sensor event ----------------- "); WHS_info.event = WHS_waste2_presence_sensor; WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor; ret = WHS_waste2_presence_sensor; @@ -686,15 +726,45 @@ WHS_sensor CartridgeWaste2CallBackFunction() /*------------------------------- Cartridge Waste -----------------------------------------*/ bool InitWasteCartStatus() { + uint32_t parameter = 6 ; + WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor(); - WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = RdWasteCartridge1Sensor(); - WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = RdWasteCartridge2Sensor(); + + if (RdWasteCartridge1Sensor()) + { + REPORT_MSG(parameter," ------------ WHS_waste1_presence_sensor event ----------------- "); + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgePrecense; + Pannel_Leds( CART_2, MODE_ON); + } + else + { + REPORT_MSG(parameter," ------------ WHS_waste1_NOT !!! presence_sensor ----------------- "); + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgeNotPrecense; + Pannel_Leds( CART_2, MODE_OFF); + } + + if (RdWasteCartridge2Sensor()) + { + REPORT_MSG(parameter," ------------ WHS_waste2_presence_sensor event ----------------- "); + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgePrecense; + Pannel_Leds( CART_3, MODE_ON); + } + else + { + REPORT_MSG(parameter," ------------ WHS_waste1_NOT !!! presence_sensor ----------------- "); + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgeNotPrecense; + Pannel_Leds( CART_3, MODE_OFF); + } + + + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge1); if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge2); SetActiveWastCartridge(); if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN) { + REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN : add callback for cart1 and cart 1 ----------------- "); WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 ); WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 ); } @@ -725,12 +795,26 @@ bool RdWasteCartridge2Sensor() bool SetActiveWastCartridge() { + uint8_t parameter = 5; + bool ret = notOK; if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) && - (WHS_info.cartridge_1.autheticate == PASSED)) WHS_info.active_cartridge = waste_cartridge1; + (WHS_info.cartridge_1.autheticate == PASSED)) + { + REPORT_MSG(parameter," ------------ WHS : active_cartridge = waste_cartridge 1 ----------------- "); + WHS_info.active_cartridge = waste_cartridge1; + } else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) && - (WHS_info.cartridge_2.autheticate == PASSED)) WHS_info.active_cartridge = waste_cartridge2; - else WHS_info.active_cartridge = no_waste_cartridge; + (WHS_info.cartridge_2.autheticate == PASSED)) + { + REPORT_MSG(parameter," ------------ WHS : active_cartridge = waste_cartridge 2 ----------------- "); + WHS_info.active_cartridge = waste_cartridge2; + } + else + { + REPORT_MSG(parameter," ------------ WHS : NO active_cartridge ----------------- "); + WHS_info.active_cartridge = no_waste_cartridge; + } return ret; } @@ -911,6 +995,7 @@ U8 RdWaste2() U8 SetValve(bool value) { bool ret = notOK; + WHS_info.WHS_valve = value; ret = SetValveDirection( ); return ret; } -- cgit v1.3.1 From 0f028a9d82e4d7dbf5fb2c81e6d6ab204a2647a6 Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 15 Apr 2019 16:17:04 +0300 Subject: Add blinkig mode for all the pannel leds --- .../Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c | 8 +- .../Embedded_SW/Embedded/Modules/Control/control.c | 86 +++++++++++++++++++++- 2 files changed, 90 insertions(+), 4 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c index f88438bd0..e219a3859 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c @@ -814,6 +814,7 @@ uint8_t Cartridges_LEDS(CARTREGE Cartridge, OPERATION_MODE LED_Mode) // CART1_LA uint8_t Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode) { uint8_t Status = OK; + bool Flag = true; short Low_Reg; short High_Reg; @@ -828,12 +829,15 @@ uint8_t Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mo Low_Reg = MAX_PWM_Command +1; High_Reg = 1; break; + //case MODE_SLOW_BLINKING://Done in ControlActivityLed + //case MODE_FAST_BLINKING://Done in ControlActivityLed + //case MODE_BREATHING://Done in Machine_Idle_Breathing_Led on idle mode (only for POWER) default: - Status = ERROR; + Flag = false; break; } - if(Status == OK) + if(Flag == true) { switch(Pannel_Led_Id) { diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index 608d17a7b..c94f0335f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -166,11 +166,51 @@ uint32_t ControlActivityLed( uint32_t Parameter1) ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF if(power.color == fastBILNK) Pannel_Leds(POWER_ON_OFF,MODE_OFF); - + else if((power.color == BLINK) && (counter % Blink_Freq == 0) ) { Pannel_Leds(POWER_ON_OFF,MODE_OFF); } + /////////////////////////////////////////////////////////// + if(jog.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + else + if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(load.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + else + if((load.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart1.color == fastBILNK) + Pannel_Leds(CART_1,MODE_OFF); + else + if((cart1.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_1,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart2.color == fastBILNK) + Pannel_Leds(CART_2,MODE_OFF); + else + if((cart2.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_2,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart3.color == fastBILNK) + Pannel_Leds(CART_3,MODE_OFF); + else + if((cart3.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_3,MODE_OFF); + } flag = false; } else @@ -181,11 +221,53 @@ uint32_t ControlActivityLed( uint32_t Parameter1) if(power.color == fastBILNK) Pannel_Leds(POWER_ON_OFF,MODE_ON); - + else if((power.color == BLINK) && (counter % Blink_Freq == 0) ) { Pannel_Leds(POWER_ON_OFF,MODE_ON); } + /////////////////////////////////////////////////////////// + if(jog.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_ON); + else + if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(load.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_ON); + else + if((load.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart1.color == fastBILNK) + Pannel_Leds(CART_1,MODE_ON); + else + if((cart1.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_1,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart2.color == fastBILNK) + Pannel_Leds(CART_2,MODE_ON); + else + if((cart2.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_2,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart3.color == fastBILNK) + Pannel_Leds(CART_3,MODE_ON); + else + if((cart3.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_3,MODE_ON); + } + + flag = true; } -- cgit v1.3.1 From e6e4c067c992233e1601f4a32e9534bb6d111bbb Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 15 Apr 2019 16:34:26 +0300 Subject: Add structs to cart1-3 --- Software/Embedded_SW/Embedded/Modules/General/buttons.c | 2 +- Software/Embedded_SW/Embedded/Modules/General/buttons.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index bbe3da526..f590a7fc9 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -37,7 +37,7 @@ int thredJog(); -button power , jog, load; +button power, jog, load, cart1, cart2, cart3; uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn); diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index 2ec6d32a0..2d14eb000 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -52,7 +52,7 @@ typedef struct Button uint32_t count; }button; -extern button power , jog, load; +extern button power, jog, load, cart1, cart2, cart3; uint32_t Buttons_Init(void); uint32_t Button_load_Init(void); -- cgit v1.3.1 From 803738c15ddbaebd07e13ee59d493a7ef56b978f Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 15 Apr 2019 17:03:20 +0300 Subject: fix bug in buttons.c (on command and blink command at the same time) --- Software/Embedded_SW/Embedded/Modules/General/buttons.c | 2 -- 1 file changed, 2 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index f590a7fc9..74cb81aac 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -545,7 +545,6 @@ uint32_t LoadStatMachine( button *pBtn) case (REPLONGPB): pBtn->state = sttPRELOAD; pBtn->color = BLINK; - Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+ if (ThreadLoadStateMachine( THREAD_LOAD_INIT)) { pBtn->state = sttPRELOAD ; // to do @@ -581,7 +580,6 @@ uint32_t LoadStatMachine( button *pBtn) { pBtn->state = sttLOADFAIL ; pBtn->color = fastBILNK ; // to do - Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+ } break; default : -- cgit v1.3.1 From 58b58bc39201cd8702be1780d22e6340478feb43 Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 15 Apr 2019 17:23:26 +0300 Subject: fix bug in ControlActivityLed --- Software/Embedded_SW/Embedded/Modules/Control/control.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index c94f0335f..b316fd73f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -173,19 +173,19 @@ uint32_t ControlActivityLed( uint32_t Parameter1) } /////////////////////////////////////////////////////////// if(jog.color == fastBILNK) - Pannel_Leds(POWER_ON_OFF,MODE_OFF); + Pannel_Leds(THREAD_JOGGING,MODE_OFF); else if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) { - Pannel_Leds(POWER_ON_OFF,MODE_OFF); + Pannel_Leds(THREAD_JOGGING,MODE_OFF); } /////////////////////////////////////////////////////////// if(load.color == fastBILNK) - Pannel_Leds(POWER_ON_OFF,MODE_OFF); + Pannel_Leds(THREAD_LOAD,MODE_OFF); else if((load.color == BLINK) && (counter % Blink_Freq == 0) ) { - Pannel_Leds(POWER_ON_OFF,MODE_OFF); + Pannel_Leds(THREAD_LOAD,MODE_OFF); } /////////////////////////////////////////////////////////// if(cart1.color == fastBILNK) @@ -228,19 +228,19 @@ uint32_t ControlActivityLed( uint32_t Parameter1) } /////////////////////////////////////////////////////////// if(jog.color == fastBILNK) - Pannel_Leds(POWER_ON_OFF,MODE_ON); + Pannel_Leds(THREAD_JOGGING,MODE_ON); else if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) { - Pannel_Leds(POWER_ON_OFF,MODE_ON); + Pannel_Leds(THREAD_JOGGING,MODE_ON); } /////////////////////////////////////////////////////////// if(load.color == fastBILNK) - Pannel_Leds(POWER_ON_OFF,MODE_ON); + Pannel_Leds(THREAD_LOAD,MODE_ON); else if((load.color == BLINK) && (counter % Blink_Freq == 0) ) { - Pannel_Leds(POWER_ON_OFF,MODE_ON); + Pannel_Leds(THREAD_LOAD,MODE_ON); } /////////////////////////////////////////////////////////// if(cart1.color == fastBILNK) -- cgit v1.3.1 From 80c89babe4608fc702c67d6253c233c970a93f94 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 16 Apr 2019 00:04:30 +0300 Subject: watchdog 2nd trial, still not good --- Software/Embedded_SW/Embedded/Common/Utilities/Utils.c | 2 ++ Software/Embedded_SW/Embedded/Main.c | 2 +- Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c index 9cdb3c6bd..542ea659a 100644 --- a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c +++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c @@ -96,6 +96,8 @@ void InitWatchdog(uint32_t clock) // // Enable the watchdog interrupt. // + MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); + ROM_WatchdogIntClear(WATCHDOG0_BASE); ROM_IntEnable(INT_WATCHDOG); // diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index a125ef10c..1c368e180 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -177,7 +177,7 @@ int main(void) #endif #ifdef WATCHDOG - InitWatchdog(ui32SysClock); + InitWatchdog(ui32SysClock*2); #endif CommunicationTaskInit(); diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 1483f2889..6f1dc2052 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -142,7 +142,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dispenserbuildpressurelag = true; EmbeddedParameters.dispenserbuildpressurelag=50; EmbeddedParameters.has_acheatersloweroperationlimit = true; - EmbeddedParameters.acheatersloweroperationlimit = 995; + EmbeddedParameters.acheatersloweroperationlimit = 980; EmbeddedParameters.has_acheatersupperoperationlimit = true; EmbeddedParameters.acheatersupperoperationlimit = 1005; EmbeddedParameters.has_dcheatersloweroperationlimit = true; -- cgit v1.3.1 From f937e17452d6e89b67a675cd7139d84cbd7b0ee3 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 16 Apr 2019 00:42:26 +0300 Subject: minor changes --- .../Embedded/Modules/Heaters/Heaters_print.c | 2 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 22 ++++++++++++++++++---- .../Embedded/Modules/Thread/Thread_Winder.c | 4 ++-- .../StateMachines/Initialization/PowerIdle.c | 2 +- 4 files changed, 22 insertions(+), 8 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index c177b9b06..93048681d 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -547,7 +547,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage - int band = 8; + int band = 10; /*if (HeaterControl[HeaterId].outputproportionalband) { band = HeaterControl[HeaterId].outputproportionalband; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index c4c9085ea..f3c5ad8da 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -661,7 +661,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId]) continue; - + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + continue; + } //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius) segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond / Dispensers[Dispenser_i]->nanoliterperpulse; @@ -677,7 +680,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); } else { - //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep IDS_Dispenser_Set_Flow_Params( DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, MotorsCfg[HW_Motor_Id].microstep); @@ -799,6 +802,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId) DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped continue; } + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + REPORT_MSG(DispenserId,"Dispenser PreSegment cleaner or lubricant"); + DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + continue; + } + //REPORT_MSG(DispenserId,"IDS_Valve_Presegment start"); IDS_Dispenser_Set_Flow_Params(DispenserId,0,0); if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) @@ -842,7 +852,10 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers) if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId]) continue; - + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + continue; + } //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius) segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond / Dispensers[Dispenser_i]->nanoliterperpulse; @@ -858,7 +871,8 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers) } else { - //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + IDS_Dispenser_Set_Flow_Params( DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, MotorsCfg[HW_Motor_Id].microstep); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 1f7836ea5..0b19d835a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -111,12 +111,12 @@ uint32_t Winder_Prepare(void) }*/ if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT) { - //REPORT_MSG(LIMIT, "Winder_Prepare at limit"); + REPORT_MSG(LIMIT, "Winder_Prepare at limit"); Winder_PrepareStage2(0,0); } else { - //REPORT_MSG(ScrewSpeed, "Winder_Prepare"); + REPORT_MSG(ScrewSpeed, "Winder_Prepare"); Winder_ScrewHoming = true; //REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, "Winder_Prepare move to limit"); status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2,2000); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c index d365aafe4..16067dcdc 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c @@ -70,7 +70,7 @@ uint32_t PowerIdleCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) { if (machineActive == true) return OK; - if (powerIdleSecondsCounter%10 == 0) + if (powerIdleSecondsCounter%100 == 0) Report("PowerIdle Idle counter ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0); if (++powerIdleSecondsCounter>=powerIdleSecondsLimit) -- cgit v1.3.1 From 8f8bae1c76df24a33d972145182335a84eb55c8d Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Wed, 17 Apr 2019 12:28:27 +0300 Subject: Reduce the code size under 720,896 bytes (0xB000) by exclude unused files --- Software/Embedded_SW/Embedded/.cproject | 2 +- .../Embedded_SW/Embedded/Communication/Container.c | 62 +- .../PMR/Diagnostics/InterfaceIOs.pb-c.c | 704 ++------------------- .../PMR/Diagnostics/InterfaceIOs.pb-c.h | 309 --------- .../Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c | 36 ++ .../Embedded_SW/Embedded/Drivers/SPI/SPI_Comm.c | 24 +- .../Embedded_SW/Embedded/Drivers/Uart_Comm/Uart.c | 3 + .../Modules/Stubs_Handler/Stub_HW_Version.c | 36 +- .../Embedded/Modules/Stubs_Handler/Stub_L6470.c | 24 +- .../Embedded/Modules/Stubs_Handler/Stub_L6470.h | 3 - 10 files changed, 161 insertions(+), 1042 deletions(-) delete mode 100644 Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/.cproject b/Software/Embedded_SW/Embedded/.cproject index 2dfc05eca..0f253578d 100644 --- a/Software/Embedded_SW/Embedded/.cproject +++ b/Software/Embedded_SW/Embedded/.cproject @@ -170,7 +170,7 @@ - + diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index ffcae9922..89d8cb062 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -16,7 +16,7 @@ #include "Modules/Stubs_Handler/Stub_ExtFlash.h" #include "Modules/Stubs_Handler/Stub_FPGAReadBackReg.h" #include "Modules/Stubs_Handler/Stub_FPGAReadVersion.h" -#include "Modules/Stubs_Handler/Stub_L6470.h" +//#include "Modules/Stubs_Handler/Stub_L6470.h" #include "Modules/Stubs_Handler/Stub_Motor.h" #include "Modules/Stubs_Handler/Stub_HW_Version.h" #include "Modules/Stubs_Handler/Stub_FPGARWReg.h" @@ -149,12 +149,12 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__ProgressRequest: Stub_ProgressRequest(requestContainer); break; - case MESSAGE_TYPE__StubCartridgeReadRequest: - Stub_CartridgeReadRequest(requestContainer); - break; - case MESSAGE_TYPE__StubCartridgeWriteRequest: - Stub_CartridgeWriteRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubCartridgeReadRequest: +// Stub_CartridgeReadRequest(requestContainer); +// break; +// case MESSAGE_TYPE__StubCartridgeWriteRequest: +// Stub_CartridgeWriteRequest(requestContainer); +// break; case MESSAGE_TYPE__StubDispenserRequest: Stub_DispenserRequest(requestContainer); break; @@ -179,12 +179,12 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__StubI2CRequest: Stub_I2CRequest(requestContainer); break; - case MESSAGE_TYPE__StubOptLimitSwitchRequest: - Stub_OptLimitSwitchRequest(requestContainer); - break; - case MESSAGE_TYPE__StubSteperMotorRequest: - Stub_SteperMotorRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubOptLimitSwitchRequest: +// Stub_OptLimitSwitchRequest(requestContainer); +// break; +// case MESSAGE_TYPE__StubSteperMotorRequest: +// Stub_SteperMotorRequest(requestContainer); +// break; case MESSAGE_TYPE__StubValveRequest: Stub_ValveRequest(requestContainer); break; @@ -194,9 +194,9 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__StubExtFlashWriteRequest: Stub_ExtFlashWriteRequest(requestContainer); break; - case MESSAGE_TYPE__StubFPGAReadBackRegRequest: - Stub_FPGAReadBackRegRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubFPGAReadBackRegRequest: +// Stub_FPGAReadBackRegRequest(requestContainer); +// break; case MESSAGE_TYPE__StubFPGAReadVersionRequest: Stub_FPGAReadVersionRequest(requestContainer); break; @@ -208,9 +208,9 @@ void receive_callback(char* buffer, size_t length) Stub_FpgaWriteRegRequest(requestContainer); break; /*************************************/ - case MESSAGE_TYPE__StubL6470DriverRequest: - Stub_L6470DriverRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubL6470DriverRequest: +// Stub_L6470DriverRequest(requestContainer); +// break; case MESSAGE_TYPE__StubMotorInitRequest: Stub_MotorInitRequest(requestContainer); break; @@ -241,9 +241,9 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__StubAbortJobRequest: Stub_AbortJobRequest(requestContainer); break; - case MESSAGE_TYPE__StubHWVersionRequest: - Stub_HWVersionRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubHWVersionRequest: +// Stub_HWVersionRequest(requestContainer); +// break; case MESSAGE_TYPE__StartDebugLogRequest: ReportInitMessage(requestContainer); break; @@ -285,18 +285,18 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__SystemResetRequest: HWSystemResetRequest(requestContainer); break; - case MESSAGE_TYPE__StubTivaReadRegRequest: - Stub_TivaReadRegRequest(requestContainer); - break; - case MESSAGE_TYPE__StubTivaWriteRegRequest: - Stub_TivaWriteRegRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubTivaReadRegRequest: +// Stub_TivaReadRegRequest(requestContainer); +// break; +// case MESSAGE_TYPE__StubTivaWriteRegRequest: +// Stub_TivaWriteRegRequest(requestContainer); +// break; case MESSAGE_TYPE__StubDancerPositionRequest: Stub_DancerPositionRequest(requestContainer); break; - case MESSAGE_TYPE__StubSpeedSensorRequest: - Stub_SpeedSensorRequest(requestContainer); - break; +// case MESSAGE_TYPE__StubSpeedSensorRequest: +// Stub_SpeedSensorRequest(requestContainer); +// break; case MESSAGE_TYPE__StubRealTimeUsageRequest: Stub_RealTimeUsageRequest(requestContainer); break; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.c index e71fd9af5..c5c19ee52 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.c @@ -7,171 +7,19 @@ #endif #include "InterfaceIOs.pb-c.h" -static const ProtobufCEnumValue interface_ios__enum_values_by_number[347] = +static const ProtobufCEnumValue interface_ios__enum_values_by_number[38] = { { "ANALOG_MIXCHIP_TEMP", "INTERFACE_IOS__ANALOG_MIXCHIP_TEMP", 0 }, - { "AN_DYEINGH_CURSEN_1", "INTERFACE_IOS__AN_DYEINGH_CURSEN_1", 1 }, - { "AN_DYEINGH_CURSEN_2", "INTERFACE_IOS__AN_DYEINGH_CURSEN_2", 2 }, - { "AN_DYEINGH_CURSEN_3", "INTERFACE_IOS__AN_DYEINGH_CURSEN_3", 3 }, - { "AN_DYEINGH_CURSEN_4", "INTERFACE_IOS__AN_DYEINGH_CURSEN_4", 4 }, - { "AN_DYEINGH_CURSEN_5", "INTERFACE_IOS__AN_DYEINGH_CURSEN_5", 5 }, - { "ANALOG_DYEINGH_TEMP1", "INTERFACE_IOS__ANALOG_DYEINGH_TEMP1", 6 }, - { "ANALOG_DYEINGH_TEMP2", "INTERFACE_IOS__ANALOG_DYEINGH_TEMP2", 7 }, - { "ANALOG_DYEINGH_TEMP3", "INTERFACE_IOS__ANALOG_DYEINGH_TEMP3", 8 }, - { "ANALOG_DYEINGH_TEMP4", "INTERFACE_IOS__ANALOG_DYEINGH_TEMP4", 9 }, - { "ANALOG_DYEINGH_TEMP5", "INTERFACE_IOS__ANALOG_DYEINGH_TEMP5", 10 }, - { "LS_DH_CLEAN_DOWN", "INTERFACE_IOS__LS_DH_CLEAN_DOWN", 11 }, - { "LS_DH_CLEAN_LEFT", "INTERFACE_IOS__LS_DH_CLEAN_LEFT", 12 }, - { "LS_DH_CLEAN_RIGHT", "INTERFACE_IOS__LS_DH_CLEAN_RIGHT", 13 }, - { "LS_DH_CLEAN_UP", "INTERFACE_IOS__LS_DH_CLEAN_UP", 14 }, - { "LS_DH_LID_CLEANING", "INTERFACE_IOS__LS_DH_LID_CLEANING", 15 }, - { "LS_DH_LID_CLOSED", "INTERFACE_IOS__LS_DH_LID_CLOSED", 16 }, - { "LS_DH_LID_OPEN", "INTERFACE_IOS__LS_DH_LID_OPEN", 17 }, - { "LS_DH_SPARE1", "INTERFACE_IOS__LS_DH_SPARE1", 18 }, { "GPO_MIXCHIP_SSR4_CTRL", "INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL", 19 }, { "GPO_DYEINGH_SSR5_CTRL", "INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL", 20 }, { "GPO_DYEINGH_SSR6_CTRL", "INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL", 21 }, { "GPO_DYEINGH_SSR7_CTRL", "INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL", 22 }, { "GPO_DYEINGH_SSR8_CTRL", "INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL", 23 }, - { "DH2", "INTERFACE_IOS__DH2", 24 }, - { "DH1", "INTERFACE_IOS__DH1", 25 }, - { "MOTO_DH_CLEANHEAD", "INTERFACE_IOS__MOTO_DH_CLEANHEAD", 26 }, - { "MOTO_DH_CLEANMECH", "INTERFACE_IOS__MOTO_DH_CLEANMECH", 27 }, - { "MOTO_DH_LID", "INTERFACE_IOS__MOTO_DH_LID", 28 }, - { "AN_DRYER_CURSEN1", "INTERFACE_IOS__AN_DRYER_CURSEN1", 29 }, - { "AN_DRYER_CURSEN2", "INTERFACE_IOS__AN_DRYER_CURSEN2", 30 }, - { "AN_DRYER_CURSEN3", "INTERFACE_IOS__AN_DRYER_CURSEN3", 31 }, - { "ANALOG_DRYER_TEMP1", "INTERFACE_IOS__ANALOG_DRYER_TEMP1", 32 }, - { "ANALOG_DRYER_TEMP2", "INTERFACE_IOS__ANALOG_DRYER_TEMP2", 33 }, - { "ANALOG_DRYER_TEMP3", "INTERFACE_IOS__ANALOG_DRYER_TEMP3", 34 }, - { "LS_DRYER_LID_CLOSED", "INTERFACE_IOS__LS_DRYER_LID_CLOSED", 35 }, - { "LS_DRYER_LID_OPEN", "INTERFACE_IOS__LS_DRYER_LID_OPEN", 36 }, - { "LS_DRYER_SPARE1", "INTERFACE_IOS__LS_DRYER_SPARE1", 37 }, - { "LS_DRYER_SPARE2", "INTERFACE_IOS__LS_DRYER_SPARE2", 38 }, - { "LS_DRYER_SPARE3", "INTERFACE_IOS__LS_DRYER_SPARE3", 39 }, - { "LS_DRYER_SPARE4", "INTERFACE_IOS__LS_DRYER_SPARE4", 40 }, - { "LS_LOADARM_LEFT", "INTERFACE_IOS__LS_LOADARM_LEFT", 41 }, - { "LS_LOADARM_RIGHT", "INTERFACE_IOS__LS_LOADARM_RIGHT", 42 }, { "GPO_DRYER_SSR1_CTRL", "INTERFACE_IOS__GPO_DRYER_SSR1_CTRL", 43 }, { "GPO_DRYER_SSR2_CTRL", "INTERFACE_IOS__GPO_DRYER_SSR2_CTRL", 44 }, { "GPO_DRYER_SSR3_CTRL", "INTERFACE_IOS__GPO_DRYER_SSR3_CTRL", 45 }, - { "DRYER2", "INTERFACE_IOS__DRYER2", 46 }, - { "DRYER1", "INTERFACE_IOS__DRYER1", 47 }, - { "MOTO_DRYER_DRIVING", "INTERFACE_IOS__MOTO_DRYER_DRIVING", 48 }, - { "MOTO_DRYER_LID", "INTERFACE_IOS__MOTO_DRYER_LID", 49 }, - { "MOTO_DRYER_LOADARM", "INTERFACE_IOS__MOTO_DRYER_LOADARM", 50 }, - { "DRYER_LOADARM_ROTENC", "INTERFACE_IOS__DRYER_LOADARM_ROTENC", 51 }, - { "GPI_PS1_DC_OK", "INTERFACE_IOS__GPI_PS1_DC_OK", 52 }, - { "GPO_PDOWN_RL1_CTRL", "INTERFACE_IOS__GPO_PDOWN_RL1_CTRL", 53 }, - { "GPO_SPARE_SSR12_CTRL", "INTERFACE_IOS__GPO_SPARE_SSR12_CTRL", 54 }, { "GPO_SPARE_SSR13_CTRL", "INTERFACE_IOS__GPO_SPARE_SSR13_CTRL", 55 }, - { "ELECTRICALENC", "INTERFACE_IOS__ELECTRICALENC", 56 }, - { "USERPANEL", "INTERFACE_IOS__USERPANEL", 57 }, - { "GPI_EXTWINDER_1", "INTERFACE_IOS__GPI_EXTWINDER_1", 58 }, - { "GPI_EXTWINDER_2", "INTERFACE_IOS__GPI_EXTWINDER_2", 59 }, - { "GPI_EXTWINDER_3", "INTERFACE_IOS__GPI_EXTWINDER_3", 60 }, - { "GPO_EXTWINDER_1", "INTERFACE_IOS__GPO_EXTWINDER_1", 61 }, - { "GPO_EXTWINDER_2", "INTERFACE_IOS__GPO_EXTWINDER_2", 62 }, - { "GPO_EXTWINDER_3", "INTERFACE_IOS__GPO_EXTWINDER_3", 63 }, { "GPO_EXTWINDER_SSR11_CTRL", "INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL", 64 }, - { "EXTWINDER_CTRL", "INTERFACE_IOS__EXTWINDER_CTRL", 65 }, - { "EXTWINDINGUNIT", "INTERFACE_IOS__EXTWINDINGUNIT", 66 }, - { "AN_IDS_PRESSENS_1", "INTERFACE_IOS__AN_IDS_PRESSENS_1", 67 }, - { "AN_IDS_PRESSENS_2", "INTERFACE_IOS__AN_IDS_PRESSENS_2", 68 }, - { "AN_IDS_PRESSENS_3", "INTERFACE_IOS__AN_IDS_PRESSENS_3", 69 }, - { "AN_IDS_PRESSENS_4", "INTERFACE_IOS__AN_IDS_PRESSENS_4", 70 }, - { "AN_IDS_PRESSENS_5", "INTERFACE_IOS__AN_IDS_PRESSENS_5", 71 }, - { "AN_IDS_PRESSENS_6", "INTERFACE_IOS__AN_IDS_PRESSENS_6", 72 }, - { "AN_IDS_PRESSENS_7", "INTERFACE_IOS__AN_IDS_PRESSENS_7", 73 }, - { "AN_IDS_PRESSENS_8", "INTERFACE_IOS__AN_IDS_PRESSENS_8", 74 }, - { "AN_MIDTANK_PRESSENS1", "INTERFACE_IOS__AN_MIDTANK_PRESSENS1", 75 }, - { "AN_MIDTANK_PRESSENS2", "INTERFACE_IOS__AN_MIDTANK_PRESSENS2", 76 }, - { "AN_MIDTANK_PRESSENS3", "INTERFACE_IOS__AN_MIDTANK_PRESSENS3", 77 }, - { "AN_MIDTANK_PRESSENS4", "INTERFACE_IOS__AN_MIDTANK_PRESSENS4", 78 }, - { "AN_MIDTANK_PRESSENS5", "INTERFACE_IOS__AN_MIDTANK_PRESSENS5", 79 }, - { "AN_MIDTANK_PRESSENS6", "INTERFACE_IOS__AN_MIDTANK_PRESSENS6", 80 }, - { "AN_MIDTANK_PRESSENS7", "INTERFACE_IOS__AN_MIDTANK_PRESSENS7", 81 }, - { "AN_MIXCHIP_CURSENn", "INTERFACE_IOS__AN_MIXCHIP_CURSENn", 82 }, - { "LS_DISPENSER_25_1", "INTERFACE_IOS__LS_DISPENSER_25_1", 83 }, - { "LS_DISPENSER_25_2", "INTERFACE_IOS__LS_DISPENSER_25_2", 84 }, - { "LS_DISPENSER_25_3", "INTERFACE_IOS__LS_DISPENSER_25_3", 85 }, - { "LS_DISPENSER_25_4", "INTERFACE_IOS__LS_DISPENSER_25_4", 86 }, - { "LS_DISPENSER_25_5", "INTERFACE_IOS__LS_DISPENSER_25_5", 87 }, - { "LS_DISPENSER_25_6", "INTERFACE_IOS__LS_DISPENSER_25_6", 88 }, - { "LS_DISPENSER_25_7", "INTERFACE_IOS__LS_DISPENSER_25_7", 89 }, - { "LS_DISPENSER_25_8", "INTERFACE_IOS__LS_DISPENSER_25_8", 90 }, - { "LS_DISPENSER_50_1", "INTERFACE_IOS__LS_DISPENSER_50_1", 91 }, - { "LS_DISPENSER_50_2", "INTERFACE_IOS__LS_DISPENSER_50_2", 92 }, - { "LS_DISPENSER_50_3", "INTERFACE_IOS__LS_DISPENSER_50_3", 93 }, - { "LS_DISPENSER_50_4", "INTERFACE_IOS__LS_DISPENSER_50_4", 94 }, - { "LS_DISPENSER_50_5", "INTERFACE_IOS__LS_DISPENSER_50_5", 95 }, - { "LS_DISPENSER_50_6", "INTERFACE_IOS__LS_DISPENSER_50_6", 96 }, - { "LS_DISPENSER_50_7", "INTERFACE_IOS__LS_DISPENSER_50_7", 97 }, - { "LS_DISPENSER_50_8", "INTERFACE_IOS__LS_DISPENSER_50_8", 98 }, - { "LS_DISPENSER_75_1", "INTERFACE_IOS__LS_DISPENSER_75_1", 99 }, - { "LS_DISPENSER_75_2", "INTERFACE_IOS__LS_DISPENSER_75_2", 100 }, - { "LS_DISPENSER_75_3", "INTERFACE_IOS__LS_DISPENSER_75_3", 101 }, - { "LS_DISPENSER_75_4", "INTERFACE_IOS__LS_DISPENSER_75_4", 102 }, - { "LS_DISPENSER_75_5", "INTERFACE_IOS__LS_DISPENSER_75_5", 103 }, - { "LS_DISPENSER_75_6", "INTERFACE_IOS__LS_DISPENSER_75_6", 104 }, - { "LS_DISPENSER_75_7", "INTERFACE_IOS__LS_DISPENSER_75_7", 105 }, - { "LS_DISPENSER_75_8", "INTERFACE_IOS__LS_DISPENSER_75_8", 106 }, - { "LS_DISPENSER_DOWN_1", "INTERFACE_IOS__LS_DISPENSER_DOWN_1", 107 }, - { "LS_DISPENSER_DOWN_2", "INTERFACE_IOS__LS_DISPENSER_DOWN_2", 108 }, - { "LS_DISPENSER_DOWN_3", "INTERFACE_IOS__LS_DISPENSER_DOWN_3", 109 }, - { "LS_DISPENSER_DOWN_4", "INTERFACE_IOS__LS_DISPENSER_DOWN_4", 110 }, - { "LS_DISPENSER_DOWN_5", "INTERFACE_IOS__LS_DISPENSER_DOWN_5", 111 }, - { "LS_DISPENSER_DOWN_6", "INTERFACE_IOS__LS_DISPENSER_DOWN_6", 112 }, - { "LS_DISPENSER_DOWN_7", "INTERFACE_IOS__LS_DISPENSER_DOWN_7", 113 }, - { "LS_DISPENSER_DOWN_8", "INTERFACE_IOS__LS_DISPENSER_DOWN_8", 114 }, - { "LS_DISPENSER_SPARE_1", "INTERFACE_IOS__LS_DISPENSER_SPARE_1", 115 }, - { "LS_DISPENSER_SPARE_2", "INTERFACE_IOS__LS_DISPENSER_SPARE_2", 116 }, - { "LS_DISPENSER_SPARE_3", "INTERFACE_IOS__LS_DISPENSER_SPARE_3", 117 }, - { "LS_DISPENSER_SPARE_4", "INTERFACE_IOS__LS_DISPENSER_SPARE_4", 118 }, - { "LS_DISPENSER_SPARE_5", "INTERFACE_IOS__LS_DISPENSER_SPARE_5", 119 }, - { "LS_DISPENSER_SPARE_6", "INTERFACE_IOS__LS_DISPENSER_SPARE_6", 120 }, - { "LS_DISPENSER_SPARE_7", "INTERFACE_IOS__LS_DISPENSER_SPARE_7", 121 }, - { "LS_DISPENSER_SPARE_8", "INTERFACE_IOS__LS_DISPENSER_SPARE_8", 122 }, - { "LS_DISPENSER_UP_1", "INTERFACE_IOS__LS_DISPENSER_UP_1", 123 }, - { "LS_DISPENSER_UP_2", "INTERFACE_IOS__LS_DISPENSER_UP_2", 124 }, - { "LS_DISPENSER_UP_3", "INTERFACE_IOS__LS_DISPENSER_UP_3", 125 }, - { "LS_DISPENSER_UP_4", "INTERFACE_IOS__LS_DISPENSER_UP_4", 126 }, - { "LS_DISPENSER_UP_5", "INTERFACE_IOS__LS_DISPENSER_UP_5", 127 }, - { "LS_DISPENSER_UP_6", "INTERFACE_IOS__LS_DISPENSER_UP_6", 128 }, - { "LS_DISPENSER_UP_7", "INTERFACE_IOS__LS_DISPENSER_UP_7", 129 }, - { "LS_DISPENSER_UP_8", "INTERFACE_IOS__LS_DISPENSER_UP_8", 130 }, - { "MIDTANK1_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK1_LVL1_FLOAT", 131 }, - { "MIDTANK1_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK1_LVL2_FLOAT", 132 }, - { "MIDTANK1_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK1_LVL3_FLOAT", 133 }, - { "MIDTANK1_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK1_LVL4_FLOAT", 134 }, - { "MIDTANK2_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK2_LVL1_FLOAT", 135 }, - { "MIDTANK2_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK2_LVL2_FLOAT", 136 }, - { "MIDTANK2_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK2_LVL3_FLOAT", 137 }, - { "MIDTANK2_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK2_LVL4_FLOAT", 138 }, - { "MIDTANK3_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK3_LVL1_FLOAT", 139 }, - { "MIDTANK3_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK3_LVL2_FLOAT", 140 }, - { "MIDTANK3_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK3_LVL3_FLOAT", 141 }, - { "MIDTANK3_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK3_LVL4_FLOAT", 142 }, - { "MIDTANK4_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK4_LVL1_FLOAT", 143 }, - { "MIDTANK4_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK4_LVL2_FLOAT", 144 }, - { "MIDTANK4_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK4_LVL3_FLOAT", 145 }, - { "MIDTANK4_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK4_LVL4_FLOAT", 146 }, - { "MIDTANK5_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK5_LVL1_FLOAT", 147 }, - { "MIDTANK5_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK5_LVL2_FLOAT", 148 }, - { "MIDTANK5_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK5_LVL3_FLOAT", 149 }, - { "MIDTANK5_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK5_LVL4_FLOAT", 150 }, - { "MIDTANK6_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK6_LVL1_FLOAT", 151 }, - { "MIDTANK6_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK6_LVL2_FLOAT", 152 }, - { "MIDTANK6_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK6_LVL3_FLOAT", 153 }, - { "MIDTANK6_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK6_LVL4_FLOAT", 154 }, - { "MIDTANK7_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK7_LVL1_FLOAT", 155 }, - { "MIDTANK7_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK7_LVL2_FLOAT", 156 }, - { "MIDTANK7_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK7_LVL3_FLOAT", 157 }, - { "MIDTANK7_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK7_LVL4_FLOAT", 158 }, - { "MIDTANK8_LVL1_FLOAT", "INTERFACE_IOS__MIDTANK8_LVL1_FLOAT", 159 }, - { "MIDTANK8_LVL2_FLOAT", "INTERFACE_IOS__MIDTANK8_LVL2_FLOAT", 160 }, - { "MIDTANK8_LVL3_FLOAT", "INTERFACE_IOS__MIDTANK8_LVL3_FLOAT", 161 }, - { "MIDTANK8_LVL4_FLOAT", "INTERFACE_IOS__MIDTANK8_LVL4_FLOAT", 162 }, { "GPO_DILUTORPUMP_SSR10_CTRL", "INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL", 163 }, { "GPO_WASTECH_PUMP2", "INTERFACE_IOS__GPO_WASTECH_PUMP2", 164 }, { "Midtank1Air", "INTERFACE_IOS__Midtank1Air", 165 }, @@ -190,166 +38,9 @@ static const ProtobufCEnumValue interface_ios__enum_values_by_number[347] = { "Midtank6Cartridge", "INTERFACE_IOS__Midtank6Cartridge", 178 }, { "Midtank7Cartridge", "INTERFACE_IOS__Midtank7Cartridge", 179 }, { "Midtank8Cartridge", "INTERFACE_IOS__Midtank8Cartridge", 180 }, - { "MOTO_DISPENSER_1", "INTERFACE_IOS__MOTO_DISPENSER_1", 181 }, - { "MOTO_DISPENSER_2", "INTERFACE_IOS__MOTO_DISPENSER_2", 182 }, - { "MOTO_DISPENSER_3", "INTERFACE_IOS__MOTO_DISPENSER_3", 183 }, - { "MOTO_DISPENSER_4", "INTERFACE_IOS__MOTO_DISPENSER_4", 184 }, - { "MOTO_DISPENSER_5", "INTERFACE_IOS__MOTO_DISPENSER_5", 185 }, - { "MOTO_DISPENSER_6", "INTERFACE_IOS__MOTO_DISPENSER_6", 186 }, - { "MOTO_DISPENSER_7", "INTERFACE_IOS__MOTO_DISPENSER_7", 187 }, - { "MOTO_DISPENSER_8", "INTERFACE_IOS__MOTO_DISPENSER_8", 188 }, - { "DISPENSER_ROTENC1", "INTERFACE_IOS__DISPENSER_ROTENC1", 189 }, - { "DISPENSER_ROTENC2", "INTERFACE_IOS__DISPENSER_ROTENC2", 190 }, - { "DISPENSER_ROTENC3", "INTERFACE_IOS__DISPENSER_ROTENC3", 191 }, - { "DISPENSER_ROTENC4", "INTERFACE_IOS__DISPENSER_ROTENC4", 192 }, - { "DISPENSER_ROTENC5", "INTERFACE_IOS__DISPENSER_ROTENC5", 193 }, - { "DISPENSER_ROTENC6", "INTERFACE_IOS__DISPENSER_ROTENC6", 194 }, - { "DISPENSER_ROTENC7", "INTERFACE_IOS__DISPENSER_ROTENC7", 195 }, - { "DISPENSER_ROTENC8", "INTERFACE_IOS__DISPENSER_ROTENC8", 196 }, - { "DISPENSER_VALVE_1", "INTERFACE_IOS__DISPENSER_VALVE_1", 197 }, - { "DISPENSER_VALVE_2", "INTERFACE_IOS__DISPENSER_VALVE_2", 198 }, - { "DISPENSER_VALVE_3", "INTERFACE_IOS__DISPENSER_VALVE_3", 199 }, - { "DISPENSER_VALVE_4", "INTERFACE_IOS__DISPENSER_VALVE_4", 200 }, - { "DISPENSER_VALVE_5", "INTERFACE_IOS__DISPENSER_VALVE_5", 201 }, - { "DISPENSER_VALVE_6", "INTERFACE_IOS__DISPENSER_VALVE_6", 202 }, - { "DISPENSER_VALVE_7", "INTERFACE_IOS__DISPENSER_VALVE_7", 203 }, - { "DISPENSER_1", "INTERFACE_IOS__DISPENSER_1", 204 }, - { "DISPENSER_3", "INTERFACE_IOS__DISPENSER_3", 205 }, - { "DISPENSER_5", "INTERFACE_IOS__DISPENSER_5", 206 }, - { "DISPENSER_7", "INTERFACE_IOS__DISPENSER_7", 207 }, - { "MIDTANK3_1", "INTERFACE_IOS__MIDTANK3_1", 208 }, - { "DISPENSER_2", "INTERFACE_IOS__DISPENSER_2", 209 }, - { "DISPENSER_4", "INTERFACE_IOS__DISPENSER_4", 210 }, - { "DISPENSER_6", "INTERFACE_IOS__DISPENSER_6", 211 }, - { "DISPENSER_8", "INTERFACE_IOS__DISPENSER_8", 212 }, - { "MIDTANK3_2", "INTERFACE_IOS__MIDTANK3_2", 213 }, - { "CART3", "INTERFACE_IOS__CART3", 214 }, - { "CART1", "INTERFACE_IOS__CART1", 215 }, - { "CART2", "INTERFACE_IOS__CART2", 216 }, - { "CART4", "INTERFACE_IOS__CART4", 217 }, - { "CART7", "INTERFACE_IOS__CART7", 218 }, - { "CART5", "INTERFACE_IOS__CART5", 219 }, - { "CART6", "INTERFACE_IOS__CART6", 220 }, - { "CART8", "INTERFACE_IOS__CART8", 221 }, - { "LS_SCREW_LEFT", "INTERFACE_IOS__LS_SCREW_LEFT", 222 }, - { "LS_SCREW_RIGHT", "INTERFACE_IOS__LS_SCREW_RIGHT", 223 }, - { "SW_SPARE", "INTERFACE_IOS__SW_SPARE", 224 }, - { "SW_SPOOL_EXISTS", "INTERFACE_IOS__SW_SPOOL_EXISTS", 225 }, - { "MOTO_SCREW", "INTERFACE_IOS__MOTO_SCREW", 226 }, - { "MOTO_WINDER", "INTERFACE_IOS__MOTO_WINDER", 227 }, - { "SCREW_ROTENC", "INTERFACE_IOS__SCREW_ROTENC", 228 }, - { "INTWINDINGUNIT", "INTERFACE_IOS__INTWINDINGUNIT", 229 }, - { "AN5V_LDANCER1", "INTERFACE_IOS__AN5V_LDANCER1", 230 }, - { "AN5V_LDANCER2", "INTERFACE_IOS__AN5V_LDANCER2", 231 }, - { "LS_LDANCER1_DOWN", "INTERFACE_IOS__LS_LDANCER1_DOWN", 232 }, - { "LS_LDANCER1_UP", "INTERFACE_IOS__LS_LDANCER1_UP", 233 }, - { "LS_LDANCER2_DOWN", "INTERFACE_IOS__LS_LDANCER2_DOWN", 234 }, - { "LS_LDANCER2_UP", "INTERFACE_IOS__LS_LDANCER2_UP", 235 }, - { "LS_LLOADMOTOR_DOWN", "INTERFACE_IOS__LS_LLOADMOTOR_DOWN", 236 }, - { "LS_LLOADMOTOR_UP", "INTERFACE_IOS__LS_LLOADMOTOR_UP", 237 }, - { "LS_LPIVOT_DOWN", "INTERFACE_IOS__LS_LPIVOT_DOWN", 238 }, - { "LS_LPIVOT_UP", "INTERFACE_IOS__LS_LPIVOT_UP", 239 }, - { "LS_LSPARE1", "INTERFACE_IOS__LS_LSPARE1", 240 }, - { "LS_LSPARE2", "INTERFACE_IOS__LS_LSPARE2", 241 }, - { "LS_PIVOT_SPARE1", "INTERFACE_IOS__LS_PIVOT_SPARE1", 242 }, - { "LS_PIVOT_SPARE2", "INTERFACE_IOS__LS_PIVOT_SPARE2", 243 }, - { "MOTO_LDANCER1", "INTERFACE_IOS__MOTO_LDANCER1", 244 }, - { "MOTO_LDANCER2", "INTERFACE_IOS__MOTO_LDANCER2", 245 }, - { "MOTO_LDRIVING", "INTERFACE_IOS__MOTO_LDRIVING", 246 }, - { "MOTO_LLOADING", "INTERFACE_IOS__MOTO_LLOADING", 247 }, - { "MOTO_LPIVOT1", "INTERFACE_IOS__MOTO_LPIVOT1", 248 }, - { "LSPARE1_ROTENC", "INTERFACE_IOS__LSPARE1_ROTENC", 249 }, - { "LSPARE2_ROTENC", "INTERFACE_IOS__LSPARE2_ROTENC", 250 }, - { "LDANCER1_ROTENC", "INTERFACE_IOS__LDANCER1_ROTENC", 251 }, - { "LDANCER2_ROTENC", "INTERFACE_IOS__LDANCER2_ROTENC", 252 }, - { "LSPARE_ROTENC", "INTERFACE_IOS__LSPARE_ROTENC", 253 }, - { "LTFEEDUNIT2", "INTERFACE_IOS__LTFEEDUNIT2", 254 }, - { "LTFEEDUNIT1", "INTERFACE_IOS__LTFEEDUNIT1", 255 }, - { "AN_ENCLOSURETEMP1", "INTERFACE_IOS__AN_ENCLOSURETEMP1", 256 }, - { "AN_ENCLOSURETEMP2", "INTERFACE_IOS__AN_ENCLOSURETEMP2", 257 }, - { "AN_ENCLOSURETEMP3", "INTERFACE_IOS__AN_ENCLOSURETEMP3", 258 }, - { "GPI_PANSW1", "INTERFACE_IOS__GPI_PANSW1", 259 }, - { "GPI_PANSW2", "INTERFACE_IOS__GPI_PANSW2", 260 }, - { "GPI_PANSW3", "INTERFACE_IOS__GPI_PANSW3", 261 }, - { "GPI_PANSW4", "INTERFACE_IOS__GPI_PANSW4", 262 }, - { "GPI_PANSW5", "INTERFACE_IOS__GPI_PANSW5", 263 }, - { "GPI_PANSW6", "INTERFACE_IOS__GPI_PANSW6", 264 }, - { "GPI_PWRBUTTON", "INTERFACE_IOS__GPI_PWRBUTTON", 265 }, - { "GPI_TACTSW1", "INTERFACE_IOS__GPI_TACTSW1", 266 }, - { "GPI_TACTSW2", "INTERFACE_IOS__GPI_TACTSW2", 267 }, - { "GPI_TACTSW3", "INTERFACE_IOS__GPI_TACTSW3", 268 }, - { "GPI_TACTSW4", "INTERFACE_IOS__GPI_TACTSW4", 269 }, - { "GPO_BUZZER", "INTERFACE_IOS__GPO_BUZZER", 270 }, - { "GPO_LED1", "INTERFACE_IOS__GPO_LED1", 271 }, - { "GPO_LED2", "INTERFACE_IOS__GPO_LED2", 272 }, - { "GPO_LED3", "INTERFACE_IOS__GPO_LED3", 273 }, { "GPO_LED4", "INTERFACE_IOS__GPO_LED4", 274 }, - { "FAN_TACHO1", "INTERFACE_IOS__FAN_TACHO1", 275 }, - { "FAN_TACHO2", "INTERFACE_IOS__FAN_TACHO2", 276 }, - { "FAN_TACHO3", "INTERFACE_IOS__FAN_TACHO3", 277 }, - { "FAN1_TACH", "INTERFACE_IOS__FAN1_TACH", 278 }, - { "FAN2_TACH", "INTERFACE_IOS__FAN2_TACH", 279 }, - { "FAN3_TACH", "INTERFACE_IOS__FAN3_TACH", 280 }, - { "FAN4_TACH", "INTERFACE_IOS__FAN4_TACH", 281 }, - { "FAN5_TACH", "INTERFACE_IOS__FAN5_TACH", 282 }, - { "AN5V_RDANCER", "INTERFACE_IOS__AN5V_RDANCER", 283 }, - { "LS_RLOADMOTOR_UP", "INTERFACE_IOS__LS_RLOADMOTOR_UP", 284 }, - { "GPI_TFEED_BREAK_1", "INTERFACE_IOS__GPI_TFEED_BREAK_1", 285 }, - { "GPI_TFEED_BREAK_2", "INTERFACE_IOS__GPI_TFEED_BREAK_2", 286 }, - { "LS_RDANCER_DOWN", "INTERFACE_IOS__LS_RDANCER_DOWN", 287 }, - { "LS_RDANCER_UP", "INTERFACE_IOS__LS_RDANCER_UP", 288 }, - { "RTFEEDUNIT2", "INTERFACE_IOS__RTFEEDUNIT2", 289 }, - { "RTFEEDUNIT1", "INTERFACE_IOS__RTFEEDUNIT1", 290 }, - { "LS_RLOADMOTOR_DOWN", "INTERFACE_IOS__LS_RLOADMOTOR_DOWN", 291 }, - { "LS_RLOADRAM_DOWN", "INTERFACE_IOS__LS_RLOADRAM_DOWN", 292 }, - { "LS_RLOADRAM_UP", "INTERFACE_IOS__LS_RLOADRAM_UP", 293 }, - { "LS_RSPARE1", "INTERFACE_IOS__LS_RSPARE1", 294 }, - { "LS_RSPARE2", "INTERFACE_IOS__LS_RSPARE2", 295 }, - { "GPO_TFEED_BREAK_1", "INTERFACE_IOS__GPO_TFEED_BREAK_1", 296 }, - { "GPO_TFEED_BREAK_2", "INTERFACE_IOS__GPO_TFEED_BREAK_2", 297 }, - { "MOTO_RDANCER", "INTERFACE_IOS__MOTO_RDANCER", 298 }, - { "MOTO_RDRIVING", "INTERFACE_IOS__MOTO_RDRIVING", 299 }, - { "MOTO_RLOADARM", "INTERFACE_IOS__MOTO_RLOADARM", 300 }, - { "MOTO_RLOADING", "INTERFACE_IOS__MOTO_RLOADING", 301 }, - { "RSPARE_ROTENC1", "INTERFACE_IOS__RSPARE_ROTENC1", 302 }, - { "RSPEEDSENS_ROTENC", "INTERFACE_IOS__RSPEEDSENS_ROTENC", 303 }, - { "RDANCER_ROTENC", "INTERFACE_IOS__RDANCER_ROTENC", 304 }, - { "RSPARE_ROTENC2", "INTERFACE_IOS__RSPARE_ROTENC2", 305 }, - { "AN10V_SPARE1", "INTERFACE_IOS__AN10V_SPARE1", 306 }, - { "AN10V_SPARE2", "INTERFACE_IOS__AN10V_SPARE2", 307 }, - { "LS_SPARE1_1", "INTERFACE_IOS__LS_SPARE1_1", 308 }, - { "LS_SPARE1_2", "INTERFACE_IOS__LS_SPARE1_2", 309 }, - { "LS_SPARE1_3", "INTERFACE_IOS__LS_SPARE1_3", 310 }, - { "LS_SPARE1_4", "INTERFACE_IOS__LS_SPARE1_4", 311 }, - { "LS_SPARE2_1", "INTERFACE_IOS__LS_SPARE2_1", 312 }, - { "SPARE2", "INTERFACE_IOS__SPARE2", 313 }, - { "SPARE1", "INTERFACE_IOS__SPARE1", 314 }, - { "LS_SPARE2_2", "INTERFACE_IOS__LS_SPARE2_2", 315 }, - { "LS_SPARE2_3", "INTERFACE_IOS__LS_SPARE2_3", 316 }, - { "LS_SPARE2_4", "INTERFACE_IOS__LS_SPARE2_4", 317 }, { "GPO_SPARE1_1", "INTERFACE_IOS__GPO_SPARE1_1", 318 }, { "GPO_SPARE1_2", "INTERFACE_IOS__GPO_SPARE1_2", 319 }, - { "GPO_SPARE2_1", "INTERFACE_IOS__GPO_SPARE2_1", 320 }, - { "GPO_SPARE2_2", "INTERFACE_IOS__GPO_SPARE2_2", 321 }, - { "MOTO_SPARE1_1", "INTERFACE_IOS__MOTO_SPARE1_1", 322 }, - { "MOTO_SPARE1_2", "INTERFACE_IOS__MOTO_SPARE1_2", 323 }, - { "MOTO_SPARE2_1", "INTERFACE_IOS__MOTO_SPARE2_1", 324 }, - { "MOTO_SPARE2_2", "INTERFACE_IOS__MOTO_SPARE2_2", 325 }, - { "SPARE1_ROTENC1", "INTERFACE_IOS__SPARE1_ROTENC1", 326 }, - { "SPARE2_ROTENC2", "INTERFACE_IOS__SPARE2_ROTENC2", 327 }, - { "SPARE1_ROTENC3", "INTERFACE_IOS__SPARE1_ROTENC3", 328 }, - { "SPARE2_ROTENC4", "INTERFACE_IOS__SPARE2_ROTENC4", 329 }, - { "CHILLER_CTRL", "INTERFACE_IOS__CHILLER_CTRL", 330 }, - { "AN_AIRPRESS_1", "INTERFACE_IOS__AN_AIRPRESS_1", 331 }, - { "AN_AIRPRESS_2", "INTERFACE_IOS__AN_AIRPRESS_2", 332 }, - { "AN_VOCSENS", "INTERFACE_IOS__AN_VOCSENS", 333 }, - { "AN_BLOWERCTRL", "INTERFACE_IOS__AN_BLOWERCTRL", 334 }, - { "GPI_AIRFLOW_FLAP", "INTERFACE_IOS__GPI_AIRFLOW_FLAP", 335 }, - { "GPI_BLOWER_TACH", "INTERFACE_IOS__GPI_BLOWER_TACH", 336 }, - { "GPI_CHILLER_FAULT", "INTERFACE_IOS__GPI_CHILLER_FAULT", 337 }, - { "GPI_CHILLER_STAT1", "INTERFACE_IOS__GPI_CHILLER_STAT1", 338 }, - { "WHS_VOCTEMP", "INTERFACE_IOS__WHS_VOCTEMP", 339 }, - { "GPI_SW_FILTER_PRES", "INTERFACE_IOS__GPI_SW_FILTER_PRES", 340 }, { "GPI_WCONTAINER_FULL", "INTERFACE_IOS__GPI_WCONTAINER_FULL", 341 }, { "GPI_WCONTAINER_WARN", "INTERFACE_IOS__GPI_WCONTAINER_WARN", 342 }, { "GPO_BLOWER_PWM", "INTERFACE_IOS__GPO_BLOWER_PWM", 343 }, @@ -358,357 +49,48 @@ static const ProtobufCEnumValue interface_ios__enum_values_by_number[347] = { "VALVE_WASTE_TANK", "INTERFACE_IOS__VALVE_WASTE_TANK", 346 }, }; static const ProtobufCIntRange interface_ios__value_ranges[] = { -{0, 0},{0, 347} +{0, 0},{19, 1},{43, 6},{55, 9},{64, 10},{163, 11},{274, 29},{318, 30},{341, 32},{0, 38} }; -static const ProtobufCEnumValueIndex interface_ios__enum_values_by_name[347] = +static const ProtobufCEnumValueIndex interface_ios__enum_values_by_name[38] = { - { "AN10V_SPARE1", 306 }, - { "AN10V_SPARE2", 307 }, - { "AN5V_LDANCER1", 230 }, - { "AN5V_LDANCER2", 231 }, - { "AN5V_RDANCER", 283 }, - { "ANALOG_DRYER_TEMP1", 32 }, - { "ANALOG_DRYER_TEMP2", 33 }, - { "ANALOG_DRYER_TEMP3", 34 }, - { "ANALOG_DYEINGH_TEMP1", 6 }, - { "ANALOG_DYEINGH_TEMP2", 7 }, - { "ANALOG_DYEINGH_TEMP3", 8 }, - { "ANALOG_DYEINGH_TEMP4", 9 }, - { "ANALOG_DYEINGH_TEMP5", 10 }, { "ANALOG_MIXCHIP_TEMP", 0 }, - { "AN_AIRPRESS_1", 331 }, - { "AN_AIRPRESS_2", 332 }, - { "AN_BLOWERCTRL", 334 }, - { "AN_DRYER_CURSEN1", 29 }, - { "AN_DRYER_CURSEN2", 30 }, - { "AN_DRYER_CURSEN3", 31 }, - { "AN_DYEINGH_CURSEN_1", 1 }, - { "AN_DYEINGH_CURSEN_2", 2 }, - { "AN_DYEINGH_CURSEN_3", 3 }, - { "AN_DYEINGH_CURSEN_4", 4 }, - { "AN_DYEINGH_CURSEN_5", 5 }, - { "AN_ENCLOSURETEMP1", 256 }, - { "AN_ENCLOSURETEMP2", 257 }, - { "AN_ENCLOSURETEMP3", 258 }, - { "AN_IDS_PRESSENS_1", 67 }, - { "AN_IDS_PRESSENS_2", 68 }, - { "AN_IDS_PRESSENS_3", 69 }, - { "AN_IDS_PRESSENS_4", 70 }, - { "AN_IDS_PRESSENS_5", 71 }, - { "AN_IDS_PRESSENS_6", 72 }, - { "AN_IDS_PRESSENS_7", 73 }, - { "AN_IDS_PRESSENS_8", 74 }, - { "AN_MIDTANK_PRESSENS1", 75 }, - { "AN_MIDTANK_PRESSENS2", 76 }, - { "AN_MIDTANK_PRESSENS3", 77 }, - { "AN_MIDTANK_PRESSENS4", 78 }, - { "AN_MIDTANK_PRESSENS5", 79 }, - { "AN_MIDTANK_PRESSENS6", 80 }, - { "AN_MIDTANK_PRESSENS7", 81 }, - { "AN_MIXCHIP_CURSENn", 82 }, - { "AN_VOCSENS", 333 }, - { "CART1", 215 }, - { "CART2", 216 }, - { "CART3", 214 }, - { "CART4", 217 }, - { "CART5", 219 }, - { "CART6", 220 }, - { "CART7", 218 }, - { "CART8", 221 }, - { "CHILLER_CTRL", 330 }, - { "DH1", 25 }, - { "DH2", 24 }, - { "DISPENSER_1", 204 }, - { "DISPENSER_2", 209 }, - { "DISPENSER_3", 205 }, - { "DISPENSER_4", 210 }, - { "DISPENSER_5", 206 }, - { "DISPENSER_6", 211 }, - { "DISPENSER_7", 207 }, - { "DISPENSER_8", 212 }, - { "DISPENSER_ROTENC1", 189 }, - { "DISPENSER_ROTENC2", 190 }, - { "DISPENSER_ROTENC3", 191 }, - { "DISPENSER_ROTENC4", 192 }, - { "DISPENSER_ROTENC5", 193 }, - { "DISPENSER_ROTENC6", 194 }, - { "DISPENSER_ROTENC7", 195 }, - { "DISPENSER_ROTENC8", 196 }, - { "DISPENSER_VALVE_1", 197 }, - { "DISPENSER_VALVE_2", 198 }, - { "DISPENSER_VALVE_3", 199 }, - { "DISPENSER_VALVE_4", 200 }, - { "DISPENSER_VALVE_5", 201 }, - { "DISPENSER_VALVE_6", 202 }, - { "DISPENSER_VALVE_7", 203 }, - { "DRYER1", 47 }, - { "DRYER2", 46 }, - { "DRYER_LOADARM_ROTENC", 51 }, - { "ELECTRICALENC", 56 }, - { "EXTWINDER_CTRL", 65 }, - { "EXTWINDINGUNIT", 66 }, - { "FAN1_TACH", 278 }, - { "FAN2_TACH", 279 }, - { "FAN3_TACH", 280 }, - { "FAN4_TACH", 281 }, - { "FAN5_TACH", 282 }, - { "FAN_TACHO1", 275 }, - { "FAN_TACHO2", 276 }, - { "FAN_TACHO3", 277 }, - { "GPI_AIRFLOW_FLAP", 335 }, - { "GPI_BLOWER_TACH", 336 }, - { "GPI_CHILLER_FAULT", 337 }, - { "GPI_CHILLER_STAT1", 338 }, - { "GPI_EXTWINDER_1", 58 }, - { "GPI_EXTWINDER_2", 59 }, - { "GPI_EXTWINDER_3", 60 }, - { "GPI_PANSW1", 259 }, - { "GPI_PANSW2", 260 }, - { "GPI_PANSW3", 261 }, - { "GPI_PANSW4", 262 }, - { "GPI_PANSW5", 263 }, - { "GPI_PANSW6", 264 }, - { "GPI_PS1_DC_OK", 52 }, - { "GPI_PWRBUTTON", 265 }, - { "GPI_SW_FILTER_PRES", 340 }, - { "GPI_TACTSW1", 266 }, - { "GPI_TACTSW2", 267 }, - { "GPI_TACTSW3", 268 }, - { "GPI_TACTSW4", 269 }, - { "GPI_TFEED_BREAK_1", 285 }, - { "GPI_TFEED_BREAK_2", 286 }, - { "GPI_WCONTAINER_FULL", 341 }, - { "GPI_WCONTAINER_WARN", 342 }, - { "GPO_BLOWER_PWM", 343 }, - { "GPO_BUZZER", 270 }, - { "GPO_CHILLER_SSR9_CTRL", 344 }, - { "GPO_DILUTORPUMP_SSR10_CTRL", 163 }, - { "GPO_DRYER_SSR1_CTRL", 43 }, - { "GPO_DRYER_SSR2_CTRL", 44 }, - { "GPO_DRYER_SSR3_CTRL", 45 }, - { "GPO_DYEINGH_SSR5_CTRL", 20 }, - { "GPO_DYEINGH_SSR6_CTRL", 21 }, - { "GPO_DYEINGH_SSR7_CTRL", 22 }, - { "GPO_DYEINGH_SSR8_CTRL", 23 }, - { "GPO_EXTWINDER_1", 61 }, - { "GPO_EXTWINDER_2", 62 }, - { "GPO_EXTWINDER_3", 63 }, - { "GPO_EXTWINDER_SSR11_CTRL", 64 }, - { "GPO_LED1", 271 }, - { "GPO_LED2", 272 }, - { "GPO_LED3", 273 }, - { "GPO_LED4", 274 }, - { "GPO_MIXCHIP_SSR4_CTRL", 19 }, - { "GPO_PDOWN_RL1_CTRL", 53 }, - { "GPO_SPARE1_1", 318 }, - { "GPO_SPARE1_2", 319 }, - { "GPO_SPARE2_1", 320 }, - { "GPO_SPARE2_2", 321 }, - { "GPO_SPARE_SSR12_CTRL", 54 }, - { "GPO_SPARE_SSR13_CTRL", 55 }, - { "GPO_TFEED_BREAK_1", 296 }, - { "GPO_TFEED_BREAK_2", 297 }, - { "GPO_WASTECH_PUMP2", 164 }, - { "GPO_WHS_WTANKPUMP2", 345 }, - { "INTWINDINGUNIT", 229 }, - { "LDANCER1_ROTENC", 251 }, - { "LDANCER2_ROTENC", 252 }, - { "LSPARE1_ROTENC", 249 }, - { "LSPARE2_ROTENC", 250 }, - { "LSPARE_ROTENC", 253 }, - { "LS_DH_CLEAN_DOWN", 11 }, - { "LS_DH_CLEAN_LEFT", 12 }, - { "LS_DH_CLEAN_RIGHT", 13 }, - { "LS_DH_CLEAN_UP", 14 }, - { "LS_DH_LID_CLEANING", 15 }, - { "LS_DH_LID_CLOSED", 16 }, - { "LS_DH_LID_OPEN", 17 }, - { "LS_DH_SPARE1", 18 }, - { "LS_DISPENSER_25_1", 83 }, - { "LS_DISPENSER_25_2", 84 }, - { "LS_DISPENSER_25_3", 85 }, - { "LS_DISPENSER_25_4", 86 }, - { "LS_DISPENSER_25_5", 87 }, - { "LS_DISPENSER_25_6", 88 }, - { "LS_DISPENSER_25_7", 89 }, - { "LS_DISPENSER_25_8", 90 }, - { "LS_DISPENSER_50_1", 91 }, - { "LS_DISPENSER_50_2", 92 }, - { "LS_DISPENSER_50_3", 93 }, - { "LS_DISPENSER_50_4", 94 }, - { "LS_DISPENSER_50_5", 95 }, - { "LS_DISPENSER_50_6", 96 }, - { "LS_DISPENSER_50_7", 97 }, - { "LS_DISPENSER_50_8", 98 }, - { "LS_DISPENSER_75_1", 99 }, - { "LS_DISPENSER_75_2", 100 }, - { "LS_DISPENSER_75_3", 101 }, - { "LS_DISPENSER_75_4", 102 }, - { "LS_DISPENSER_75_5", 103 }, - { "LS_DISPENSER_75_6", 104 }, - { "LS_DISPENSER_75_7", 105 }, - { "LS_DISPENSER_75_8", 106 }, - { "LS_DISPENSER_DOWN_1", 107 }, - { "LS_DISPENSER_DOWN_2", 108 }, - { "LS_DISPENSER_DOWN_3", 109 }, - { "LS_DISPENSER_DOWN_4", 110 }, - { "LS_DISPENSER_DOWN_5", 111 }, - { "LS_DISPENSER_DOWN_6", 112 }, - { "LS_DISPENSER_DOWN_7", 113 }, - { "LS_DISPENSER_DOWN_8", 114 }, - { "LS_DISPENSER_SPARE_1", 115 }, - { "LS_DISPENSER_SPARE_2", 116 }, - { "LS_DISPENSER_SPARE_3", 117 }, - { "LS_DISPENSER_SPARE_4", 118 }, - { "LS_DISPENSER_SPARE_5", 119 }, - { "LS_DISPENSER_SPARE_6", 120 }, - { "LS_DISPENSER_SPARE_7", 121 }, - { "LS_DISPENSER_SPARE_8", 122 }, - { "LS_DISPENSER_UP_1", 123 }, - { "LS_DISPENSER_UP_2", 124 }, - { "LS_DISPENSER_UP_3", 125 }, - { "LS_DISPENSER_UP_4", 126 }, - { "LS_DISPENSER_UP_5", 127 }, - { "LS_DISPENSER_UP_6", 128 }, - { "LS_DISPENSER_UP_7", 129 }, - { "LS_DISPENSER_UP_8", 130 }, - { "LS_DRYER_LID_CLOSED", 35 }, - { "LS_DRYER_LID_OPEN", 36 }, - { "LS_DRYER_SPARE1", 37 }, - { "LS_DRYER_SPARE2", 38 }, - { "LS_DRYER_SPARE3", 39 }, - { "LS_DRYER_SPARE4", 40 }, - { "LS_LDANCER1_DOWN", 232 }, - { "LS_LDANCER1_UP", 233 }, - { "LS_LDANCER2_DOWN", 234 }, - { "LS_LDANCER2_UP", 235 }, - { "LS_LLOADMOTOR_DOWN", 236 }, - { "LS_LLOADMOTOR_UP", 237 }, - { "LS_LOADARM_LEFT", 41 }, - { "LS_LOADARM_RIGHT", 42 }, - { "LS_LPIVOT_DOWN", 238 }, - { "LS_LPIVOT_UP", 239 }, - { "LS_LSPARE1", 240 }, - { "LS_LSPARE2", 241 }, - { "LS_PIVOT_SPARE1", 242 }, - { "LS_PIVOT_SPARE2", 243 }, - { "LS_RDANCER_DOWN", 287 }, - { "LS_RDANCER_UP", 288 }, - { "LS_RLOADMOTOR_DOWN", 291 }, - { "LS_RLOADMOTOR_UP", 284 }, - { "LS_RLOADRAM_DOWN", 292 }, - { "LS_RLOADRAM_UP", 293 }, - { "LS_RSPARE1", 294 }, - { "LS_RSPARE2", 295 }, - { "LS_SCREW_LEFT", 222 }, - { "LS_SCREW_RIGHT", 223 }, - { "LS_SPARE1_1", 308 }, - { "LS_SPARE1_2", 309 }, - { "LS_SPARE1_3", 310 }, - { "LS_SPARE1_4", 311 }, - { "LS_SPARE2_1", 312 }, - { "LS_SPARE2_2", 315 }, - { "LS_SPARE2_3", 316 }, - { "LS_SPARE2_4", 317 }, - { "LTFEEDUNIT1", 255 }, - { "LTFEEDUNIT2", 254 }, - { "MIDTANK1_LVL1_FLOAT", 131 }, - { "MIDTANK1_LVL2_FLOAT", 132 }, - { "MIDTANK1_LVL3_FLOAT", 133 }, - { "MIDTANK1_LVL4_FLOAT", 134 }, - { "MIDTANK2_LVL1_FLOAT", 135 }, - { "MIDTANK2_LVL2_FLOAT", 136 }, - { "MIDTANK2_LVL3_FLOAT", 137 }, - { "MIDTANK2_LVL4_FLOAT", 138 }, - { "MIDTANK3_1", 208 }, - { "MIDTANK3_2", 213 }, - { "MIDTANK3_LVL1_FLOAT", 139 }, - { "MIDTANK3_LVL2_FLOAT", 140 }, - { "MIDTANK3_LVL3_FLOAT", 141 }, - { "MIDTANK3_LVL4_FLOAT", 142 }, - { "MIDTANK4_LVL1_FLOAT", 143 }, - { "MIDTANK4_LVL2_FLOAT", 144 }, - { "MIDTANK4_LVL3_FLOAT", 145 }, - { "MIDTANK4_LVL4_FLOAT", 146 }, - { "MIDTANK5_LVL1_FLOAT", 147 }, - { "MIDTANK5_LVL2_FLOAT", 148 }, - { "MIDTANK5_LVL3_FLOAT", 149 }, - { "MIDTANK5_LVL4_FLOAT", 150 }, - { "MIDTANK6_LVL1_FLOAT", 151 }, - { "MIDTANK6_LVL2_FLOAT", 152 }, - { "MIDTANK6_LVL3_FLOAT", 153 }, - { "MIDTANK6_LVL4_FLOAT", 154 }, - { "MIDTANK7_LVL1_FLOAT", 155 }, - { "MIDTANK7_LVL2_FLOAT", 156 }, - { "MIDTANK7_LVL3_FLOAT", 157 }, - { "MIDTANK7_LVL4_FLOAT", 158 }, - { "MIDTANK8_LVL1_FLOAT", 159 }, - { "MIDTANK8_LVL2_FLOAT", 160 }, - { "MIDTANK8_LVL3_FLOAT", 161 }, - { "MIDTANK8_LVL4_FLOAT", 162 }, - { "MOTO_DH_CLEANHEAD", 26 }, - { "MOTO_DH_CLEANMECH", 27 }, - { "MOTO_DH_LID", 28 }, - { "MOTO_DISPENSER_1", 181 }, - { "MOTO_DISPENSER_2", 182 }, - { "MOTO_DISPENSER_3", 183 }, - { "MOTO_DISPENSER_4", 184 }, - { "MOTO_DISPENSER_5", 185 }, - { "MOTO_DISPENSER_6", 186 }, - { "MOTO_DISPENSER_7", 187 }, - { "MOTO_DISPENSER_8", 188 }, - { "MOTO_DRYER_DRIVING", 48 }, - { "MOTO_DRYER_LID", 49 }, - { "MOTO_DRYER_LOADARM", 50 }, - { "MOTO_LDANCER1", 244 }, - { "MOTO_LDANCER2", 245 }, - { "MOTO_LDRIVING", 246 }, - { "MOTO_LLOADING", 247 }, - { "MOTO_LPIVOT1", 248 }, - { "MOTO_RDANCER", 298 }, - { "MOTO_RDRIVING", 299 }, - { "MOTO_RLOADARM", 300 }, - { "MOTO_RLOADING", 301 }, - { "MOTO_SCREW", 226 }, - { "MOTO_SPARE1_1", 322 }, - { "MOTO_SPARE1_2", 323 }, - { "MOTO_SPARE2_1", 324 }, - { "MOTO_SPARE2_2", 325 }, - { "MOTO_WINDER", 227 }, - { "Midtank1Air", 165 }, - { "Midtank1Cartridge", 173 }, - { "Midtank2Air", 166 }, - { "Midtank2Cartridge", 174 }, - { "Midtank3Air", 167 }, - { "Midtank3Cartridge", 175 }, - { "Midtank4Air", 168 }, - { "Midtank4Cartridge", 176 }, - { "Midtank5Air", 169 }, - { "Midtank5Cartridge", 177 }, - { "Midtank6Air", 170 }, - { "Midtank6Cartridge", 178 }, - { "Midtank7Air", 171 }, - { "Midtank7Cartridge", 179 }, - { "Midtank8Air", 172 }, - { "Midtank8Cartridge", 180 }, - { "RDANCER_ROTENC", 304 }, - { "RSPARE_ROTENC1", 302 }, - { "RSPARE_ROTENC2", 305 }, - { "RSPEEDSENS_ROTENC", 303 }, - { "RTFEEDUNIT1", 290 }, - { "RTFEEDUNIT2", 289 }, - { "SCREW_ROTENC", 228 }, - { "SPARE1", 314 }, - { "SPARE1_ROTENC1", 326 }, - { "SPARE1_ROTENC3", 328 }, - { "SPARE2", 313 }, - { "SPARE2_ROTENC2", 327 }, - { "SPARE2_ROTENC4", 329 }, - { "SW_SPARE", 224 }, - { "SW_SPOOL_EXISTS", 225 }, - { "USERPANEL", 57 }, - { "VALVE_WASTE_TANK", 346 }, - { "WHS_VOCTEMP", 339 }, + { "GPI_WCONTAINER_FULL", 32 }, + { "GPI_WCONTAINER_WARN", 33 }, + { "GPO_BLOWER_PWM", 34 }, + { "GPO_CHILLER_SSR9_CTRL", 35 }, + { "GPO_DILUTORPUMP_SSR10_CTRL", 11 }, + { "GPO_DRYER_SSR1_CTRL", 6 }, + { "GPO_DRYER_SSR2_CTRL", 7 }, + { "GPO_DRYER_SSR3_CTRL", 8 }, + { "GPO_DYEINGH_SSR5_CTRL", 2 }, + { "GPO_DYEINGH_SSR6_CTRL", 3 }, + { "GPO_DYEINGH_SSR7_CTRL", 4 }, + { "GPO_DYEINGH_SSR8_CTRL", 5 }, + { "GPO_EXTWINDER_SSR11_CTRL", 10 }, + { "GPO_LED4", 29 }, + { "GPO_MIXCHIP_SSR4_CTRL", 1 }, + { "GPO_SPARE1_1", 30 }, + { "GPO_SPARE1_2", 31 }, + { "GPO_SPARE_SSR13_CTRL", 9 }, + { "GPO_WASTECH_PUMP2", 12 }, + { "GPO_WHS_WTANKPUMP2", 36 }, + { "Midtank1Air", 13 }, + { "Midtank1Cartridge", 21 }, + { "Midtank2Air", 14 }, + { "Midtank2Cartridge", 22 }, + { "Midtank3Air", 15 }, + { "Midtank3Cartridge", 23 }, + { "Midtank4Air", 16 }, + { "Midtank4Cartridge", 24 }, + { "Midtank5Air", 17 }, + { "Midtank5Cartridge", 25 }, + { "Midtank6Air", 18 }, + { "Midtank6Cartridge", 26 }, + { "Midtank7Air", 19 }, + { "Midtank7Cartridge", 27 }, + { "Midtank8Air", 20 }, + { "Midtank8Cartridge", 28 }, + { "VALVE_WASTE_TANK", 37 }, }; const ProtobufCEnumDescriptor interface_ios__descriptor = { @@ -717,11 +99,11 @@ const ProtobufCEnumDescriptor interface_ios__descriptor = "InterfaceIOs", "InterfaceIOs", "", - 347, + 38, interface_ios__enum_values_by_number, - 347, + 38, interface_ios__enum_values_by_name, - 1, + 9, interface_ios__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.h index 006eab1d7..c3608b155 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/InterfaceIOs.pb-c.h @@ -21,168 +21,16 @@ PROTOBUF_C__BEGIN_DECLS typedef enum _InterfaceIOs { INTERFACE_IOS__ANALOG_MIXCHIP_TEMP = 0, - INTERFACE_IOS__AN_DYEINGH_CURSEN_1 = 1, - INTERFACE_IOS__AN_DYEINGH_CURSEN_2 = 2, - INTERFACE_IOS__AN_DYEINGH_CURSEN_3 = 3, - INTERFACE_IOS__AN_DYEINGH_CURSEN_4 = 4, - INTERFACE_IOS__AN_DYEINGH_CURSEN_5 = 5, - INTERFACE_IOS__ANALOG_DYEINGH_TEMP1 = 6, - INTERFACE_IOS__ANALOG_DYEINGH_TEMP2 = 7, - INTERFACE_IOS__ANALOG_DYEINGH_TEMP3 = 8, - INTERFACE_IOS__ANALOG_DYEINGH_TEMP4 = 9, - INTERFACE_IOS__ANALOG_DYEINGH_TEMP5 = 10, - INTERFACE_IOS__LS_DH_CLEAN_DOWN = 11, - INTERFACE_IOS__LS_DH_CLEAN_LEFT = 12, - INTERFACE_IOS__LS_DH_CLEAN_RIGHT = 13, - INTERFACE_IOS__LS_DH_CLEAN_UP = 14, - INTERFACE_IOS__LS_DH_LID_CLEANING = 15, - INTERFACE_IOS__LS_DH_LID_CLOSED = 16, - INTERFACE_IOS__LS_DH_LID_OPEN = 17, - INTERFACE_IOS__LS_DH_SPARE1 = 18, INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL = 19, INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL = 20, INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL = 21, INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL = 22, INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL = 23, - INTERFACE_IOS__DH2 = 24, - INTERFACE_IOS__DH1 = 25, - INTERFACE_IOS__MOTO_DH_CLEANHEAD = 26, - INTERFACE_IOS__MOTO_DH_CLEANMECH = 27, - INTERFACE_IOS__MOTO_DH_LID = 28, - INTERFACE_IOS__AN_DRYER_CURSEN1 = 29, - INTERFACE_IOS__AN_DRYER_CURSEN2 = 30, - INTERFACE_IOS__AN_DRYER_CURSEN3 = 31, - INTERFACE_IOS__ANALOG_DRYER_TEMP1 = 32, - INTERFACE_IOS__ANALOG_DRYER_TEMP2 = 33, - INTERFACE_IOS__ANALOG_DRYER_TEMP3 = 34, - INTERFACE_IOS__LS_DRYER_LID_CLOSED = 35, - INTERFACE_IOS__LS_DRYER_LID_OPEN = 36, - INTERFACE_IOS__LS_DRYER_SPARE1 = 37, - INTERFACE_IOS__LS_DRYER_SPARE2 = 38, - INTERFACE_IOS__LS_DRYER_SPARE3 = 39, - INTERFACE_IOS__LS_DRYER_SPARE4 = 40, - INTERFACE_IOS__LS_LOADARM_LEFT = 41, - INTERFACE_IOS__LS_LOADARM_RIGHT = 42, INTERFACE_IOS__GPO_DRYER_SSR1_CTRL = 43, INTERFACE_IOS__GPO_DRYER_SSR2_CTRL = 44, INTERFACE_IOS__GPO_DRYER_SSR3_CTRL = 45, - INTERFACE_IOS__DRYER2 = 46, - INTERFACE_IOS__DRYER1 = 47, - INTERFACE_IOS__MOTO_DRYER_DRIVING = 48, - INTERFACE_IOS__MOTO_DRYER_LID = 49, - INTERFACE_IOS__MOTO_DRYER_LOADARM = 50, - INTERFACE_IOS__DRYER_LOADARM_ROTENC = 51, - INTERFACE_IOS__GPI_PS1_DC_OK = 52, - INTERFACE_IOS__GPO_PDOWN_RL1_CTRL = 53, - INTERFACE_IOS__GPO_SPARE_SSR12_CTRL = 54, INTERFACE_IOS__GPO_SPARE_SSR13_CTRL = 55, - INTERFACE_IOS__ELECTRICALENC = 56, - INTERFACE_IOS__USERPANEL = 57, - INTERFACE_IOS__GPI_EXTWINDER_1 = 58, - INTERFACE_IOS__GPI_EXTWINDER_2 = 59, - INTERFACE_IOS__GPI_EXTWINDER_3 = 60, - INTERFACE_IOS__GPO_EXTWINDER_1 = 61, - INTERFACE_IOS__GPO_EXTWINDER_2 = 62, - INTERFACE_IOS__GPO_EXTWINDER_3 = 63, INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL = 64, - INTERFACE_IOS__EXTWINDER_CTRL = 65, - INTERFACE_IOS__EXTWINDINGUNIT = 66, - INTERFACE_IOS__AN_IDS_PRESSENS_1 = 67, - INTERFACE_IOS__AN_IDS_PRESSENS_2 = 68, - INTERFACE_IOS__AN_IDS_PRESSENS_3 = 69, - INTERFACE_IOS__AN_IDS_PRESSENS_4 = 70, - INTERFACE_IOS__AN_IDS_PRESSENS_5 = 71, - INTERFACE_IOS__AN_IDS_PRESSENS_6 = 72, - INTERFACE_IOS__AN_IDS_PRESSENS_7 = 73, - INTERFACE_IOS__AN_IDS_PRESSENS_8 = 74, - INTERFACE_IOS__AN_MIDTANK_PRESSENS1 = 75, - INTERFACE_IOS__AN_MIDTANK_PRESSENS2 = 76, - INTERFACE_IOS__AN_MIDTANK_PRESSENS3 = 77, - INTERFACE_IOS__AN_MIDTANK_PRESSENS4 = 78, - INTERFACE_IOS__AN_MIDTANK_PRESSENS5 = 79, - INTERFACE_IOS__AN_MIDTANK_PRESSENS6 = 80, - INTERFACE_IOS__AN_MIDTANK_PRESSENS7 = 81, - INTERFACE_IOS__AN_MIXCHIP_CURSENn = 82, - INTERFACE_IOS__LS_DISPENSER_25_1 = 83, - INTERFACE_IOS__LS_DISPENSER_25_2 = 84, - INTERFACE_IOS__LS_DISPENSER_25_3 = 85, - INTERFACE_IOS__LS_DISPENSER_25_4 = 86, - INTERFACE_IOS__LS_DISPENSER_25_5 = 87, - INTERFACE_IOS__LS_DISPENSER_25_6 = 88, - INTERFACE_IOS__LS_DISPENSER_25_7 = 89, - INTERFACE_IOS__LS_DISPENSER_25_8 = 90, - INTERFACE_IOS__LS_DISPENSER_50_1 = 91, - INTERFACE_IOS__LS_DISPENSER_50_2 = 92, - INTERFACE_IOS__LS_DISPENSER_50_3 = 93, - INTERFACE_IOS__LS_DISPENSER_50_4 = 94, - INTERFACE_IOS__LS_DISPENSER_50_5 = 95, - INTERFACE_IOS__LS_DISPENSER_50_6 = 96, - INTERFACE_IOS__LS_DISPENSER_50_7 = 97, - INTERFACE_IOS__LS_DISPENSER_50_8 = 98, - INTERFACE_IOS__LS_DISPENSER_75_1 = 99, - INTERFACE_IOS__LS_DISPENSER_75_2 = 100, - INTERFACE_IOS__LS_DISPENSER_75_3 = 101, - INTERFACE_IOS__LS_DISPENSER_75_4 = 102, - INTERFACE_IOS__LS_DISPENSER_75_5 = 103, - INTERFACE_IOS__LS_DISPENSER_75_6 = 104, - INTERFACE_IOS__LS_DISPENSER_75_7 = 105, - INTERFACE_IOS__LS_DISPENSER_75_8 = 106, - INTERFACE_IOS__LS_DISPENSER_DOWN_1 = 107, - INTERFACE_IOS__LS_DISPENSER_DOWN_2 = 108, - INTERFACE_IOS__LS_DISPENSER_DOWN_3 = 109, - INTERFACE_IOS__LS_DISPENSER_DOWN_4 = 110, - INTERFACE_IOS__LS_DISPENSER_DOWN_5 = 111, - INTERFACE_IOS__LS_DISPENSER_DOWN_6 = 112, - INTERFACE_IOS__LS_DISPENSER_DOWN_7 = 113, - INTERFACE_IOS__LS_DISPENSER_DOWN_8 = 114, - INTERFACE_IOS__LS_DISPENSER_SPARE_1 = 115, - INTERFACE_IOS__LS_DISPENSER_SPARE_2 = 116, - INTERFACE_IOS__LS_DISPENSER_SPARE_3 = 117, - INTERFACE_IOS__LS_DISPENSER_SPARE_4 = 118, - INTERFACE_IOS__LS_DISPENSER_SPARE_5 = 119, - INTERFACE_IOS__LS_DISPENSER_SPARE_6 = 120, - INTERFACE_IOS__LS_DISPENSER_SPARE_7 = 121, - INTERFACE_IOS__LS_DISPENSER_SPARE_8 = 122, - INTERFACE_IOS__LS_DISPENSER_UP_1 = 123, - INTERFACE_IOS__LS_DISPENSER_UP_2 = 124, - INTERFACE_IOS__LS_DISPENSER_UP_3 = 125, - INTERFACE_IOS__LS_DISPENSER_UP_4 = 126, - INTERFACE_IOS__LS_DISPENSER_UP_5 = 127, - INTERFACE_IOS__LS_DISPENSER_UP_6 = 128, - INTERFACE_IOS__LS_DISPENSER_UP_7 = 129, - INTERFACE_IOS__LS_DISPENSER_UP_8 = 130, - INTERFACE_IOS__MIDTANK1_LVL1_FLOAT = 131, - INTERFACE_IOS__MIDTANK1_LVL2_FLOAT = 132, - INTERFACE_IOS__MIDTANK1_LVL3_FLOAT = 133, - INTERFACE_IOS__MIDTANK1_LVL4_FLOAT = 134, - INTERFACE_IOS__MIDTANK2_LVL1_FLOAT = 135, - INTERFACE_IOS__MIDTANK2_LVL2_FLOAT = 136, - INTERFACE_IOS__MIDTANK2_LVL3_FLOAT = 137, - INTERFACE_IOS__MIDTANK2_LVL4_FLOAT = 138, - INTERFACE_IOS__MIDTANK3_LVL1_FLOAT = 139, - INTERFACE_IOS__MIDTANK3_LVL2_FLOAT = 140, - INTERFACE_IOS__MIDTANK3_LVL3_FLOAT = 141, - INTERFACE_IOS__MIDTANK3_LVL4_FLOAT = 142, - INTERFACE_IOS__MIDTANK4_LVL1_FLOAT = 143, - INTERFACE_IOS__MIDTANK4_LVL2_FLOAT = 144, - INTERFACE_IOS__MIDTANK4_LVL3_FLOAT = 145, - INTERFACE_IOS__MIDTANK4_LVL4_FLOAT = 146, - INTERFACE_IOS__MIDTANK5_LVL1_FLOAT = 147, - INTERFACE_IOS__MIDTANK5_LVL2_FLOAT = 148, - INTERFACE_IOS__MIDTANK5_LVL3_FLOAT = 149, - INTERFACE_IOS__MIDTANK5_LVL4_FLOAT = 150, - INTERFACE_IOS__MIDTANK6_LVL1_FLOAT = 151, - INTERFACE_IOS__MIDTANK6_LVL2_FLOAT = 152, - INTERFACE_IOS__MIDTANK6_LVL3_FLOAT = 153, - INTERFACE_IOS__MIDTANK6_LVL4_FLOAT = 154, - INTERFACE_IOS__MIDTANK7_LVL1_FLOAT = 155, - INTERFACE_IOS__MIDTANK7_LVL2_FLOAT = 156, - INTERFACE_IOS__MIDTANK7_LVL3_FLOAT = 157, - INTERFACE_IOS__MIDTANK7_LVL4_FLOAT = 158, - INTERFACE_IOS__MIDTANK8_LVL1_FLOAT = 159, - INTERFACE_IOS__MIDTANK8_LVL2_FLOAT = 160, - INTERFACE_IOS__MIDTANK8_LVL3_FLOAT = 161, - INTERFACE_IOS__MIDTANK8_LVL4_FLOAT = 162, INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL = 163, INTERFACE_IOS__GPO_WASTECH_PUMP2 = 164, INTERFACE_IOS__Midtank1Air = 165, @@ -201,166 +49,9 @@ typedef enum _InterfaceIOs { INTERFACE_IOS__Midtank6Cartridge = 178, INTERFACE_IOS__Midtank7Cartridge = 179, INTERFACE_IOS__Midtank8Cartridge = 180, - INTERFACE_IOS__MOTO_DISPENSER_1 = 181, - INTERFACE_IOS__MOTO_DISPENSER_2 = 182, - INTERFACE_IOS__MOTO_DISPENSER_3 = 183, - INTERFACE_IOS__MOTO_DISPENSER_4 = 184, - INTERFACE_IOS__MOTO_DISPENSER_5 = 185, - INTERFACE_IOS__MOTO_DISPENSER_6 = 186, - INTERFACE_IOS__MOTO_DISPENSER_7 = 187, - INTERFACE_IOS__MOTO_DISPENSER_8 = 188, - INTERFACE_IOS__DISPENSER_ROTENC1 = 189, - INTERFACE_IOS__DISPENSER_ROTENC2 = 190, - INTERFACE_IOS__DISPENSER_ROTENC3 = 191, - INTERFACE_IOS__DISPENSER_ROTENC4 = 192, - INTERFACE_IOS__DISPENSER_ROTENC5 = 193, - INTERFACE_IOS__DISPENSER_ROTENC6 = 194, - INTERFACE_IOS__DISPENSER_ROTENC7 = 195, - INTERFACE_IOS__DISPENSER_ROTENC8 = 196, - INTERFACE_IOS__DISPENSER_VALVE_1 = 197, - INTERFACE_IOS__DISPENSER_VALVE_2 = 198, - INTERFACE_IOS__DISPENSER_VALVE_3 = 199, - INTERFACE_IOS__DISPENSER_VALVE_4 = 200, - INTERFACE_IOS__DISPENSER_VALVE_5 = 201, - INTERFACE_IOS__DISPENSER_VALVE_6 = 202, - INTERFACE_IOS__DISPENSER_VALVE_7 = 203, - INTERFACE_IOS__DISPENSER_1 = 204, - INTERFACE_IOS__DISPENSER_3 = 205, - INTERFACE_IOS__DISPENSER_5 = 206, - INTERFACE_IOS__DISPENSER_7 = 207, - INTERFACE_IOS__MIDTANK3_1 = 208, - INTERFACE_IOS__DISPENSER_2 = 209, - INTERFACE_IOS__DISPENSER_4 = 210, - INTERFACE_IOS__DISPENSER_6 = 211, - INTERFACE_IOS__DISPENSER_8 = 212, - INTERFACE_IOS__MIDTANK3_2 = 213, - INTERFACE_IOS__CART3 = 214, - INTERFACE_IOS__CART1 = 215, - INTERFACE_IOS__CART2 = 216, - INTERFACE_IOS__CART4 = 217, - INTERFACE_IOS__CART7 = 218, - INTERFACE_IOS__CART5 = 219, - INTERFACE_IOS__CART6 = 220, - INTERFACE_IOS__CART8 = 221, - INTERFACE_IOS__LS_SCREW_LEFT = 222, - INTERFACE_IOS__LS_SCREW_RIGHT = 223, - INTERFACE_IOS__SW_SPARE = 224, - INTERFACE_IOS__SW_SPOOL_EXISTS = 225, - INTERFACE_IOS__MOTO_SCREW = 226, - INTERFACE_IOS__MOTO_WINDER = 227, - INTERFACE_IOS__SCREW_ROTENC = 228, - INTERFACE_IOS__INTWINDINGUNIT = 229, - INTERFACE_IOS__AN5V_LDANCER1 = 230, - INTERFACE_IOS__AN5V_LDANCER2 = 231, - INTERFACE_IOS__LS_LDANCER1_DOWN = 232, - INTERFACE_IOS__LS_LDANCER1_UP = 233, - INTERFACE_IOS__LS_LDANCER2_DOWN = 234, - INTERFACE_IOS__LS_LDANCER2_UP = 235, - INTERFACE_IOS__LS_LLOADMOTOR_DOWN = 236, - INTERFACE_IOS__LS_LLOADMOTOR_UP = 237, - INTERFACE_IOS__LS_LPIVOT_DOWN = 238, - INTERFACE_IOS__LS_LPIVOT_UP = 239, - INTERFACE_IOS__LS_LSPARE1 = 240, - INTERFACE_IOS__LS_LSPARE2 = 241, - INTERFACE_IOS__LS_PIVOT_SPARE1 = 242, - INTERFACE_IOS__LS_PIVOT_SPARE2 = 243, - INTERFACE_IOS__MOTO_LDANCER1 = 244, - INTERFACE_IOS__MOTO_LDANCER2 = 245, - INTERFACE_IOS__MOTO_LDRIVING = 246, - INTERFACE_IOS__MOTO_LLOADING = 247, - INTERFACE_IOS__MOTO_LPIVOT1 = 248, - INTERFACE_IOS__LSPARE1_ROTENC = 249, - INTERFACE_IOS__LSPARE2_ROTENC = 250, - INTERFACE_IOS__LDANCER1_ROTENC = 251, - INTERFACE_IOS__LDANCER2_ROTENC = 252, - INTERFACE_IOS__LSPARE_ROTENC = 253, - INTERFACE_IOS__LTFEEDUNIT2 = 254, - INTERFACE_IOS__LTFEEDUNIT1 = 255, - INTERFACE_IOS__AN_ENCLOSURETEMP1 = 256, - INTERFACE_IOS__AN_ENCLOSURETEMP2 = 257, - INTERFACE_IOS__AN_ENCLOSURETEMP3 = 258, - INTERFACE_IOS__GPI_PANSW1 = 259, - INTERFACE_IOS__GPI_PANSW2 = 260, - INTERFACE_IOS__GPI_PANSW3 = 261, - INTERFACE_IOS__GPI_PANSW4 = 262, - INTERFACE_IOS__GPI_PANSW5 = 263, - INTERFACE_IOS__GPI_PANSW6 = 264, - INTERFACE_IOS__GPI_PWRBUTTON = 265, - INTERFACE_IOS__GPI_TACTSW1 = 266, - INTERFACE_IOS__GPI_TACTSW2 = 267, - INTERFACE_IOS__GPI_TACTSW3 = 268, - INTERFACE_IOS__GPI_TACTSW4 = 269, - INTERFACE_IOS__GPO_BUZZER = 270, - INTERFACE_IOS__GPO_LED1 = 271, - INTERFACE_IOS__GPO_LED2 = 272, - INTERFACE_IOS__GPO_LED3 = 273, INTERFACE_IOS__GPO_LED4 = 274, - INTERFACE_IOS__FAN_TACHO1 = 275, - INTERFACE_IOS__FAN_TACHO2 = 276, - INTERFACE_IOS__FAN_TACHO3 = 277, - INTERFACE_IOS__FAN1_TACH = 278, - INTERFACE_IOS__FAN2_TACH = 279, - INTERFACE_IOS__FAN3_TACH = 280, - INTERFACE_IOS__FAN4_TACH = 281, - INTERFACE_IOS__FAN5_TACH = 282, - INTERFACE_IOS__AN5V_RDANCER = 283, - INTERFACE_IOS__LS_RLOADMOTOR_UP = 284, - INTERFACE_IOS__GPI_TFEED_BREAK_1 = 285, - INTERFACE_IOS__GPI_TFEED_BREAK_2 = 286, - INTERFACE_IOS__LS_RDANCER_DOWN = 287, - INTERFACE_IOS__LS_RDANCER_UP = 288, - INTERFACE_IOS__RTFEEDUNIT2 = 289, - INTERFACE_IOS__RTFEEDUNIT1 = 290, - INTERFACE_IOS__LS_RLOADMOTOR_DOWN = 291, - INTERFACE_IOS__LS_RLOADRAM_DOWN = 292, - INTERFACE_IOS__LS_RLOADRAM_UP = 293, - INTERFACE_IOS__LS_RSPARE1 = 294, - INTERFACE_IOS__LS_RSPARE2 = 295, - INTERFACE_IOS__GPO_TFEED_BREAK_1 = 296, - INTERFACE_IOS__GPO_TFEED_BREAK_2 = 297, - INTERFACE_IOS__MOTO_RDANCER = 298, - INTERFACE_IOS__MOTO_RDRIVING = 299, - INTERFACE_IOS__MOTO_RLOADARM = 300, - INTERFACE_IOS__MOTO_RLOADING = 301, - INTERFACE_IOS__RSPARE_ROTENC1 = 302, - INTERFACE_IOS__RSPEEDSENS_ROTENC = 303, - INTERFACE_IOS__RDANCER_ROTENC = 304, - INTERFACE_IOS__RSPARE_ROTENC2 = 305, - INTERFACE_IOS__AN10V_SPARE1 = 306, - INTERFACE_IOS__AN10V_SPARE2 = 307, - INTERFACE_IOS__LS_SPARE1_1 = 308, - INTERFACE_IOS__LS_SPARE1_2 = 309, - INTERFACE_IOS__LS_SPARE1_3 = 310, - INTERFACE_IOS__LS_SPARE1_4 = 311, - INTERFACE_IOS__LS_SPARE2_1 = 312, - INTERFACE_IOS__SPARE2 = 313, - INTERFACE_IOS__SPARE1 = 314, - INTERFACE_IOS__LS_SPARE2_2 = 315, - INTERFACE_IOS__LS_SPARE2_3 = 316, - INTERFACE_IOS__LS_SPARE2_4 = 317, INTERFACE_IOS__GPO_SPARE1_1 = 318, INTERFACE_IOS__GPO_SPARE1_2 = 319, - INTERFACE_IOS__GPO_SPARE2_1 = 320, - INTERFACE_IOS__GPO_SPARE2_2 = 321, - INTERFACE_IOS__MOTO_SPARE1_1 = 322, - INTERFACE_IOS__MOTO_SPARE1_2 = 323, - INTERFACE_IOS__MOTO_SPARE2_1 = 324, - INTERFACE_IOS__MOTO_SPARE2_2 = 325, - INTERFACE_IOS__SPARE1_ROTENC1 = 326, - INTERFACE_IOS__SPARE2_ROTENC2 = 327, - INTERFACE_IOS__SPARE1_ROTENC3 = 328, - INTERFACE_IOS__SPARE2_ROTENC4 = 329, - INTERFACE_IOS__CHILLER_CTRL = 330, - INTERFACE_IOS__AN_AIRPRESS_1 = 331, - INTERFACE_IOS__AN_AIRPRESS_2 = 332, - INTERFACE_IOS__AN_VOCSENS = 333, - INTERFACE_IOS__AN_BLOWERCTRL = 334, - INTERFACE_IOS__GPI_AIRFLOW_FLAP = 335, - INTERFACE_IOS__GPI_BLOWER_TACH = 336, - INTERFACE_IOS__GPI_CHILLER_FAULT = 337, - INTERFACE_IOS__GPI_CHILLER_STAT1 = 338, - INTERFACE_IOS__WHS_VOCTEMP = 339, - INTERFACE_IOS__GPI_SW_FILTER_PRES = 340, INTERFACE_IOS__GPI_WCONTAINER_FULL = 341, INTERFACE_IOS__GPI_WCONTAINER_WARN = 342, INTERFACE_IOS__GPO_BLOWER_PWM = 343, diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c index e219a3859..2ecf83560 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c @@ -944,6 +944,42 @@ bool Dryer_Door_Switch()//move to Get_COVER_1_State } */ +char Read_HW_Version(unsigned char *Brd_ID, unsigned char *Assy_ID) +{ + //TODO Move in GPIO Initialisation + + // ----------- Set HW Version GPIO as Input ----------- + //MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); + //MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7); + //MAP_GPIOPinTypeGPIOInput(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5); + + //Set HW Version GPIO to Pull down + GPIOPadConfigSet(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); + GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); + GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); + // ------------------------------------------------------ + + if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3) == GPIO_PIN_3) + *Brd_ID |= 0x08; + if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_2) == GPIO_PIN_2) + *Brd_ID |= 0x04; + if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_5) == GPIO_PIN_5) + *Brd_ID |= 0x02; + if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_4) == GPIO_PIN_4) + *Brd_ID |= 0x01; + + if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_3) == GPIO_PIN_3) + *Assy_ID |= 0x08; + if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_5) == GPIO_PIN_5) + *Assy_ID |= 0x04; + if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_1) == GPIO_PIN_1) + *Assy_ID |= 0x02; + if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_7) == GPIO_PIN_7) + *Assy_ID |= 0x01; + + return PASSED; +} + diff --git a/Software/Embedded_SW/Embedded/Drivers/SPI/SPI_Comm.c b/Software/Embedded_SW/Embedded/Drivers/SPI/SPI_Comm.c index 43174ec89..4cfb0704b 100644 --- a/Software/Embedded_SW/Embedded/Drivers/SPI/SPI_Comm.c +++ b/Software/Embedded_SW/Embedded/Drivers/SPI/SPI_Comm.c @@ -33,7 +33,7 @@ uint32_t Get_and_Clear_Status(); uint32_t Get_Param(byte param); unsigned long MaxSpdCalc(float stepsPerSec); - +/* extern unsigned long Run_Value ; extern unsigned long Mov_Value ; extern unsigned long Pos_Value; @@ -55,6 +55,28 @@ extern unsigned long TestUint32_3; extern unsigned long TestUint32_4; extern unsigned long TestUint32_5; extern unsigned long TestUint32_6; +*/ +unsigned long Run_Value = 136902 ; +unsigned long Pos_Value; +unsigned long Mov_Value ; +bool Direction ; +unsigned long Time_2_Change_Direction ; +bool Display_Tx_ON_LCD; +bool Display_Rx_on_LCD; +unsigned long Init_MicroStep ; +unsigned long Init_Acc; +unsigned long Init_Dec; +bool TestBool_1; +bool TestBool_2; +bool TestBool_3; +bool TestBool_4; +bool TestBool_5; +unsigned long TestUint32_1; +unsigned long TestUint32_2; +unsigned long TestUint32_3; +unsigned long TestUint32_4; +unsigned long TestUint32_5; +unsigned long TestUint32_6; extern unsigned char Stop_Command; diff --git a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/Uart.c b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/Uart.c index b5c61eb46..b86cabc75 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/Uart.c +++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/Uart.c @@ -21,6 +21,7 @@ #include "driverlib/interrupt.h" #include "utils/uartstdio.h" +#include "utils/uartstdio.c" /// /* XDCtools Header files */ @@ -115,6 +116,8 @@ static void UartClockHandle(UArg arg0) Clock_start(UartClock); } + + //***************************************************************************** // // The UART Initialization. diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c index e2f2013c9..4867587d9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c @@ -22,41 +22,7 @@ #include "driverlib/rom.h" -char Read_HW_Version(unsigned char *Brd_ID, unsigned char *Assy_ID) -{ - //TODO Move in GPIO Initialisation - - // ----------- Set HW Version GPIO as Input ----------- - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7); - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5); - - //Set HW Version GPIO to Pull down - GPIOPadConfigSet(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - // ------------------------------------------------------ - - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3) == GPIO_PIN_3) - *Brd_ID |= 0x08; - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_2) == GPIO_PIN_2) - *Brd_ID |= 0x04; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_5) == GPIO_PIN_5) - *Brd_ID |= 0x02; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_4) == GPIO_PIN_4) - *Brd_ID |= 0x01; - - if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_3) == GPIO_PIN_3) - *Assy_ID |= 0x08; - if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_5) == GPIO_PIN_5) - *Assy_ID |= 0x04; - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_1) == GPIO_PIN_1) - *Assy_ID |= 0x02; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_7) == GPIO_PIN_7) - *Assy_ID |= 0x01; - - return PASSED; -} + void Stub_HWVersionRequest(MessageContainer* requestContainer) { diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c index 636889127..7995b1a42 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c @@ -21,7 +21,7 @@ #include "drivers/SPI/SPI_Comm.h" #include "driverlib/ssi.h" - +/* unsigned long Run_Value = 136902 ; unsigned long Pos_Value; unsigned long Mov_Value ; @@ -43,6 +43,28 @@ unsigned long TestUint32_4; unsigned long TestUint32_5; unsigned long TestUint32_6; + */ + extern unsigned long Run_Value ; + extern unsigned long Mov_Value ; + extern unsigned long Pos_Value; + extern bool Direction ; + extern unsigned long Time_2_Change_Direction ; + extern bool Display_Tx_ON_LCD; + extern bool Display_Rx_on_LCD; + extern unsigned long Init_MicroStep ; + extern unsigned long Init_Acc; + extern unsigned long Init_Dec; + extern bool TestBool_1; + extern bool TestBool_2; + extern bool TestBool_3; + extern bool TestBool_4; + extern bool TestBool_5; + extern unsigned long TestUint32_1; + extern unsigned long TestUint32_2; + extern unsigned long TestUint32_3; + extern unsigned long TestUint32_4; + extern unsigned long TestUint32_5; + extern unsigned long TestUint32_6; void Stub_L6470DriverRequest(MessageContainer* requestContainer) { diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h deleted file mode 100644 index 0b4702861..000000000 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h +++ /dev/null @@ -1,3 +0,0 @@ -void Stub_L6470DriverRequest(MessageContainer* requestContainer); - -void temp_init_spi2(); -- cgit v1.3.1 From f3a7578c8c53e50c95ed62eba4dcab80e4408b12 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Wed, 17 Apr 2019 14:38:45 +0300 Subject: version 1.3.8.51: bug fix in winder; many fixes in heaters --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- Software/Embedded_SW/Embedded/Main.c | 2 +- .../Embedded/Modules/Heaters/Heaters_print.c | 71 ++++++++++++++++------ .../Embedded/Modules/Thread/Thread_Winder.c | 12 ++-- 4 files changed, 62 insertions(+), 25 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 075f0c5d9..07fbf3ddd 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,8,5}; +TangoVersion_t _gTangoVersion = {1,3,8,51}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 1c368e180..a125ef10c 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -177,7 +177,7 @@ int main(void) #endif #ifdef WATCHDOG - InitWatchdog(ui32SysClock*2); + InitWatchdog(ui32SysClock); #endif CommunicationTaskInit(); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 93048681d..75ed06b05 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -218,7 +218,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) HeaterState->heatertype = HeaterType; HeaterState->has_setpoint = true; HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100; - // HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; + //HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; HeaterState->has_currentvalue = true; HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100; HeaterState->has_isactive = true; @@ -227,11 +227,16 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) HeaterState->isrampingup = 1-HeaterReady[HeaterId]; HeaterState->has_isinsetpoint = true; HeaterState->isinsetpoint = HeaterReady[HeaterId]; - /*if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) { HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit; //HeaterState->isrampingup = InitialHeating; - }*/ + } + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) + { + HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit; + //HeaterState->isrampingup = InitialHeating; + } return; } uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId) @@ -667,10 +672,10 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off"); } DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true; + HeaterMaxTempFlag[index] = true; //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); - HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true; + //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true; //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } @@ -842,17 +847,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } // if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)) + if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; + Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); HeatersControlStart(); @@ -891,15 +897,30 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else //PID active { - if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))) { - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 0; + HeaterPIDConfig[index].m_integral = 0; + } + else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))) + { + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 10000; + HeaterPIDConfig[index].m_integral = 0; } else { - HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } } // len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); @@ -1015,15 +1036,31 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { //check only for the proportional band limits HeaterPIDConfig[index].m_mesuredParam = readValue; - if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))) { - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 0; + HeaterPIDConfig[index].m_integral = 0; + } + else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))) + { + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 10000; + HeaterPIDConfig[index].m_integral = 0; } else { - HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + } // error[index][Counter[index]] = HeaterPIDConfig[index].m_preError; // integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 0b19d835a..70f32ce6d 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -111,12 +111,12 @@ uint32_t Winder_Prepare(void) }*/ if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT) { - REPORT_MSG(LIMIT, "Winder_Prepare at limit"); + //REPORT_MSG(LIMIT, "Winder_Prepare at limit"); Winder_PrepareStage2(0,0); } else { - REPORT_MSG(ScrewSpeed, "Winder_Prepare"); + //REPORT_MSG(ScrewSpeed, "Winder_Prepare"); Winder_ScrewHoming = true; //REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, "Winder_Prepare move to limit"); status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2,2000); @@ -322,7 +322,9 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId) // * calculate // * 1. calculate speed according to JobTicket->processparameters->dyeingspeed // * calculation input: traverse length in milimeters/pulses, number of rotations per traverse ==> length of traverse per rotation. - screw_horizontal_speed = InternalWinderCfg.segmentoffsetpulses / InternalWinderCfg.NumberOfRotationPerPassage; + ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; + ScrewNumberOfSteps -= 100; + screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; // calculation input#2: number of rotations per second - (basically: speed/winder perimeter. later - according to winder actual speed - calculate according to winder position accumulation in the last second. //RotationsPerSecond = dyeingspeed / (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulleyradius * PI); RotationsPerSecond = OriginalMotorSpd_2PPS[WINDER_MOTOR] / MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; @@ -343,10 +345,8 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId) // * 3. calculate cart travel length from winding parameters // * 4. start move of travel length // * 5. register motor nBusy callback. this callback will flip between move(traverse length, hardstop) and goto(0), with handline og the coneshape and adjusting maxspeed - ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; - ScrewNumberOfSteps -= 100; temp = SYS_CLK_FREQ; - temp *= InternalWinderCfg.segmentoffsetpulses; + temp *= ScrewNumberOfSteps; temp /= ScrewSpeed; ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed; REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); -- cgit v1.3.1 From 0cb273ba234d5a2bf420e39eff1f180e95c370e5 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Wed, 17 Apr 2019 16:00:20 +0300 Subject: bug fixes in heaters and IDS --- .../Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 16 +++++++++++----- Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 5 ++++- 2 files changed, 15 insertions(+), 6 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 75ed06b05..84cff942e 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -858,17 +858,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { ////////////////// //InitialHeating = false; - Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); HeatersControlStart(); //////////////////////// - HeaterReady[index] = true; - Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); - Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); AlarmHandlingSetAlarm(HeaterUnderEventType[index], false); - HeaterPrepareReady(); if (BlowerCfg.enabled == true) { Turn_the_Blower_On();//Turn on with the Default_Voltage @@ -877,6 +872,17 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } + if ((HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + { +////////////////// + //InitialHeating = false; + Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); +//////////////////////// + HeaterReady[index] = true; + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + + HeaterPrepareReady(); + } return OK; } if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0)) diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index f3c5ad8da..5ebe10705 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -800,12 +800,14 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId) { REPORT_MSG(DispenserId,"Dispenser PreSegment not configured"); DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added continue; } if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) { REPORT_MSG(DispenserId,"Dispenser PreSegment cleaner or lubricant"); DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added continue; } @@ -823,12 +825,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId) { MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test without valves CurrentDispenserSpeed[DispenserId] = 0; + DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped REPORT_MSG(DispenserId,"Dispenser stopped pre Segment"); } IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added } } - + //Task_sleep(5); return OK; } //******************************************************************************************************************** -- cgit v1.3.1 From 05e6dd6f41a2fc20624d82be6bcc06c245650c6d Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Wed, 17 Apr 2019 16:39:31 +0300 Subject: fix bug in heaters when drier heaters are above 250 --- .../Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 84cff942e..8fe0a9fd8 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -848,11 +848,14 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } // if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000)) - { - ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); - ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - return OK; - } + { + if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) + { + ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + } + return OK; + } if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { -- cgit v1.3.1 From c21f4e667c6812bd447f74431a710d3bcc34133d Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Thu, 18 Apr 2019 15:30:01 +0300 Subject: alarm handling bug --- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 22 ++- .../stubs/technician view files/lp4 Tech Board.tpf | 208 ++++++++++----------- 2 files changed, 117 insertions(+), 113 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 13f0515f9..ec4c81fdb 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -674,21 +674,25 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); event__init(AlarmState[Alarm_i].EventPtr); AlarmState[Alarm_i].EventPtr->has_type = true; AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; - AlarmState[Alarm_i].Status = value; - Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } + AlarmState[Alarm_i].Status = value; + //ROM_IntMasterEnable(); + Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else { Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); } AlarmState[Alarm_i].Status = value; } @@ -923,8 +927,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) // alarm on { - AlarmState[Alarm_i].Status = true; - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) @@ -934,15 +936,21 @@ uint32_t AlarmHandlingLoop(uint32_t tick) AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } + AlarmState[Alarm_i].Status = true; + AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmState[Alarm_i].Status = false; - AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); - // report the alarm! if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); + } + AlarmState[Alarm_i].Status = false; + AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } diff --git a/Software/Stubs Collection/stubs/technician view files/lp4 Tech Board.tpf b/Software/Stubs Collection/stubs/technician view files/lp4 Tech Board.tpf index 4ab568b59..382c31a21 100644 --- a/Software/Stubs Collection/stubs/technician view files/lp4 Tech Board.tpf +++ b/Software/Stubs Collection/stubs/technician view files/lp4 Tech Board.tpf @@ -26,25 +26,11 @@ 0 AFB7B6F7-8FFB-4A7F-B814-04F0C163CAA1 -14774017 - 1 701 - true 0 300 - - - ba743caa-95f2-4b20-8c32-8e5943ada3fc - 144 - 589.78318584070769 - 380 - 194.54867256637203 - 0 - 78482AA4-3DF6-421F-944C-64328D3C3EF2 - -14774017 - 10 - 0 - 70 - true + true + 1 e4892498-fa1a-413c-9dd8-633efaade51c @@ -124,7 +110,7 @@ DryerAirHeater 160 - 167.79999999999998 + 121.55999999999999 false true false @@ -143,7 +129,7 @@ DryerMainHeater 0 - 205.73 + 164.16 true false true @@ -162,8 +148,8 @@ DryerSecondaryHeater 0 - 203.23 - false + 167.2 + true false true @@ -181,7 +167,7 @@ HeaterZone3 110 - 109.38999999999999 + 107.77 false false true @@ -200,7 +186,7 @@ HeaterZone2 100 - 99.279999999999987 + 105.58 false false true @@ -219,7 +205,7 @@ HeaterZone1 80 - 79.51 + 79.52 false false true @@ -238,7 +224,7 @@ MixerHeater 80 - 79.68 + 79.47 false false true @@ -257,8 +243,8 @@ HeaterZone4 120 - 117.99 - false + 116.08 + true false true @@ -276,7 +262,7 @@ HeaterZone5 130 - 130.79 + 127.86 false false true @@ -295,10 +281,10 @@ HeaterZone6 140 - 134.62 + 131.75 true - false - true + true + false 140 @@ -394,6 +380,16 @@ cac03991-b332-4dfa-b491-c0e381b74fb9 -1 + + 929aeb7f-8f42-4a17-9b33-6e6e719b11e6 + 69 + 601.88053097345141 + 347 + 108.42035398230087 + 0 + 0B1752D6-7D4B-4957-BCDE-15465EA8EB55 + -1 + @@ -456,11 +452,11 @@ 0 D126DB23-784B-4F0C-8F88-D89A65A7549F -14774017 - 1 1460 - true 0 16384 + true + 1 984b4126-3dda-4624-a79f-0646eb0e1358 @@ -471,11 +467,11 @@ 0 10102BC3-0EAE-47FF-A8E5-8640780CAA3D -14774017 - 1 1516 - true 0 16384 + true + 1 8ebc3ab7-a02d-4b12-93b3-2563443831d7 @@ -486,11 +482,11 @@ 0 C0BCCD5C-346B-4C4A-A080-39D28E9E1A0C -14774017 - 1 1398 - true 0 16384 + true + 1 acafb268-5e97-4277-8dc8-173250a9e3f8 @@ -501,11 +497,11 @@ 0 9FBC5460-BA59-486B-8D85-BD7D8A959F98 -14774017 - 1 1273 - true 0 100 + true + 1 3ccb1485-b0e9-4d36-a931-a1b3865edeaa @@ -527,11 +523,11 @@ 0 4CE6A82E-D841-4D33-BBB2-11F0743A441C -14774017 - 1 514 - true 0 100000 + true + 1 75b99507-4eba-4b11-b52e-26732d4c5479 @@ -542,11 +538,11 @@ 0 F1DF490B-0577-4FA7-ACA1-0EEF4F934E8F -14774017 - 4 1398 - true 0 100 + true + 4 a30e48de-be76-4230-92d0-d27d6f37b940 @@ -557,11 +553,11 @@ 0 5F12B974-2C9E-4DDD-9B20-733251A5D7E6 -14774017 - 4 1398 - true 0 100 + true + 4 5ac4b368-093a-4192-98d4-e9d24f229b13 @@ -572,11 +568,11 @@ 0 84CF23C9-D20D-4C08-BE1D-80201FC43C06 -14774017 - 4 1398 - true 0 100 + true + 4 9c34dc69-cfaa-48b4-9d02-8f0d9bba79dd @@ -1179,11 +1175,11 @@ 0 D7585119-4A42-4370-8F1E-F3E62553E588 -14774017 - 2 2962 - true 0 300 + true + 2 c4e19f7c-e6e9-4f45-987e-f124456b2529 @@ -1194,11 +1190,11 @@ 0 A8DB1D27-6B25-4FB4-A3F5-46A29BA51955 -14774017 - 3 2817 - true 0 300 + true + 3 b8b24455-1c20-417d-bd78-5fe4c7e3d023 @@ -1209,11 +1205,11 @@ 0 6C0C1AB0-3EE9-40D7-8424-A79436FBC804 -14774017 - 2 2982 - true 0 300 + true + 2 2129a0cd-454f-4834-8197-3b048bf4b978 @@ -1224,11 +1220,11 @@ 0 098F7CAB-030C-46B0-B2B8-A85AF2253032 -14774017 - 2 2949 - true 0 100 + true + 2 892fabb7-01fa-4b39-a19e-a557fafae0ac @@ -1239,11 +1235,11 @@ 0 DACEBF90-E2B4-4CC9-A973-B8B429AA0089 -14774017 - 2 2628 - true 0 300 + true + 2 4859974c-7224-42d5-97ca-0e2e549372f5 @@ -1254,11 +1250,11 @@ 0 246C2551-5EFD-48E9-94F6-6313C5E5018F -14774017 - 2 3153 - true 0 300 + true + 2 81b78212-14d8-4a66-bf3a-eeea9900e0d6 @@ -1329,11 +1325,11 @@ 0 AFB7B6F7-8FFB-4A7F-B814-04F0C163CAA1 -14774017 - 2 3153 - true 0 300 + true + 2 9330a6be-17f1-4ecb-978d-719adf9fec1f @@ -1344,11 +1340,11 @@ 0 9A3877B2-9F98-4A5C-9A93-DECA2836FA8A -14774017 - 2 3153 - true 0 300 + true + 2 3228b2ba-83f3-4eb2-a6d2-7200301758a4 @@ -1382,8 +1378,8 @@ HeaterZone4 120 - 117.99 - false + 116.08 + true false true @@ -1401,7 +1397,7 @@ HeaterZone1 80 - 79.51 + 79.52 false false true @@ -1420,7 +1416,7 @@ HeaterZone3 110 - 109.38999999999999 + 107.77 false false true @@ -1439,7 +1435,7 @@ HeaterZone5 130 - 130.79 + 127.86 false false true @@ -1458,7 +1454,7 @@ MixerHeater 80 - 79.68 + 79.47 false false true @@ -1477,7 +1473,7 @@ HeaterZone2 100 - 99.279999999999987 + 105.58 false false true @@ -1496,10 +1492,10 @@ HeaterZone6 140 - 134.62 + 131.75 true - false - true + true + false 140 @@ -1515,7 +1511,7 @@ DryerAirHeater 160 - 167.79999999999998 + 121.55999999999999 false true false @@ -1547,11 +1543,11 @@ 0 098F7CAB-030C-46B0-B2B8-A85AF2253032 -14774017 - 1 10 - true 0 100 + true + 1 3bf6782d-117d-4589-a1d6-6454b67e3862 @@ -1562,11 +1558,11 @@ 0 6C0C1AB0-3EE9-40D7-8424-A79436FBC804 -14774017 - 1 10 - true 0 300 + true + 1 c7a89d21-7383-4caa-941e-b42e1109b16a @@ -1577,11 +1573,11 @@ 0 246C2551-5EFD-48E9-94F6-6313C5E5018F -14774017 - 1 10 - true 0 300 + true + 1 4c789472-cb4f-4ede-b22a-c733591117c8 @@ -1595,7 +1591,7 @@ HeaterZone3 110 - 109.38999999999999 + 107.77 false false true @@ -1614,8 +1610,8 @@ HeaterZone4 120 - 117.99 - false + 116.08 + true false true @@ -1633,7 +1629,7 @@ HeaterZone5 130 - 130.79 + 127.86 false false true @@ -1793,11 +1789,11 @@ 0 A499E5E0-A812-4032-8F96-B38C6762C4BD -14774017 - 3 1858 - true 0 100 + true + 3 aae29286-81b3-476a-9f58-c0fd246cae96 @@ -1808,11 +1804,11 @@ 0 F33667BD-D9FA-4DC7-BC2C-0E89E60AE4BE -14774017 - 3 1803 - true 0 100 + true + 3 7d94c7c4-1288-4f9d-b0e6-a06794829642 @@ -1895,11 +1891,11 @@ 0 1F0F907A-EC16-4386-AFC8-B2B156F2A822 -14774017 - 3 1833 - true 0 100 + true + 3 1c254a92-c075-453f-9667-cdcc91cf8e6a @@ -1932,11 +1928,11 @@ 0 6B1DF4B0-BCC2-400C-A3B7-31C5119A55BB -14774017 - 3 1833 - true 0 100 + true + 3 0bef6e9d-6da0-4f06-9e1a-c00142bde4c1 @@ -1969,11 +1965,11 @@ 0 19645882-6587-4A50-BD85-AF06617DC654 -14774017 - 3 1850 - true 0 100 + true + 3 39f6a02c-c4d9-47d0-b92d-bdea0ed5d3ce @@ -2041,11 +2037,11 @@ 0 96B89605-F999-43FE-A1CD-2645BFB33A36 -14774017 - 1 10 - true 0 100000 + true + 1 3d0f66be-0002-403d-8d4b-0d49d85c0570 @@ -2056,11 +2052,11 @@ 0 D126DB23-784B-4F0C-8F88-D89A65A7549F -14774017 - 1 10 - true 0 16384 + true + 1 6ce9bf4a-e710-4bc6-bcc1-e8055b77530c @@ -2071,11 +2067,11 @@ 0 FC60060A-3736-4910-B41A-FF6DABDF0E9E -14774017 - 1 10 - true 0 100000 + true + 1 da0aa379-4643-40cb-b990-45574e5545df @@ -2086,11 +2082,11 @@ 0 10102BC3-0EAE-47FF-A8E5-8640780CAA3D -14774017 - 1 10 - true 0 16384 + true + 1 09b31ecb-8eaf-4c70-8057-1a11b5f10bad @@ -2101,11 +2097,11 @@ 0 89B7B89D-8050-4188-B568-35B1910CFB6F -14774017 - 1 10 - true 0 100000 + true + 1 2a970ff9-b593-4df4-977f-7d29ce25d0c6 @@ -2116,11 +2112,11 @@ 0 84CF23C9-D20D-4C08-BE1D-80201FC43C06 -14774017 - 1 10 - true 0 100 + true + 1 eebe8aa9-cff0-45ef-b1dd-d71cbe3b2947 @@ -2167,5 +2163,5 @@ - 6 + 0 \ No newline at end of file -- cgit v1.3.1 From 8e2bd137671dfb6532648ec259c66091379d1240 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Thu, 18 Apr 2019 16:02:36 +0300 Subject: version 1.3.9.1 bug fix in alarm handling: set the alarm info, then call consequent actions --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 2 +- .../configPkg/package/cfg/Embedded_pem4f.c | 23438 ------------------- .../configPkg/package/cfg/Embedded_pem4f.cfg | 268 - .../configPkg/package/cfg/Embedded_pem4f.h | 88 - 5 files changed, 2 insertions(+), 23796 deletions(-) delete mode 100644 Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.c delete mode 100644 Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.cfg delete mode 100644 Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.h (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 97e2b2d61..54c24efa7 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,9,0}; +TangoVersion_t _gTangoVersion = {1,3,9,1}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index ec4c81fdb..6acdf5d67 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -679,8 +679,8 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) AlarmState[Alarm_i].EventPtr->has_type = true; AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + AlarmState[Alarm_i].Status = value; } - AlarmState[Alarm_i].Status = value; //ROM_IntMasterEnable(); Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.c b/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.c deleted file mode 100644 index e99fe5dc5..000000000 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.c +++ /dev/null @@ -1,23438 +0,0 @@ -/* - * Do not modify this file; it is automatically - * generated and any modifications will be overwritten. - * - * @(#) xdc-B06 - */ - -#define __nested__ -#define __config__ - -#include - -/* - * ======== GENERATED SECTIONS ======== - * - * MODULE INCLUDES - * - * INTERNALS - * INHERITS - * VTABLE - * PATCH TABLE - * DECLARATIONS - * OBJECT OFFSETS - * TEMPLATES - * INITIALIZERS - * FUNCTION STUBS - * PROXY BODY - * OBJECT DESCRIPTOR - * VIRTUAL FUNCTIONS - * SYSTEM FUNCTIONS - * PRAGMAS - * - * INITIALIZATION ENTRY POINT - * PROGRAM GLOBALS - * CLINK DIRECTIVES - */ - - -/* - * ======== MODULE INCLUDES ======== - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* - * ======== ti.catalog.arm.cortexm4.tiva.ce.Boot INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.BIOS INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.BIOS_RtsGateProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_BIOS_RtsGateProxy_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_BIOS_RtsGateProxy_Module__; - -/* Module__root__V */ -extern ti_sysbios_BIOS_RtsGateProxy_Module__ ti_sysbios_BIOS_RtsGateProxy_Module__root__V; - -/* @@@ ti_sysbios_knl_Queue_Object__ */ -typedef struct ti_sysbios_knl_Queue_Object__ { - ti_sysbios_knl_Queue_Elem elem; -} ti_sysbios_knl_Queue_Object__; - -/* @@@ ti_sysbios_knl_Queue_Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Queue_Object__ obj; -} ti_sysbios_knl_Queue_Object2__; - -/* @@@ ti_sysbios_knl_Semaphore_Object__ */ -typedef struct ti_sysbios_knl_Semaphore_Object__ { - ti_sysbios_knl_Event_Handle event; - xdc_UInt eventId; - ti_sysbios_knl_Semaphore_Mode mode; - volatile xdc_UInt16 count; - ti_sysbios_knl_Queue_Object__ Object_field_pendQ; -} ti_sysbios_knl_Semaphore_Object__; - -/* @@@ ti_sysbios_knl_Semaphore_Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Semaphore_Object__ obj; -} ti_sysbios_knl_Semaphore_Object2__; - -/* Object__ */ -typedef struct ti_sysbios_gates_GateMutex_Object__ { - const ti_sysbios_gates_GateMutex_Fxns__ *__fxns; - ti_sysbios_knl_Task_Handle owner; - ti_sysbios_knl_Semaphore_Object__ Object_field_sem; -} ti_sysbios_gates_GateMutex_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_gates_GateMutex_Object__ obj; -} ti_sysbios_gates_GateMutex_Object2__; - -/* Object */ -typedef ti_sysbios_gates_GateMutex_Object__ ti_sysbios_BIOS_RtsGateProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_BIOS_RtsGateProxy_Object__ obj; -} ti_sysbios_BIOS_RtsGateProxy_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_BIOS_RtsGateProxy___VERS - #define ti_sysbios_BIOS_RtsGateProxy___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_BIOS_RtsGateProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.family.arm.lm4.Seconds INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.lm4.Timer INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_family_arm_lm4_Timer_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_family_arm_lm4_Timer_Module__; - -/* Module__root__V */ -extern ti_sysbios_family_arm_lm4_Timer_Module__ ti_sysbios_family_arm_lm4_Timer_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_family_arm_lm4_Timer_Object__ { - const ti_sysbios_family_arm_lm4_Timer_Fxns__ *__fxns; - xdc_Bool staticInst; - xdc_Int id; - ti_sysbios_family_arm_lm4_Timer_RunMode runMode; - ti_sysbios_family_arm_lm4_Timer_StartMode startMode; - xdc_UInt period; - ti_sysbios_family_arm_lm4_Timer_PeriodType periodType; - xdc_UInt intNum; - xdc_UArg arg; - ti_sysbios_family_arm_m3_Hwi_FuncPtr tickFxn; - xdc_runtime_Types_FreqHz extFreq; - ti_sysbios_family_arm_m3_Hwi_Handle hwi; - xdc_UInt prevThreshold; - xdc_UInt rollovers; - xdc_UInt savedCurrCount; - xdc_Bool altclk; -} ti_sysbios_family_arm_lm4_Timer_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_family_arm_lm4_Timer_Object__ obj; -} ti_sysbios_family_arm_lm4_Timer_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_family_arm_lm4_Timer___VERS - #define ti_sysbios_family_arm_lm4_Timer___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_family_arm_lm4_Timer___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.family.arm.lm4.TimestampProvider INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_family_arm_m3_Hwi_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_family_arm_m3_Hwi_Module__; - -/* Module__root__V */ -extern ti_sysbios_family_arm_m3_Hwi_Module__ ti_sysbios_family_arm_m3_Hwi_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_family_arm_m3_Hwi_Object__ { - const ti_sysbios_family_arm_m3_Hwi_Fxns__ *__fxns; - xdc_UArg arg; - ti_sysbios_family_arm_m3_Hwi_FuncPtr fxn; - ti_sysbios_family_arm_m3_Hwi_Irp irp; - xdc_UInt8 priority; - xdc_Int16 intNum; - __TA_ti_sysbios_family_arm_m3_Hwi_Instance_State__hookEnv hookEnv; -} ti_sysbios_family_arm_m3_Hwi_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_family_arm_m3_Hwi_Object__ obj; -} ti_sysbios_family_arm_m3_Hwi_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_family_arm_m3_Hwi___VERS - #define ti_sysbios_family_arm_m3_Hwi___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_family_arm_m3_Hwi___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.family.arm.m3.IntrinsicsSupport INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.m3.TaskSupport INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.gates.GateHwi INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_gates_GateHwi_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_gates_GateHwi_Module__; - -/* Module__root__V */ -extern ti_sysbios_gates_GateHwi_Module__ ti_sysbios_gates_GateHwi_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_gates_GateHwi_Object__ { - const ti_sysbios_gates_GateHwi_Fxns__ *__fxns; -} ti_sysbios_gates_GateHwi_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_gates_GateHwi_Object__ obj; -} ti_sysbios_gates_GateHwi_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_gates_GateHwi___VERS - #define ti_sysbios_gates_GateHwi___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_gates_GateHwi___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.gates.GateMutex INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_gates_GateMutex_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_gates_GateMutex_Module__; - -/* Module__root__V */ -extern ti_sysbios_gates_GateMutex_Module__ ti_sysbios_gates_GateMutex_Module__root__V; - -/* <-- ti_sysbios_gates_GateMutex_Object */ - -/* __ParamsPtr */ -#ifdef ti_sysbios_gates_GateMutex___VERS - #define ti_sysbios_gates_GateMutex___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_gates_GateMutex___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.hal.Hwi INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_hal_Hwi_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_hal_Hwi_Module__; - -/* Module__root__V */ -extern ti_sysbios_hal_Hwi_Module__ ti_sysbios_hal_Hwi_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_hal_Hwi_Object__ { - const ti_sysbios_hal_Hwi_Fxns__ *__fxns; - ti_sysbios_hal_Hwi_HwiProxy_Handle pi; -} ti_sysbios_hal_Hwi_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_hal_Hwi_Object__ obj; -} ti_sysbios_hal_Hwi_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_hal_Hwi___VERS - #define ti_sysbios_hal_Hwi___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_hal_Hwi___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.hal.Hwi_HwiProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_hal_Hwi_HwiProxy_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_hal_Hwi_HwiProxy_Module__; - -/* Module__root__V */ -extern ti_sysbios_hal_Hwi_HwiProxy_Module__ ti_sysbios_hal_Hwi_HwiProxy_Module__root__V; - -/* <-- ti_sysbios_family_arm_m3_Hwi_Object */ - -/* Object */ -typedef ti_sysbios_family_arm_m3_Hwi_Object__ ti_sysbios_hal_Hwi_HwiProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_hal_Hwi_HwiProxy_Object__ obj; -} ti_sysbios_hal_Hwi_HwiProxy_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_hal_Hwi_HwiProxy___VERS - #define ti_sysbios_hal_Hwi_HwiProxy___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_hal_Hwi_HwiProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.hal.Seconds INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.hal.Seconds_SecondsProxy INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.heaps.HeapMem INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_heaps_HeapMem_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_heaps_HeapMem_Module__; - -/* Module__root__V */ -extern ti_sysbios_heaps_HeapMem_Module__ ti_sysbios_heaps_HeapMem_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_heaps_HeapMem_Object__ { - const ti_sysbios_heaps_HeapMem_Fxns__ *__fxns; - xdc_runtime_Memory_Size align; - __TA_ti_sysbios_heaps_HeapMem_Instance_State__buf buf; - ti_sysbios_heaps_HeapMem_Header head; - xdc_SizeT minBlockAlign; -} ti_sysbios_heaps_HeapMem_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_heaps_HeapMem_Object__ obj; -} ti_sysbios_heaps_HeapMem_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_heaps_HeapMem___VERS - #define ti_sysbios_heaps_HeapMem___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_heaps_HeapMem___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.heaps.HeapMem_Module_GateProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__; - -/* Module__root__V */ -extern ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__ ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__root__V; - -/* <-- ti_sysbios_gates_GateMutex_Object */ - -/* Object */ -typedef ti_sysbios_gates_GateMutex_Object__ ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__ obj; -} ti_sysbios_heaps_HeapMem_Module_GateProxy_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_heaps_HeapMem_Module_GateProxy___VERS - #define ti_sysbios_heaps_HeapMem_Module_GateProxy___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_heaps_HeapMem_Module_GateProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.io.DEV INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_io_DEV_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_io_DEV_Module__; - -/* Module__root__V */ -extern ti_sysbios_io_DEV_Module__ ti_sysbios_io_DEV_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_io_DEV_Object__ { - xdc_String name; - ti_sysbios_io_DEV_Fxns *fxns; - ti_sysbios_io_DEV_InitFxn initFxn; - xdc_Int devid; - ti_sysbios_io_DEV_DeviceParams *deviceParams; - xdc_Ptr devp; -} ti_sysbios_io_DEV_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_io_DEV_Object__ obj; -} ti_sysbios_io_DEV_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_io_DEV___VERS - #define ti_sysbios_io_DEV___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_io_DEV___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.io.GIO INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_io_GIO_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_io_GIO_Module__; - -/* Module__root__V */ -extern ti_sysbios_io_GIO_Module__ ti_sysbios_io_GIO_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* Object__ */ -typedef struct ti_sysbios_io_GIO_Object__ { - xdc_String name; - xdc_UInt mode; - xdc_UInt model; - xdc_UInt timeout; - xdc_runtime_IHeap_Handle packetHeap; - xdc_runtime_knl_ISync_Handle sync; - xdc_Bool userSync; - xdc_Bool userPackets; - xdc_Ptr packets; - xdc_Int numPackets; - xdc_Int freeCount; - xdc_Int doneCount; - xdc_Int submitCount; - xdc_Ptr fxns; - xdc_Ptr mdChan; - ti_sysbios_knl_Queue_Object__ Object_field_doneList; - ti_sysbios_knl_Queue_Object__ Object_field_freeList; -} ti_sysbios_io_GIO_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_io_GIO_Object__ obj; -} ti_sysbios_io_GIO_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_io_GIO___VERS - #define ti_sysbios_io_GIO___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_io_GIO___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Clock INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Clock_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Clock_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Clock_Module__ ti_sysbios_knl_Clock_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* Object__ */ -typedef struct ti_sysbios_knl_Clock_Object__ { - ti_sysbios_knl_Queue_Elem elem; - xdc_UInt32 timeout; - xdc_UInt32 currTimeout; - xdc_UInt32 period; - volatile xdc_Bool active; - ti_sysbios_knl_Clock_FuncPtr fxn; - xdc_UArg arg; -} ti_sysbios_knl_Clock_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Clock_Object__ obj; -} ti_sysbios_knl_Clock_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Clock___VERS - #define ti_sysbios_knl_Clock___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Clock___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Clock_TimerProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Clock_TimerProxy_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Clock_TimerProxy_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Clock_TimerProxy_Module__ ti_sysbios_knl_Clock_TimerProxy_Module__root__V; - -/* <-- ti_sysbios_family_arm_lm4_Timer_Object */ - -/* Object */ -typedef ti_sysbios_family_arm_lm4_Timer_Object__ ti_sysbios_knl_Clock_TimerProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Clock_TimerProxy_Object__ obj; -} ti_sysbios_knl_Clock_TimerProxy_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Clock_TimerProxy___VERS - #define ti_sysbios_knl_Clock_TimerProxy___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Clock_TimerProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Event INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Event_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Event_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Event_Module__ ti_sysbios_knl_Event_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* Object__ */ -typedef struct ti_sysbios_knl_Event_Object__ { - volatile xdc_UInt postedEvents; - ti_sysbios_knl_Queue_Object__ Object_field_pendQ; -} ti_sysbios_knl_Event_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Event_Object__ obj; -} ti_sysbios_knl_Event_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Event___VERS - #define ti_sysbios_knl_Event___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Event___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Idle INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.knl.Intrinsics INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.knl.Intrinsics_SupportProxy INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.knl.Mailbox INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Mailbox_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Mailbox_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Mailbox_Module__ ti_sysbios_knl_Mailbox_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* <-- ti_sysbios_knl_Semaphore_Object */ - -/* Object__ */ -typedef struct ti_sysbios_knl_Mailbox_Object__ { - xdc_runtime_IHeap_Handle heap; - xdc_SizeT msgSize; - xdc_UInt numMsgs; - xdc_Ptr buf; - xdc_UInt numFreeMsgs; - __TA_ti_sysbios_knl_Mailbox_Instance_State__allocBuf allocBuf; - ti_sysbios_knl_Queue_Object__ Object_field_dataQue; - ti_sysbios_knl_Queue_Object__ Object_field_freeQue; - ti_sysbios_knl_Semaphore_Object__ Object_field_dataSem; - ti_sysbios_knl_Semaphore_Object__ Object_field_freeSem; -} ti_sysbios_knl_Mailbox_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Mailbox_Object__ obj; -} ti_sysbios_knl_Mailbox_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Mailbox___VERS - #define ti_sysbios_knl_Mailbox___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Mailbox___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Queue INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Queue_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Queue_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Queue_Module__ ti_sysbios_knl_Queue_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Queue___VERS - #define ti_sysbios_knl_Queue___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Queue___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Semaphore INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Semaphore_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Semaphore_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Semaphore_Module__ ti_sysbios_knl_Semaphore_Module__root__V; - -/* <-- ti_sysbios_knl_Semaphore_Object */ - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Semaphore___VERS - #define ti_sysbios_knl_Semaphore___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Semaphore___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Swi INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Swi_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Swi_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Swi_Module__ ti_sysbios_knl_Swi_Module__root__V; - -/* Object__ */ -typedef struct ti_sysbios_knl_Swi_Object__ { - ti_sysbios_knl_Queue_Elem qElem; - ti_sysbios_knl_Swi_FuncPtr fxn; - xdc_UArg arg0; - xdc_UArg arg1; - xdc_UInt priority; - xdc_UInt mask; - xdc_Bool posted; - xdc_UInt initTrigger; - xdc_UInt trigger; - ti_sysbios_knl_Queue_Handle readyQ; - __TA_ti_sysbios_knl_Swi_Instance_State__hookEnv hookEnv; -} ti_sysbios_knl_Swi_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Swi_Object__ obj; -} ti_sysbios_knl_Swi_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Swi___VERS - #define ti_sysbios_knl_Swi___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Swi___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Task INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_knl_Task_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_knl_Task_Module__; - -/* Module__root__V */ -extern ti_sysbios_knl_Task_Module__ ti_sysbios_knl_Task_Module__root__V; - -/* <-- ti_sysbios_knl_Queue_Object */ - -/* Object__ */ -typedef struct ti_sysbios_knl_Task_Object__ { - ti_sysbios_knl_Queue_Elem qElem; - volatile xdc_Int priority; - xdc_UInt mask; - xdc_Ptr context; - ti_sysbios_knl_Task_Mode mode; - ti_sysbios_knl_Task_PendElem *pendElem; - xdc_SizeT stackSize; - __TA_ti_sysbios_knl_Task_Instance_State__stack stack; - xdc_runtime_IHeap_Handle stackHeap; - ti_sysbios_knl_Task_FuncPtr fxn; - xdc_UArg arg0; - xdc_UArg arg1; - xdc_Ptr env; - __TA_ti_sysbios_knl_Task_Instance_State__hookEnv hookEnv; - xdc_Bool vitalTaskFlag; - ti_sysbios_knl_Queue_Handle readyQ; - xdc_UInt curCoreId; - xdc_UInt affinity; -} ti_sysbios_knl_Task_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_knl_Task_Object__ obj; -} ti_sysbios_knl_Task_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_knl_Task___VERS - #define ti_sysbios_knl_Task___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_knl_Task___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== ti.sysbios.knl.Task_SupportProxy INTERNALS ======== - */ - - -/* - * ======== ti.sysbios.xdcruntime.SemThreadSupport INTERNALS ======== - */ - -/* Module__ */ -typedef struct ti_sysbios_xdcruntime_SemThreadSupport_Module__ { - xdc_runtime_Types_Link link; -} ti_sysbios_xdcruntime_SemThreadSupport_Module__; - -/* Module__root__V */ -extern ti_sysbios_xdcruntime_SemThreadSupport_Module__ ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V; - -/* <-- ti_sysbios_knl_Semaphore_Object */ - -/* Object__ */ -typedef struct ti_sysbios_xdcruntime_SemThreadSupport_Object__ { - const ti_sysbios_xdcruntime_SemThreadSupport_Fxns__ *__fxns; - ti_sysbios_knl_Semaphore_Object__ Object_field_sem; -} ti_sysbios_xdcruntime_SemThreadSupport_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - ti_sysbios_xdcruntime_SemThreadSupport_Object__ obj; -} ti_sysbios_xdcruntime_SemThreadSupport_Object2__; - -/* __ParamsPtr */ -#ifdef ti_sysbios_xdcruntime_SemThreadSupport___VERS - #define ti_sysbios_xdcruntime_SemThreadSupport___ParamsPtr xdc_UChar* -#else - #define ti_sysbios_xdcruntime_SemThreadSupport___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.Assert INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Core INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Defaults INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Diags INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Error INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Gate INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.HeapStd INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_HeapStd_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_HeapStd_Module__; - -/* Module__root__V */ -extern xdc_runtime_HeapStd_Module__ xdc_runtime_HeapStd_Module__root__V; - -/* Object__ */ -typedef struct xdc_runtime_HeapStd_Object__ { - const xdc_runtime_HeapStd_Fxns__ *__fxns; - xdc_runtime_Memory_Size remainSize; - xdc_runtime_Memory_Size startSize; -} xdc_runtime_HeapStd_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_HeapStd_Object__ obj; -} xdc_runtime_HeapStd_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_HeapStd___VERS - #define xdc_runtime_HeapStd___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_HeapStd___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.Log INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Main INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Main_Module_GateProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_Main_Module_GateProxy_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_Main_Module_GateProxy_Module__; - -/* Module__root__V */ -extern xdc_runtime_Main_Module_GateProxy_Module__ xdc_runtime_Main_Module_GateProxy_Module__root__V; - -/* <-- ti_sysbios_gates_GateHwi_Object */ - -/* Object */ -typedef ti_sysbios_gates_GateHwi_Object__ xdc_runtime_Main_Module_GateProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_Main_Module_GateProxy_Object__ obj; -} xdc_runtime_Main_Module_GateProxy_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_Main_Module_GateProxy___VERS - #define xdc_runtime_Main_Module_GateProxy___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_Main_Module_GateProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.Memory INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Memory_HeapProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_Memory_HeapProxy_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_Memory_HeapProxy_Module__; - -/* Module__root__V */ -extern xdc_runtime_Memory_HeapProxy_Module__ xdc_runtime_Memory_HeapProxy_Module__root__V; - -/* <-- ti_sysbios_heaps_HeapMem_Object */ - -/* Object */ -typedef ti_sysbios_heaps_HeapMem_Object__ xdc_runtime_Memory_HeapProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_Memory_HeapProxy_Object__ obj; -} xdc_runtime_Memory_HeapProxy_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_Memory_HeapProxy___VERS - #define xdc_runtime_Memory_HeapProxy___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_Memory_HeapProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.Registry INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Startup INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.SysMin INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.System INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.System_Module_GateProxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_System_Module_GateProxy_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_System_Module_GateProxy_Module__; - -/* Module__root__V */ -extern xdc_runtime_System_Module_GateProxy_Module__ xdc_runtime_System_Module_GateProxy_Module__root__V; - -/* <-- ti_sysbios_gates_GateHwi_Object */ - -/* Object */ -typedef ti_sysbios_gates_GateHwi_Object__ xdc_runtime_System_Module_GateProxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_System_Module_GateProxy_Object__ obj; -} xdc_runtime_System_Module_GateProxy_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_System_Module_GateProxy___VERS - #define xdc_runtime_System_Module_GateProxy___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_System_Module_GateProxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.System_SupportProxy INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Text INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Timestamp INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.Timestamp_SupportProxy INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.knl.SemThread INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_SemThread_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_SemThread_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_SemThread_Module__ xdc_runtime_knl_SemThread_Module__root__V; - -/* Object__ */ -typedef struct xdc_runtime_knl_SemThread_Object__ { - const xdc_runtime_knl_SemThread_Fxns__ *__fxns; - xdc_runtime_knl_SemThread_Proxy_Handle proxyHandle; -} xdc_runtime_knl_SemThread_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_SemThread_Object__ obj; -} xdc_runtime_knl_SemThread_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_SemThread___VERS - #define xdc_runtime_knl_SemThread___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_SemThread___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.knl.SemThread_Proxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_SemThread_Proxy_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_SemThread_Proxy_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_SemThread_Proxy_Module__ xdc_runtime_knl_SemThread_Proxy_Module__root__V; - -/* <-- ti_sysbios_xdcruntime_SemThreadSupport_Object */ - -/* Object */ -typedef ti_sysbios_xdcruntime_SemThreadSupport_Object__ xdc_runtime_knl_SemThread_Proxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_SemThread_Proxy_Object__ obj; -} xdc_runtime_knl_SemThread_Proxy_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_SemThread_Proxy___VERS - #define xdc_runtime_knl_SemThread_Proxy___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_SemThread_Proxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.knl.Sync INTERNALS ======== - */ - - -/* - * ======== xdc.runtime.knl.SyncGeneric INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_SyncGeneric_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_SyncGeneric_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_SyncGeneric_Module__ xdc_runtime_knl_SyncGeneric_Module__root__V; - -/* Object__ */ -typedef struct xdc_runtime_knl_SyncGeneric_Object__ { - const xdc_runtime_knl_SyncGeneric_Fxns__ *__fxns; - xdc_runtime_knl_SyncGeneric_SignalFunc userSignal; - xdc_UArg signalArg; - xdc_runtime_knl_SyncGeneric_WaitFunc userWait; - xdc_UArg waitArg; - xdc_runtime_knl_SyncGeneric_QueryFunc userQuery; -} xdc_runtime_knl_SyncGeneric_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_SyncGeneric_Object__ obj; -} xdc_runtime_knl_SyncGeneric_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_SyncGeneric___VERS - #define xdc_runtime_knl_SyncGeneric___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_SyncGeneric___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.knl.SyncNull INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_SyncNull_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_SyncNull_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_SyncNull_Module__ xdc_runtime_knl_SyncNull_Module__root__V; - -/* Object__ */ -typedef struct xdc_runtime_knl_SyncNull_Object__ { - const xdc_runtime_knl_SyncNull_Fxns__ *__fxns; -} xdc_runtime_knl_SyncNull_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_SyncNull_Object__ obj; -} xdc_runtime_knl_SyncNull_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_SyncNull___VERS - #define xdc_runtime_knl_SyncNull___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_SyncNull___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.knl.SyncSemThread INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_SyncSemThread_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_SyncSemThread_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_SyncSemThread_Module__ xdc_runtime_knl_SyncSemThread_Module__root__V; - -/* Object__ */ -typedef struct xdc_runtime_knl_SyncSemThread_Object__ { - const xdc_runtime_knl_SyncSemThread_Fxns__ *__fxns; - xdc_runtime_knl_SemThread_Handle semThread; -} xdc_runtime_knl_SyncSemThread_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_SyncSemThread_Object__ obj; -} xdc_runtime_knl_SyncSemThread_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_SyncSemThread___VERS - #define xdc_runtime_knl_SyncSemThread___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_SyncSemThread___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== xdc.runtime.knl.Sync_Proxy INTERNALS ======== - */ - -/* Module__ */ -typedef struct xdc_runtime_knl_Sync_Proxy_Module__ { - xdc_runtime_Types_Link link; -} xdc_runtime_knl_Sync_Proxy_Module__; - -/* Module__root__V */ -extern xdc_runtime_knl_Sync_Proxy_Module__ xdc_runtime_knl_Sync_Proxy_Module__root__V; - -/* <-- xdc_runtime_knl_SyncNull_Object */ - -/* Object */ -typedef xdc_runtime_knl_SyncNull_Object__ xdc_runtime_knl_Sync_Proxy_Object__; - -/* Object2__ */ -typedef struct { - xdc_runtime_Types_InstHdr hdr; - xdc_runtime_knl_Sync_Proxy_Object__ obj; -} xdc_runtime_knl_Sync_Proxy_Object2__; - -/* __ParamsPtr */ -#ifdef xdc_runtime_knl_Sync_Proxy___VERS - #define xdc_runtime_knl_Sync_Proxy___ParamsPtr xdc_UChar* -#else - #define xdc_runtime_knl_Sync_Proxy___ParamsPtr xdc_Ptr -#endif - - -/* - * ======== INHERITS ======== - */ - -#pragma DATA_SECTION(xdc_runtime_IHeap_Interface__BASE__C, ".const:xdc_runtime_IHeap_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_IHeap_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(xdc_runtime_knl_ISemaphore_Interface__BASE__C, ".const:xdc_runtime_knl_ISemaphore_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_knl_ISemaphore_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(xdc_runtime_ISystemSupport_Interface__BASE__C, ".const:xdc_runtime_ISystemSupport_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_ISystemSupport_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(ti_sysbios_interfaces_IIntrinsicsSupport_Interface__BASE__C, ".const:ti_sysbios_interfaces_IIntrinsicsSupport_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base ti_sysbios_interfaces_IIntrinsicsSupport_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(xdc_runtime_IGateProvider_Interface__BASE__C, ".const:xdc_runtime_IGateProvider_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_IGateProvider_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(ti_sysbios_interfaces_ISeconds_Interface__BASE__C, ".const:ti_sysbios_interfaces_ISeconds_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base ti_sysbios_interfaces_ISeconds_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(xdc_runtime_knl_ISync_Interface__BASE__C, ".const:xdc_runtime_knl_ISync_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_knl_ISync_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - -#pragma DATA_SECTION(xdc_runtime_IModule_Interface__BASE__C, ".const:xdc_runtime_IModule_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_IModule_Interface__BASE__C = {0}; - -#pragma DATA_SECTION(xdc_runtime_ITimestampClient_Interface__BASE__C, ".const:xdc_runtime_ITimestampClient_Interface__BASE__C"); -__FAR__ const xdc_runtime_Types_Base xdc_runtime_ITimestampClient_Interface__BASE__C = {(void*)&xdc_runtime_IModule_Interface__BASE__C}; - - -/* - * ======== ti.sysbios.family.arm.lm4.Seconds VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__FXNS__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__FXNS__C"); -const ti_sysbios_family_arm_lm4_Seconds_Fxns__ ti_sysbios_family_arm_lm4_Seconds_Module__FXNS__C = { - (void*)&ti_sysbios_interfaces_ISeconds_Interface__BASE__C, /* __base */ - &ti_sysbios_family_arm_lm4_Seconds_Module__FXNS__C.__sfxns, /* __sysp */ - ti_sysbios_family_arm_lm4_Seconds_get__E, - ti_sysbios_family_arm_lm4_Seconds_getTime__E, - ti_sysbios_family_arm_lm4_Seconds_set__E, - { - NULL, /* __create */ - NULL, /* __delete */ - NULL, /* __label */ - 0x802e, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== ti.sysbios.family.arm.m3.IntrinsicsSupport VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__FXNS__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__FXNS__C"); -const ti_sysbios_family_arm_m3_IntrinsicsSupport_Fxns__ ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__FXNS__C = { - (void*)&ti_sysbios_interfaces_IIntrinsicsSupport_Interface__BASE__C, /* __base */ - &ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__FXNS__C.__sfxns, /* __sysp */ - ti_sysbios_family_arm_m3_IntrinsicsSupport_maxbit__E, - { - NULL, /* __create */ - NULL, /* __delete */ - NULL, /* __label */ - 0x801e, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== ti.sysbios.gates.GateHwi VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__FXNS__C, ".const:ti_sysbios_gates_GateHwi_Module__FXNS__C"); -const ti_sysbios_gates_GateHwi_Fxns__ ti_sysbios_gates_GateHwi_Module__FXNS__C = { - (void*)&xdc_runtime_IGateProvider_Interface__BASE__C, /* __base */ - &ti_sysbios_gates_GateHwi_Module__FXNS__C.__sfxns, /* __sysp */ - ti_sysbios_gates_GateHwi_query__E, - ti_sysbios_gates_GateHwi_enter__E, - ti_sysbios_gates_GateHwi_leave__E, - { - ti_sysbios_gates_GateHwi_Object__create__S, - ti_sysbios_gates_GateHwi_Object__delete__S, - ti_sysbios_gates_GateHwi_Handle__label__S, - 0x803b, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== ti.sysbios.gates.GateMutex VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__FXNS__C, ".const:ti_sysbios_gates_GateMutex_Module__FXNS__C"); -const ti_sysbios_gates_GateMutex_Fxns__ ti_sysbios_gates_GateMutex_Module__FXNS__C = { - (void*)&xdc_runtime_IGateProvider_Interface__BASE__C, /* __base */ - &ti_sysbios_gates_GateMutex_Module__FXNS__C.__sfxns, /* __sysp */ - ti_sysbios_gates_GateMutex_query__E, - ti_sysbios_gates_GateMutex_enter__E, - ti_sysbios_gates_GateMutex_leave__E, - { - ti_sysbios_gates_GateMutex_Object__create__S, - ti_sysbios_gates_GateMutex_Object__delete__S, - ti_sysbios_gates_GateMutex_Handle__label__S, - 0x803c, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== ti.sysbios.heaps.HeapMem VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__FXNS__C, ".const:ti_sysbios_heaps_HeapMem_Module__FXNS__C"); -const ti_sysbios_heaps_HeapMem_Fxns__ ti_sysbios_heaps_HeapMem_Module__FXNS__C = { - (void*)&xdc_runtime_IHeap_Interface__BASE__C, /* __base */ - &ti_sysbios_heaps_HeapMem_Module__FXNS__C.__sfxns, /* __sysp */ - ti_sysbios_heaps_HeapMem_alloc__E, - ti_sysbios_heaps_HeapMem_free__E, - ti_sysbios_heaps_HeapMem_isBlocking__E, - ti_sysbios_heaps_HeapMem_getStats__E, - { - ti_sysbios_heaps_HeapMem_Object__create__S, - ti_sysbios_heaps_HeapMem_Object__delete__S, - ti_sysbios_heaps_HeapMem_Handle__label__S, - 0x8040, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.HeapStd VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__FXNS__C, ".const:xdc_runtime_HeapStd_Module__FXNS__C"); -const xdc_runtime_HeapStd_Fxns__ xdc_runtime_HeapStd_Module__FXNS__C = { - (void*)&xdc_runtime_IHeap_Interface__BASE__C, /* __base */ - &xdc_runtime_HeapStd_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_HeapStd_alloc__E, - xdc_runtime_HeapStd_free__E, - xdc_runtime_HeapStd_isBlocking__E, - xdc_runtime_HeapStd_getStats__E, - { - xdc_runtime_HeapStd_Object__create__S, - xdc_runtime_HeapStd_Object__delete__S, - xdc_runtime_HeapStd_Handle__label__S, - 0x800b, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.SysMin VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__FXNS__C, ".const:xdc_runtime_SysMin_Module__FXNS__C"); -const xdc_runtime_SysMin_Fxns__ xdc_runtime_SysMin_Module__FXNS__C = { - (void*)&xdc_runtime_ISystemSupport_Interface__BASE__C, /* __base */ - &xdc_runtime_SysMin_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_SysMin_abort__E, - xdc_runtime_SysMin_exit__E, - xdc_runtime_SysMin_flush__E, - xdc_runtime_SysMin_putch__E, - xdc_runtime_SysMin_ready__E, - { - NULL, /* __create */ - NULL, /* __delete */ - NULL, /* __label */ - 0x800f, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.Timestamp VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__FXNS__C, ".const:xdc_runtime_Timestamp_Module__FXNS__C"); -const xdc_runtime_Timestamp_Fxns__ xdc_runtime_Timestamp_Module__FXNS__C = { - (void*)&xdc_runtime_ITimestampClient_Interface__BASE__C, /* __base */ - &xdc_runtime_Timestamp_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_Timestamp_get32__E, - xdc_runtime_Timestamp_get64__E, - xdc_runtime_Timestamp_getFreq__E, - { - NULL, /* __create */ - NULL, /* __delete */ - NULL, /* __label */ - 0x8011, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.knl.SemThread VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__FXNS__C, ".const:xdc_runtime_knl_SemThread_Module__FXNS__C"); -const xdc_runtime_knl_SemThread_Fxns__ xdc_runtime_knl_SemThread_Module__FXNS__C = { - (void*)&xdc_runtime_knl_ISemaphore_Interface__BASE__C, /* __base */ - &xdc_runtime_knl_SemThread_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_knl_SemThread_pend__E, - xdc_runtime_knl_SemThread_post__E, - { - xdc_runtime_knl_SemThread_Object__create__S, - xdc_runtime_knl_SemThread_Object__delete__S, - xdc_runtime_knl_SemThread_Handle__label__S, - 0x8033, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.knl.SyncGeneric VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__FXNS__C, ".const:xdc_runtime_knl_SyncGeneric_Module__FXNS__C"); -const xdc_runtime_knl_SyncGeneric_Fxns__ xdc_runtime_knl_SyncGeneric_Module__FXNS__C = { - (void*)&xdc_runtime_knl_ISync_Interface__BASE__C, /* __base */ - &xdc_runtime_knl_SyncGeneric_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_knl_SyncGeneric_query__E, - xdc_runtime_knl_SyncGeneric_signal__E, - xdc_runtime_knl_SyncGeneric_wait__E, - { - xdc_runtime_knl_SyncGeneric_Object__create__S, - xdc_runtime_knl_SyncGeneric_Object__delete__S, - xdc_runtime_knl_SyncGeneric_Handle__label__S, - 0x8034, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.knl.SyncNull VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__FXNS__C, ".const:xdc_runtime_knl_SyncNull_Module__FXNS__C"); -const xdc_runtime_knl_SyncNull_Fxns__ xdc_runtime_knl_SyncNull_Module__FXNS__C = { - (void*)&xdc_runtime_knl_ISync_Interface__BASE__C, /* __base */ - &xdc_runtime_knl_SyncNull_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_knl_SyncNull_query__E, - xdc_runtime_knl_SyncNull_signal__E, - xdc_runtime_knl_SyncNull_wait__E, - { - xdc_runtime_knl_SyncNull_Object__create__S, - xdc_runtime_knl_SyncNull_Object__delete__S, - xdc_runtime_knl_SyncNull_Handle__label__S, - 0x8035, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== xdc.runtime.knl.SyncSemThread VTABLE ======== - */ - -/* Module__FXNS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__FXNS__C, ".const:xdc_runtime_knl_SyncSemThread_Module__FXNS__C"); -const xdc_runtime_knl_SyncSemThread_Fxns__ xdc_runtime_knl_SyncSemThread_Module__FXNS__C = { - (void*)&xdc_runtime_knl_ISync_Interface__BASE__C, /* __base */ - &xdc_runtime_knl_SyncSemThread_Module__FXNS__C.__sfxns, /* __sysp */ - xdc_runtime_knl_SyncSemThread_query__E, - xdc_runtime_knl_SyncSemThread_signal__E, - xdc_runtime_knl_SyncSemThread_wait__E, - { - xdc_runtime_knl_SyncSemThread_Object__create__S, - xdc_runtime_knl_SyncSemThread_Object__delete__S, - xdc_runtime_knl_SyncSemThread_Handle__label__S, - 0x8036, /* __mid */ - } /* __sfxns */ -}; - - -/* - * ======== ti.catalog.arm.cortexm4.tiva.ce.Boot DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.BIOS DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct ti_sysbios_BIOS_Module_State__ { - xdc_runtime_Types_FreqHz cpuFreq; - xdc_UInt rtsGateCount; - xdc_IArg rtsGateKey; - ti_sysbios_BIOS_RtsGateProxy_Handle rtsGate; - ti_sysbios_BIOS_ThreadType threadType; - __TA_ti_sysbios_BIOS_Module_State__smpThreadType smpThreadType; - volatile ti_sysbios_BIOS_StartFuncPtr startFunc; - volatile ti_sysbios_BIOS_ExitFuncPtr exitFunc; -} ti_sysbios_BIOS_Module_State__; - -/* --> ti_sysbios_BIOS_startFunc */ -extern xdc_Void ti_sysbios_BIOS_startFunc(xdc_Void); - -/* --> ti_sysbios_BIOS_exitFunc */ -extern xdc_Void ti_sysbios_BIOS_exitFunc(xdc_Int); - -/* Module__state__V */ -ti_sysbios_BIOS_Module_State__ ti_sysbios_BIOS_Module__state__V; - - -/* - * ======== ti.sysbios.BIOS_RtsGateProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.lm4.Seconds DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct ti_sysbios_family_arm_lm4_Seconds_Module_State__ { - xdc_UInt32 setSeconds; - xdc_UInt32 refSeconds; -} ti_sysbios_family_arm_lm4_Seconds_Module_State__; - -/* Module__state__V */ -ti_sysbios_family_arm_lm4_Seconds_Module_State__ ti_sysbios_family_arm_lm4_Seconds_Module__state__V; - - -/* - * ======== ti.sysbios.family.arm.lm4.Timer DECLARATIONS ======== - */ - -/* Object__table__V */ -ti_sysbios_family_arm_lm4_Timer_Object__ ti_sysbios_family_arm_lm4_Timer_Object__table__V[1]; - -/* Module_State__ */ -typedef struct ti_sysbios_family_arm_lm4_Timer_Module_State__ { - xdc_UInt availMask; - __TA_ti_sysbios_family_arm_lm4_Timer_Module_State__device device; - __TA_ti_sysbios_family_arm_lm4_Timer_Module_State__handles handles; -} ti_sysbios_family_arm_lm4_Timer_Module_State__; - -/* --> ti_sysbios_family_arm_lm4_Timer_Module_State_0_device__A */ -__T1_ti_sysbios_family_arm_lm4_Timer_Module_State__device ti_sysbios_family_arm_lm4_Timer_Module_State_0_device__A[8]; - -/* --> ti_sysbios_family_arm_lm4_Timer_Module_State_0_handles__A */ -__T1_ti_sysbios_family_arm_lm4_Timer_Module_State__handles ti_sysbios_family_arm_lm4_Timer_Module_State_0_handles__A[8]; - -/* Module__state__V */ -ti_sysbios_family_arm_lm4_Timer_Module_State__ ti_sysbios_family_arm_lm4_Timer_Module__state__V; - -/* --> ti_sysbios_family_arm_lm4_Timer_enableTiva */ -extern xdc_Void ti_sysbios_family_arm_lm4_Timer_enableTiva(xdc_Int); - -/* --> ti_sysbios_family_arm_lm4_Timer_disableTiva */ -extern xdc_Void ti_sysbios_family_arm_lm4_Timer_disableTiva(xdc_Int); - - -/* - * ======== ti.sysbios.family.arm.lm4.TimestampProvider DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct ti_sysbios_family_arm_lm4_TimestampProvider_Module_State__ { - ti_sysbios_family_arm_lm4_Timer_Handle timer; - volatile xdc_UInt32 hi; -} ti_sysbios_family_arm_lm4_TimestampProvider_Module_State__; - -/* Module__state__V */ -ti_sysbios_family_arm_lm4_TimestampProvider_Module_State__ ti_sysbios_family_arm_lm4_TimestampProvider_Module__state__V; - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi DECLARATIONS ======== - */ - -/* --> ADC0SS0Handler */ -extern xdc_Void ADC0SS0Handler(xdc_UArg); - -/* --> SysTickHandler */ -extern xdc_Void SysTickHandler(xdc_UArg); - -/* --> PortPIntHandler */ -extern xdc_Void PortPIntHandler(xdc_UArg); - -/* --> OneMilliSecondControlInterrupt */ -extern xdc_Void OneMilliSecondControlInterrupt(xdc_UArg); - -/* --> WatchdogIntHandler */ -extern xdc_Void WatchdogIntHandler(xdc_UArg); - -/* --> EightMilliSecondHeatersInterrupt */ -extern xdc_Void EightMilliSecondHeatersInterrupt(xdc_UArg); - -/* --> OneMilliSecondMillisecInterrupt */ -extern xdc_Void OneMilliSecondMillisecInterrupt(xdc_UArg); - -/* --> ScrewTimerInterrupt */ -extern xdc_Void ScrewTimerInterrupt(xdc_UArg); - -/* Object__table__V */ -ti_sysbios_family_arm_m3_Hwi_Object__ ti_sysbios_family_arm_m3_Hwi_Object__table__V[9]; - -/* Module_State__ */ -typedef struct ti_sysbios_family_arm_m3_Hwi_Module_State__ { - xdc_Char *taskSP; - __TA_ti_sysbios_family_arm_m3_Hwi_Module_State__excActive excActive; - __TA_ti_sysbios_family_arm_m3_Hwi_Module_State__excContext excContext; - __TA_ti_sysbios_family_arm_m3_Hwi_Module_State__excStack excStack; - xdc_Ptr isrStack; - xdc_Ptr isrStackBase; - xdc_SizeT isrStackSize; - xdc_Ptr vectorTableBase; - xdc_UInt swiTaskKeys; - xdc_Ptr dispatchTable; - volatile xdc_Bool vnvicFlushRequired; - __TA_ti_sysbios_family_arm_m3_Hwi_Module_State__intAffinity intAffinity; - __TA_ti_sysbios_family_arm_m3_Hwi_Module_State__intAffinityMasks intAffinityMasks; -} ti_sysbios_family_arm_m3_Hwi_Module_State__; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excActive__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excActive ti_sysbios_family_arm_m3_Hwi_Module_State_0_excActive__A[1]; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excContext__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excContext ti_sysbios_family_arm_m3_Hwi_Module_State_0_excContext__A[1]; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excStack__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excStack ti_sysbios_family_arm_m3_Hwi_Module_State_0_excStack__A[1]; - -/* --> __TI_STACK_BASE */ -extern void* __TI_STACK_BASE; - -/* Module__state__V */ -ti_sysbios_family_arm_m3_Hwi_Module_State__ ti_sysbios_family_arm_m3_Hwi_Module__state__V; - -/* --> ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A */ -const __T1_ti_sysbios_family_arm_m3_Hwi_excHookFuncs ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A[2]; - -/* --> ti_sysbios_knl_Swi_disable__E */ -extern xdc_UInt ti_sysbios_knl_Swi_disable__E(xdc_Void); - -/* --> ti_sysbios_knl_Swi_restoreHwi__E */ -extern xdc_Void ti_sysbios_knl_Swi_restoreHwi__E(xdc_UInt); - -/* --> ti_sysbios_knl_Task_disable__E */ -extern xdc_UInt ti_sysbios_knl_Task_disable__E(xdc_Void); - -/* --> ti_sysbios_knl_Task_restoreHwi__E */ -extern xdc_Void ti_sysbios_knl_Task_restoreHwi__E(xdc_UInt); - - -/* - * ======== ti.sysbios.family.arm.m3.IntrinsicsSupport DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.m3.TaskSupport DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.gates.GateHwi DECLARATIONS ======== - */ - -/* Object__table__V */ -ti_sysbios_gates_GateHwi_Object__ ti_sysbios_gates_GateHwi_Object__table__V[1]; - - -/* - * ======== ti.sysbios.gates.GateMutex DECLARATIONS ======== - */ - -/* Object__table__V */ -ti_sysbios_gates_GateMutex_Object__ ti_sysbios_gates_GateMutex_Object__table__V[2]; - - -/* - * ======== ti.sysbios.hal.Hwi DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.hal.Hwi_HwiProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.hal.Seconds DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.hal.Seconds_SecondsProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.heaps.HeapMem DECLARATIONS ======== - */ - -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif -/* --> ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A */ -__T1_ti_sysbios_heaps_HeapMem_Instance_State__buf ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A[30760]; -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_heaps_HeapMem_Instance_State__buf ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A[30760] __attribute__ ((aligned(8))); -#endif -#endif - -/* Object__table__V */ -ti_sysbios_heaps_HeapMem_Object__ ti_sysbios_heaps_HeapMem_Object__table__V[1]; - - -/* - * ======== ti.sysbios.heaps.HeapMem_Module_GateProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.io.DEV DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct ti_sysbios_io_DEV_Module_State__ { - __TA_ti_sysbios_io_DEV_Module_State__table table; -} ti_sysbios_io_DEV_Module_State__; - -/* --> ti_sysbios_io_DEV_Module_State_0_table__A */ -__T1_ti_sysbios_io_DEV_Module_State__table ti_sysbios_io_DEV_Module_State_0_table__A[8]; - -/* Module__state__V */ -ti_sysbios_io_DEV_Module_State__ ti_sysbios_io_DEV_Module__state__V; - - -/* - * ======== ti.sysbios.io.GIO DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Clock DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct ti_sysbios_knl_Clock_Module_State__ { - volatile xdc_UInt32 ticks; - xdc_UInt swiCount; - ti_sysbios_knl_Clock_TimerProxy_Handle timer; - ti_sysbios_knl_Swi_Handle swi; - volatile xdc_UInt numTickSkip; - xdc_UInt32 nextScheduledTick; - xdc_UInt32 maxSkippable; - xdc_Bool inWorkFunc; - xdc_Bool startDuringWorkFunc; - xdc_Bool ticking; - ti_sysbios_knl_Queue_Object__ Object_field_clockQ; -} ti_sysbios_knl_Clock_Module_State__; - -/* Module__state__V */ -ti_sysbios_knl_Clock_Module_State__ ti_sysbios_knl_Clock_Module__state__V; - -/* --> ti_sysbios_knl_Clock_doTick__I */ -extern xdc_Void ti_sysbios_knl_Clock_doTick__I(xdc_UArg); - - -/* - * ======== ti.sysbios.knl.Clock_TimerProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Event DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Idle DECLARATIONS ======== - */ - -/* --> ti_sysbios_hal_Hwi_checkStack */ -extern xdc_Void ti_sysbios_hal_Hwi_checkStack(xdc_Void); - -/* --> ti_sysbios_knl_Idle_funcList__A */ -const __T1_ti_sysbios_knl_Idle_funcList ti_sysbios_knl_Idle_funcList__A[1]; - -/* --> ti_sysbios_knl_Idle_coreList__A */ -const __T1_ti_sysbios_knl_Idle_coreList ti_sysbios_knl_Idle_coreList__A[1]; - - -/* - * ======== ti.sysbios.knl.Intrinsics DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Intrinsics_SupportProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Mailbox DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Queue DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.knl.Semaphore DECLARATIONS ======== - */ - -/* Object__table__V */ -ti_sysbios_knl_Semaphore_Object__ ti_sysbios_knl_Semaphore_Object__table__V[4]; - - -/* - * ======== ti.sysbios.knl.Swi DECLARATIONS ======== - */ - -/* Object__table__V */ -ti_sysbios_knl_Swi_Object__ ti_sysbios_knl_Swi_Object__table__V[1]; - -/* Module_State__ */ -typedef struct ti_sysbios_knl_Swi_Module_State__ { - volatile xdc_Bool locked; - xdc_UInt curSet; - xdc_UInt curTrigger; - ti_sysbios_knl_Swi_Handle curSwi; - ti_sysbios_knl_Queue_Handle curQ; - __TA_ti_sysbios_knl_Swi_Module_State__readyQ readyQ; - __TA_ti_sysbios_knl_Swi_Module_State__constructedSwis constructedSwis; -} ti_sysbios_knl_Swi_Module_State__; - -/* --> ti_sysbios_knl_Swi_Module_State_0_readyQ__A */ -__T1_ti_sysbios_knl_Swi_Module_State__readyQ ti_sysbios_knl_Swi_Module_State_0_readyQ__A[16]; - -/* Module__state__V */ -ti_sysbios_knl_Swi_Module_State__ ti_sysbios_knl_Swi_Module__state__V; - -/* --> ti_sysbios_knl_Task_disable__E */ -extern xdc_UInt ti_sysbios_knl_Task_disable__E(xdc_Void); - -/* --> ti_sysbios_knl_Task_restore__E */ -extern xdc_Void ti_sysbios_knl_Task_restore__E(xdc_UInt); - - -/* - * ======== ti.sysbios.knl.Task DECLARATIONS ======== - */ - -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif -/* --> ti_sysbios_knl_Task_Instance_State_0_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_0_stack__A[2048]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_0_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_0_stack__A[2048] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_0_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_0_stack__A[2048] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> MillisecTask */ -extern xdc_Void MillisecTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_1_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_1_stack__A[2048]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_1_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_1_stack__A[2048] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_1_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_1_stack__A[2048] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> controlTask */ -extern xdc_Void controlTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_2_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_2_stack__A[1024]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_2_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_2_stack__A[1024] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_2_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_2_stack__A[1024] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> AlarmHandlingTask */ -extern xdc_Void AlarmHandlingTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_3_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_3_stack__A[4096]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_3_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_3_stack__A[4096] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_3_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_3_stack__A[4096] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> communicationTxTask */ -extern xdc_Void communicationTxTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_4_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_4_stack__A[2048]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_4_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_4_stack__A[2048] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_4_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_4_stack__A[2048] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> jobTask */ -extern xdc_Void jobTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_5_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_5_stack__A[1024]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_5_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_5_stack__A[1024] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_5_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_5_stack__A[1024] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> HeatersControlTask */ -extern xdc_Void HeatersControlTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_6_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_6_stack__A[8192]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_6_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_6_stack__A[8192] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_6_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_6_stack__A[8192] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> communicationTask */ -extern xdc_Void communicationTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_7_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_7_stack__A[2048]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_7_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_7_stack__A[2048] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_7_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_7_stack__A[2048] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> MillisecLowTask */ -extern xdc_Void MillisecLowTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_8_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_8_stack__A[2048]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_8_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_8_stack__A[2048] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_8_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_8_stack__A[2048] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> controlLowTask */ -extern xdc_Void controlLowTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_9_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_9_stack__A[8192]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_9_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_9_stack__A[8192] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_9_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_9_stack__A[8192] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> DiagnosticsTask */ -extern xdc_Void DiagnosticsTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_10_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_10_stack__A[512]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_10_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_10_stack__A[512] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_10_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_10_stack__A[512] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> ADCProcessTask */ -extern xdc_Void ADCProcessTask(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_11_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_11_stack__A[1024]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_11_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_11_stack__A[1024] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_11_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_11_stack__A[1024] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> reportService */ -extern xdc_Void reportService(xdc_UArg,xdc_UArg); -#ifdef __IAR_SYSTEMS_ICC__ - #pragma data_alignment=8 -#endif - -/* --> ti_sysbios_knl_Task_Instance_State_12_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_12_stack__A[1024]; -#ifdef __ti__sect - #pragma DATA_SECTION(ti_sysbios_knl_Task_Instance_State_12_stack__A, ".bss:taskStackSection"); -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_12_stack__A[1024] __attribute__ ((section(".bss:taskStackSection"))); -#endif -#endif -#ifdef __ti__align - #pragma DATA_ALIGN(ti_sysbios_knl_Task_Instance_State_12_stack__A, 8); -#endif -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_12_stack__A[1024] __attribute__ ((aligned(8))); -#endif -#endif - -/* --> updateTask */ -extern xdc_Void updateTask(xdc_UArg,xdc_UArg); - -/* Object__table__V */ -ti_sysbios_knl_Task_Object__ ti_sysbios_knl_Task_Object__table__V[13]; - -/* Module_State__ */ -typedef struct ti_sysbios_knl_Task_Module_State__ { - volatile xdc_Bool locked; - volatile xdc_UInt curSet; - xdc_Bool workFlag; - xdc_UInt vitalTasks; - ti_sysbios_knl_Task_Handle curTask; - ti_sysbios_knl_Queue_Handle curQ; - __TA_ti_sysbios_knl_Task_Module_State__readyQ readyQ; - __TA_ti_sysbios_knl_Task_Module_State__smpCurSet smpCurSet; - __TA_ti_sysbios_knl_Task_Module_State__smpCurMask smpCurMask; - __TA_ti_sysbios_knl_Task_Module_State__smpCurTask smpCurTask; - __TA_ti_sysbios_knl_Task_Module_State__smpReadyQ smpReadyQ; - __TA_ti_sysbios_knl_Task_Module_State__idleTask idleTask; - __TA_ti_sysbios_knl_Task_Module_State__constructedTasks constructedTasks; - ti_sysbios_knl_Queue_Object__ Object_field_inactiveQ; - ti_sysbios_knl_Queue_Object__ Object_field_terminatedQ; -} ti_sysbios_knl_Task_Module_State__; - -/* --> ti_sysbios_knl_Task_Module_State_0_readyQ__A */ -__T1_ti_sysbios_knl_Task_Module_State__readyQ ti_sysbios_knl_Task_Module_State_0_readyQ__A[16]; - -/* --> ti_sysbios_knl_Task_Module_State_0_idleTask__A */ -__T1_ti_sysbios_knl_Task_Module_State__idleTask ti_sysbios_knl_Task_Module_State_0_idleTask__A[1]; - -/* Module__state__V */ -ti_sysbios_knl_Task_Module_State__ ti_sysbios_knl_Task_Module__state__V; - - -/* - * ======== ti.sysbios.knl.Task_SupportProxy DECLARATIONS ======== - */ - - -/* - * ======== ti.sysbios.xdcruntime.SemThreadSupport DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Assert DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Core DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Defaults DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Diags DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Error DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_Error_Module_State__ { - xdc_UInt16 count; -} xdc_runtime_Error_Module_State__; - -/* Module__state__V */ -xdc_runtime_Error_Module_State__ xdc_runtime_Error_Module__state__V; - - -/* - * ======== xdc.runtime.Gate DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.HeapStd DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_HeapStd_Module_State__ { - xdc_runtime_Memory_Size remainRTSSize; -} xdc_runtime_HeapStd_Module_State__; - -/* Module__state__V */ -xdc_runtime_HeapStd_Module_State__ xdc_runtime_HeapStd_Module__state__V; - - -/* - * ======== xdc.runtime.Log DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Main DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Main_Module_GateProxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Memory DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_Memory_Module_State__ { - xdc_SizeT maxDefaultTypeAlign; -} xdc_runtime_Memory_Module_State__; - -/* Module__state__V */ -xdc_runtime_Memory_Module_State__ xdc_runtime_Memory_Module__state__V; - - -/* - * ======== xdc.runtime.Memory_HeapProxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Registry DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_Registry_Module_State__ { - xdc_runtime_Registry_Desc *listHead; - xdc_runtime_Types_ModuleId curId; -} xdc_runtime_Registry_Module_State__; - -/* Module__state__V */ -xdc_runtime_Registry_Module_State__ xdc_runtime_Registry_Module__state__V; - - -/* - * ======== xdc.runtime.Startup DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_Startup_Module_State__ { - xdc_Int *stateTab; - xdc_Bool execFlag; - xdc_Bool rtsDoneFlag; -} xdc_runtime_Startup_Module_State__; - -/* Module__state__V */ -xdc_runtime_Startup_Module_State__ xdc_runtime_Startup_Module__state__V; - -/* --> ti_sysbios_hal_Hwi_initStack */ -extern xdc_Void ti_sysbios_hal_Hwi_initStack(xdc_Void); - -/* --> xdc_runtime_Startup_firstFxns__A */ -const __T1_xdc_runtime_Startup_firstFxns xdc_runtime_Startup_firstFxns__A[6]; - -/* --> xdc_runtime_System_Module_startup__E */ -extern xdc_Int xdc_runtime_System_Module_startup__E(xdc_Int); - -/* --> xdc_runtime_SysMin_Module_startup__E */ -extern xdc_Int xdc_runtime_SysMin_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_startup__E */ -extern xdc_Int ti_sysbios_family_arm_m3_Hwi_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_knl_Clock_Module_startup__E */ -extern xdc_Int ti_sysbios_knl_Clock_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_knl_Mailbox_Module_startup__E */ -extern xdc_Int ti_sysbios_knl_Mailbox_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_knl_Swi_Module_startup__E */ -extern xdc_Int ti_sysbios_knl_Swi_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_knl_Task_Module_startup__E */ -extern xdc_Int ti_sysbios_knl_Task_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_hal_Hwi_Module_startup__E */ -extern xdc_Int ti_sysbios_hal_Hwi_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_family_arm_lm4_TimestampProvider_Module_startup__E */ -extern xdc_Int ti_sysbios_family_arm_lm4_TimestampProvider_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_family_arm_lm4_Timer_Module_startup__E */ -extern xdc_Int ti_sysbios_family_arm_lm4_Timer_Module_startup__E(xdc_Int); - -/* --> ti_sysbios_io_DEV_Module_startup__E */ -extern xdc_Int ti_sysbios_io_DEV_Module_startup__E(xdc_Int); - -/* --> xdc_runtime_Startup_sfxnTab__A */ -const __T1_xdc_runtime_Startup_sfxnTab xdc_runtime_Startup_sfxnTab__A[11]; - -/* --> xdc_runtime_Startup_sfxnRts__A */ -const __T1_xdc_runtime_Startup_sfxnRts xdc_runtime_Startup_sfxnRts__A[11]; - - -/* - * ======== xdc.runtime.SysMin DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_SysMin_Module_State__ { - __TA_xdc_runtime_SysMin_Module_State__outbuf outbuf; - xdc_UInt outidx; - xdc_Bool wrapped; -} xdc_runtime_SysMin_Module_State__; - -/* --> xdc_runtime_SysMin_Module_State_0_outbuf__A */ -__T1_xdc_runtime_SysMin_Module_State__outbuf xdc_runtime_SysMin_Module_State_0_outbuf__A[1024]; - -/* Module__state__V */ -xdc_runtime_SysMin_Module_State__ xdc_runtime_SysMin_Module__state__V; - -/* --> xdc_runtime_SysMin_output__I */ -extern xdc_Void xdc_runtime_SysMin_output__I(xdc_Char*,xdc_UInt); - - -/* - * ======== xdc.runtime.System DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_System_Module_State__ { - __TA_xdc_runtime_System_Module_State__atexitHandlers atexitHandlers; - xdc_Int numAtexitHandlers; -} xdc_runtime_System_Module_State__; - -/* --> xdc_runtime_System_Module_State_0_atexitHandlers__A */ -__T1_xdc_runtime_System_Module_State__atexitHandlers xdc_runtime_System_Module_State_0_atexitHandlers__A[2]; - -/* Module__state__V */ -xdc_runtime_System_Module_State__ xdc_runtime_System_Module__state__V; - -/* --> xdc_runtime_System_printfExtend__I */ -extern xdc_Int xdc_runtime_System_printfExtend__I(xdc_Char**,xdc_CString*,xdc_VaList*,xdc_runtime_System_ParseData*); - - -/* - * ======== xdc.runtime.System_Module_GateProxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.System_SupportProxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Text DECLARATIONS ======== - */ - -/* Module_State__ */ -typedef struct xdc_runtime_Text_Module_State__ { - xdc_Ptr charBase; - xdc_Ptr nodeBase; -} xdc_runtime_Text_Module_State__; - -/* Module__state__V */ -xdc_runtime_Text_Module_State__ xdc_runtime_Text_Module__state__V; - -/* --> xdc_runtime_Text_charTab__A */ -const __T1_xdc_runtime_Text_charTab xdc_runtime_Text_charTab__A[6893]; - -/* --> xdc_runtime_Text_nodeTab__A */ -const __T1_xdc_runtime_Text_nodeTab xdc_runtime_Text_nodeTab__A[65]; - - -/* - * ======== xdc.runtime.Timestamp DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.Timestamp_SupportProxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.SemThread DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.SemThread_Proxy DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.Sync DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.SyncGeneric DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.SyncNull DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.SyncSemThread DECLARATIONS ======== - */ - - -/* - * ======== xdc.runtime.knl.Sync_Proxy DECLARATIONS ======== - */ - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Instance_State_sem__O, ".const:ti_sysbios_gates_GateMutex_Instance_State_sem__O"); -__FAR__ const xdc_SizeT ti_sysbios_gates_GateMutex_Instance_State_sem__O = offsetof(ti_sysbios_gates_GateMutex_Object__, Object_field_sem); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_io_GIO_Instance_State_doneList__O, ".const:ti_sysbios_io_GIO_Instance_State_doneList__O"); -__FAR__ const xdc_SizeT ti_sysbios_io_GIO_Instance_State_doneList__O = offsetof(ti_sysbios_io_GIO_Object__, Object_field_doneList); -#pragma DATA_SECTION(ti_sysbios_io_GIO_Instance_State_freeList__O, ".const:ti_sysbios_io_GIO_Instance_State_freeList__O"); -__FAR__ const xdc_SizeT ti_sysbios_io_GIO_Instance_State_freeList__O = offsetof(ti_sysbios_io_GIO_Object__, Object_field_freeList); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module_State_clockQ__O, ".const:ti_sysbios_knl_Clock_Module_State_clockQ__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Clock_Module_State_clockQ__O = offsetof(ti_sysbios_knl_Clock_Module_State__, Object_field_clockQ); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_knl_Event_Instance_State_pendQ__O, ".const:ti_sysbios_knl_Event_Instance_State_pendQ__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Event_Instance_State_pendQ__O = offsetof(ti_sysbios_knl_Event_Object__, Object_field_pendQ); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Instance_State_dataQue__O, ".const:ti_sysbios_knl_Mailbox_Instance_State_dataQue__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Mailbox_Instance_State_dataQue__O = offsetof(ti_sysbios_knl_Mailbox_Object__, Object_field_dataQue); -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Instance_State_freeQue__O, ".const:ti_sysbios_knl_Mailbox_Instance_State_freeQue__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Mailbox_Instance_State_freeQue__O = offsetof(ti_sysbios_knl_Mailbox_Object__, Object_field_freeQue); -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Instance_State_dataSem__O, ".const:ti_sysbios_knl_Mailbox_Instance_State_dataSem__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Mailbox_Instance_State_dataSem__O = offsetof(ti_sysbios_knl_Mailbox_Object__, Object_field_dataSem); -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Instance_State_freeSem__O, ".const:ti_sysbios_knl_Mailbox_Instance_State_freeSem__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Mailbox_Instance_State_freeSem__O = offsetof(ti_sysbios_knl_Mailbox_Object__, Object_field_freeSem); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Instance_State_pendQ__O, ".const:ti_sysbios_knl_Semaphore_Instance_State_pendQ__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Semaphore_Instance_State_pendQ__O = offsetof(ti_sysbios_knl_Semaphore_Object__, Object_field_pendQ); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module_State_inactiveQ__O, ".const:ti_sysbios_knl_Task_Module_State_inactiveQ__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Task_Module_State_inactiveQ__O = offsetof(ti_sysbios_knl_Task_Module_State__, Object_field_inactiveQ); -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module_State_terminatedQ__O, ".const:ti_sysbios_knl_Task_Module_State_terminatedQ__O"); -__FAR__ const xdc_SizeT ti_sysbios_knl_Task_Module_State_terminatedQ__O = offsetof(ti_sysbios_knl_Task_Module_State__, Object_field_terminatedQ); - - -/* - * ======== OBJECT OFFSETS ======== - */ - -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Instance_State_sem__O, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Instance_State_sem__O"); -__FAR__ const xdc_SizeT ti_sysbios_xdcruntime_SemThreadSupport_Instance_State_sem__O = offsetof(ti_sysbios_xdcruntime_SemThreadSupport_Object__, Object_field_sem); - - -/* - * ======== xdc.cfg.Program TEMPLATE ======== - */ - -/* - * ======== __ASM__ ======== - * Define absolute path prefix for this executable's - * configuration generated files. - */ -xdc__META(__ASM__, "@(#)__ASM__ = C:/Tango/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f"); - -/* - * ======== __ISA__ ======== - * Define the ISA of this executable. This symbol is used by platform - * specific "exec" commands that support more than one ISA; e.g., gdb - */ -xdc__META(__ISA__, "@(#)__ISA__ = v7M4"); - -/* - * ======== __PLAT__ ======== - * Define the name of the platform that can run this executable. This - * symbol is used by platform independent "exec" commands - */ -xdc__META(__PLAT__, "@(#)__PLAT__ = ti.platforms.tiva"); - -/* - * ======== __TARG__ ======== - * Define the name of the target used to build this executable. - */ -xdc__META(__TARG__, "@(#)__TARG__ = ti.targets.arm.elf.M4F"); - -/* - * ======== __TRDR__ ======== - * Define the name of the class that can read/parse this executable. - */ -xdc__META(__TRDR__, "@(#)__TRDR__ = ti.targets.omf.elf.Elf32"); - - -/* - * ======== xdc.cfg.SourceDir TEMPLATE ======== - */ - - - -/* - * ======== ti.platforms.tiva.Platform TEMPLATE ======== - */ - - - -/* - * ======== xdc.runtime.Diags TEMPLATE ======== - */ - - - -/* - * ======== xdc.runtime.Startup TEMPLATE ======== - */ - -/* - * ======== MODULE STARTUP DONE FUNCTIONS ======== - */ -xdc_Bool xdc_runtime_System_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[0] < 0; -} -xdc_Bool xdc_runtime_SysMin_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[1] < 0; -} -xdc_Bool ti_sysbios_family_arm_m3_Hwi_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[2] < 0; -} -xdc_Bool ti_sysbios_knl_Clock_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[3] < 0; -} -xdc_Bool ti_sysbios_knl_Mailbox_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[4] < 0; -} -xdc_Bool ti_sysbios_knl_Swi_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[5] < 0; -} -xdc_Bool ti_sysbios_knl_Task_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[6] < 0; -} -xdc_Bool ti_sysbios_hal_Hwi_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[7] < 0; -} -xdc_Bool ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[8] < 0; -} -xdc_Bool ti_sysbios_family_arm_lm4_Timer_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[9] < 0; -} -xdc_Bool ti_sysbios_io_DEV_Module__startupDone__F(void) { - return (&xdc_runtime_Startup_Module__state__V)->stateTab == 0 || (&xdc_runtime_Startup_Module__state__V)->stateTab[10] < 0; -} - - -/* - * Startup_exec__I is an internal entry point called by target/platform - * boot code. Boot code is not brought into a partial-link assembly. So, - * without this pragma, whole program optimizers would otherwise optimize-out - * this function. - */ -#ifdef __ti__ -#pragma FUNC_EXT_CALLED(xdc_runtime_Startup_exec__I); -#endif - -#ifdef __GNUC__ -#if __GNUC__ >= 4 -xdc_Void xdc_runtime_Startup_exec__I(void) __attribute__ ((externally_visible)); -#endif -#endif - -/* - * ======== xdc_runtime_Startup_exec__I ======== - * Initialize all used modules that have startup functions - */ -xdc_Void xdc_runtime_Startup_exec__I(void) -{ - xdc_Int state[11]; - xdc_runtime_Startup_startModsFxn__C(state, 11); -} - -/* - * ======== xdc.runtime.Reset TEMPLATE ======== - */ - -/* - * Startup_reset__I is an internal entry point called by target/platform - * boot code. Boot code is not brought into a partial-link assembly. So, - * without this pragma, whole program optimizers would otherwise optimize-out - * this function. - */ -#ifdef __ti__ -#pragma FUNC_EXT_CALLED(xdc_runtime_Startup_reset__I); -#endif - -#ifdef __GNUC__ -#if __GNUC__ >= 4 -xdc_Void xdc_runtime_Startup_reset__I(void) __attribute__ ((externally_visible)); -#endif -#endif - - -/* - * ======== xdc_runtime_Startup_reset__I ======== - * This function is called by bootstrap initialization code as early as - * possible in the startup process. This function calls all functions in - * the Reset.fxns array _as well as_ Startup.resetFxn (if it's non-NULL) - */ -xdc_Void xdc_runtime_Startup_reset__I(void) -{ -} - -/* - * ======== xdc.runtime.System TEMPLATE ======== - */ - - -#include -#include -#include -#include -#include - -#include -#include - -/* - * ======== System_printfExtend__I ======== - * This function processes optional extended formats of printf. - * - * It returns the number of characters added to the result. - * - * Precision (maximum string length) is not supported for %$S. - * - * Right-justified (which is default) minimum width is not supported - * for %$L, %$S, or %$F. - */ -xdc_Int xdc_runtime_System_printfExtend__I(xdc_Char **pbuf, xdc_CString *pfmt, - xdc_VaList *pva, xdc_runtime_System_ParseData *parse) -{ - xdc_CString fmt = *pfmt; - xdc_Int res; - xdc_Char c; - xdc_Bool found = FALSE; - - /* - * Create a local variable 'va' to ensure that the dereference of - * pva only occurs once. - */ - va_list va = *pva; - - res = 0; - - c = *fmt++; - *pfmt = *pfmt + 1; - - - if (c == '$') { - c = *fmt++; - *pfmt = *pfmt + 1; - - if (c == 'L') { - xdc_runtime_Types_Label *lab = parse->aFlag ? - (xdc_runtime_Types_Label *)xdc_iargToPtr(va_arg(va, xdc_IArg)) : - (xdc_runtime_Types_Label *)va_arg(va, void *); - - /* - * Call Text_putLab to write out the label, taking the precision - * into account. - */ - res = xdc_runtime_Text_putLab(lab, pbuf, parse->precis); - - /* - * Set the length to 0 to indicate to 'doPrint' that nothing should - * be copied from parse.ptr. - */ - parse->len = 0; - - /* Update the minimum width field. */ - parse->width -= res; - - found = TRUE; - } - - if (c == 'F') { - xdc_runtime_Types_Site site; - - /* Retrieve the file name string from the argument list */ - site.file = parse->aFlag ? (xdc_Char *) xdc_iargToPtr(va_arg(va, xdc_IArg)) : - (xdc_Char *) va_arg(va, xdc_Char *); - - /* Retrieve the line number from the argument list. */ - site.line = parse->aFlag ? (xdc_Int) va_arg(va, xdc_IArg) : - (xdc_Int) va_arg(va, xdc_Int); - - /* - * Omit the 'mod' field, set it to 0. - * '0' is a safe sentinel value - the IDs for named modules are - * 0x8000 and higher, and the IDs for unnamed modules go from 0x1 - * to 0x7fff. - */ - site.mod = 0; - - /* - * Call putSite to format the file and line number. - * If a precision was specified, it will be used as the maximum - * string lengrth. - */ - res = xdc_runtime_Text_putSite(&site, pbuf, parse->precis); - - /* - * Set the length to 0 to indicate to 'doPrint' that nothing should - * be copied from parse.ptr. - */ - parse->len = 0; - - /* Update the minimum width field */ - parse->width -= res; - - found = TRUE; - } - - if (c == 'S') { - /* Retrieve the format string from the argument list */ - parse->ptr = parse->aFlag ? - (xdc_Char *) xdc_iargToPtr(va_arg(va, xdc_IArg)) : - (xdc_Char *) va_arg(va, xdc_Char *); - - /* Update pva before passing it to doPrint. */ - *pva = va; - - /* Perform the recursive format. System_doPrint does not advance - * the buffer pointer, so it has to be done explicitly. - */ - res = xdc_runtime_System_doPrint__I(*pbuf, parse->precis, - parse->ptr, pva, parse->aFlag); - - if (*pbuf) { - *pbuf += res; - } - - /* Update the temporary variable with any changes to *pva */ - va = *pva; - - /* - * Set the length to 0 to indicate to 'doPrint' that nothing should - * be copied from parse.ptr - */ - parse->len = 0; - - /* Update the minimum width field */ - parse->width -= res; - - /* Indicate that we were able to interpret the specifier */ - found = TRUE; - } - - } - - if (c == 'f') { - /* support arguments _after_ optional float support */ - if (parse->aFlag) { - (void)va_arg(va, xdc_IArg); - } - else { - (void)va_arg(va, double); - } - } - - if (found == FALSE) { - /* other character (like %) copy to output */ - *(parse->ptr) = c; - parse->len = 1; - } - - /* - * Before returning, we must update the value of pva. We use a label here - * so that all return points will go through this update. - * The 'goto end' is here to ensure that there is always a reference to the - * label (to avoid the compiler complaining). - */ - goto end; -end: - *pva = va; - return (res); -} - -/* - * ======== xdc.runtime.SysMin TEMPLATE ======== - */ - - -#if defined(__ti__) -extern int HOSTwrite(int, const char *, unsigned); -#elif (defined(gnu_targets_STD_) && defined(xdc_target__os_undefined)) -extern int _write(int, char *, int); -#define HOSTwrite(x,y,z) _write((int)(x),(char *)(y),(int)(z)) -#elif defined(__IAR_SYSTEMS_ICC__) -#include -#define HOSTwrite(x,y,z) __write((x),(unsigned char *)(y),(z)) -#else -#include -#endif - -/* - * ======== SysMin_output__I ======== - * HOSTWrite only writes a max of N chars at a time. The amount it writes - * is returned. This function loops until the entire buffer is written. - * Being a static function allows it to conditionally compile out. - */ -xdc_Void xdc_runtime_SysMin_output__I(xdc_Char *buf, xdc_UInt size) -{ -#if defined(__ti__) || (defined(gnu_targets_STD_) && defined(xdc_target__os_undefined)) || defined (__IAR_SYSTEMS_ICC__) - xdc_Int printCount; - - while (size != 0) { - printCount = HOSTwrite(1, buf, size); - if ((printCount <= 0) || (printCount > size)) { - break; /* ensure we never get stuck in an infinite loop */ - } - size -= printCount; - buf = buf + printCount; - } -#else - fwrite(buf, 1, size, stdout); -#endif -} - -/* - * ======== xdc.runtime.Text TEMPLATE ======== - */ - - -/* - * ======== xdc_runtime_Text_visitRope__I ======== - * This function is indirectly called within Text.c through - * the visitRopeFxn configuration parameter of xdc.runtime.Text. - */ -void xdc_runtime_Text_visitRope__I(xdc_runtime_Text_RopeId rope, - xdc_Fxn visFxn, xdc_Ptr visState) -{ - xdc_String stack[7]; - xdc_runtime_Text_visitRope2__I(rope, visFxn, visState, stack); -} - - -/* - * ======== ti.catalog.arm.cortexm4.tiva.ce.Boot TEMPLATE ======== - */ - -#if defined(__ti__) -#pragma CODE_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_init, ".text:.bootCodeSection") -#endif - -/* - * ======== ti_catalog_arm_cortexm4_tiva_ce_Boot_init ======== - */ -xdc_Void ti_catalog_arm_cortexm4_tiva_ce_Boot_init() -{ - ti_catalog_arm_cortexm4_tiva_ce_Boot_sysCtlClockFreqSet((xdc_ULong) - (-251656576), (xdc_ULong)(120000000)); -} - - -/* - * ======== ti.sysbios.BIOS TEMPLATE ======== - */ - - -Void ti_sysbios_BIOS_atExitFunc__I(Int); - -extern Void ti_sysbios_BIOS_registerRTSLock(); -extern Void ti_mw_fatfs_startup(); -extern Void ti_sysbios_family_arm_lm4_Timer_startup__E(); - -Void ti_sysbios_BIOS_startFunc__I() -{ - xdc_runtime_System_atexit( - (xdc_runtime_System_AtexitHandler)ti_sysbios_BIOS_atExitFunc__I); - ti_sysbios_BIOS_registerRTSLock(); - ti_mw_fatfs_startup(); - ti_sysbios_family_arm_lm4_Timer_startup__E(); - ti_sysbios_hal_Hwi_startup(); - ti_sysbios_knl_Swi_startup(); - ti_sysbios_knl_Task_startup(); -} - -#include <_lock.h> - -Void ti_sysbios_BIOS_atExitFunc__I(Int notused) -{ - ti_sysbios_knl_Swi_disable(); - ti_sysbios_knl_Task_disable(); - ti_sysbios_BIOS_setThreadType(ti_sysbios_BIOS_ThreadType_Main); - - if ((&ti_sysbios_BIOS_Module__state__V)->rtsGate != NULL) { - _register_lock(_nop); - _register_unlock(_nop); - } -} - -/* - * ======== BIOS_rtsLock ======== - * Called by rts _lock() function - */ -Void ti_sysbios_BIOS_rtsLock() -{ - IArg key; - - key = ti_sysbios_BIOS_RtsGateProxy_enter((&ti_sysbios_BIOS_Module__state__V)->rtsGate); - if ((&ti_sysbios_BIOS_Module__state__V)->rtsGateCount == 0) { - (&ti_sysbios_BIOS_Module__state__V)->rtsGateKey = key; - } - /* Increment need not be atomic */ - (&ti_sysbios_BIOS_Module__state__V)->rtsGateCount++; -} - -/* - * ======== BIOS_rtsUnLock ======== - * Called by rts _unlock() function - */ -Void ti_sysbios_BIOS_rtsUnlock() -{ - xdc_runtime_Assert_isTrue(((&ti_sysbios_BIOS_Module__state__V)->rtsGateCount), NULL); - - (&ti_sysbios_BIOS_Module__state__V)->rtsGateCount--; - - if ((&ti_sysbios_BIOS_Module__state__V)->rtsGateCount == 0) { - ti_sysbios_BIOS_RtsGateProxy_leave((&ti_sysbios_BIOS_Module__state__V)->rtsGate, (&ti_sysbios_BIOS_Module__state__V)->rtsGateKey); - } -} - -/* - * ======== BIOS_nullFunc ======== - */ -Void ti_sysbios_BIOS_nullFunc__I() -{ -} - -/* - * ======== BIOS_registerRTSLock ======== - */ -Void ti_sysbios_BIOS_registerRTSLock(Void) -{ - if ((&ti_sysbios_BIOS_Module__state__V)->rtsGate != NULL) { - _register_lock(ti_sysbios_BIOS_rtsLock); - _register_unlock(ti_sysbios_BIOS_rtsUnlock); - } -} - -/* - * ======== BIOS_removeRTSLock ======== - */ -Void ti_sysbios_BIOS_removeRTSLock(Void) -{ - if ((&ti_sysbios_BIOS_Module__state__V)->rtsGate != NULL) { - _register_lock(ti_sysbios_BIOS_nullFunc); - _register_unlock(ti_sysbios_BIOS_nullFunc); - } -} - -/* - * ======== BIOS_exitFunc ======== - */ -Void ti_sysbios_BIOS_exitFunc(Int stat) -{ - /* remove the RTS lock */ - ti_sysbios_BIOS_removeRTSLock(); - - /* force thread type to 'Main' */ - ti_sysbios_BIOS_setThreadType(ti_sysbios_BIOS_ThreadType_Main); - - xdc_runtime_System_exit(stat); -} - -/* - * ======== BIOS_errorRaiseHook ======== - */ -Void ti_sysbios_BIOS_errorRaiseHook(xdc_runtime_Error_Block *eb) -{ - /* - * If this is an Assert thread, defang Gate threadtype check - */ - if (eb->id == xdc_runtime_Assert_E_assertFailed) { - /* remove the RTS lock */ - ti_sysbios_BIOS_removeRTSLock(); - /* force thread type to 'Main' */ - ti_sysbios_BIOS_setThreadType(ti_sysbios_BIOS_ThreadType_Main); - } - - /* Call the installed Error.raiseHook */ - ti_sysbios_BIOS_installedErrorHook(eb); -} - -/* - * ======== ti.sysbios.Build TEMPLATE ======== - */ - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi TEMPLATE ======== - */ - -extern Void _c_int00(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); -extern Void ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I(); - - -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_resetVectors, ".resetVecs"); - -/* const because it is meant to be placed in ROM */ -const UInt32 ti_sysbios_family_arm_m3_Hwi_resetVectors[] = { - (UInt32)(&__TI_STACK_BASE), - (UInt32)(&_c_int00), - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* NMI */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* Hard Fault */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* Mem Fault */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* Bus Fault */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* Usage Fault */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* reserved */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* reserved */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* reserved */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* reserved */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* SVCall */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* Debug Mon */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I), /* reserved */ - (UInt32)(&ti_sysbios_family_arm_m3_Hwi_pendSV__I), /* pendSV */ -}; - -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_ramVectors, ".vecs"); - -/* place holder for RAM vector table */ -UInt32 ti_sysbios_family_arm_m3_Hwi_ramVectors[216]; - -UInt32 ti_sysbios_family_arm_m3_Hwi_dispatchTable[216]; - -#if defined(__IAR_SYSTEMS_ICC__) -Void ti_sysbios_family_arm_m3_Hwi_initIsrStackSize() -{ - #pragma section = "CSTACK" - ti_sysbios_family_arm_m3_Hwi_Module__state__V.isrStackSize = (SizeT)__section_size("CSTACK"); -} -#endif - -/* - * ======== ti.sysbios.knl.Clock TEMPLATE ======== - */ - -Void ti_sysbios_knl_Clock_doTick__I(UArg arg) -{ - /* update system time */ - (&ti_sysbios_knl_Clock_Module__state__V)->ticks++; - - ti_sysbios_knl_Clock_logTick__E(); - - if (!ti_sysbios_knl_Queue_empty(ti_sysbios_knl_Clock_Module_State_clockQ())) { - (&ti_sysbios_knl_Clock_Module__state__V)->swiCount++; - - ti_sysbios_knl_Swi_post((&ti_sysbios_knl_Clock_Module__state__V)->swi); - } -} - -/* - * ======== ti.sysbios.knl.Task TEMPLATE ======== - */ - - - -/* - * ======== ti.sysbios.hal.Seconds TEMPLATE ======== - */ - - - -#if defined(__ti__) - -#pragma FUNC_EXT_CALLED(time); - -#define ATTRIBUTE - -#elif defined(__IAR_SYSTEMS_ICC__) - -#define ATTRIBUTE -#define _NO_DEFINITIONS_IN_HEADER_FILES 1 -#else - -#define ATTRIBUTE __attribute__ ((used)) - -#endif - -#include -#include - -#include - -/* - * ======== time ======== - */ -time_t ATTRIBUTE time(time_t *tout) -{ - UInt32 t; - - /* Seconds_get() returns number of seconds since Jan 1, 1970 00:00:00 GMT. */ - t = ti_sysbios_hal_Seconds_get(); - -#if defined(__ti__) - /* - * TI time() function returns seconds since 1900, so add the number - * of seconds from 1900 to 1970 (2208988800). - */ - t += 2208988800; -#endif - - if (tout) { - *tout = t; - } - - return (t); -} - -/* - * ======== ti.mw.fatfs.FatFS TEMPLATE ======== - */ - - -#include - -#ifdef __ti__ -#include -#endif - -#include - -#include - -#include -#include -#include - -extern DRESULT ramdisk_start(BYTE, unsigned char *, int, int); - -/* - * ======== ti_mw_fatfs_startup ======== - */ -Void ti_mw_fatfs_startup() -{ -#ifdef __ti__ - add_device("fat", _MSA, ffcio_open, ffcio_close, ffcio_read, - ffcio_write, ffcio_lseek, ffcio_unlink, ffcio_rename); -#endif -} - - -#if defined(__IAR_SYSTEMS_ICC__) -/* - * Prevent time() macro in time.h from being used instead of our - * generated time() function. - */ -#define _NO_DEFINITIONS_IN_HEADER_FILES 1 -#endif - -#include - -#if defined(__IAR_SYSTEMS_ICC__) -#undef _NO_DEFINITIONS_IN_HEADER_FILES -#endif - -#include - -/* - * ======== fatfs_getFatTime ======== - */ -Int32 ti_mw_fatfs_getFatTime(Void) -{ - time_t seconds; - UInt32 fatTime; - struct tm *pTime; - - seconds = time(NULL); - - pTime = localtime(&seconds); - - /* - * localtime() sets pTime->tm_year to number of years - * since 1900, so subtract 80 from tm_year to get FAT time - * offset from 1980. - */ - fatTime = ((UInt32)(pTime->tm_year - 80) << 25) | - ((UInt32)(pTime->tm_mon) << 21) | - ((UInt32)(pTime->tm_mday) << 16) | - ((UInt32)(pTime->tm_hour) << 11) | - ((UInt32)(pTime->tm_min) << 5) | - ((UInt32)(pTime->tm_sec) >> 1); - - return ((Int32)fatTime); -} - -/* - * ======== ti.sysbios.rts.MemAlloc TEMPLATE ======== - */ - - - -/* - * ======== ti.catalog.arm.cortexm4.tiva.ce.Boot INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsEnabled__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsEnabled__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsEnabled ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsIncluded__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsIncluded__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsIncluded ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsMask__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsMask__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsMask ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsMask__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gateObj__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gateObj__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gateObj ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gateObj__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gatePrms__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gatePrms__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gatePrms ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gatePrms__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__id__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__id__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__id ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__id__C = (xdc_Bits16)0x8017; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerDefined__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerDefined__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerDefined ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerObj__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerObj__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerObj ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerObj__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn0__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn0__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn0 ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn0__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn1__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn1__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn1 ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn1__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn2__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn2__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn2 ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn2__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn4__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn4__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn4 ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn4__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn8__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn8__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn8 ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn8__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDoneFxn__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDoneFxn ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDoneFxn__C = ((CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__count__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__count__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__count ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__heap__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__heap__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__heap ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__sizeof__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__sizeof__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__sizeof ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__table__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__table__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__table ti_catalog_arm_cortexm4_tiva_ce_Boot_Object__table__C = 0; - -/* A_mustUseEnhancedClockMode__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustUseEnhancedClockMode__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustUseEnhancedClockMode__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustUseEnhancedClockMode ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustUseEnhancedClockMode__C = (((xdc_runtime_Assert_Id)400) << 16 | 16); - -/* A_mustNotUseEnhancedClockMode__C */ -#pragma DATA_SECTION(ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustNotUseEnhancedClockMode__C, ".const:ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustNotUseEnhancedClockMode__C"); -__FAR__ const CT__ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustNotUseEnhancedClockMode ti_catalog_arm_cortexm4_tiva_ce_Boot_A_mustNotUseEnhancedClockMode__C = (((xdc_runtime_Assert_Id)474) << 16 | 16); - - -/* - * ======== ti.sysbios.BIOS INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_BIOS_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_BIOS_Module_State__ ti_sysbios_BIOS_Module__state__V __attribute__ ((section(".data_ti_sysbios_BIOS_Module__state__V"))); -#endif -#endif -ti_sysbios_BIOS_Module_State__ ti_sysbios_BIOS_Module__state__V = { - { - (xdc_Bits32)0x0, /* hi */ - (xdc_Bits32)0x7270e00, /* lo */ - }, /* cpuFreq */ - (xdc_UInt)0x0, /* rtsGateCount */ - ((xdc_IArg)(0x0)), /* rtsGateKey */ - (ti_sysbios_BIOS_RtsGateProxy_Handle)&ti_sysbios_gates_GateMutex_Object__table__V[1], /* rtsGate */ - ti_sysbios_BIOS_ThreadType_Main, /* threadType */ - ((void*)0), /* smpThreadType */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_BIOS_startFunc)), /* startFunc */ - ((xdc_Void(*)(xdc_Int))((xdc_Fxn)ti_sysbios_BIOS_exitFunc)), /* exitFunc */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__diagsEnabled__C, ".const:ti_sysbios_BIOS_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__diagsEnabled ti_sysbios_BIOS_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__diagsIncluded__C, ".const:ti_sysbios_BIOS_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__diagsIncluded ti_sysbios_BIOS_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__diagsMask__C, ".const:ti_sysbios_BIOS_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__diagsMask ti_sysbios_BIOS_Module__diagsMask__C = ((CT__ti_sysbios_BIOS_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__gateObj__C, ".const:ti_sysbios_BIOS_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__gateObj ti_sysbios_BIOS_Module__gateObj__C = ((CT__ti_sysbios_BIOS_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__gatePrms__C, ".const:ti_sysbios_BIOS_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__gatePrms ti_sysbios_BIOS_Module__gatePrms__C = ((CT__ti_sysbios_BIOS_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__id__C, ".const:ti_sysbios_BIOS_Module__id__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__id ti_sysbios_BIOS_Module__id__C = (xdc_Bits16)0x8019; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerDefined__C, ".const:ti_sysbios_BIOS_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerDefined ti_sysbios_BIOS_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerObj__C, ".const:ti_sysbios_BIOS_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerObj ti_sysbios_BIOS_Module__loggerObj__C = ((CT__ti_sysbios_BIOS_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerFxn0__C, ".const:ti_sysbios_BIOS_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerFxn0 ti_sysbios_BIOS_Module__loggerFxn0__C = ((CT__ti_sysbios_BIOS_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerFxn1__C, ".const:ti_sysbios_BIOS_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerFxn1 ti_sysbios_BIOS_Module__loggerFxn1__C = ((CT__ti_sysbios_BIOS_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerFxn2__C, ".const:ti_sysbios_BIOS_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerFxn2 ti_sysbios_BIOS_Module__loggerFxn2__C = ((CT__ti_sysbios_BIOS_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerFxn4__C, ".const:ti_sysbios_BIOS_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerFxn4 ti_sysbios_BIOS_Module__loggerFxn4__C = ((CT__ti_sysbios_BIOS_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__loggerFxn8__C, ".const:ti_sysbios_BIOS_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__loggerFxn8 ti_sysbios_BIOS_Module__loggerFxn8__C = ((CT__ti_sysbios_BIOS_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Module__startupDoneFxn__C, ".const:ti_sysbios_BIOS_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_BIOS_Module__startupDoneFxn ti_sysbios_BIOS_Module__startupDoneFxn__C = ((CT__ti_sysbios_BIOS_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Object__count__C, ".const:ti_sysbios_BIOS_Object__count__C"); -__FAR__ const CT__ti_sysbios_BIOS_Object__count ti_sysbios_BIOS_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Object__heap__C, ".const:ti_sysbios_BIOS_Object__heap__C"); -__FAR__ const CT__ti_sysbios_BIOS_Object__heap ti_sysbios_BIOS_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Object__sizeof__C, ".const:ti_sysbios_BIOS_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_BIOS_Object__sizeof ti_sysbios_BIOS_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_Object__table__C, ".const:ti_sysbios_BIOS_Object__table__C"); -__FAR__ const CT__ti_sysbios_BIOS_Object__table ti_sysbios_BIOS_Object__table__C = 0; - -/* smpEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_smpEnabled__C, ".const:ti_sysbios_BIOS_smpEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_smpEnabled ti_sysbios_BIOS_smpEnabled__C = 0; - -/* cpuFreq__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_cpuFreq__C, ".const:ti_sysbios_BIOS_cpuFreq__C"); -__FAR__ const CT__ti_sysbios_BIOS_cpuFreq ti_sysbios_BIOS_cpuFreq__C = { - (xdc_Bits32)0x0, /* hi */ - (xdc_Bits32)0x7270e00, /* lo */ -}; - -/* runtimeCreatesEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_runtimeCreatesEnabled__C, ".const:ti_sysbios_BIOS_runtimeCreatesEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_runtimeCreatesEnabled ti_sysbios_BIOS_runtimeCreatesEnabled__C = 1; - -/* taskEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_taskEnabled__C, ".const:ti_sysbios_BIOS_taskEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_taskEnabled ti_sysbios_BIOS_taskEnabled__C = 1; - -/* swiEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_swiEnabled__C, ".const:ti_sysbios_BIOS_swiEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_swiEnabled ti_sysbios_BIOS_swiEnabled__C = 1; - -/* clockEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_clockEnabled__C, ".const:ti_sysbios_BIOS_clockEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_clockEnabled ti_sysbios_BIOS_clockEnabled__C = 1; - -/* heapSize__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_heapSize__C, ".const:ti_sysbios_BIOS_heapSize__C"); -__FAR__ const CT__ti_sysbios_BIOS_heapSize ti_sysbios_BIOS_heapSize__C = (xdc_SizeT)0x782f; - -/* heapSection__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_heapSection__C, ".const:ti_sysbios_BIOS_heapSection__C"); -__FAR__ const CT__ti_sysbios_BIOS_heapSection ti_sysbios_BIOS_heapSection__C = 0; - -/* heapTrackEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_heapTrackEnabled__C, ".const:ti_sysbios_BIOS_heapTrackEnabled__C"); -__FAR__ const CT__ti_sysbios_BIOS_heapTrackEnabled ti_sysbios_BIOS_heapTrackEnabled__C = 0; - -/* setupSecureContext__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_setupSecureContext__C, ".const:ti_sysbios_BIOS_setupSecureContext__C"); -__FAR__ const CT__ti_sysbios_BIOS_setupSecureContext ti_sysbios_BIOS_setupSecureContext__C = 0; - -/* useSK__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_useSK__C, ".const:ti_sysbios_BIOS_useSK__C"); -__FAR__ const CT__ti_sysbios_BIOS_useSK ti_sysbios_BIOS_useSK__C = 0; - -/* installedErrorHook__C */ -#pragma DATA_SECTION(ti_sysbios_BIOS_installedErrorHook__C, ".const:ti_sysbios_BIOS_installedErrorHook__C"); -__FAR__ const CT__ti_sysbios_BIOS_installedErrorHook ti_sysbios_BIOS_installedErrorHook__C = ((CT__ti_sysbios_BIOS_installedErrorHook)((xdc_Fxn)xdc_runtime_Error_print__E)); - - -/* - * ======== ti.sysbios.BIOS_RtsGateProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.family.arm.lm4.Seconds INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_family_arm_lm4_Seconds_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_family_arm_lm4_Seconds_Module_State__ ti_sysbios_family_arm_lm4_Seconds_Module__state__V __attribute__ ((section(".data_ti_sysbios_family_arm_lm4_Seconds_Module__state__V"))); -#endif -#endif -ti_sysbios_family_arm_lm4_Seconds_Module_State__ ti_sysbios_family_arm_lm4_Seconds_Module__state__V = { - (xdc_UInt32)0x0, /* setSeconds */ - (xdc_UInt32)0x0, /* refSeconds */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__diagsEnabled ti_sysbios_family_arm_lm4_Seconds_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__diagsIncluded ti_sysbios_family_arm_lm4_Seconds_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__diagsMask__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__diagsMask ti_sysbios_family_arm_lm4_Seconds_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__gateObj__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__gateObj ti_sysbios_family_arm_lm4_Seconds_Module__gateObj__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__gatePrms__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__gatePrms ti_sysbios_family_arm_lm4_Seconds_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__id__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__id ti_sysbios_family_arm_lm4_Seconds_Module__id__C = (xdc_Bits16)0x802e; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerDefined ti_sysbios_family_arm_lm4_Seconds_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerObj__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerObj ti_sysbios_family_arm_lm4_Seconds_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn0 ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn1 ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn2 ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn4 ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn8 ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Module__startupDoneFxn ti_sysbios_family_arm_lm4_Seconds_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_lm4_Seconds_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Object__count__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Object__count ti_sysbios_family_arm_lm4_Seconds_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Object__heap__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Object__heap ti_sysbios_family_arm_lm4_Seconds_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Object__sizeof__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Object__sizeof ti_sysbios_family_arm_lm4_Seconds_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Seconds_Object__table__C, ".const:ti_sysbios_family_arm_lm4_Seconds_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Seconds_Object__table ti_sysbios_family_arm_lm4_Seconds_Object__table__C = 0; - - -/* - * ======== ti.sysbios.family.arm.lm4.Timer INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_family_arm_lm4_Timer_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C"); -__FAR__ const ti_sysbios_family_arm_lm4_Timer_Params ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C = { - sizeof (ti_sysbios_family_arm_lm4_Timer_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C.__iprms, /* instance */ - ti_sysbios_interfaces_ITimer_RunMode_CONTINUOUS, /* runMode */ - ti_sysbios_interfaces_ITimer_StartMode_AUTO, /* startMode */ - ((xdc_UArg)0), /* arg */ - (xdc_UInt32)0x0, /* period */ - ti_sysbios_interfaces_ITimer_PeriodType_MICROSECS, /* periodType */ - { - (xdc_Bits32)0x0, /* hi */ - (xdc_Bits32)0x0, /* lo */ - }, /* extFreq */ - ((ti_sysbios_family_arm_m3_Hwi_Params*)0), /* hwiParams */ - (xdc_UInt)0xffffffff, /* prevThreshold */ - 0, /* altclk */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_family_arm_lm4_Timer_Module__ ti_sysbios_family_arm_lm4_Timer_Module__root__V = { - {&ti_sysbios_family_arm_lm4_Timer_Module__root__V.link, /* link.next */ - &ti_sysbios_family_arm_lm4_Timer_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_family_arm_lm4_Timer_Object__ ti_sysbios_family_arm_lm4_Timer_Object__table__V[1] = { - {/* instance#0 */ - 0, - 1, /* staticInst */ - (xdc_Int)0x7, /* id */ - ti_sysbios_interfaces_ITimer_RunMode_CONTINUOUS, /* runMode */ - ti_sysbios_interfaces_ITimer_StartMode_AUTO, /* startMode */ - (xdc_UInt)0x1d4c0, /* period */ - ti_sysbios_interfaces_ITimer_PeriodType_COUNTS, /* periodType */ - (xdc_UInt)0x74, /* intNum */ - ((xdc_UArg)0), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)ti_sysbios_knl_Clock_doTick__I)), /* tickFxn */ - { - (xdc_Bits32)0x0, /* hi */ - (xdc_Bits32)0x0, /* lo */ - }, /* extFreq */ - (ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[8], /* hwi */ - (xdc_UInt)0xffffffff, /* prevThreshold */ - (xdc_UInt)0x0, /* rollovers */ - (xdc_UInt)0x0, /* savedCurrCount */ - 0, /* altclk */ - }, -}; - -/* --> ti_sysbios_family_arm_lm4_Timer_Module_State_0_device__A */ -__T1_ti_sysbios_family_arm_lm4_Timer_Module_State__device ti_sysbios_family_arm_lm4_Timer_Module_State_0_device__A[8] = { - { - (xdc_UInt)0x23, /* intNum */ - ((xdc_Ptr)(0x40030000)), /* baseAddr */ - }, /* [0] */ - { - (xdc_UInt)0x25, /* intNum */ - ((xdc_Ptr)(0x40031000)), /* baseAddr */ - }, /* [1] */ - { - (xdc_UInt)0x27, /* intNum */ - ((xdc_Ptr)(0x40032000)), /* baseAddr */ - }, /* [2] */ - { - (xdc_UInt)0x33, /* intNum */ - ((xdc_Ptr)(0x40033000)), /* baseAddr */ - }, /* [3] */ - { - (xdc_UInt)0x4f, /* intNum */ - ((xdc_Ptr)(0x40034000)), /* baseAddr */ - }, /* [4] */ - { - (xdc_UInt)0x51, /* intNum */ - ((xdc_Ptr)(0x40035000)), /* baseAddr */ - }, /* [5] */ - { - (xdc_UInt)0x72, /* intNum */ - ((xdc_Ptr)(0x400e0000)), /* baseAddr */ - }, /* [6] */ - { - (xdc_UInt)0x74, /* intNum */ - ((xdc_Ptr)(0x400e1000)), /* baseAddr */ - }, /* [7] */ -}; - -/* --> ti_sysbios_family_arm_lm4_Timer_Module_State_0_handles__A */ -__T1_ti_sysbios_family_arm_lm4_Timer_Module_State__handles ti_sysbios_family_arm_lm4_Timer_Module_State_0_handles__A[8] = { - 0, /* [0] */ - 0, /* [1] */ - 0, /* [2] */ - 0, /* [3] */ - 0, /* [4] */ - 0, /* [5] */ - 0, /* [6] */ - (ti_sysbios_family_arm_lm4_Timer_Handle)&ti_sysbios_family_arm_lm4_Timer_Object__table__V[0], /* [7] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_family_arm_lm4_Timer_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_family_arm_lm4_Timer_Module_State__ ti_sysbios_family_arm_lm4_Timer_Module__state__V __attribute__ ((section(".data_ti_sysbios_family_arm_lm4_Timer_Module__state__V"))); -#endif -#endif -ti_sysbios_family_arm_lm4_Timer_Module_State__ ti_sysbios_family_arm_lm4_Timer_Module__state__V = { - (xdc_UInt)0x7f, /* availMask */ - ((void*)ti_sysbios_family_arm_lm4_Timer_Module_State_0_device__A), /* device */ - ((void*)ti_sysbios_family_arm_lm4_Timer_Module_State_0_handles__A), /* handles */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__diagsEnabled ti_sysbios_family_arm_lm4_Timer_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__diagsIncluded ti_sysbios_family_arm_lm4_Timer_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__diagsMask__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__diagsMask ti_sysbios_family_arm_lm4_Timer_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__gateObj__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__gateObj ti_sysbios_family_arm_lm4_Timer_Module__gateObj__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__gatePrms__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__gatePrms ti_sysbios_family_arm_lm4_Timer_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__id__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__id ti_sysbios_family_arm_lm4_Timer_Module__id__C = (xdc_Bits16)0x8030; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerDefined ti_sysbios_family_arm_lm4_Timer_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerObj__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerObj ti_sysbios_family_arm_lm4_Timer_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_lm4_Timer_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Module__startupDoneFxn ti_sysbios_family_arm_lm4_Timer_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_lm4_Timer_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__count__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Object__count ti_sysbios_family_arm_lm4_Timer_Object__count__C = 1; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__heap__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Object__heap ti_sysbios_family_arm_lm4_Timer_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__sizeof__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Object__sizeof ti_sysbios_family_arm_lm4_Timer_Object__sizeof__C = sizeof(ti_sysbios_family_arm_lm4_Timer_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__table__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_Object__table ti_sysbios_family_arm_lm4_Timer_Object__table__C = ti_sysbios_family_arm_lm4_Timer_Object__table__V; - -/* E_invalidTimer__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_E_invalidTimer__C, ".const:ti_sysbios_family_arm_lm4_Timer_E_invalidTimer__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_E_invalidTimer ti_sysbios_family_arm_lm4_Timer_E_invalidTimer__C = (((xdc_runtime_Error_Id)4413) << 16 | 0); - -/* E_notAvailable__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_E_notAvailable__C, ".const:ti_sysbios_family_arm_lm4_Timer_E_notAvailable__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_E_notAvailable ti_sysbios_family_arm_lm4_Timer_E_notAvailable__C = (((xdc_runtime_Error_Id)4449) << 16 | 0); - -/* E_cannotSupport__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_E_cannotSupport__C, ".const:ti_sysbios_family_arm_lm4_Timer_E_cannotSupport__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_E_cannotSupport ti_sysbios_family_arm_lm4_Timer_E_cannotSupport__C = (((xdc_runtime_Error_Id)4488) << 16 | 0); - -/* E_noaltclk__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_E_noaltclk__C, ".const:ti_sysbios_family_arm_lm4_Timer_E_noaltclk__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_E_noaltclk ti_sysbios_family_arm_lm4_Timer_E_noaltclk__C = (((xdc_runtime_Error_Id)4708) << 16 | 0); - -/* anyMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_anyMask__C, ".const:ti_sysbios_family_arm_lm4_Timer_anyMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_anyMask ti_sysbios_family_arm_lm4_Timer_anyMask__C = (xdc_UInt)0xff; - -/* supportsAltclk__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_supportsAltclk__C, ".const:ti_sysbios_family_arm_lm4_Timer_supportsAltclk__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_supportsAltclk ti_sysbios_family_arm_lm4_Timer_supportsAltclk__C = 1; - -/* enableFunc__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_enableFunc__C, ".const:ti_sysbios_family_arm_lm4_Timer_enableFunc__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_enableFunc ti_sysbios_family_arm_lm4_Timer_enableFunc__C = ((CT__ti_sysbios_family_arm_lm4_Timer_enableFunc)((xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_enableTiva)); - -/* disableFunc__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_disableFunc__C, ".const:ti_sysbios_family_arm_lm4_Timer_disableFunc__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_disableFunc ti_sysbios_family_arm_lm4_Timer_disableFunc__C = ((CT__ti_sysbios_family_arm_lm4_Timer_disableFunc)((xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_disableTiva)); - -/* startupNeeded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_startupNeeded__C, ".const:ti_sysbios_family_arm_lm4_Timer_startupNeeded__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_startupNeeded ti_sysbios_family_arm_lm4_Timer_startupNeeded__C = (xdc_UInt)0x1; - -/* numTimerDevices__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_numTimerDevices__C, ".const:ti_sysbios_family_arm_lm4_Timer_numTimerDevices__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_Timer_numTimerDevices ti_sysbios_family_arm_lm4_Timer_numTimerDevices__C = (xdc_Int)0x8; - - -/* - * ======== ti.sysbios.family.arm.lm4.TimestampProvider INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_family_arm_lm4_TimestampProvider_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_family_arm_lm4_TimestampProvider_Module_State__ ti_sysbios_family_arm_lm4_TimestampProvider_Module__state__V __attribute__ ((section(".data_ti_sysbios_family_arm_lm4_TimestampProvider_Module__state__V"))); -#endif -#endif -ti_sysbios_family_arm_lm4_TimestampProvider_Module_State__ ti_sysbios_family_arm_lm4_TimestampProvider_Module__state__V = { - 0, /* timer */ - (xdc_UInt32)0x0, /* hi */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsEnabled ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsIncluded ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsMask__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsMask ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__gateObj__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__gateObj ti_sysbios_family_arm_lm4_TimestampProvider_Module__gateObj__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__gatePrms__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__gatePrms ti_sysbios_family_arm_lm4_TimestampProvider_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__id__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__id ti_sysbios_family_arm_lm4_TimestampProvider_Module__id__C = (xdc_Bits16)0x802f; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerDefined ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerObj__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerObj ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn0 ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn1 ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn2 ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn4 ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn8 ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDoneFxn ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Object__count__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Object__count ti_sysbios_family_arm_lm4_TimestampProvider_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Object__heap__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Object__heap ti_sysbios_family_arm_lm4_TimestampProvider_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Object__sizeof__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Object__sizeof ti_sysbios_family_arm_lm4_TimestampProvider_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_Object__table__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_Object__table ti_sysbios_family_arm_lm4_TimestampProvider_Object__table__C = 0; - -/* useClockTimer__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_useClockTimer__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_useClockTimer__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_useClockTimer ti_sysbios_family_arm_lm4_TimestampProvider_useClockTimer__C = 1; - -/* timerId__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_TimestampProvider_timerId__C, ".const:ti_sysbios_family_arm_lm4_TimestampProvider_timerId__C"); -__FAR__ const CT__ti_sysbios_family_arm_lm4_TimestampProvider_timerId ti_sysbios_family_arm_lm4_TimestampProvider_timerId__C = (xdc_UInt)0x3; - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_family_arm_m3_Hwi_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C"); -__FAR__ const ti_sysbios_family_arm_m3_Hwi_Params ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C = { - sizeof (ti_sysbios_family_arm_m3_Hwi_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C.__iprms, /* instance */ - ti_sysbios_interfaces_IHwi_MaskingOption_LOWER, /* maskSetting */ - ((xdc_UArg)(0x0)), /* arg */ - 1, /* enableInt */ - (xdc_Int)(-0x0 - 1), /* eventId */ - (xdc_Int)0xff, /* priority */ - 1, /* useDispatcher */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_family_arm_m3_Hwi_Module__ ti_sysbios_family_arm_m3_Hwi_Module__root__V = { - {&ti_sysbios_family_arm_m3_Hwi_Module__root__V.link, /* link.next */ - &ti_sysbios_family_arm_m3_Hwi_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_family_arm_m3_Hwi_Object__ ti_sysbios_family_arm_m3_Hwi_Object__table__V[9] = { - {/* instance#0 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)ADC0SS0Handler)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x1e, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#1 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)SysTickHandler)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0xf, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#2 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)PortPIntHandler)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x5c, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#3 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)OneMilliSecondControlInterrupt)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x23, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#4 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)WatchdogIntHandler)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x22, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#5 */ - 0, - ((xdc_UArg)(0x2)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)EightMilliSecondHeatersInterrupt)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x27, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#6 */ - 0, - ((xdc_UArg)(0x0)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)OneMilliSecondMillisecInterrupt)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x25, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#7 */ - 0, - ((xdc_UArg)(0x3)), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)ScrewTimerInterrupt)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x33, /* intNum */ - ((void*)0), /* hookEnv */ - }, - {/* instance#8 */ - 0, - ((xdc_UArg)((void*)(ti_sysbios_family_arm_lm4_Timer_Handle)&ti_sysbios_family_arm_lm4_Timer_Object__table__V[0])), /* arg */ - ((xdc_Void(*)(xdc_UArg))((xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_isrStub__E)), /* fxn */ - ((xdc_UArg)(0x3)), /* irp */ - (xdc_UInt8)0xff, /* priority */ - (xdc_Int16)0x74, /* intNum */ - ((void*)0), /* hookEnv */ - }, -}; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excActive__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excActive ti_sysbios_family_arm_m3_Hwi_Module_State_0_excActive__A[1] = { - 0, /* [0] */ -}; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excContext__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excContext ti_sysbios_family_arm_m3_Hwi_Module_State_0_excContext__A[1] = { - ((ti_sysbios_family_arm_m3_Hwi_ExcContext*)0), /* [0] */ -}; - -/* --> ti_sysbios_family_arm_m3_Hwi_Module_State_0_excStack__A */ -__T1_ti_sysbios_family_arm_m3_Hwi_Module_State__excStack ti_sysbios_family_arm_m3_Hwi_Module_State_0_excStack__A[1] = { - ((xdc_Ptr)0), /* [0] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_family_arm_m3_Hwi_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_family_arm_m3_Hwi_Module_State__ ti_sysbios_family_arm_m3_Hwi_Module__state__V __attribute__ ((section(".data_ti_sysbios_family_arm_m3_Hwi_Module__state__V"))); -#endif -#endif -ti_sysbios_family_arm_m3_Hwi_Module_State__ ti_sysbios_family_arm_m3_Hwi_Module__state__V = { - ((xdc_Char*)0), /* taskSP */ - ((void*)ti_sysbios_family_arm_m3_Hwi_Module_State_0_excActive__A), /* excActive */ - ((void*)ti_sysbios_family_arm_m3_Hwi_Module_State_0_excContext__A), /* excContext */ - ((void*)ti_sysbios_family_arm_m3_Hwi_Module_State_0_excStack__A), /* excStack */ - ((xdc_Ptr)0), /* isrStack */ - ((xdc_Ptr)((void*)&__TI_STACK_BASE)), /* isrStackBase */ - (xdc_SizeT)0x1000, /* isrStackSize */ - ((xdc_Ptr)(0x20000000)), /* vectorTableBase */ - (xdc_UInt)0x101, /* swiTaskKeys */ - ((xdc_Ptr)((void*)&ti_sysbios_family_arm_m3_Hwi_dispatchTable[0])), /* dispatchTable */ - 0, /* vnvicFlushRequired */ - ((void*)0), /* intAffinity */ - ((void*)0), /* intAffinityMasks */ -}; - -/* --> ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A, ".const:ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A"); -const __T1_ti_sysbios_family_arm_m3_Hwi_excHookFuncs ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A[2] = { - ((xdc_Void(*)(ti_sysbios_family_arm_m3_Hwi_ExcContext*))0), /* [0] */ - ((xdc_Void(*)(ti_sysbios_family_arm_m3_Hwi_ExcContext*))0), /* [1] */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__diagsEnabled ti_sysbios_family_arm_m3_Hwi_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__diagsIncluded ti_sysbios_family_arm_m3_Hwi_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__diagsMask__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__diagsMask ti_sysbios_family_arm_m3_Hwi_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__gateObj__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__gateObj ti_sysbios_family_arm_m3_Hwi_Module__gateObj__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__gatePrms__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__gatePrms ti_sysbios_family_arm_m3_Hwi_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__id__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__id ti_sysbios_family_arm_m3_Hwi_Module__id__C = (xdc_Bits16)0x801d; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerDefined ti_sysbios_family_arm_m3_Hwi_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerObj__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerObj ti_sysbios_family_arm_m3_Hwi_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_m3_Hwi_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Module__startupDoneFxn ti_sysbios_family_arm_m3_Hwi_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_m3_Hwi_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__count__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Object__count ti_sysbios_family_arm_m3_Hwi_Object__count__C = 9; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__heap__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Object__heap ti_sysbios_family_arm_m3_Hwi_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__sizeof__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Object__sizeof ti_sysbios_family_arm_m3_Hwi_Object__sizeof__C = sizeof(ti_sysbios_family_arm_m3_Hwi_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__table__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_Object__table ti_sysbios_family_arm_m3_Hwi_Object__table__C = ti_sysbios_family_arm_m3_Hwi_Object__table__V; - -/* dispatcherAutoNestingSupport__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_dispatcherAutoNestingSupport__C, ".const:ti_sysbios_family_arm_m3_Hwi_dispatcherAutoNestingSupport__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_dispatcherAutoNestingSupport ti_sysbios_family_arm_m3_Hwi_dispatcherAutoNestingSupport__C = 1; - -/* dispatcherSwiSupport__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_dispatcherSwiSupport__C, ".const:ti_sysbios_family_arm_m3_Hwi_dispatcherSwiSupport__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_dispatcherSwiSupport ti_sysbios_family_arm_m3_Hwi_dispatcherSwiSupport__C = 1; - -/* dispatcherTaskSupport__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_dispatcherTaskSupport__C, ".const:ti_sysbios_family_arm_m3_Hwi_dispatcherTaskSupport__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_dispatcherTaskSupport ti_sysbios_family_arm_m3_Hwi_dispatcherTaskSupport__C = 1; - -/* dispatcherIrpTrackingSupport__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_dispatcherIrpTrackingSupport__C, ".const:ti_sysbios_family_arm_m3_Hwi_dispatcherIrpTrackingSupport__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_dispatcherIrpTrackingSupport ti_sysbios_family_arm_m3_Hwi_dispatcherIrpTrackingSupport__C = 1; - -/* NUM_INTERRUPTS__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_NUM_INTERRUPTS__C, ".const:ti_sysbios_family_arm_m3_Hwi_NUM_INTERRUPTS__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_NUM_INTERRUPTS ti_sysbios_family_arm_m3_Hwi_NUM_INTERRUPTS__C = (xdc_Int)0xd8; - -/* NUM_PRIORITIES__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_NUM_PRIORITIES__C, ".const:ti_sysbios_family_arm_m3_Hwi_NUM_PRIORITIES__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_NUM_PRIORITIES ti_sysbios_family_arm_m3_Hwi_NUM_PRIORITIES__C = (xdc_Int)0x8; - -/* LM_begin__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_LM_begin__C, ".const:ti_sysbios_family_arm_m3_Hwi_LM_begin__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_LM_begin ti_sysbios_family_arm_m3_Hwi_LM_begin__C = (((xdc_runtime_Log_Event)5129) << 16 | 768); - -/* LD_end__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_LD_end__C, ".const:ti_sysbios_family_arm_m3_Hwi_LD_end__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_LD_end ti_sysbios_family_arm_m3_Hwi_LD_end__C = (((xdc_runtime_Log_Event)5199) << 16 | 512); - -/* A_unsupportedMaskingOption__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_A_unsupportedMaskingOption__C, ".const:ti_sysbios_family_arm_m3_Hwi_A_unsupportedMaskingOption__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_A_unsupportedMaskingOption ti_sysbios_family_arm_m3_Hwi_A_unsupportedMaskingOption__C = (((xdc_runtime_Assert_Id)712) << 16 | 16); - -/* E_alreadyDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_alreadyDefined__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_alreadyDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_alreadyDefined ti_sysbios_family_arm_m3_Hwi_E_alreadyDefined__C = (((xdc_runtime_Error_Id)3927) << 16 | 0); - -/* E_hwiLimitExceeded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_hwiLimitExceeded__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_hwiLimitExceeded__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_hwiLimitExceeded ti_sysbios_family_arm_m3_Hwi_E_hwiLimitExceeded__C = (((xdc_runtime_Error_Id)3975) << 16 | 0); - -/* E_exception__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_exception__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_exception__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_exception ti_sysbios_family_arm_m3_Hwi_E_exception__C = (((xdc_runtime_Error_Id)4023) << 16 | 0); - -/* E_noIsr__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_noIsr__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_noIsr__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_noIsr ti_sysbios_family_arm_m3_Hwi_E_noIsr__C = (((xdc_runtime_Error_Id)4228) << 16 | 0); - -/* E_NMI__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_NMI__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_NMI__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_NMI ti_sysbios_family_arm_m3_Hwi_E_NMI__C = (((xdc_runtime_Error_Id)4256) << 16 | 0); - -/* E_hardFault__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_hardFault__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_hardFault__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_hardFault ti_sysbios_family_arm_m3_Hwi_E_hardFault__C = (((xdc_runtime_Error_Id)4266) << 16 | 0); - -/* E_memFault__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_memFault__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_memFault__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_memFault ti_sysbios_family_arm_m3_Hwi_E_memFault__C = (((xdc_runtime_Error_Id)4282) << 16 | 0); - -/* E_busFault__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_busFault__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_busFault__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_busFault ti_sysbios_family_arm_m3_Hwi_E_busFault__C = (((xdc_runtime_Error_Id)4312) << 16 | 0); - -/* E_usageFault__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_usageFault__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_usageFault__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_usageFault ti_sysbios_family_arm_m3_Hwi_E_usageFault__C = (((xdc_runtime_Error_Id)4342) << 16 | 0); - -/* E_svCall__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_svCall__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_svCall__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_svCall ti_sysbios_family_arm_m3_Hwi_E_svCall__C = (((xdc_runtime_Error_Id)4359) << 16 | 0); - -/* E_debugMon__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_debugMon__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_debugMon__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_debugMon ti_sysbios_family_arm_m3_Hwi_E_debugMon__C = (((xdc_runtime_Error_Id)4380) << 16 | 0); - -/* E_reserved__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_E_reserved__C, ".const:ti_sysbios_family_arm_m3_Hwi_E_reserved__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_E_reserved ti_sysbios_family_arm_m3_Hwi_E_reserved__C = (((xdc_runtime_Error_Id)4395) << 16 | 0); - -/* nullIsrFunc__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_nullIsrFunc__C, ".const:ti_sysbios_family_arm_m3_Hwi_nullIsrFunc__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_nullIsrFunc ti_sysbios_family_arm_m3_Hwi_nullIsrFunc__C = ((CT__ti_sysbios_family_arm_m3_Hwi_nullIsrFunc)((xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I)); - -/* excHandlerFunc__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_excHandlerFunc__C, ".const:ti_sysbios_family_arm_m3_Hwi_excHandlerFunc__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_excHandlerFunc ti_sysbios_family_arm_m3_Hwi_excHandlerFunc__C = ((CT__ti_sysbios_family_arm_m3_Hwi_excHandlerFunc)((xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_excHandlerMax__I)); - -/* excHookFunc__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_excHookFunc__C, ".const:ti_sysbios_family_arm_m3_Hwi_excHookFunc__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_excHookFunc ti_sysbios_family_arm_m3_Hwi_excHookFunc__C = ((CT__ti_sysbios_family_arm_m3_Hwi_excHookFunc)0); - -/* excHookFuncs__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_excHookFuncs__C, ".const:ti_sysbios_family_arm_m3_Hwi_excHookFuncs__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_excHookFuncs ti_sysbios_family_arm_m3_Hwi_excHookFuncs__C = ((CT__ti_sysbios_family_arm_m3_Hwi_excHookFuncs)ti_sysbios_family_arm_m3_Hwi_excHookFuncs__A); - -/* disablePriority__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_disablePriority__C, ".const:ti_sysbios_family_arm_m3_Hwi_disablePriority__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_disablePriority ti_sysbios_family_arm_m3_Hwi_disablePriority__C = (xdc_UInt)0x20; - -/* priGroup__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_priGroup__C, ".const:ti_sysbios_family_arm_m3_Hwi_priGroup__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_priGroup ti_sysbios_family_arm_m3_Hwi_priGroup__C = (xdc_UInt)0x0; - -/* numSparseInterrupts__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_numSparseInterrupts__C, ".const:ti_sysbios_family_arm_m3_Hwi_numSparseInterrupts__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_numSparseInterrupts ti_sysbios_family_arm_m3_Hwi_numSparseInterrupts__C = (xdc_UInt)0x0; - -/* swiDisable__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_swiDisable__C, ".const:ti_sysbios_family_arm_m3_Hwi_swiDisable__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_swiDisable ti_sysbios_family_arm_m3_Hwi_swiDisable__C = ((CT__ti_sysbios_family_arm_m3_Hwi_swiDisable)((xdc_Fxn)ti_sysbios_knl_Swi_disable__E)); - -/* swiRestoreHwi__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_swiRestoreHwi__C, ".const:ti_sysbios_family_arm_m3_Hwi_swiRestoreHwi__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_swiRestoreHwi ti_sysbios_family_arm_m3_Hwi_swiRestoreHwi__C = ((CT__ti_sysbios_family_arm_m3_Hwi_swiRestoreHwi)((xdc_Fxn)ti_sysbios_knl_Swi_restoreHwi__E)); - -/* taskDisable__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_taskDisable__C, ".const:ti_sysbios_family_arm_m3_Hwi_taskDisable__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_taskDisable ti_sysbios_family_arm_m3_Hwi_taskDisable__C = ((CT__ti_sysbios_family_arm_m3_Hwi_taskDisable)((xdc_Fxn)ti_sysbios_knl_Task_disable__E)); - -/* taskRestoreHwi__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_taskRestoreHwi__C, ".const:ti_sysbios_family_arm_m3_Hwi_taskRestoreHwi__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_taskRestoreHwi ti_sysbios_family_arm_m3_Hwi_taskRestoreHwi__C = ((CT__ti_sysbios_family_arm_m3_Hwi_taskRestoreHwi)((xdc_Fxn)ti_sysbios_knl_Task_restoreHwi__E)); - -/* ccr__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_ccr__C, ".const:ti_sysbios_family_arm_m3_Hwi_ccr__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_ccr ti_sysbios_family_arm_m3_Hwi_ccr__C = (xdc_UInt32)0x200; - -/* hooks__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_hooks__C, ".const:ti_sysbios_family_arm_m3_Hwi_hooks__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_Hwi_hooks ti_sysbios_family_arm_m3_Hwi_hooks__C = {0, 0}; - - -/* - * ======== ti.sysbios.family.arm.m3.IntrinsicsSupport INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsEnabled ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsIncluded ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsMask__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsMask ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gateObj__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gateObj ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gateObj__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gatePrms__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gatePrms ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__id__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__id ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__id__C = (xdc_Bits16)0x801e; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerDefined ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerObj__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerObj ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn0 ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn1 ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn2 ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn4 ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn8 ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDoneFxn ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__count__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__count ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__heap__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__heap ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__sizeof__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__sizeof ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__table__C, ".const:ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__table ti_sysbios_family_arm_m3_IntrinsicsSupport_Object__table__C = 0; - - -/* - * ======== ti.sysbios.family.arm.m3.TaskSupport INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__diagsEnabled__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__diagsEnabled ti_sysbios_family_arm_m3_TaskSupport_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__diagsIncluded__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__diagsIncluded ti_sysbios_family_arm_m3_TaskSupport_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__diagsMask__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__diagsMask ti_sysbios_family_arm_m3_TaskSupport_Module__diagsMask__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__gateObj__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__gateObj ti_sysbios_family_arm_m3_TaskSupport_Module__gateObj__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__gatePrms__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__gatePrms ti_sysbios_family_arm_m3_TaskSupport_Module__gatePrms__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__id__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__id__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__id ti_sysbios_family_arm_m3_TaskSupport_Module__id__C = (xdc_Bits16)0x801f; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerDefined__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerDefined ti_sysbios_family_arm_m3_TaskSupport_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerObj__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerObj ti_sysbios_family_arm_m3_TaskSupport_Module__loggerObj__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn0__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn0 ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn0__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn1__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn1 ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn1__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn2__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn2 ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn2__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn4__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn4 ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn4__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn8__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn8 ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn8__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Module__startupDoneFxn__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Module__startupDoneFxn ti_sysbios_family_arm_m3_TaskSupport_Module__startupDoneFxn__C = ((CT__ti_sysbios_family_arm_m3_TaskSupport_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Object__count__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Object__count__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Object__count ti_sysbios_family_arm_m3_TaskSupport_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Object__heap__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Object__heap__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Object__heap ti_sysbios_family_arm_m3_TaskSupport_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Object__sizeof__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Object__sizeof ti_sysbios_family_arm_m3_TaskSupport_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_Object__table__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_Object__table__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_Object__table ti_sysbios_family_arm_m3_TaskSupport_Object__table__C = 0; - -/* defaultStackSize__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_defaultStackSize__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_defaultStackSize__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_defaultStackSize ti_sysbios_family_arm_m3_TaskSupport_defaultStackSize__C = (xdc_SizeT)0x800; - -/* stackAlignment__C */ -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_TaskSupport_stackAlignment__C, ".const:ti_sysbios_family_arm_m3_TaskSupport_stackAlignment__C"); -__FAR__ const CT__ti_sysbios_family_arm_m3_TaskSupport_stackAlignment ti_sysbios_family_arm_m3_TaskSupport_stackAlignment__C = (xdc_UInt)0x8; - - -/* - * ======== ti.sysbios.gates.GateHwi INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_gates_GateHwi_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__PARAMS__C, ".const:ti_sysbios_gates_GateHwi_Object__PARAMS__C"); -__FAR__ const ti_sysbios_gates_GateHwi_Params ti_sysbios_gates_GateHwi_Object__PARAMS__C = { - sizeof (ti_sysbios_gates_GateHwi_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_gates_GateHwi_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_gates_GateHwi_Module__ ti_sysbios_gates_GateHwi_Module__root__V = { - {&ti_sysbios_gates_GateHwi_Module__root__V.link, /* link.next */ - &ti_sysbios_gates_GateHwi_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_gates_GateHwi_Object__ ti_sysbios_gates_GateHwi_Object__table__V[1] = { - {/* instance#0 */ - &ti_sysbios_gates_GateHwi_Module__FXNS__C, - }, -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__diagsEnabled__C, ".const:ti_sysbios_gates_GateHwi_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__diagsEnabled ti_sysbios_gates_GateHwi_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__diagsIncluded__C, ".const:ti_sysbios_gates_GateHwi_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__diagsIncluded ti_sysbios_gates_GateHwi_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__diagsMask__C, ".const:ti_sysbios_gates_GateHwi_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__diagsMask ti_sysbios_gates_GateHwi_Module__diagsMask__C = ((CT__ti_sysbios_gates_GateHwi_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__gateObj__C, ".const:ti_sysbios_gates_GateHwi_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__gateObj ti_sysbios_gates_GateHwi_Module__gateObj__C = ((CT__ti_sysbios_gates_GateHwi_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__gatePrms__C, ".const:ti_sysbios_gates_GateHwi_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__gatePrms ti_sysbios_gates_GateHwi_Module__gatePrms__C = ((CT__ti_sysbios_gates_GateHwi_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__id__C, ".const:ti_sysbios_gates_GateHwi_Module__id__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__id ti_sysbios_gates_GateHwi_Module__id__C = (xdc_Bits16)0x803b; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerDefined__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerDefined ti_sysbios_gates_GateHwi_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerObj__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerObj ti_sysbios_gates_GateHwi_Module__loggerObj__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerFxn0__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerFxn0 ti_sysbios_gates_GateHwi_Module__loggerFxn0__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerFxn1__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerFxn1 ti_sysbios_gates_GateHwi_Module__loggerFxn1__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerFxn2__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerFxn2 ti_sysbios_gates_GateHwi_Module__loggerFxn2__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerFxn4__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerFxn4 ti_sysbios_gates_GateHwi_Module__loggerFxn4__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__loggerFxn8__C, ".const:ti_sysbios_gates_GateHwi_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__loggerFxn8 ti_sysbios_gates_GateHwi_Module__loggerFxn8__C = ((CT__ti_sysbios_gates_GateHwi_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Module__startupDoneFxn__C, ".const:ti_sysbios_gates_GateHwi_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Module__startupDoneFxn ti_sysbios_gates_GateHwi_Module__startupDoneFxn__C = ((CT__ti_sysbios_gates_GateHwi_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__count__C, ".const:ti_sysbios_gates_GateHwi_Object__count__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Object__count ti_sysbios_gates_GateHwi_Object__count__C = 1; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__heap__C, ".const:ti_sysbios_gates_GateHwi_Object__heap__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Object__heap ti_sysbios_gates_GateHwi_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__sizeof__C, ".const:ti_sysbios_gates_GateHwi_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Object__sizeof ti_sysbios_gates_GateHwi_Object__sizeof__C = sizeof(ti_sysbios_gates_GateHwi_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__table__C, ".const:ti_sysbios_gates_GateHwi_Object__table__C"); -__FAR__ const CT__ti_sysbios_gates_GateHwi_Object__table ti_sysbios_gates_GateHwi_Object__table__C = ti_sysbios_gates_GateHwi_Object__table__V; - - -/* - * ======== ti.sysbios.gates.GateMutex INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_gates_GateMutex_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__PARAMS__C, ".const:ti_sysbios_gates_GateMutex_Object__PARAMS__C"); -__FAR__ const ti_sysbios_gates_GateMutex_Params ti_sysbios_gates_GateMutex_Object__PARAMS__C = { - sizeof (ti_sysbios_gates_GateMutex_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_gates_GateMutex_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_gates_GateMutex_Module__ ti_sysbios_gates_GateMutex_Module__root__V = { - {&ti_sysbios_gates_GateMutex_Module__root__V.link, /* link.next */ - &ti_sysbios_gates_GateMutex_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_gates_GateMutex_Object__ ti_sysbios_gates_GateMutex_Object__table__V[2] = { - {/* instance#0 */ - &ti_sysbios_gates_GateMutex_Module__FXNS__C, - 0, /* owner */ - { - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_COUNTING, /* mode */ - (xdc_UInt16)0x1, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_gates_GateMutex_Object__table__V[0].Object_field_sem.Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_gates_GateMutex_Object__table__V[0].Object_field_sem.Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, /* Object_field_sem */ - }, - {/* instance#1 */ - &ti_sysbios_gates_GateMutex_Module__FXNS__C, - 0, /* owner */ - { - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_COUNTING, /* mode */ - (xdc_UInt16)0x1, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_gates_GateMutex_Object__table__V[1].Object_field_sem.Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_gates_GateMutex_Object__table__V[1].Object_field_sem.Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, /* Object_field_sem */ - }, -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__diagsEnabled__C, ".const:ti_sysbios_gates_GateMutex_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__diagsEnabled ti_sysbios_gates_GateMutex_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__diagsIncluded__C, ".const:ti_sysbios_gates_GateMutex_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__diagsIncluded ti_sysbios_gates_GateMutex_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__diagsMask__C, ".const:ti_sysbios_gates_GateMutex_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__diagsMask ti_sysbios_gates_GateMutex_Module__diagsMask__C = ((CT__ti_sysbios_gates_GateMutex_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__gateObj__C, ".const:ti_sysbios_gates_GateMutex_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__gateObj ti_sysbios_gates_GateMutex_Module__gateObj__C = ((CT__ti_sysbios_gates_GateMutex_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__gatePrms__C, ".const:ti_sysbios_gates_GateMutex_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__gatePrms ti_sysbios_gates_GateMutex_Module__gatePrms__C = ((CT__ti_sysbios_gates_GateMutex_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__id__C, ".const:ti_sysbios_gates_GateMutex_Module__id__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__id ti_sysbios_gates_GateMutex_Module__id__C = (xdc_Bits16)0x803c; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerDefined__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerDefined ti_sysbios_gates_GateMutex_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerObj__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerObj ti_sysbios_gates_GateMutex_Module__loggerObj__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerFxn0__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerFxn0 ti_sysbios_gates_GateMutex_Module__loggerFxn0__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerFxn1__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerFxn1 ti_sysbios_gates_GateMutex_Module__loggerFxn1__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerFxn2__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerFxn2 ti_sysbios_gates_GateMutex_Module__loggerFxn2__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerFxn4__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerFxn4 ti_sysbios_gates_GateMutex_Module__loggerFxn4__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__loggerFxn8__C, ".const:ti_sysbios_gates_GateMutex_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__loggerFxn8 ti_sysbios_gates_GateMutex_Module__loggerFxn8__C = ((CT__ti_sysbios_gates_GateMutex_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Module__startupDoneFxn__C, ".const:ti_sysbios_gates_GateMutex_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Module__startupDoneFxn ti_sysbios_gates_GateMutex_Module__startupDoneFxn__C = ((CT__ti_sysbios_gates_GateMutex_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__count__C, ".const:ti_sysbios_gates_GateMutex_Object__count__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Object__count ti_sysbios_gates_GateMutex_Object__count__C = 2; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__heap__C, ".const:ti_sysbios_gates_GateMutex_Object__heap__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Object__heap ti_sysbios_gates_GateMutex_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__sizeof__C, ".const:ti_sysbios_gates_GateMutex_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Object__sizeof ti_sysbios_gates_GateMutex_Object__sizeof__C = sizeof(ti_sysbios_gates_GateMutex_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__table__C, ".const:ti_sysbios_gates_GateMutex_Object__table__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_Object__table ti_sysbios_gates_GateMutex_Object__table__C = ti_sysbios_gates_GateMutex_Object__table__V; - -/* A_badContext__C */ -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_A_badContext__C, ".const:ti_sysbios_gates_GateMutex_A_badContext__C"); -__FAR__ const CT__ti_sysbios_gates_GateMutex_A_badContext ti_sysbios_gates_GateMutex_A_badContext__C = (((xdc_runtime_Assert_Id)2658) << 16 | 16); - - -/* - * ======== ti.sysbios.hal.Hwi INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_hal_Hwi_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__PARAMS__C, ".const:ti_sysbios_hal_Hwi_Object__PARAMS__C"); -__FAR__ const ti_sysbios_hal_Hwi_Params ti_sysbios_hal_Hwi_Object__PARAMS__C = { - sizeof (ti_sysbios_hal_Hwi_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_hal_Hwi_Object__PARAMS__C.__iprms, /* instance */ - ti_sysbios_interfaces_IHwi_MaskingOption_LOWER, /* maskSetting */ - ((xdc_UArg)(0x0)), /* arg */ - 1, /* enableInt */ - (xdc_Int)(-0x0 - 1), /* eventId */ - (xdc_Int)(-0x0 - 1), /* priority */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_hal_Hwi_Module__ ti_sysbios_hal_Hwi_Module__root__V = { - {&ti_sysbios_hal_Hwi_Module__root__V.link, /* link.next */ - &ti_sysbios_hal_Hwi_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__diagsEnabled__C, ".const:ti_sysbios_hal_Hwi_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__diagsEnabled ti_sysbios_hal_Hwi_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__diagsIncluded__C, ".const:ti_sysbios_hal_Hwi_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__diagsIncluded ti_sysbios_hal_Hwi_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__diagsMask__C, ".const:ti_sysbios_hal_Hwi_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__diagsMask ti_sysbios_hal_Hwi_Module__diagsMask__C = ((CT__ti_sysbios_hal_Hwi_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__gateObj__C, ".const:ti_sysbios_hal_Hwi_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__gateObj ti_sysbios_hal_Hwi_Module__gateObj__C = ((CT__ti_sysbios_hal_Hwi_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__gatePrms__C, ".const:ti_sysbios_hal_Hwi_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__gatePrms ti_sysbios_hal_Hwi_Module__gatePrms__C = ((CT__ti_sysbios_hal_Hwi_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__id__C, ".const:ti_sysbios_hal_Hwi_Module__id__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__id ti_sysbios_hal_Hwi_Module__id__C = (xdc_Bits16)0x802b; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerDefined__C, ".const:ti_sysbios_hal_Hwi_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerDefined ti_sysbios_hal_Hwi_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerObj__C, ".const:ti_sysbios_hal_Hwi_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerObj ti_sysbios_hal_Hwi_Module__loggerObj__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerFxn0__C, ".const:ti_sysbios_hal_Hwi_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerFxn0 ti_sysbios_hal_Hwi_Module__loggerFxn0__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerFxn1__C, ".const:ti_sysbios_hal_Hwi_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerFxn1 ti_sysbios_hal_Hwi_Module__loggerFxn1__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerFxn2__C, ".const:ti_sysbios_hal_Hwi_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerFxn2 ti_sysbios_hal_Hwi_Module__loggerFxn2__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerFxn4__C, ".const:ti_sysbios_hal_Hwi_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerFxn4 ti_sysbios_hal_Hwi_Module__loggerFxn4__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__loggerFxn8__C, ".const:ti_sysbios_hal_Hwi_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__loggerFxn8 ti_sysbios_hal_Hwi_Module__loggerFxn8__C = ((CT__ti_sysbios_hal_Hwi_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Module__startupDoneFxn__C, ".const:ti_sysbios_hal_Hwi_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Module__startupDoneFxn ti_sysbios_hal_Hwi_Module__startupDoneFxn__C = ((CT__ti_sysbios_hal_Hwi_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__count__C, ".const:ti_sysbios_hal_Hwi_Object__count__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Object__count ti_sysbios_hal_Hwi_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__heap__C, ".const:ti_sysbios_hal_Hwi_Object__heap__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Object__heap ti_sysbios_hal_Hwi_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__sizeof__C, ".const:ti_sysbios_hal_Hwi_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Object__sizeof ti_sysbios_hal_Hwi_Object__sizeof__C = sizeof(ti_sysbios_hal_Hwi_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__table__C, ".const:ti_sysbios_hal_Hwi_Object__table__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_Object__table ti_sysbios_hal_Hwi_Object__table__C = 0; - -/* dispatcherAutoNestingSupport__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_dispatcherAutoNestingSupport__C, ".const:ti_sysbios_hal_Hwi_dispatcherAutoNestingSupport__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_dispatcherAutoNestingSupport ti_sysbios_hal_Hwi_dispatcherAutoNestingSupport__C = 1; - -/* dispatcherSwiSupport__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_dispatcherSwiSupport__C, ".const:ti_sysbios_hal_Hwi_dispatcherSwiSupport__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_dispatcherSwiSupport ti_sysbios_hal_Hwi_dispatcherSwiSupport__C = 1; - -/* dispatcherTaskSupport__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_dispatcherTaskSupport__C, ".const:ti_sysbios_hal_Hwi_dispatcherTaskSupport__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_dispatcherTaskSupport ti_sysbios_hal_Hwi_dispatcherTaskSupport__C = 1; - -/* dispatcherIrpTrackingSupport__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_dispatcherIrpTrackingSupport__C, ".const:ti_sysbios_hal_Hwi_dispatcherIrpTrackingSupport__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_dispatcherIrpTrackingSupport ti_sysbios_hal_Hwi_dispatcherIrpTrackingSupport__C = 1; - -/* E_stackOverflow__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_E_stackOverflow__C, ".const:ti_sysbios_hal_Hwi_E_stackOverflow__C"); -__FAR__ const CT__ti_sysbios_hal_Hwi_E_stackOverflow ti_sysbios_hal_Hwi_E_stackOverflow__C = (((xdc_runtime_Error_Id)4671) << 16 | 0); - - -/* - * ======== ti.sysbios.hal.Hwi_HwiProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.hal.Seconds INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__diagsEnabled__C, ".const:ti_sysbios_hal_Seconds_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__diagsEnabled ti_sysbios_hal_Seconds_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__diagsIncluded__C, ".const:ti_sysbios_hal_Seconds_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__diagsIncluded ti_sysbios_hal_Seconds_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__diagsMask__C, ".const:ti_sysbios_hal_Seconds_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__diagsMask ti_sysbios_hal_Seconds_Module__diagsMask__C = ((CT__ti_sysbios_hal_Seconds_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__gateObj__C, ".const:ti_sysbios_hal_Seconds_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__gateObj ti_sysbios_hal_Seconds_Module__gateObj__C = ((CT__ti_sysbios_hal_Seconds_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__gatePrms__C, ".const:ti_sysbios_hal_Seconds_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__gatePrms ti_sysbios_hal_Seconds_Module__gatePrms__C = ((CT__ti_sysbios_hal_Seconds_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__id__C, ".const:ti_sysbios_hal_Seconds_Module__id__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__id ti_sysbios_hal_Seconds_Module__id__C = (xdc_Bits16)0x802c; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerDefined__C, ".const:ti_sysbios_hal_Seconds_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerDefined ti_sysbios_hal_Seconds_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerObj__C, ".const:ti_sysbios_hal_Seconds_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerObj ti_sysbios_hal_Seconds_Module__loggerObj__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerFxn0__C, ".const:ti_sysbios_hal_Seconds_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerFxn0 ti_sysbios_hal_Seconds_Module__loggerFxn0__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerFxn1__C, ".const:ti_sysbios_hal_Seconds_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerFxn1 ti_sysbios_hal_Seconds_Module__loggerFxn1__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerFxn2__C, ".const:ti_sysbios_hal_Seconds_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerFxn2 ti_sysbios_hal_Seconds_Module__loggerFxn2__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerFxn4__C, ".const:ti_sysbios_hal_Seconds_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerFxn4 ti_sysbios_hal_Seconds_Module__loggerFxn4__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__loggerFxn8__C, ".const:ti_sysbios_hal_Seconds_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__loggerFxn8 ti_sysbios_hal_Seconds_Module__loggerFxn8__C = ((CT__ti_sysbios_hal_Seconds_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Module__startupDoneFxn__C, ".const:ti_sysbios_hal_Seconds_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Module__startupDoneFxn ti_sysbios_hal_Seconds_Module__startupDoneFxn__C = ((CT__ti_sysbios_hal_Seconds_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Object__count__C, ".const:ti_sysbios_hal_Seconds_Object__count__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Object__count ti_sysbios_hal_Seconds_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Object__heap__C, ".const:ti_sysbios_hal_Seconds_Object__heap__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Object__heap ti_sysbios_hal_Seconds_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Object__sizeof__C, ".const:ti_sysbios_hal_Seconds_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Object__sizeof ti_sysbios_hal_Seconds_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_hal_Seconds_Object__table__C, ".const:ti_sysbios_hal_Seconds_Object__table__C"); -__FAR__ const CT__ti_sysbios_hal_Seconds_Object__table ti_sysbios_hal_Seconds_Object__table__C = 0; - - -/* - * ======== ti.sysbios.hal.Seconds_SecondsProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.heaps.HeapMem INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_heaps_HeapMem_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__PARAMS__C, ".const:ti_sysbios_heaps_HeapMem_Object__PARAMS__C"); -__FAR__ const ti_sysbios_heaps_HeapMem_Params ti_sysbios_heaps_HeapMem_Object__PARAMS__C = { - sizeof (ti_sysbios_heaps_HeapMem_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_heaps_HeapMem_Object__PARAMS__C.__iprms, /* instance */ - (xdc_SizeT)0x0, /* minBlockAlign */ - ((xdc_Ptr)(0x0)), /* buf */ - ((xdc_UArg)(0x0)), /* size */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* --> ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A */ -__T1_ti_sysbios_heaps_HeapMem_Instance_State__buf ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A[30760]; - -/* Module__root__V */ -ti_sysbios_heaps_HeapMem_Module__ ti_sysbios_heaps_HeapMem_Module__root__V = { - {&ti_sysbios_heaps_HeapMem_Module__root__V.link, /* link.next */ - &ti_sysbios_heaps_HeapMem_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_heaps_HeapMem_Object__ ti_sysbios_heaps_HeapMem_Object__table__V[1] = { - {/* instance#0 */ - &ti_sysbios_heaps_HeapMem_Module__FXNS__C, - ((xdc_UArg)(0x8)), /* align */ - ((void*)ti_sysbios_heaps_HeapMem_Instance_State_0_buf__A), /* buf */ - { - ((ti_sysbios_heaps_HeapMem_Header*)0), /* next */ - ((xdc_UArg)(0x7828)), /* size */ - }, /* head */ - (xdc_SizeT)0x8, /* minBlockAlign */ - }, -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__diagsEnabled__C, ".const:ti_sysbios_heaps_HeapMem_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__diagsEnabled ti_sysbios_heaps_HeapMem_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__diagsIncluded__C, ".const:ti_sysbios_heaps_HeapMem_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__diagsIncluded ti_sysbios_heaps_HeapMem_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__diagsMask__C, ".const:ti_sysbios_heaps_HeapMem_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__diagsMask ti_sysbios_heaps_HeapMem_Module__diagsMask__C = ((CT__ti_sysbios_heaps_HeapMem_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__gateObj__C, ".const:ti_sysbios_heaps_HeapMem_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__gateObj ti_sysbios_heaps_HeapMem_Module__gateObj__C = ((CT__ti_sysbios_heaps_HeapMem_Module__gateObj)((void*)(xdc_runtime_IGateProvider_Handle)&ti_sysbios_gates_GateMutex_Object__table__V[0])); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__gatePrms__C, ".const:ti_sysbios_heaps_HeapMem_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__gatePrms ti_sysbios_heaps_HeapMem_Module__gatePrms__C = ((CT__ti_sysbios_heaps_HeapMem_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__id__C, ".const:ti_sysbios_heaps_HeapMem_Module__id__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__id ti_sysbios_heaps_HeapMem_Module__id__C = (xdc_Bits16)0x8040; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerDefined__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerDefined ti_sysbios_heaps_HeapMem_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerObj__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerObj ti_sysbios_heaps_HeapMem_Module__loggerObj__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerFxn0__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn0 ti_sysbios_heaps_HeapMem_Module__loggerFxn0__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerFxn1__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn1 ti_sysbios_heaps_HeapMem_Module__loggerFxn1__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerFxn2__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn2 ti_sysbios_heaps_HeapMem_Module__loggerFxn2__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerFxn4__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn4 ti_sysbios_heaps_HeapMem_Module__loggerFxn4__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__loggerFxn8__C, ".const:ti_sysbios_heaps_HeapMem_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn8 ti_sysbios_heaps_HeapMem_Module__loggerFxn8__C = ((CT__ti_sysbios_heaps_HeapMem_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Module__startupDoneFxn__C, ".const:ti_sysbios_heaps_HeapMem_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Module__startupDoneFxn ti_sysbios_heaps_HeapMem_Module__startupDoneFxn__C = ((CT__ti_sysbios_heaps_HeapMem_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__count__C, ".const:ti_sysbios_heaps_HeapMem_Object__count__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Object__count ti_sysbios_heaps_HeapMem_Object__count__C = 1; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__heap__C, ".const:ti_sysbios_heaps_HeapMem_Object__heap__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Object__heap ti_sysbios_heaps_HeapMem_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__sizeof__C, ".const:ti_sysbios_heaps_HeapMem_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Object__sizeof ti_sysbios_heaps_HeapMem_Object__sizeof__C = sizeof(ti_sysbios_heaps_HeapMem_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__table__C, ".const:ti_sysbios_heaps_HeapMem_Object__table__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_Object__table ti_sysbios_heaps_HeapMem_Object__table__C = ti_sysbios_heaps_HeapMem_Object__table__V; - -/* A_zeroBlock__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_A_zeroBlock__C, ".const:ti_sysbios_heaps_HeapMem_A_zeroBlock__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_A_zeroBlock ti_sysbios_heaps_HeapMem_A_zeroBlock__C = (((xdc_runtime_Assert_Id)3344) << 16 | 16); - -/* A_heapSize__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_A_heapSize__C, ".const:ti_sysbios_heaps_HeapMem_A_heapSize__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_A_heapSize ti_sysbios_heaps_HeapMem_A_heapSize__C = (((xdc_runtime_Assert_Id)3380) << 16 | 16); - -/* A_align__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_A_align__C, ".const:ti_sysbios_heaps_HeapMem_A_align__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_A_align ti_sysbios_heaps_HeapMem_A_align__C = (((xdc_runtime_Assert_Id)3425) << 16 | 16); - -/* E_memory__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_E_memory__C, ".const:ti_sysbios_heaps_HeapMem_E_memory__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_E_memory ti_sysbios_heaps_HeapMem_E_memory__C = (((xdc_runtime_Error_Id)4917) << 16 | 0); - -/* A_invalidFree__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_A_invalidFree__C, ".const:ti_sysbios_heaps_HeapMem_A_invalidFree__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_A_invalidFree ti_sysbios_heaps_HeapMem_A_invalidFree__C = (((xdc_runtime_Assert_Id)3316) << 16 | 16); - -/* primaryHeapBaseAddr__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_primaryHeapBaseAddr__C, ".const:ti_sysbios_heaps_HeapMem_primaryHeapBaseAddr__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_primaryHeapBaseAddr ti_sysbios_heaps_HeapMem_primaryHeapBaseAddr__C = ((CT__ti_sysbios_heaps_HeapMem_primaryHeapBaseAddr)0); - -/* primaryHeapEndAddr__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_primaryHeapEndAddr__C, ".const:ti_sysbios_heaps_HeapMem_primaryHeapEndAddr__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_primaryHeapEndAddr ti_sysbios_heaps_HeapMem_primaryHeapEndAddr__C = ((CT__ti_sysbios_heaps_HeapMem_primaryHeapEndAddr)0); - -/* reqAlign__C */ -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_reqAlign__C, ".const:ti_sysbios_heaps_HeapMem_reqAlign__C"); -__FAR__ const CT__ti_sysbios_heaps_HeapMem_reqAlign ti_sysbios_heaps_HeapMem_reqAlign__C = (xdc_SizeT)0x8; - - -/* - * ======== ti.sysbios.heaps.HeapMem_Module_GateProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.io.DEV INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_io_DEV_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__PARAMS__C, ".const:ti_sysbios_io_DEV_Object__PARAMS__C"); -__FAR__ const ti_sysbios_io_DEV_Params ti_sysbios_io_DEV_Object__PARAMS__C = { - sizeof (ti_sysbios_io_DEV_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_io_DEV_Object__PARAMS__C.__iprms, /* instance */ - ((xdc_Ptr)0), /* deviceParams */ - ((xdc_Void(*)(xdc_Void))0), /* initFxn */ - (xdc_Int)0x0, /* devid */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_io_DEV_Module__ ti_sysbios_io_DEV_Module__root__V = { - {&ti_sysbios_io_DEV_Module__root__V.link, /* link.next */ - &ti_sysbios_io_DEV_Module__root__V.link}, /* link.prev */ -}; - -/* --> ti_sysbios_io_DEV_Module_State_0_table__A */ -__T1_ti_sysbios_io_DEV_Module_State__table ti_sysbios_io_DEV_Module_State_0_table__A[8] = { - 0, /* [0] */ - 0, /* [1] */ - 0, /* [2] */ - 0, /* [3] */ - 0, /* [4] */ - 0, /* [5] */ - 0, /* [6] */ - 0, /* [7] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_io_DEV_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_io_DEV_Module_State__ ti_sysbios_io_DEV_Module__state__V __attribute__ ((section(".data_ti_sysbios_io_DEV_Module__state__V"))); -#endif -#endif -ti_sysbios_io_DEV_Module_State__ ti_sysbios_io_DEV_Module__state__V = { - ((void*)ti_sysbios_io_DEV_Module_State_0_table__A), /* table */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__diagsEnabled__C, ".const:ti_sysbios_io_DEV_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__diagsEnabled ti_sysbios_io_DEV_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__diagsIncluded__C, ".const:ti_sysbios_io_DEV_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__diagsIncluded ti_sysbios_io_DEV_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__diagsMask__C, ".const:ti_sysbios_io_DEV_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__diagsMask ti_sysbios_io_DEV_Module__diagsMask__C = ((CT__ti_sysbios_io_DEV_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__gateObj__C, ".const:ti_sysbios_io_DEV_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__gateObj ti_sysbios_io_DEV_Module__gateObj__C = ((CT__ti_sysbios_io_DEV_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__gatePrms__C, ".const:ti_sysbios_io_DEV_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__gatePrms ti_sysbios_io_DEV_Module__gatePrms__C = ((CT__ti_sysbios_io_DEV_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__id__C, ".const:ti_sysbios_io_DEV_Module__id__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__id ti_sysbios_io_DEV_Module__id__C = (xdc_Bits16)0x8038; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerDefined__C, ".const:ti_sysbios_io_DEV_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerDefined ti_sysbios_io_DEV_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerObj__C, ".const:ti_sysbios_io_DEV_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerObj ti_sysbios_io_DEV_Module__loggerObj__C = ((CT__ti_sysbios_io_DEV_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerFxn0__C, ".const:ti_sysbios_io_DEV_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerFxn0 ti_sysbios_io_DEV_Module__loggerFxn0__C = ((CT__ti_sysbios_io_DEV_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerFxn1__C, ".const:ti_sysbios_io_DEV_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerFxn1 ti_sysbios_io_DEV_Module__loggerFxn1__C = ((CT__ti_sysbios_io_DEV_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerFxn2__C, ".const:ti_sysbios_io_DEV_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerFxn2 ti_sysbios_io_DEV_Module__loggerFxn2__C = ((CT__ti_sysbios_io_DEV_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerFxn4__C, ".const:ti_sysbios_io_DEV_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerFxn4 ti_sysbios_io_DEV_Module__loggerFxn4__C = ((CT__ti_sysbios_io_DEV_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__loggerFxn8__C, ".const:ti_sysbios_io_DEV_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__loggerFxn8 ti_sysbios_io_DEV_Module__loggerFxn8__C = ((CT__ti_sysbios_io_DEV_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Module__startupDoneFxn__C, ".const:ti_sysbios_io_DEV_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Module__startupDoneFxn ti_sysbios_io_DEV_Module__startupDoneFxn__C = ((CT__ti_sysbios_io_DEV_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__count__C, ".const:ti_sysbios_io_DEV_Object__count__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Object__count ti_sysbios_io_DEV_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__heap__C, ".const:ti_sysbios_io_DEV_Object__heap__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Object__heap ti_sysbios_io_DEV_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__sizeof__C, ".const:ti_sysbios_io_DEV_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Object__sizeof ti_sysbios_io_DEV_Object__sizeof__C = sizeof(ti_sysbios_io_DEV_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__table__C, ".const:ti_sysbios_io_DEV_Object__table__C"); -__FAR__ const CT__ti_sysbios_io_DEV_Object__table ti_sysbios_io_DEV_Object__table__C = 0; - -/* tableSize__C */ -#pragma DATA_SECTION(ti_sysbios_io_DEV_tableSize__C, ".const:ti_sysbios_io_DEV_tableSize__C"); -__FAR__ const CT__ti_sysbios_io_DEV_tableSize ti_sysbios_io_DEV_tableSize__C = (xdc_UInt)0x8; - - -/* - * ======== ti.sysbios.io.GIO INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_io_GIO_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__PARAMS__C, ".const:ti_sysbios_io_GIO_Object__PARAMS__C"); -__FAR__ const ti_sysbios_io_GIO_Params ti_sysbios_io_GIO_Object__PARAMS__C = { - sizeof (ti_sysbios_io_GIO_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_io_GIO_Object__PARAMS__C.__iprms, /* instance */ - ti_sysbios_io_GIO_Model_STANDARD, /* model */ - (xdc_Int)0x2, /* numPackets */ - (xdc_UInt)(-0x0 - 1), /* timeout */ - 0, /* sync */ - ((xdc_Ptr)0), /* chanParams */ - ((xdc_Ptr)0), /* packets */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_io_GIO_Module__ ti_sysbios_io_GIO_Module__root__V = { - {&ti_sysbios_io_GIO_Module__root__V.link, /* link.next */ - &ti_sysbios_io_GIO_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__diagsEnabled__C, ".const:ti_sysbios_io_GIO_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__diagsEnabled ti_sysbios_io_GIO_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__diagsIncluded__C, ".const:ti_sysbios_io_GIO_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__diagsIncluded ti_sysbios_io_GIO_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__diagsMask__C, ".const:ti_sysbios_io_GIO_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__diagsMask ti_sysbios_io_GIO_Module__diagsMask__C = ((CT__ti_sysbios_io_GIO_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__gateObj__C, ".const:ti_sysbios_io_GIO_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__gateObj ti_sysbios_io_GIO_Module__gateObj__C = ((CT__ti_sysbios_io_GIO_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__gatePrms__C, ".const:ti_sysbios_io_GIO_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__gatePrms ti_sysbios_io_GIO_Module__gatePrms__C = ((CT__ti_sysbios_io_GIO_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__id__C, ".const:ti_sysbios_io_GIO_Module__id__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__id ti_sysbios_io_GIO_Module__id__C = (xdc_Bits16)0x8039; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerDefined__C, ".const:ti_sysbios_io_GIO_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerDefined ti_sysbios_io_GIO_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerObj__C, ".const:ti_sysbios_io_GIO_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerObj ti_sysbios_io_GIO_Module__loggerObj__C = ((CT__ti_sysbios_io_GIO_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerFxn0__C, ".const:ti_sysbios_io_GIO_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerFxn0 ti_sysbios_io_GIO_Module__loggerFxn0__C = ((CT__ti_sysbios_io_GIO_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerFxn1__C, ".const:ti_sysbios_io_GIO_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerFxn1 ti_sysbios_io_GIO_Module__loggerFxn1__C = ((CT__ti_sysbios_io_GIO_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerFxn2__C, ".const:ti_sysbios_io_GIO_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerFxn2 ti_sysbios_io_GIO_Module__loggerFxn2__C = ((CT__ti_sysbios_io_GIO_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerFxn4__C, ".const:ti_sysbios_io_GIO_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerFxn4 ti_sysbios_io_GIO_Module__loggerFxn4__C = ((CT__ti_sysbios_io_GIO_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__loggerFxn8__C, ".const:ti_sysbios_io_GIO_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__loggerFxn8 ti_sysbios_io_GIO_Module__loggerFxn8__C = ((CT__ti_sysbios_io_GIO_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Module__startupDoneFxn__C, ".const:ti_sysbios_io_GIO_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Module__startupDoneFxn ti_sysbios_io_GIO_Module__startupDoneFxn__C = ((CT__ti_sysbios_io_GIO_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__count__C, ".const:ti_sysbios_io_GIO_Object__count__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Object__count ti_sysbios_io_GIO_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__heap__C, ".const:ti_sysbios_io_GIO_Object__heap__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Object__heap ti_sysbios_io_GIO_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__sizeof__C, ".const:ti_sysbios_io_GIO_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Object__sizeof ti_sysbios_io_GIO_Object__sizeof__C = sizeof(ti_sysbios_io_GIO_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__table__C, ".const:ti_sysbios_io_GIO_Object__table__C"); -__FAR__ const CT__ti_sysbios_io_GIO_Object__table ti_sysbios_io_GIO_Object__table__C = 0; - -/* E_notFound__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_E_notFound__C, ".const:ti_sysbios_io_GIO_E_notFound__C"); -__FAR__ const CT__ti_sysbios_io_GIO_E_notFound ti_sysbios_io_GIO_E_notFound__C = (((xdc_runtime_Error_Id)4750) << 16 | 0); - -/* E_createFailed__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_E_createFailed__C, ".const:ti_sysbios_io_GIO_E_createFailed__C"); -__FAR__ const CT__ti_sysbios_io_GIO_E_createFailed ti_sysbios_io_GIO_E_createFailed__C = (((xdc_runtime_Error_Id)4780) << 16 | 0); - -/* A_badModel__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_A_badModel__C, ".const:ti_sysbios_io_GIO_A_badModel__C"); -__FAR__ const CT__ti_sysbios_io_GIO_A_badModel ti_sysbios_io_GIO_A_badModel__C = (((xdc_runtime_Assert_Id)2245) << 16 | 16); - -/* deviceTableSize__C */ -#pragma DATA_SECTION(ti_sysbios_io_GIO_deviceTableSize__C, ".const:ti_sysbios_io_GIO_deviceTableSize__C"); -__FAR__ const CT__ti_sysbios_io_GIO_deviceTableSize ti_sysbios_io_GIO_deviceTableSize__C = (xdc_Int)0x8; - - -/* - * ======== ti.sysbios.knl.Clock INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Clock_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__PARAMS__C, ".const:ti_sysbios_knl_Clock_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Clock_Params ti_sysbios_knl_Clock_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Clock_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Clock_Object__PARAMS__C.__iprms, /* instance */ - 0, /* startFlag */ - (xdc_UInt32)0x0, /* period */ - ((xdc_UArg)0), /* arg */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Clock_Module__ ti_sysbios_knl_Clock_Module__root__V = { - {&ti_sysbios_knl_Clock_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Clock_Module__root__V.link}, /* link.prev */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_knl_Clock_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_knl_Clock_Module_State__ ti_sysbios_knl_Clock_Module__state__V __attribute__ ((section(".data_ti_sysbios_knl_Clock_Module__state__V"))); -#endif -#endif -ti_sysbios_knl_Clock_Module_State__ ti_sysbios_knl_Clock_Module__state__V = { - (xdc_UInt32)0x0, /* ticks */ - (xdc_UInt)0x0, /* swiCount */ - (ti_sysbios_knl_Clock_TimerProxy_Handle)&ti_sysbios_family_arm_lm4_Timer_Object__table__V[0], /* timer */ - (ti_sysbios_knl_Swi_Handle)&ti_sysbios_knl_Swi_Object__table__V[0], /* swi */ - (xdc_UInt)0x1, /* numTickSkip */ - (xdc_UInt32)0x1, /* nextScheduledTick */ - (xdc_UInt32)0x0, /* maxSkippable */ - 0, /* inWorkFunc */ - 0, /* startDuringWorkFunc */ - 0, /* ticking */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Clock_Module__state__V.Object_field_clockQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Clock_Module__state__V.Object_field_clockQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_clockQ */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Clock_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__diagsEnabled ti_sysbios_knl_Clock_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Clock_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__diagsIncluded ti_sysbios_knl_Clock_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__diagsMask__C, ".const:ti_sysbios_knl_Clock_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__diagsMask ti_sysbios_knl_Clock_Module__diagsMask__C = ((CT__ti_sysbios_knl_Clock_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__gateObj__C, ".const:ti_sysbios_knl_Clock_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__gateObj ti_sysbios_knl_Clock_Module__gateObj__C = ((CT__ti_sysbios_knl_Clock_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__gatePrms__C, ".const:ti_sysbios_knl_Clock_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__gatePrms ti_sysbios_knl_Clock_Module__gatePrms__C = ((CT__ti_sysbios_knl_Clock_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__id__C, ".const:ti_sysbios_knl_Clock_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__id ti_sysbios_knl_Clock_Module__id__C = (xdc_Bits16)0x8021; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerDefined__C, ".const:ti_sysbios_knl_Clock_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerDefined ti_sysbios_knl_Clock_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerObj__C, ".const:ti_sysbios_knl_Clock_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerObj ti_sysbios_knl_Clock_Module__loggerObj__C = ((CT__ti_sysbios_knl_Clock_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Clock_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerFxn0 ti_sysbios_knl_Clock_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Clock_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Clock_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerFxn1 ti_sysbios_knl_Clock_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Clock_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Clock_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerFxn2 ti_sysbios_knl_Clock_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Clock_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Clock_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerFxn4 ti_sysbios_knl_Clock_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Clock_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Clock_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__loggerFxn8 ti_sysbios_knl_Clock_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Clock_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Clock_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Module__startupDoneFxn ti_sysbios_knl_Clock_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Clock_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__count__C, ".const:ti_sysbios_knl_Clock_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Object__count ti_sysbios_knl_Clock_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__heap__C, ".const:ti_sysbios_knl_Clock_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Object__heap ti_sysbios_knl_Clock_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__sizeof__C, ".const:ti_sysbios_knl_Clock_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Object__sizeof ti_sysbios_knl_Clock_Object__sizeof__C = sizeof(ti_sysbios_knl_Clock_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__table__C, ".const:ti_sysbios_knl_Clock_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_Object__table ti_sysbios_knl_Clock_Object__table__C = 0; - -/* LW_delayed__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_LW_delayed__C, ".const:ti_sysbios_knl_Clock_LW_delayed__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_LW_delayed ti_sysbios_knl_Clock_LW_delayed__C = (((xdc_runtime_Log_Event)5217) << 16 | 1024); - -/* LM_tick__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_LM_tick__C, ".const:ti_sysbios_knl_Clock_LM_tick__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_LM_tick ti_sysbios_knl_Clock_LM_tick__C = (((xdc_runtime_Log_Event)5239) << 16 | 768); - -/* LM_begin__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_LM_begin__C, ".const:ti_sysbios_knl_Clock_LM_begin__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_LM_begin ti_sysbios_knl_Clock_LM_begin__C = (((xdc_runtime_Log_Event)5257) << 16 | 768); - -/* A_clockDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_A_clockDisabled__C, ".const:ti_sysbios_knl_Clock_A_clockDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_A_clockDisabled ti_sysbios_knl_Clock_A_clockDisabled__C = (((xdc_runtime_Assert_Id)765) << 16 | 16); - -/* A_badThreadType__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_A_badThreadType__C, ".const:ti_sysbios_knl_Clock_A_badThreadType__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_A_badThreadType ti_sysbios_knl_Clock_A_badThreadType__C = (((xdc_runtime_Assert_Id)846) << 16 | 16); - -/* serviceMargin__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_serviceMargin__C, ".const:ti_sysbios_knl_Clock_serviceMargin__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_serviceMargin ti_sysbios_knl_Clock_serviceMargin__C = (xdc_UInt32)0x0; - -/* tickSource__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_tickSource__C, ".const:ti_sysbios_knl_Clock_tickSource__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_tickSource ti_sysbios_knl_Clock_tickSource__C = ti_sysbios_knl_Clock_TickSource_TIMER; - -/* tickMode__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_tickMode__C, ".const:ti_sysbios_knl_Clock_tickMode__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_tickMode ti_sysbios_knl_Clock_tickMode__C = ti_sysbios_knl_Clock_TickMode_PERIODIC; - -/* timerId__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_timerId__C, ".const:ti_sysbios_knl_Clock_timerId__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_timerId ti_sysbios_knl_Clock_timerId__C = (xdc_UInt)0x7; - -/* tickPeriod__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_tickPeriod__C, ".const:ti_sysbios_knl_Clock_tickPeriod__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_tickPeriod ti_sysbios_knl_Clock_tickPeriod__C = (xdc_UInt32)0x3e8; - -/* doTickFunc__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_doTickFunc__C, ".const:ti_sysbios_knl_Clock_doTickFunc__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_doTickFunc ti_sysbios_knl_Clock_doTickFunc__C = ((CT__ti_sysbios_knl_Clock_doTickFunc)((xdc_Fxn)ti_sysbios_knl_Clock_doTick__I)); - -/* triggerClock__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Clock_triggerClock__C, ".const:ti_sysbios_knl_Clock_triggerClock__C"); -__FAR__ const CT__ti_sysbios_knl_Clock_triggerClock ti_sysbios_knl_Clock_triggerClock__C = 0; - - -/* - * ======== ti.sysbios.knl.Clock_TimerProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.knl.Event INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Event_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__PARAMS__C, ".const:ti_sysbios_knl_Event_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Event_Params ti_sysbios_knl_Event_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Event_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Event_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Event_Module__ ti_sysbios_knl_Event_Module__root__V = { - {&ti_sysbios_knl_Event_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Event_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Event_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__diagsEnabled ti_sysbios_knl_Event_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Event_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__diagsIncluded ti_sysbios_knl_Event_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__diagsMask__C, ".const:ti_sysbios_knl_Event_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__diagsMask ti_sysbios_knl_Event_Module__diagsMask__C = ((CT__ti_sysbios_knl_Event_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__gateObj__C, ".const:ti_sysbios_knl_Event_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__gateObj ti_sysbios_knl_Event_Module__gateObj__C = ((CT__ti_sysbios_knl_Event_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__gatePrms__C, ".const:ti_sysbios_knl_Event_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__gatePrms ti_sysbios_knl_Event_Module__gatePrms__C = ((CT__ti_sysbios_knl_Event_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__id__C, ".const:ti_sysbios_knl_Event_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__id ti_sysbios_knl_Event_Module__id__C = (xdc_Bits16)0x8024; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerDefined__C, ".const:ti_sysbios_knl_Event_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerDefined ti_sysbios_knl_Event_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerObj__C, ".const:ti_sysbios_knl_Event_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerObj ti_sysbios_knl_Event_Module__loggerObj__C = ((CT__ti_sysbios_knl_Event_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Event_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerFxn0 ti_sysbios_knl_Event_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Event_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Event_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerFxn1 ti_sysbios_knl_Event_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Event_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Event_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerFxn2 ti_sysbios_knl_Event_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Event_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Event_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerFxn4 ti_sysbios_knl_Event_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Event_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Event_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__loggerFxn8 ti_sysbios_knl_Event_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Event_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Event_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Module__startupDoneFxn ti_sysbios_knl_Event_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Event_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__count__C, ".const:ti_sysbios_knl_Event_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Object__count ti_sysbios_knl_Event_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__heap__C, ".const:ti_sysbios_knl_Event_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Object__heap ti_sysbios_knl_Event_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__sizeof__C, ".const:ti_sysbios_knl_Event_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Object__sizeof ti_sysbios_knl_Event_Object__sizeof__C = sizeof(ti_sysbios_knl_Event_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__table__C, ".const:ti_sysbios_knl_Event_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Event_Object__table ti_sysbios_knl_Event_Object__table__C = 0; - -/* LM_post__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_LM_post__C, ".const:ti_sysbios_knl_Event_LM_post__C"); -__FAR__ const CT__ti_sysbios_knl_Event_LM_post ti_sysbios_knl_Event_LM_post__C = (((xdc_runtime_Log_Event)5289) << 16 | 768); - -/* LM_pend__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_LM_pend__C, ".const:ti_sysbios_knl_Event_LM_pend__C"); -__FAR__ const CT__ti_sysbios_knl_Event_LM_pend ti_sysbios_knl_Event_LM_pend__C = (((xdc_runtime_Log_Event)5343) << 16 | 768); - -/* A_nullEventMasks__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_A_nullEventMasks__C, ".const:ti_sysbios_knl_Event_A_nullEventMasks__C"); -__FAR__ const CT__ti_sysbios_knl_Event_A_nullEventMasks ti_sysbios_knl_Event_A_nullEventMasks__C = (((xdc_runtime_Assert_Id)916) << 16 | 16); - -/* A_nullEventId__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_A_nullEventId__C, ".const:ti_sysbios_knl_Event_A_nullEventId__C"); -__FAR__ const CT__ti_sysbios_knl_Event_A_nullEventId ti_sysbios_knl_Event_A_nullEventId__C = (((xdc_runtime_Assert_Id)963) << 16 | 16); - -/* A_eventInUse__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_A_eventInUse__C, ".const:ti_sysbios_knl_Event_A_eventInUse__C"); -__FAR__ const CT__ti_sysbios_knl_Event_A_eventInUse ti_sysbios_knl_Event_A_eventInUse__C = (((xdc_runtime_Assert_Id)1002) << 16 | 16); - -/* A_badContext__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_A_badContext__C, ".const:ti_sysbios_knl_Event_A_badContext__C"); -__FAR__ const CT__ti_sysbios_knl_Event_A_badContext ti_sysbios_knl_Event_A_badContext__C = (((xdc_runtime_Assert_Id)1045) << 16 | 16); - -/* A_pendTaskDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Event_A_pendTaskDisabled__C, ".const:ti_sysbios_knl_Event_A_pendTaskDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Event_A_pendTaskDisabled ti_sysbios_knl_Event_A_pendTaskDisabled__C = (((xdc_runtime_Assert_Id)1108) << 16 | 16); - - -/* - * ======== ti.sysbios.knl.Idle INITIALIZERS ======== - */ - -/* --> ti_sysbios_knl_Idle_funcList__A */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_funcList__A, ".const:ti_sysbios_knl_Idle_funcList__A"); -const __T1_ti_sysbios_knl_Idle_funcList ti_sysbios_knl_Idle_funcList__A[1] = { - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_hal_Hwi_checkStack)), /* [0] */ -}; - -/* --> ti_sysbios_knl_Idle_coreList__A */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_coreList__A, ".const:ti_sysbios_knl_Idle_coreList__A"); -const __T1_ti_sysbios_knl_Idle_coreList ti_sysbios_knl_Idle_coreList__A[1] = { - (xdc_UInt)0x0, /* [0] */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Idle_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__diagsEnabled ti_sysbios_knl_Idle_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Idle_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__diagsIncluded ti_sysbios_knl_Idle_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__diagsMask__C, ".const:ti_sysbios_knl_Idle_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__diagsMask ti_sysbios_knl_Idle_Module__diagsMask__C = ((CT__ti_sysbios_knl_Idle_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__gateObj__C, ".const:ti_sysbios_knl_Idle_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__gateObj ti_sysbios_knl_Idle_Module__gateObj__C = ((CT__ti_sysbios_knl_Idle_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__gatePrms__C, ".const:ti_sysbios_knl_Idle_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__gatePrms ti_sysbios_knl_Idle_Module__gatePrms__C = ((CT__ti_sysbios_knl_Idle_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__id__C, ".const:ti_sysbios_knl_Idle_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__id ti_sysbios_knl_Idle_Module__id__C = (xdc_Bits16)0x8022; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerDefined__C, ".const:ti_sysbios_knl_Idle_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerDefined ti_sysbios_knl_Idle_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerObj__C, ".const:ti_sysbios_knl_Idle_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerObj ti_sysbios_knl_Idle_Module__loggerObj__C = ((CT__ti_sysbios_knl_Idle_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Idle_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerFxn0 ti_sysbios_knl_Idle_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Idle_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Idle_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerFxn1 ti_sysbios_knl_Idle_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Idle_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Idle_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerFxn2 ti_sysbios_knl_Idle_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Idle_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Idle_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerFxn4 ti_sysbios_knl_Idle_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Idle_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Idle_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__loggerFxn8 ti_sysbios_knl_Idle_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Idle_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Idle_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Module__startupDoneFxn ti_sysbios_knl_Idle_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Idle_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Object__count__C, ".const:ti_sysbios_knl_Idle_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Object__count ti_sysbios_knl_Idle_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Object__heap__C, ".const:ti_sysbios_knl_Idle_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Object__heap ti_sysbios_knl_Idle_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Object__sizeof__C, ".const:ti_sysbios_knl_Idle_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Object__sizeof ti_sysbios_knl_Idle_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_Object__table__C, ".const:ti_sysbios_knl_Idle_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_Object__table ti_sysbios_knl_Idle_Object__table__C = 0; - -/* funcList__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_funcList__C, ".const:ti_sysbios_knl_Idle_funcList__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_funcList ti_sysbios_knl_Idle_funcList__C = {1, ((__T1_ti_sysbios_knl_Idle_funcList*)ti_sysbios_knl_Idle_funcList__A)}; - -/* coreList__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Idle_coreList__C, ".const:ti_sysbios_knl_Idle_coreList__C"); -__FAR__ const CT__ti_sysbios_knl_Idle_coreList ti_sysbios_knl_Idle_coreList__C = {1, ((__T1_ti_sysbios_knl_Idle_coreList*)ti_sysbios_knl_Idle_coreList__A)}; - - -/* - * ======== ti.sysbios.knl.Intrinsics INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Intrinsics_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__diagsEnabled ti_sysbios_knl_Intrinsics_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Intrinsics_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__diagsIncluded ti_sysbios_knl_Intrinsics_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__diagsMask__C, ".const:ti_sysbios_knl_Intrinsics_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__diagsMask ti_sysbios_knl_Intrinsics_Module__diagsMask__C = ((CT__ti_sysbios_knl_Intrinsics_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__gateObj__C, ".const:ti_sysbios_knl_Intrinsics_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__gateObj ti_sysbios_knl_Intrinsics_Module__gateObj__C = ((CT__ti_sysbios_knl_Intrinsics_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__gatePrms__C, ".const:ti_sysbios_knl_Intrinsics_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__gatePrms ti_sysbios_knl_Intrinsics_Module__gatePrms__C = ((CT__ti_sysbios_knl_Intrinsics_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__id__C, ".const:ti_sysbios_knl_Intrinsics_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__id ti_sysbios_knl_Intrinsics_Module__id__C = (xdc_Bits16)0x8023; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerDefined__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerDefined ti_sysbios_knl_Intrinsics_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerObj__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerObj ti_sysbios_knl_Intrinsics_Module__loggerObj__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn0 ti_sysbios_knl_Intrinsics_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn1 ti_sysbios_knl_Intrinsics_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn2 ti_sysbios_knl_Intrinsics_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn4 ti_sysbios_knl_Intrinsics_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Intrinsics_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn8 ti_sysbios_knl_Intrinsics_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Intrinsics_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Intrinsics_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Module__startupDoneFxn ti_sysbios_knl_Intrinsics_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Intrinsics_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Object__count__C, ".const:ti_sysbios_knl_Intrinsics_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Object__count ti_sysbios_knl_Intrinsics_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Object__heap__C, ".const:ti_sysbios_knl_Intrinsics_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Object__heap ti_sysbios_knl_Intrinsics_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Object__sizeof__C, ".const:ti_sysbios_knl_Intrinsics_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Object__sizeof ti_sysbios_knl_Intrinsics_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Intrinsics_Object__table__C, ".const:ti_sysbios_knl_Intrinsics_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Intrinsics_Object__table ti_sysbios_knl_Intrinsics_Object__table__C = 0; - - -/* - * ======== ti.sysbios.knl.Intrinsics_SupportProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.knl.Mailbox INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Mailbox_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__PARAMS__C, ".const:ti_sysbios_knl_Mailbox_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Mailbox_Params ti_sysbios_knl_Mailbox_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Mailbox_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Mailbox_Object__PARAMS__C.__iprms, /* instance */ - 0, /* heap */ - 0, /* readerEvent */ - (xdc_UInt)0x1, /* readerEventId */ - 0, /* writerEvent */ - (xdc_UInt)0x1, /* writerEventId */ - ((xdc_Ptr)0), /* buf */ - (xdc_UInt)0x0, /* bufSize */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Mailbox_Module__ ti_sysbios_knl_Mailbox_Module__root__V = { - {&ti_sysbios_knl_Mailbox_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Mailbox_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Mailbox_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__diagsEnabled ti_sysbios_knl_Mailbox_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Mailbox_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__diagsIncluded ti_sysbios_knl_Mailbox_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__diagsMask__C, ".const:ti_sysbios_knl_Mailbox_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__diagsMask ti_sysbios_knl_Mailbox_Module__diagsMask__C = ((CT__ti_sysbios_knl_Mailbox_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__gateObj__C, ".const:ti_sysbios_knl_Mailbox_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__gateObj ti_sysbios_knl_Mailbox_Module__gateObj__C = ((CT__ti_sysbios_knl_Mailbox_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__gatePrms__C, ".const:ti_sysbios_knl_Mailbox_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__gatePrms ti_sysbios_knl_Mailbox_Module__gatePrms__C = ((CT__ti_sysbios_knl_Mailbox_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__id__C, ".const:ti_sysbios_knl_Mailbox_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__id ti_sysbios_knl_Mailbox_Module__id__C = (xdc_Bits16)0x8025; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerDefined__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerDefined ti_sysbios_knl_Mailbox_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerObj__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerObj ti_sysbios_knl_Mailbox_Module__loggerObj__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerFxn0 ti_sysbios_knl_Mailbox_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerFxn1 ti_sysbios_knl_Mailbox_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerFxn2 ti_sysbios_knl_Mailbox_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerFxn4 ti_sysbios_knl_Mailbox_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Mailbox_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__loggerFxn8 ti_sysbios_knl_Mailbox_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Mailbox_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Mailbox_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Module__startupDoneFxn ti_sysbios_knl_Mailbox_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Mailbox_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__count__C, ".const:ti_sysbios_knl_Mailbox_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Object__count ti_sysbios_knl_Mailbox_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__heap__C, ".const:ti_sysbios_knl_Mailbox_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Object__heap ti_sysbios_knl_Mailbox_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__sizeof__C, ".const:ti_sysbios_knl_Mailbox_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Object__sizeof ti_sysbios_knl_Mailbox_Object__sizeof__C = sizeof(ti_sysbios_knl_Mailbox_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__table__C, ".const:ti_sysbios_knl_Mailbox_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_Object__table ti_sysbios_knl_Mailbox_Object__table__C = 0; - -/* A_invalidBufSize__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_A_invalidBufSize__C, ".const:ti_sysbios_knl_Mailbox_A_invalidBufSize__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_A_invalidBufSize ti_sysbios_knl_Mailbox_A_invalidBufSize__C = (((xdc_runtime_Assert_Id)1198) << 16 | 16); - -/* maxTypeAlign__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_maxTypeAlign__C, ".const:ti_sysbios_knl_Mailbox_maxTypeAlign__C"); -__FAR__ const CT__ti_sysbios_knl_Mailbox_maxTypeAlign ti_sysbios_knl_Mailbox_maxTypeAlign__C = (xdc_UInt)0x8; - - -/* - * ======== ti.sysbios.knl.Queue INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Queue_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__PARAMS__C, ".const:ti_sysbios_knl_Queue_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Queue_Params ti_sysbios_knl_Queue_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Queue_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Queue_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Queue_Module__ ti_sysbios_knl_Queue_Module__root__V = { - {&ti_sysbios_knl_Queue_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Queue_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Queue_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__diagsEnabled ti_sysbios_knl_Queue_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Queue_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__diagsIncluded ti_sysbios_knl_Queue_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__diagsMask__C, ".const:ti_sysbios_knl_Queue_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__diagsMask ti_sysbios_knl_Queue_Module__diagsMask__C = ((CT__ti_sysbios_knl_Queue_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__gateObj__C, ".const:ti_sysbios_knl_Queue_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__gateObj ti_sysbios_knl_Queue_Module__gateObj__C = ((CT__ti_sysbios_knl_Queue_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__gatePrms__C, ".const:ti_sysbios_knl_Queue_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__gatePrms ti_sysbios_knl_Queue_Module__gatePrms__C = ((CT__ti_sysbios_knl_Queue_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__id__C, ".const:ti_sysbios_knl_Queue_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__id ti_sysbios_knl_Queue_Module__id__C = (xdc_Bits16)0x8026; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerDefined__C, ".const:ti_sysbios_knl_Queue_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerDefined ti_sysbios_knl_Queue_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerObj__C, ".const:ti_sysbios_knl_Queue_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerObj ti_sysbios_knl_Queue_Module__loggerObj__C = ((CT__ti_sysbios_knl_Queue_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Queue_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerFxn0 ti_sysbios_knl_Queue_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Queue_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Queue_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerFxn1 ti_sysbios_knl_Queue_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Queue_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Queue_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerFxn2 ti_sysbios_knl_Queue_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Queue_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Queue_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerFxn4 ti_sysbios_knl_Queue_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Queue_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Queue_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__loggerFxn8 ti_sysbios_knl_Queue_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Queue_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Queue_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Module__startupDoneFxn ti_sysbios_knl_Queue_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Queue_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__count__C, ".const:ti_sysbios_knl_Queue_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Object__count ti_sysbios_knl_Queue_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__heap__C, ".const:ti_sysbios_knl_Queue_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Object__heap ti_sysbios_knl_Queue_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__sizeof__C, ".const:ti_sysbios_knl_Queue_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Object__sizeof ti_sysbios_knl_Queue_Object__sizeof__C = sizeof(ti_sysbios_knl_Queue_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__table__C, ".const:ti_sysbios_knl_Queue_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Queue_Object__table ti_sysbios_knl_Queue_Object__table__C = 0; - - -/* - * ======== ti.sysbios.knl.Semaphore INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Semaphore_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__PARAMS__C, ".const:ti_sysbios_knl_Semaphore_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Semaphore_Params ti_sysbios_knl_Semaphore_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Semaphore_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Semaphore_Object__PARAMS__C.__iprms, /* instance */ - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_COUNTING, /* mode */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Semaphore_Module__ ti_sysbios_knl_Semaphore_Module__root__V = { - {&ti_sysbios_knl_Semaphore_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Semaphore_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_knl_Semaphore_Object__ ti_sysbios_knl_Semaphore_Object__table__V[4] = { - {/* instance#0 */ - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_BINARY, /* mode */ - (xdc_UInt16)0x0, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[0].Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[0].Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, - {/* instance#1 */ - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_BINARY, /* mode */ - (xdc_UInt16)0x0, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[1].Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[1].Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, - {/* instance#2 */ - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_BINARY, /* mode */ - (xdc_UInt16)0x0, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[2].Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[2].Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, - {/* instance#3 */ - 0, /* event */ - (xdc_UInt)0x1, /* eventId */ - ti_sysbios_knl_Semaphore_Mode_BINARY, /* mode */ - (xdc_UInt16)0x0, /* count */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[3].Object_field_pendQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Semaphore_Object__table__V[3].Object_field_pendQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_pendQ */ - }, -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Semaphore_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__diagsEnabled ti_sysbios_knl_Semaphore_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Semaphore_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__diagsIncluded ti_sysbios_knl_Semaphore_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__diagsMask__C, ".const:ti_sysbios_knl_Semaphore_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__diagsMask ti_sysbios_knl_Semaphore_Module__diagsMask__C = ((CT__ti_sysbios_knl_Semaphore_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__gateObj__C, ".const:ti_sysbios_knl_Semaphore_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__gateObj ti_sysbios_knl_Semaphore_Module__gateObj__C = ((CT__ti_sysbios_knl_Semaphore_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__gatePrms__C, ".const:ti_sysbios_knl_Semaphore_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__gatePrms ti_sysbios_knl_Semaphore_Module__gatePrms__C = ((CT__ti_sysbios_knl_Semaphore_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__id__C, ".const:ti_sysbios_knl_Semaphore_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__id ti_sysbios_knl_Semaphore_Module__id__C = (xdc_Bits16)0x8027; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerDefined__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerDefined ti_sysbios_knl_Semaphore_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerObj__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerObj ti_sysbios_knl_Semaphore_Module__loggerObj__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerFxn0 ti_sysbios_knl_Semaphore_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerFxn1 ti_sysbios_knl_Semaphore_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerFxn2 ti_sysbios_knl_Semaphore_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerFxn4 ti_sysbios_knl_Semaphore_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Semaphore_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__loggerFxn8 ti_sysbios_knl_Semaphore_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Semaphore_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Semaphore_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Module__startupDoneFxn ti_sysbios_knl_Semaphore_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Semaphore_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__count__C, ".const:ti_sysbios_knl_Semaphore_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Object__count ti_sysbios_knl_Semaphore_Object__count__C = 4; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__heap__C, ".const:ti_sysbios_knl_Semaphore_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Object__heap ti_sysbios_knl_Semaphore_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__sizeof__C, ".const:ti_sysbios_knl_Semaphore_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Object__sizeof ti_sysbios_knl_Semaphore_Object__sizeof__C = sizeof(ti_sysbios_knl_Semaphore_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__table__C, ".const:ti_sysbios_knl_Semaphore_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_Object__table ti_sysbios_knl_Semaphore_Object__table__C = ti_sysbios_knl_Semaphore_Object__table__V; - -/* LM_post__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_LM_post__C, ".const:ti_sysbios_knl_Semaphore_LM_post__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_LM_post ti_sysbios_knl_Semaphore_LM_post__C = (((xdc_runtime_Log_Event)5424) << 16 | 768); - -/* LM_pend__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_LM_pend__C, ".const:ti_sysbios_knl_Semaphore_LM_pend__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_LM_pend ti_sysbios_knl_Semaphore_LM_pend__C = (((xdc_runtime_Log_Event)5454) << 16 | 768); - -/* A_noEvents__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_A_noEvents__C, ".const:ti_sysbios_knl_Semaphore_A_noEvents__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_A_noEvents ti_sysbios_knl_Semaphore_A_noEvents__C = (((xdc_runtime_Assert_Id)1256) << 16 | 16); - -/* A_invTimeout__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_A_invTimeout__C, ".const:ti_sysbios_knl_Semaphore_A_invTimeout__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_A_invTimeout ti_sysbios_knl_Semaphore_A_invTimeout__C = (((xdc_runtime_Assert_Id)1311) << 16 | 16); - -/* A_badContext__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_A_badContext__C, ".const:ti_sysbios_knl_Semaphore_A_badContext__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_A_badContext ti_sysbios_knl_Semaphore_A_badContext__C = (((xdc_runtime_Assert_Id)1045) << 16 | 16); - -/* A_overflow__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_A_overflow__C, ".const:ti_sysbios_knl_Semaphore_A_overflow__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_A_overflow ti_sysbios_knl_Semaphore_A_overflow__C = (((xdc_runtime_Assert_Id)1376) << 16 | 16); - -/* A_pendTaskDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_A_pendTaskDisabled__C, ".const:ti_sysbios_knl_Semaphore_A_pendTaskDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_A_pendTaskDisabled ti_sysbios_knl_Semaphore_A_pendTaskDisabled__C = (((xdc_runtime_Assert_Id)1430) << 16 | 16); - -/* supportsEvents__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_supportsEvents__C, ".const:ti_sysbios_knl_Semaphore_supportsEvents__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_supportsEvents ti_sysbios_knl_Semaphore_supportsEvents__C = 0; - -/* supportsPriority__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_supportsPriority__C, ".const:ti_sysbios_knl_Semaphore_supportsPriority__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_supportsPriority ti_sysbios_knl_Semaphore_supportsPriority__C = 1; - -/* eventPost__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_eventPost__C, ".const:ti_sysbios_knl_Semaphore_eventPost__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_eventPost ti_sysbios_knl_Semaphore_eventPost__C = ((CT__ti_sysbios_knl_Semaphore_eventPost)0); - -/* eventSync__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_eventSync__C, ".const:ti_sysbios_knl_Semaphore_eventSync__C"); -__FAR__ const CT__ti_sysbios_knl_Semaphore_eventSync ti_sysbios_knl_Semaphore_eventSync__C = ((CT__ti_sysbios_knl_Semaphore_eventSync)0); - - -/* - * ======== ti.sysbios.knl.Swi INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Swi_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__PARAMS__C, ".const:ti_sysbios_knl_Swi_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Swi_Params ti_sysbios_knl_Swi_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Swi_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Swi_Object__PARAMS__C.__iprms, /* instance */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - (xdc_UInt)(-0x0 - 1), /* priority */ - (xdc_UInt)0x0, /* trigger */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_knl_Swi_Module__ ti_sysbios_knl_Swi_Module__root__V = { - {&ti_sysbios_knl_Swi_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Swi_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_knl_Swi_Object__ ti_sysbios_knl_Swi_Object__table__V[1] = { - {/* instance#0 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Object__table__V[0].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Object__table__V[0].qElem)), /* prev */ - }, /* qElem */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)ti_sysbios_knl_Clock_workFunc__E)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - (xdc_UInt)0xf, /* priority */ - (xdc_UInt)0x8000, /* mask */ - 0, /* posted */ - (xdc_UInt)0x0, /* initTrigger */ - (xdc_UInt)0x0, /* trigger */ - (ti_sysbios_knl_Queue_Handle)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[15], /* readyQ */ - ((void*)0), /* hookEnv */ - }, -}; - -/* --> ti_sysbios_knl_Swi_Module_State_0_readyQ__A */ -__T1_ti_sysbios_knl_Swi_Module_State__readyQ ti_sysbios_knl_Swi_Module_State_0_readyQ__A[16] = { - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[0].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[0].elem)), /* prev */ - }, /* elem */ - }, /* [0] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[1].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[1].elem)), /* prev */ - }, /* elem */ - }, /* [1] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[2].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[2].elem)), /* prev */ - }, /* elem */ - }, /* [2] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[3].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[3].elem)), /* prev */ - }, /* elem */ - }, /* [3] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[4].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[4].elem)), /* prev */ - }, /* elem */ - }, /* [4] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[5].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[5].elem)), /* prev */ - }, /* elem */ - }, /* [5] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[6].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[6].elem)), /* prev */ - }, /* elem */ - }, /* [6] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[7].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[7].elem)), /* prev */ - }, /* elem */ - }, /* [7] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[8].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[8].elem)), /* prev */ - }, /* elem */ - }, /* [8] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[9].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[9].elem)), /* prev */ - }, /* elem */ - }, /* [9] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[10].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[10].elem)), /* prev */ - }, /* elem */ - }, /* [10] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[11].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[11].elem)), /* prev */ - }, /* elem */ - }, /* [11] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[12].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[12].elem)), /* prev */ - }, /* elem */ - }, /* [12] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[13].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[13].elem)), /* prev */ - }, /* elem */ - }, /* [13] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[14].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[14].elem)), /* prev */ - }, /* elem */ - }, /* [14] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[15].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Swi_Module_State_0_readyQ__A[15].elem)), /* prev */ - }, /* elem */ - }, /* [15] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_knl_Swi_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_knl_Swi_Module_State__ ti_sysbios_knl_Swi_Module__state__V __attribute__ ((section(".data_ti_sysbios_knl_Swi_Module__state__V"))); -#endif -#endif -ti_sysbios_knl_Swi_Module_State__ ti_sysbios_knl_Swi_Module__state__V = { - 1, /* locked */ - (xdc_UInt)0x0, /* curSet */ - (xdc_UInt)0x0, /* curTrigger */ - 0, /* curSwi */ - 0, /* curQ */ - ((void*)ti_sysbios_knl_Swi_Module_State_0_readyQ__A), /* readyQ */ - ((void*)0), /* constructedSwis */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Swi_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__diagsEnabled ti_sysbios_knl_Swi_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Swi_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__diagsIncluded ti_sysbios_knl_Swi_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__diagsMask__C, ".const:ti_sysbios_knl_Swi_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__diagsMask ti_sysbios_knl_Swi_Module__diagsMask__C = ((CT__ti_sysbios_knl_Swi_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__gateObj__C, ".const:ti_sysbios_knl_Swi_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__gateObj ti_sysbios_knl_Swi_Module__gateObj__C = ((CT__ti_sysbios_knl_Swi_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__gatePrms__C, ".const:ti_sysbios_knl_Swi_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__gatePrms ti_sysbios_knl_Swi_Module__gatePrms__C = ((CT__ti_sysbios_knl_Swi_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__id__C, ".const:ti_sysbios_knl_Swi_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__id ti_sysbios_knl_Swi_Module__id__C = (xdc_Bits16)0x8028; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerDefined__C, ".const:ti_sysbios_knl_Swi_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerDefined ti_sysbios_knl_Swi_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerObj__C, ".const:ti_sysbios_knl_Swi_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerObj ti_sysbios_knl_Swi_Module__loggerObj__C = ((CT__ti_sysbios_knl_Swi_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Swi_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerFxn0 ti_sysbios_knl_Swi_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Swi_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Swi_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerFxn1 ti_sysbios_knl_Swi_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Swi_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Swi_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerFxn2 ti_sysbios_knl_Swi_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Swi_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Swi_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerFxn4 ti_sysbios_knl_Swi_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Swi_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Swi_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__loggerFxn8 ti_sysbios_knl_Swi_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Swi_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Swi_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Module__startupDoneFxn ti_sysbios_knl_Swi_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Swi_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__count__C, ".const:ti_sysbios_knl_Swi_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Object__count ti_sysbios_knl_Swi_Object__count__C = 1; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__heap__C, ".const:ti_sysbios_knl_Swi_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Object__heap ti_sysbios_knl_Swi_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__sizeof__C, ".const:ti_sysbios_knl_Swi_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Object__sizeof ti_sysbios_knl_Swi_Object__sizeof__C = sizeof(ti_sysbios_knl_Swi_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__table__C, ".const:ti_sysbios_knl_Swi_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_Object__table ti_sysbios_knl_Swi_Object__table__C = ti_sysbios_knl_Swi_Object__table__V; - -/* LM_begin__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_LM_begin__C, ".const:ti_sysbios_knl_Swi_LM_begin__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_LM_begin ti_sysbios_knl_Swi_LM_begin__C = (((xdc_runtime_Log_Event)5497) << 16 | 768); - -/* LD_end__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_LD_end__C, ".const:ti_sysbios_knl_Swi_LD_end__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_LD_end ti_sysbios_knl_Swi_LD_end__C = (((xdc_runtime_Log_Event)5544) << 16 | 512); - -/* LM_post__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_LM_post__C, ".const:ti_sysbios_knl_Swi_LM_post__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_LM_post ti_sysbios_knl_Swi_LM_post__C = (((xdc_runtime_Log_Event)5562) << 16 | 768); - -/* A_swiDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_A_swiDisabled__C, ".const:ti_sysbios_knl_Swi_A_swiDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_A_swiDisabled ti_sysbios_knl_Swi_A_swiDisabled__C = (((xdc_runtime_Assert_Id)1524) << 16 | 16); - -/* A_badPriority__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_A_badPriority__C, ".const:ti_sysbios_knl_Swi_A_badPriority__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_A_badPriority ti_sysbios_knl_Swi_A_badPriority__C = (((xdc_runtime_Assert_Id)1581) << 16 | 16); - -/* numPriorities__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_numPriorities__C, ".const:ti_sysbios_knl_Swi_numPriorities__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_numPriorities ti_sysbios_knl_Swi_numPriorities__C = (xdc_UInt)0x10; - -/* hooks__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_hooks__C, ".const:ti_sysbios_knl_Swi_hooks__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_hooks ti_sysbios_knl_Swi_hooks__C = {0, 0}; - -/* taskDisable__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_taskDisable__C, ".const:ti_sysbios_knl_Swi_taskDisable__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_taskDisable ti_sysbios_knl_Swi_taskDisable__C = ((CT__ti_sysbios_knl_Swi_taskDisable)((xdc_Fxn)ti_sysbios_knl_Task_disable__E)); - -/* taskRestore__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_taskRestore__C, ".const:ti_sysbios_knl_Swi_taskRestore__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_taskRestore ti_sysbios_knl_Swi_taskRestore__C = ((CT__ti_sysbios_knl_Swi_taskRestore)((xdc_Fxn)ti_sysbios_knl_Task_restore__E)); - -/* numConstructedSwis__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Swi_numConstructedSwis__C, ".const:ti_sysbios_knl_Swi_numConstructedSwis__C"); -__FAR__ const CT__ti_sysbios_knl_Swi_numConstructedSwis ti_sysbios_knl_Swi_numConstructedSwis__C = (xdc_UInt)0x0; - - -/* - * ======== ti.sysbios.knl.Task INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Task_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__PARAMS__C, ".const:ti_sysbios_knl_Task_Object__PARAMS__C"); -__FAR__ const ti_sysbios_knl_Task_Params ti_sysbios_knl_Task_Object__PARAMS__C = { - sizeof (ti_sysbios_knl_Task_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_knl_Task_Object__PARAMS__C.__iprms, /* instance */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - (xdc_Int)0x1, /* priority */ - ((xdc_Ptr)0), /* stack */ - (xdc_SizeT)0x0, /* stackSize */ - 0, /* stackHeap */ - ((xdc_Ptr)0), /* env */ - 1, /* vitalTaskFlag */ - (xdc_UInt)0x0, /* affinity */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* --> ti_sysbios_knl_Task_Instance_State_0_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_0_stack__A[2048]; - -/* --> ti_sysbios_knl_Task_Instance_State_1_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_1_stack__A[2048]; - -/* --> ti_sysbios_knl_Task_Instance_State_2_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_2_stack__A[1024]; - -/* --> ti_sysbios_knl_Task_Instance_State_3_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_3_stack__A[4096]; - -/* --> ti_sysbios_knl_Task_Instance_State_4_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_4_stack__A[2048]; - -/* --> ti_sysbios_knl_Task_Instance_State_5_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_5_stack__A[1024]; - -/* --> ti_sysbios_knl_Task_Instance_State_6_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_6_stack__A[8192]; - -/* --> ti_sysbios_knl_Task_Instance_State_7_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_7_stack__A[2048]; - -/* --> ti_sysbios_knl_Task_Instance_State_8_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_8_stack__A[2048]; - -/* --> ti_sysbios_knl_Task_Instance_State_9_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_9_stack__A[8192]; - -/* --> ti_sysbios_knl_Task_Instance_State_10_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_10_stack__A[512]; - -/* --> ti_sysbios_knl_Task_Instance_State_11_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_11_stack__A[1024]; - -/* --> ti_sysbios_knl_Task_Instance_State_12_stack__A */ -__T1_ti_sysbios_knl_Task_Instance_State__stack ti_sysbios_knl_Task_Instance_State_12_stack__A[1024]; - -/* Module__root__V */ -ti_sysbios_knl_Task_Module__ ti_sysbios_knl_Task_Module__root__V = { - {&ti_sysbios_knl_Task_Module__root__V.link, /* link.next */ - &ti_sysbios_knl_Task_Module__root__V.link}, /* link.prev */ -}; - -/* Object__table__V */ -ti_sysbios_knl_Task_Object__ ti_sysbios_knl_Task_Object__table__V[13] = { - {/* instance#0 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[0].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[0].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0xc, /* priority */ - (xdc_UInt)0x1000, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x800, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_0_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)MillisecTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#1 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[1].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[1].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0xb, /* priority */ - (xdc_UInt)0x800, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x800, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_1_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)controlTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#2 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[2].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[2].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0xa, /* priority */ - (xdc_UInt)0x400, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x400, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_2_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)AlarmHandlingTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#3 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[3].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[3].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x9, /* priority */ - (xdc_UInt)0x200, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x1000, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_3_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)communicationTxTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#4 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[4].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[4].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x8, /* priority */ - (xdc_UInt)0x100, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x800, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_4_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)jobTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#5 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[5].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[5].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x7, /* priority */ - (xdc_UInt)0x80, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x400, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_5_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)HeatersControlTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#6 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[6].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[6].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x6, /* priority */ - (xdc_UInt)0x40, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x2000, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_6_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)communicationTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#7 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[7].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[7].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x5, /* priority */ - (xdc_UInt)0x20, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x800, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_7_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)MillisecLowTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#8 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[8].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[8].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x5, /* priority */ - (xdc_UInt)0x20, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x800, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_8_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)controlLowTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#9 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[9].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[9].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x4, /* priority */ - (xdc_UInt)0x10, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x2000, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_9_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)DiagnosticsTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#10 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[10].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[10].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x3, /* priority */ - (xdc_UInt)0x8, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x200, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_10_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)ADCProcessTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#11 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[11].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[11].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x3, /* priority */ - (xdc_UInt)0x8, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x400, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_11_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)reportService)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, - {/* instance#12 */ - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[12].qElem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Object__table__V[12].qElem)), /* prev */ - }, /* qElem */ - (xdc_Int)0x4, /* priority */ - (xdc_UInt)0x10, /* mask */ - ((xdc_Ptr)0), /* context */ - ti_sysbios_knl_Task_Mode_INACTIVE, /* mode */ - ((ti_sysbios_knl_Task_PendElem*)0), /* pendElem */ - (xdc_SizeT)0x400, /* stackSize */ - ((void*)ti_sysbios_knl_Task_Instance_State_12_stack__A), /* stack */ - 0, /* stackHeap */ - ((xdc_Void(*)(xdc_UArg,xdc_UArg))((xdc_Fxn)updateTask)), /* fxn */ - ((xdc_UArg)(0x0)), /* arg0 */ - ((xdc_UArg)(0x0)), /* arg1 */ - ((xdc_Ptr)0), /* env */ - ((void*)0), /* hookEnv */ - 1, /* vitalTaskFlag */ - 0, /* readyQ */ - (xdc_UInt)0x0, /* curCoreId */ - (xdc_UInt)0x0, /* affinity */ - }, -}; - -/* --> ti_sysbios_knl_Task_Module_State_0_readyQ__A */ -__T1_ti_sysbios_knl_Task_Module_State__readyQ ti_sysbios_knl_Task_Module_State_0_readyQ__A[16] = { - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[0].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[0].elem)), /* prev */ - }, /* elem */ - }, /* [0] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[1].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[1].elem)), /* prev */ - }, /* elem */ - }, /* [1] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[2].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[2].elem)), /* prev */ - }, /* elem */ - }, /* [2] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[3].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[3].elem)), /* prev */ - }, /* elem */ - }, /* [3] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[4].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[4].elem)), /* prev */ - }, /* elem */ - }, /* [4] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[5].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[5].elem)), /* prev */ - }, /* elem */ - }, /* [5] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[6].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[6].elem)), /* prev */ - }, /* elem */ - }, /* [6] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[7].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[7].elem)), /* prev */ - }, /* elem */ - }, /* [7] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[8].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[8].elem)), /* prev */ - }, /* elem */ - }, /* [8] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[9].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[9].elem)), /* prev */ - }, /* elem */ - }, /* [9] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[10].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[10].elem)), /* prev */ - }, /* elem */ - }, /* [10] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[11].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[11].elem)), /* prev */ - }, /* elem */ - }, /* [11] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[12].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[12].elem)), /* prev */ - }, /* elem */ - }, /* [12] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[13].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[13].elem)), /* prev */ - }, /* elem */ - }, /* [13] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[14].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[14].elem)), /* prev */ - }, /* elem */ - }, /* [14] */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[15].elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module_State_0_readyQ__A[15].elem)), /* prev */ - }, /* elem */ - }, /* [15] */ -}; - -/* --> ti_sysbios_knl_Task_Module_State_0_idleTask__A */ -__T1_ti_sysbios_knl_Task_Module_State__idleTask ti_sysbios_knl_Task_Module_State_0_idleTask__A[1] = { - 0, /* [0] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_ti_sysbios_knl_Task_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -ti_sysbios_knl_Task_Module_State__ ti_sysbios_knl_Task_Module__state__V __attribute__ ((section(".data_ti_sysbios_knl_Task_Module__state__V"))); -#endif -#endif -ti_sysbios_knl_Task_Module_State__ ti_sysbios_knl_Task_Module__state__V = { - 1, /* locked */ - (xdc_UInt)0x0, /* curSet */ - 0, /* workFlag */ - (xdc_UInt)0xd, /* vitalTasks */ - 0, /* curTask */ - 0, /* curQ */ - ((void*)ti_sysbios_knl_Task_Module_State_0_readyQ__A), /* readyQ */ - ((void*)0), /* smpCurSet */ - ((void*)0), /* smpCurMask */ - ((void*)0), /* smpCurTask */ - ((void*)0), /* smpReadyQ */ - ((void*)ti_sysbios_knl_Task_Module_State_0_idleTask__A), /* idleTask */ - ((void*)0), /* constructedTasks */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module__state__V.Object_field_inactiveQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module__state__V.Object_field_inactiveQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_inactiveQ */ - { - { - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module__state__V.Object_field_terminatedQ.elem)), /* next */ - ((ti_sysbios_knl_Queue_Elem*)((void*)&ti_sysbios_knl_Task_Module__state__V.Object_field_terminatedQ.elem)), /* prev */ - }, /* elem */ - }, /* Object_field_terminatedQ */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__diagsEnabled__C, ".const:ti_sysbios_knl_Task_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__diagsEnabled ti_sysbios_knl_Task_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__diagsIncluded__C, ".const:ti_sysbios_knl_Task_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__diagsIncluded ti_sysbios_knl_Task_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__diagsMask__C, ".const:ti_sysbios_knl_Task_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__diagsMask ti_sysbios_knl_Task_Module__diagsMask__C = ((CT__ti_sysbios_knl_Task_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__gateObj__C, ".const:ti_sysbios_knl_Task_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__gateObj ti_sysbios_knl_Task_Module__gateObj__C = ((CT__ti_sysbios_knl_Task_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__gatePrms__C, ".const:ti_sysbios_knl_Task_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__gatePrms ti_sysbios_knl_Task_Module__gatePrms__C = ((CT__ti_sysbios_knl_Task_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__id__C, ".const:ti_sysbios_knl_Task_Module__id__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__id ti_sysbios_knl_Task_Module__id__C = (xdc_Bits16)0x8029; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerDefined__C, ".const:ti_sysbios_knl_Task_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerDefined ti_sysbios_knl_Task_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerObj__C, ".const:ti_sysbios_knl_Task_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerObj ti_sysbios_knl_Task_Module__loggerObj__C = ((CT__ti_sysbios_knl_Task_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerFxn0__C, ".const:ti_sysbios_knl_Task_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerFxn0 ti_sysbios_knl_Task_Module__loggerFxn0__C = ((CT__ti_sysbios_knl_Task_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerFxn1__C, ".const:ti_sysbios_knl_Task_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerFxn1 ti_sysbios_knl_Task_Module__loggerFxn1__C = ((CT__ti_sysbios_knl_Task_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerFxn2__C, ".const:ti_sysbios_knl_Task_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerFxn2 ti_sysbios_knl_Task_Module__loggerFxn2__C = ((CT__ti_sysbios_knl_Task_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerFxn4__C, ".const:ti_sysbios_knl_Task_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerFxn4 ti_sysbios_knl_Task_Module__loggerFxn4__C = ((CT__ti_sysbios_knl_Task_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__loggerFxn8__C, ".const:ti_sysbios_knl_Task_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__loggerFxn8 ti_sysbios_knl_Task_Module__loggerFxn8__C = ((CT__ti_sysbios_knl_Task_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Module__startupDoneFxn__C, ".const:ti_sysbios_knl_Task_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Module__startupDoneFxn ti_sysbios_knl_Task_Module__startupDoneFxn__C = ((CT__ti_sysbios_knl_Task_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__count__C, ".const:ti_sysbios_knl_Task_Object__count__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Object__count ti_sysbios_knl_Task_Object__count__C = 13; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__heap__C, ".const:ti_sysbios_knl_Task_Object__heap__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Object__heap ti_sysbios_knl_Task_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__sizeof__C, ".const:ti_sysbios_knl_Task_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Object__sizeof ti_sysbios_knl_Task_Object__sizeof__C = sizeof(ti_sysbios_knl_Task_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__table__C, ".const:ti_sysbios_knl_Task_Object__table__C"); -__FAR__ const CT__ti_sysbios_knl_Task_Object__table ti_sysbios_knl_Task_Object__table__C = ti_sysbios_knl_Task_Object__table__V; - -/* LM_switch__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_switch__C, ".const:ti_sysbios_knl_Task_LM_switch__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_switch ti_sysbios_knl_Task_LM_switch__C = (((xdc_runtime_Log_Event)5602) << 16 | 768); - -/* LM_sleep__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_sleep__C, ".const:ti_sysbios_knl_Task_LM_sleep__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_sleep ti_sysbios_knl_Task_LM_sleep__C = (((xdc_runtime_Log_Event)5670) << 16 | 768); - -/* LD_ready__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LD_ready__C, ".const:ti_sysbios_knl_Task_LD_ready__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LD_ready ti_sysbios_knl_Task_LD_ready__C = (((xdc_runtime_Log_Event)5715) << 16 | 512); - -/* LD_block__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LD_block__C, ".const:ti_sysbios_knl_Task_LD_block__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LD_block ti_sysbios_knl_Task_LD_block__C = (((xdc_runtime_Log_Event)5756) << 16 | 512); - -/* LM_yield__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_yield__C, ".const:ti_sysbios_knl_Task_LM_yield__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_yield ti_sysbios_knl_Task_LM_yield__C = (((xdc_runtime_Log_Event)5788) << 16 | 768); - -/* LM_setPri__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_setPri__C, ".const:ti_sysbios_knl_Task_LM_setPri__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_setPri ti_sysbios_knl_Task_LM_setPri__C = (((xdc_runtime_Log_Event)5836) << 16 | 768); - -/* LD_exit__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LD_exit__C, ".const:ti_sysbios_knl_Task_LD_exit__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LD_exit ti_sysbios_knl_Task_LD_exit__C = (((xdc_runtime_Log_Event)5892) << 16 | 512); - -/* LM_setAffinity__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_setAffinity__C, ".const:ti_sysbios_knl_Task_LM_setAffinity__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_setAffinity ti_sysbios_knl_Task_LM_setAffinity__C = (((xdc_runtime_Log_Event)5923) << 16 | 768); - -/* LM_schedule__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_schedule__C, ".const:ti_sysbios_knl_Task_LM_schedule__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_schedule ti_sysbios_knl_Task_LM_schedule__C = (((xdc_runtime_Log_Event)6006) << 16 | 1024); - -/* LM_noWork__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_LM_noWork__C, ".const:ti_sysbios_knl_Task_LM_noWork__C"); -__FAR__ const CT__ti_sysbios_knl_Task_LM_noWork ti_sysbios_knl_Task_LM_noWork__C = (((xdc_runtime_Log_Event)6092) << 16 | 1024); - -/* E_stackOverflow__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_E_stackOverflow__C, ".const:ti_sysbios_knl_Task_E_stackOverflow__C"); -__FAR__ const CT__ti_sysbios_knl_Task_E_stackOverflow ti_sysbios_knl_Task_E_stackOverflow__C = (((xdc_runtime_Error_Id)4546) << 16 | 0); - -/* E_spOutOfBounds__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_E_spOutOfBounds__C, ".const:ti_sysbios_knl_Task_E_spOutOfBounds__C"); -__FAR__ const CT__ti_sysbios_knl_Task_E_spOutOfBounds ti_sysbios_knl_Task_E_spOutOfBounds__C = (((xdc_runtime_Error_Id)4589) << 16 | 0); - -/* E_deleteNotAllowed__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_E_deleteNotAllowed__C, ".const:ti_sysbios_knl_Task_E_deleteNotAllowed__C"); -__FAR__ const CT__ti_sysbios_knl_Task_E_deleteNotAllowed ti_sysbios_knl_Task_E_deleteNotAllowed__C = (((xdc_runtime_Error_Id)4640) << 16 | 0); - -/* A_badThreadType__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_badThreadType__C, ".const:ti_sysbios_knl_Task_A_badThreadType__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_badThreadType ti_sysbios_knl_Task_A_badThreadType__C = (((xdc_runtime_Assert_Id)1630) << 16 | 16); - -/* A_badTaskState__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_badTaskState__C, ".const:ti_sysbios_knl_Task_A_badTaskState__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_badTaskState ti_sysbios_knl_Task_A_badTaskState__C = (((xdc_runtime_Assert_Id)1699) << 16 | 16); - -/* A_noPendElem__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_noPendElem__C, ".const:ti_sysbios_knl_Task_A_noPendElem__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_noPendElem ti_sysbios_knl_Task_A_noPendElem__C = (((xdc_runtime_Assert_Id)1753) << 16 | 16); - -/* A_taskDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_taskDisabled__C, ".const:ti_sysbios_knl_Task_A_taskDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_taskDisabled ti_sysbios_knl_Task_A_taskDisabled__C = (((xdc_runtime_Assert_Id)1807) << 16 | 16); - -/* A_badPriority__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_badPriority__C, ".const:ti_sysbios_knl_Task_A_badPriority__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_badPriority ti_sysbios_knl_Task_A_badPriority__C = (((xdc_runtime_Assert_Id)1870) << 16 | 16); - -/* A_badTimeout__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_badTimeout__C, ".const:ti_sysbios_knl_Task_A_badTimeout__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_badTimeout ti_sysbios_knl_Task_A_badTimeout__C = (((xdc_runtime_Assert_Id)1920) << 16 | 16); - -/* A_badAffinity__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_badAffinity__C, ".const:ti_sysbios_knl_Task_A_badAffinity__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_badAffinity ti_sysbios_knl_Task_A_badAffinity__C = (((xdc_runtime_Assert_Id)1955) << 16 | 16); - -/* A_sleepTaskDisabled__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_sleepTaskDisabled__C, ".const:ti_sysbios_knl_Task_A_sleepTaskDisabled__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_sleepTaskDisabled ti_sysbios_knl_Task_A_sleepTaskDisabled__C = (((xdc_runtime_Assert_Id)1988) << 16 | 16); - -/* A_invalidCoreId__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_A_invalidCoreId__C, ".const:ti_sysbios_knl_Task_A_invalidCoreId__C"); -__FAR__ const CT__ti_sysbios_knl_Task_A_invalidCoreId ti_sysbios_knl_Task_A_invalidCoreId__C = (((xdc_runtime_Assert_Id)2072) << 16 | 16); - -/* numPriorities__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_numPriorities__C, ".const:ti_sysbios_knl_Task_numPriorities__C"); -__FAR__ const CT__ti_sysbios_knl_Task_numPriorities ti_sysbios_knl_Task_numPriorities__C = (xdc_UInt)0x10; - -/* defaultStackSize__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_defaultStackSize__C, ".const:ti_sysbios_knl_Task_defaultStackSize__C"); -__FAR__ const CT__ti_sysbios_knl_Task_defaultStackSize ti_sysbios_knl_Task_defaultStackSize__C = (xdc_SizeT)0x400; - -/* defaultStackHeap__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_defaultStackHeap__C, ".const:ti_sysbios_knl_Task_defaultStackHeap__C"); -__FAR__ const CT__ti_sysbios_knl_Task_defaultStackHeap ti_sysbios_knl_Task_defaultStackHeap__C = 0; - -/* allBlockedFunc__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_allBlockedFunc__C, ".const:ti_sysbios_knl_Task_allBlockedFunc__C"); -__FAR__ const CT__ti_sysbios_knl_Task_allBlockedFunc ti_sysbios_knl_Task_allBlockedFunc__C = ((CT__ti_sysbios_knl_Task_allBlockedFunc)0); - -/* initStackFlag__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_initStackFlag__C, ".const:ti_sysbios_knl_Task_initStackFlag__C"); -__FAR__ const CT__ti_sysbios_knl_Task_initStackFlag ti_sysbios_knl_Task_initStackFlag__C = 1; - -/* checkStackFlag__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_checkStackFlag__C, ".const:ti_sysbios_knl_Task_checkStackFlag__C"); -__FAR__ const CT__ti_sysbios_knl_Task_checkStackFlag ti_sysbios_knl_Task_checkStackFlag__C = 1; - -/* deleteTerminatedTasks__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_deleteTerminatedTasks__C, ".const:ti_sysbios_knl_Task_deleteTerminatedTasks__C"); -__FAR__ const CT__ti_sysbios_knl_Task_deleteTerminatedTasks ti_sysbios_knl_Task_deleteTerminatedTasks__C = 0; - -/* hooks__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_hooks__C, ".const:ti_sysbios_knl_Task_hooks__C"); -__FAR__ const CT__ti_sysbios_knl_Task_hooks ti_sysbios_knl_Task_hooks__C = {0, 0}; - -/* numConstructedTasks__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_numConstructedTasks__C, ".const:ti_sysbios_knl_Task_numConstructedTasks__C"); -__FAR__ const CT__ti_sysbios_knl_Task_numConstructedTasks ti_sysbios_knl_Task_numConstructedTasks__C = (xdc_UInt)0x0; - -/* startupHookFunc__C */ -#pragma DATA_SECTION(ti_sysbios_knl_Task_startupHookFunc__C, ".const:ti_sysbios_knl_Task_startupHookFunc__C"); -__FAR__ const CT__ti_sysbios_knl_Task_startupHookFunc ti_sysbios_knl_Task_startupHookFunc__C = ((CT__ti_sysbios_knl_Task_startupHookFunc)0); - - -/* - * ======== ti.sysbios.knl.Task_SupportProxy INITIALIZERS ======== - */ - - -/* - * ======== ti.sysbios.xdcruntime.SemThreadSupport INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C"); -__FAR__ const ti_sysbios_xdcruntime_SemThreadSupport_Params ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C = { - sizeof (ti_sysbios_xdcruntime_SemThreadSupport_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C.__iprms, /* instance */ - xdc_runtime_knl_ISemaphore_Mode_COUNTING, /* mode */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -ti_sysbios_xdcruntime_SemThreadSupport_Module__ ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V = { - {&ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link, /* link.next */ - &ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsEnabled__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsEnabled__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsEnabled ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsIncluded__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsIncluded__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsIncluded ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__id__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__id__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__id ti_sysbios_xdcruntime_SemThreadSupport_Module__id__C = (xdc_Bits16)0x803e; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerDefined__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerDefined__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerDefined ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDoneFxn__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDoneFxn__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDoneFxn ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDoneFxn__C = ((CT__ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__count__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__count__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Object__count ti_sysbios_xdcruntime_SemThreadSupport_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__heap__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__heap__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Object__heap ti_sysbios_xdcruntime_SemThreadSupport_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__sizeof__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__sizeof__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Object__sizeof ti_sysbios_xdcruntime_SemThreadSupport_Object__sizeof__C = sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__table__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__table__C"); -__FAR__ const CT__ti_sysbios_xdcruntime_SemThreadSupport_Object__table ti_sysbios_xdcruntime_SemThreadSupport_Object__table__C = 0; - - -/* - * ======== xdc.runtime.Assert INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__diagsEnabled__C, ".const:xdc_runtime_Assert_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__diagsEnabled xdc_runtime_Assert_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__diagsIncluded__C, ".const:xdc_runtime_Assert_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__diagsIncluded xdc_runtime_Assert_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__diagsMask__C, ".const:xdc_runtime_Assert_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__diagsMask xdc_runtime_Assert_Module__diagsMask__C = ((CT__xdc_runtime_Assert_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__gateObj__C, ".const:xdc_runtime_Assert_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__gateObj xdc_runtime_Assert_Module__gateObj__C = ((CT__xdc_runtime_Assert_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__gatePrms__C, ".const:xdc_runtime_Assert_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__gatePrms xdc_runtime_Assert_Module__gatePrms__C = ((CT__xdc_runtime_Assert_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__id__C, ".const:xdc_runtime_Assert_Module__id__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__id xdc_runtime_Assert_Module__id__C = (xdc_Bits16)0x8002; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerDefined__C, ".const:xdc_runtime_Assert_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerDefined xdc_runtime_Assert_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerObj__C, ".const:xdc_runtime_Assert_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerObj xdc_runtime_Assert_Module__loggerObj__C = ((CT__xdc_runtime_Assert_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerFxn0__C, ".const:xdc_runtime_Assert_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerFxn0 xdc_runtime_Assert_Module__loggerFxn0__C = ((CT__xdc_runtime_Assert_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerFxn1__C, ".const:xdc_runtime_Assert_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerFxn1 xdc_runtime_Assert_Module__loggerFxn1__C = ((CT__xdc_runtime_Assert_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerFxn2__C, ".const:xdc_runtime_Assert_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerFxn2 xdc_runtime_Assert_Module__loggerFxn2__C = ((CT__xdc_runtime_Assert_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerFxn4__C, ".const:xdc_runtime_Assert_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerFxn4 xdc_runtime_Assert_Module__loggerFxn4__C = ((CT__xdc_runtime_Assert_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__loggerFxn8__C, ".const:xdc_runtime_Assert_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__loggerFxn8 xdc_runtime_Assert_Module__loggerFxn8__C = ((CT__xdc_runtime_Assert_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Module__startupDoneFxn__C, ".const:xdc_runtime_Assert_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Assert_Module__startupDoneFxn xdc_runtime_Assert_Module__startupDoneFxn__C = ((CT__xdc_runtime_Assert_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Object__count__C, ".const:xdc_runtime_Assert_Object__count__C"); -__FAR__ const CT__xdc_runtime_Assert_Object__count xdc_runtime_Assert_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Object__heap__C, ".const:xdc_runtime_Assert_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Assert_Object__heap xdc_runtime_Assert_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Object__sizeof__C, ".const:xdc_runtime_Assert_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Assert_Object__sizeof xdc_runtime_Assert_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_Object__table__C, ".const:xdc_runtime_Assert_Object__table__C"); -__FAR__ const CT__xdc_runtime_Assert_Object__table xdc_runtime_Assert_Object__table__C = 0; - -/* E_assertFailed__C */ -#pragma DATA_SECTION(xdc_runtime_Assert_E_assertFailed__C, ".const:xdc_runtime_Assert_E_assertFailed__C"); -__FAR__ const CT__xdc_runtime_Assert_E_assertFailed xdc_runtime_Assert_E_assertFailed__C = (((xdc_runtime_Error_Id)3687) << 16 | 0); - - -/* - * ======== xdc.runtime.Core INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__diagsEnabled__C, ".const:xdc_runtime_Core_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Core_Module__diagsEnabled xdc_runtime_Core_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__diagsIncluded__C, ".const:xdc_runtime_Core_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Core_Module__diagsIncluded xdc_runtime_Core_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__diagsMask__C, ".const:xdc_runtime_Core_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Core_Module__diagsMask xdc_runtime_Core_Module__diagsMask__C = ((CT__xdc_runtime_Core_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__gateObj__C, ".const:xdc_runtime_Core_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Core_Module__gateObj xdc_runtime_Core_Module__gateObj__C = ((CT__xdc_runtime_Core_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__gatePrms__C, ".const:xdc_runtime_Core_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Core_Module__gatePrms xdc_runtime_Core_Module__gatePrms__C = ((CT__xdc_runtime_Core_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__id__C, ".const:xdc_runtime_Core_Module__id__C"); -__FAR__ const CT__xdc_runtime_Core_Module__id xdc_runtime_Core_Module__id__C = (xdc_Bits16)0x8003; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerDefined__C, ".const:xdc_runtime_Core_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerDefined xdc_runtime_Core_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerObj__C, ".const:xdc_runtime_Core_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerObj xdc_runtime_Core_Module__loggerObj__C = ((CT__xdc_runtime_Core_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerFxn0__C, ".const:xdc_runtime_Core_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerFxn0 xdc_runtime_Core_Module__loggerFxn0__C = ((CT__xdc_runtime_Core_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerFxn1__C, ".const:xdc_runtime_Core_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerFxn1 xdc_runtime_Core_Module__loggerFxn1__C = ((CT__xdc_runtime_Core_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerFxn2__C, ".const:xdc_runtime_Core_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerFxn2 xdc_runtime_Core_Module__loggerFxn2__C = ((CT__xdc_runtime_Core_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerFxn4__C, ".const:xdc_runtime_Core_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerFxn4 xdc_runtime_Core_Module__loggerFxn4__C = ((CT__xdc_runtime_Core_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__loggerFxn8__C, ".const:xdc_runtime_Core_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Core_Module__loggerFxn8 xdc_runtime_Core_Module__loggerFxn8__C = ((CT__xdc_runtime_Core_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Module__startupDoneFxn__C, ".const:xdc_runtime_Core_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Core_Module__startupDoneFxn xdc_runtime_Core_Module__startupDoneFxn__C = ((CT__xdc_runtime_Core_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Object__count__C, ".const:xdc_runtime_Core_Object__count__C"); -__FAR__ const CT__xdc_runtime_Core_Object__count xdc_runtime_Core_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Object__heap__C, ".const:xdc_runtime_Core_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Core_Object__heap xdc_runtime_Core_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Object__sizeof__C, ".const:xdc_runtime_Core_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Core_Object__sizeof xdc_runtime_Core_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Core_Object__table__C, ".const:xdc_runtime_Core_Object__table__C"); -__FAR__ const CT__xdc_runtime_Core_Object__table xdc_runtime_Core_Object__table__C = 0; - -/* A_initializedParams__C */ -#pragma DATA_SECTION(xdc_runtime_Core_A_initializedParams__C, ".const:xdc_runtime_Core_A_initializedParams__C"); -__FAR__ const CT__xdc_runtime_Core_A_initializedParams xdc_runtime_Core_A_initializedParams__C = (((xdc_runtime_Assert_Id)1) << 16 | 16); - - -/* - * ======== xdc.runtime.Defaults INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__diagsEnabled__C, ".const:xdc_runtime_Defaults_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__diagsEnabled xdc_runtime_Defaults_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__diagsIncluded__C, ".const:xdc_runtime_Defaults_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__diagsIncluded xdc_runtime_Defaults_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__diagsMask__C, ".const:xdc_runtime_Defaults_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__diagsMask xdc_runtime_Defaults_Module__diagsMask__C = ((CT__xdc_runtime_Defaults_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__gateObj__C, ".const:xdc_runtime_Defaults_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__gateObj xdc_runtime_Defaults_Module__gateObj__C = ((CT__xdc_runtime_Defaults_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__gatePrms__C, ".const:xdc_runtime_Defaults_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__gatePrms xdc_runtime_Defaults_Module__gatePrms__C = ((CT__xdc_runtime_Defaults_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__id__C, ".const:xdc_runtime_Defaults_Module__id__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__id xdc_runtime_Defaults_Module__id__C = (xdc_Bits16)0x8004; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerDefined__C, ".const:xdc_runtime_Defaults_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerDefined xdc_runtime_Defaults_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerObj__C, ".const:xdc_runtime_Defaults_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerObj xdc_runtime_Defaults_Module__loggerObj__C = ((CT__xdc_runtime_Defaults_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerFxn0__C, ".const:xdc_runtime_Defaults_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerFxn0 xdc_runtime_Defaults_Module__loggerFxn0__C = ((CT__xdc_runtime_Defaults_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerFxn1__C, ".const:xdc_runtime_Defaults_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerFxn1 xdc_runtime_Defaults_Module__loggerFxn1__C = ((CT__xdc_runtime_Defaults_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerFxn2__C, ".const:xdc_runtime_Defaults_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerFxn2 xdc_runtime_Defaults_Module__loggerFxn2__C = ((CT__xdc_runtime_Defaults_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerFxn4__C, ".const:xdc_runtime_Defaults_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerFxn4 xdc_runtime_Defaults_Module__loggerFxn4__C = ((CT__xdc_runtime_Defaults_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__loggerFxn8__C, ".const:xdc_runtime_Defaults_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__loggerFxn8 xdc_runtime_Defaults_Module__loggerFxn8__C = ((CT__xdc_runtime_Defaults_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Module__startupDoneFxn__C, ".const:xdc_runtime_Defaults_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Defaults_Module__startupDoneFxn xdc_runtime_Defaults_Module__startupDoneFxn__C = ((CT__xdc_runtime_Defaults_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Object__count__C, ".const:xdc_runtime_Defaults_Object__count__C"); -__FAR__ const CT__xdc_runtime_Defaults_Object__count xdc_runtime_Defaults_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Object__heap__C, ".const:xdc_runtime_Defaults_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Defaults_Object__heap xdc_runtime_Defaults_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Object__sizeof__C, ".const:xdc_runtime_Defaults_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Defaults_Object__sizeof xdc_runtime_Defaults_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Defaults_Object__table__C, ".const:xdc_runtime_Defaults_Object__table__C"); -__FAR__ const CT__xdc_runtime_Defaults_Object__table xdc_runtime_Defaults_Object__table__C = 0; - - -/* - * ======== xdc.runtime.Diags INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__diagsEnabled__C, ".const:xdc_runtime_Diags_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__diagsEnabled xdc_runtime_Diags_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__diagsIncluded__C, ".const:xdc_runtime_Diags_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__diagsIncluded xdc_runtime_Diags_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__diagsMask__C, ".const:xdc_runtime_Diags_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__diagsMask xdc_runtime_Diags_Module__diagsMask__C = ((CT__xdc_runtime_Diags_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__gateObj__C, ".const:xdc_runtime_Diags_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__gateObj xdc_runtime_Diags_Module__gateObj__C = ((CT__xdc_runtime_Diags_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__gatePrms__C, ".const:xdc_runtime_Diags_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__gatePrms xdc_runtime_Diags_Module__gatePrms__C = ((CT__xdc_runtime_Diags_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__id__C, ".const:xdc_runtime_Diags_Module__id__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__id xdc_runtime_Diags_Module__id__C = (xdc_Bits16)0x8005; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerDefined__C, ".const:xdc_runtime_Diags_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerDefined xdc_runtime_Diags_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerObj__C, ".const:xdc_runtime_Diags_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerObj xdc_runtime_Diags_Module__loggerObj__C = ((CT__xdc_runtime_Diags_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerFxn0__C, ".const:xdc_runtime_Diags_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerFxn0 xdc_runtime_Diags_Module__loggerFxn0__C = ((CT__xdc_runtime_Diags_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerFxn1__C, ".const:xdc_runtime_Diags_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerFxn1 xdc_runtime_Diags_Module__loggerFxn1__C = ((CT__xdc_runtime_Diags_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerFxn2__C, ".const:xdc_runtime_Diags_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerFxn2 xdc_runtime_Diags_Module__loggerFxn2__C = ((CT__xdc_runtime_Diags_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerFxn4__C, ".const:xdc_runtime_Diags_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerFxn4 xdc_runtime_Diags_Module__loggerFxn4__C = ((CT__xdc_runtime_Diags_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__loggerFxn8__C, ".const:xdc_runtime_Diags_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__loggerFxn8 xdc_runtime_Diags_Module__loggerFxn8__C = ((CT__xdc_runtime_Diags_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Module__startupDoneFxn__C, ".const:xdc_runtime_Diags_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Diags_Module__startupDoneFxn xdc_runtime_Diags_Module__startupDoneFxn__C = ((CT__xdc_runtime_Diags_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Object__count__C, ".const:xdc_runtime_Diags_Object__count__C"); -__FAR__ const CT__xdc_runtime_Diags_Object__count xdc_runtime_Diags_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Object__heap__C, ".const:xdc_runtime_Diags_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Diags_Object__heap xdc_runtime_Diags_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Object__sizeof__C, ".const:xdc_runtime_Diags_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Diags_Object__sizeof xdc_runtime_Diags_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_Object__table__C, ".const:xdc_runtime_Diags_Object__table__C"); -__FAR__ const CT__xdc_runtime_Diags_Object__table xdc_runtime_Diags_Object__table__C = 0; - -/* setMaskEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_setMaskEnabled__C, ".const:xdc_runtime_Diags_setMaskEnabled__C"); -__FAR__ const CT__xdc_runtime_Diags_setMaskEnabled xdc_runtime_Diags_setMaskEnabled__C = 0; - -/* dictBase__C */ -#pragma DATA_SECTION(xdc_runtime_Diags_dictBase__C, ".const:xdc_runtime_Diags_dictBase__C"); -__FAR__ const CT__xdc_runtime_Diags_dictBase xdc_runtime_Diags_dictBase__C = ((CT__xdc_runtime_Diags_dictBase)0); - - -/* - * ======== xdc.runtime.Error INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_Error_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_Error_Module_State__ xdc_runtime_Error_Module__state__V __attribute__ ((section(".data_xdc_runtime_Error_Module__state__V"))); -#endif -#endif -xdc_runtime_Error_Module_State__ xdc_runtime_Error_Module__state__V = { - (xdc_UInt16)0x0, /* count */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__diagsEnabled__C, ".const:xdc_runtime_Error_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Error_Module__diagsEnabled xdc_runtime_Error_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__diagsIncluded__C, ".const:xdc_runtime_Error_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Error_Module__diagsIncluded xdc_runtime_Error_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__diagsMask__C, ".const:xdc_runtime_Error_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Error_Module__diagsMask xdc_runtime_Error_Module__diagsMask__C = ((CT__xdc_runtime_Error_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__gateObj__C, ".const:xdc_runtime_Error_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Error_Module__gateObj xdc_runtime_Error_Module__gateObj__C = ((CT__xdc_runtime_Error_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__gatePrms__C, ".const:xdc_runtime_Error_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Error_Module__gatePrms xdc_runtime_Error_Module__gatePrms__C = ((CT__xdc_runtime_Error_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__id__C, ".const:xdc_runtime_Error_Module__id__C"); -__FAR__ const CT__xdc_runtime_Error_Module__id xdc_runtime_Error_Module__id__C = (xdc_Bits16)0x8006; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerDefined__C, ".const:xdc_runtime_Error_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerDefined xdc_runtime_Error_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerObj__C, ".const:xdc_runtime_Error_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerObj xdc_runtime_Error_Module__loggerObj__C = ((CT__xdc_runtime_Error_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerFxn0__C, ".const:xdc_runtime_Error_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerFxn0 xdc_runtime_Error_Module__loggerFxn0__C = ((CT__xdc_runtime_Error_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerFxn1__C, ".const:xdc_runtime_Error_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerFxn1 xdc_runtime_Error_Module__loggerFxn1__C = ((CT__xdc_runtime_Error_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerFxn2__C, ".const:xdc_runtime_Error_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerFxn2 xdc_runtime_Error_Module__loggerFxn2__C = ((CT__xdc_runtime_Error_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerFxn4__C, ".const:xdc_runtime_Error_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerFxn4 xdc_runtime_Error_Module__loggerFxn4__C = ((CT__xdc_runtime_Error_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__loggerFxn8__C, ".const:xdc_runtime_Error_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Error_Module__loggerFxn8 xdc_runtime_Error_Module__loggerFxn8__C = ((CT__xdc_runtime_Error_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Module__startupDoneFxn__C, ".const:xdc_runtime_Error_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Error_Module__startupDoneFxn xdc_runtime_Error_Module__startupDoneFxn__C = ((CT__xdc_runtime_Error_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Object__count__C, ".const:xdc_runtime_Error_Object__count__C"); -__FAR__ const CT__xdc_runtime_Error_Object__count xdc_runtime_Error_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Object__heap__C, ".const:xdc_runtime_Error_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Error_Object__heap xdc_runtime_Error_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Object__sizeof__C, ".const:xdc_runtime_Error_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Error_Object__sizeof xdc_runtime_Error_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Error_Object__table__C, ".const:xdc_runtime_Error_Object__table__C"); -__FAR__ const CT__xdc_runtime_Error_Object__table xdc_runtime_Error_Object__table__C = 0; - -/* policyFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Error_policyFxn__C, ".const:xdc_runtime_Error_policyFxn__C"); -__FAR__ const CT__xdc_runtime_Error_policyFxn xdc_runtime_Error_policyFxn__C = ((CT__xdc_runtime_Error_policyFxn)((xdc_Fxn)xdc_runtime_Error_policyDefault__E)); - -/* E_generic__C */ -#pragma DATA_SECTION(xdc_runtime_Error_E_generic__C, ".const:xdc_runtime_Error_E_generic__C"); -__FAR__ const CT__xdc_runtime_Error_E_generic xdc_runtime_Error_E_generic__C = (((xdc_runtime_Error_Id)3709) << 16 | 0); - -/* E_memory__C */ -#pragma DATA_SECTION(xdc_runtime_Error_E_memory__C, ".const:xdc_runtime_Error_E_memory__C"); -__FAR__ const CT__xdc_runtime_Error_E_memory xdc_runtime_Error_E_memory__C = (((xdc_runtime_Error_Id)3713) << 16 | 0); - -/* E_msgCode__C */ -#pragma DATA_SECTION(xdc_runtime_Error_E_msgCode__C, ".const:xdc_runtime_Error_E_msgCode__C"); -__FAR__ const CT__xdc_runtime_Error_E_msgCode xdc_runtime_Error_E_msgCode__C = (((xdc_runtime_Error_Id)3747) << 16 | 0); - -/* policy__C */ -#pragma DATA_SECTION(xdc_runtime_Error_policy__C, ".const:xdc_runtime_Error_policy__C"); -__FAR__ const CT__xdc_runtime_Error_policy xdc_runtime_Error_policy__C = xdc_runtime_Error_UNWIND; - -/* raiseHook__C */ -#pragma DATA_SECTION(xdc_runtime_Error_raiseHook__C, ".const:xdc_runtime_Error_raiseHook__C"); -__FAR__ const CT__xdc_runtime_Error_raiseHook xdc_runtime_Error_raiseHook__C = ((CT__xdc_runtime_Error_raiseHook)((xdc_Fxn)ti_sysbios_BIOS_errorRaiseHook__I)); - -/* maxDepth__C */ -#pragma DATA_SECTION(xdc_runtime_Error_maxDepth__C, ".const:xdc_runtime_Error_maxDepth__C"); -__FAR__ const CT__xdc_runtime_Error_maxDepth xdc_runtime_Error_maxDepth__C = (xdc_UInt16)0x10; - - -/* - * ======== xdc.runtime.Gate INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__diagsEnabled__C, ".const:xdc_runtime_Gate_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__diagsEnabled xdc_runtime_Gate_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__diagsIncluded__C, ".const:xdc_runtime_Gate_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__diagsIncluded xdc_runtime_Gate_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__diagsMask__C, ".const:xdc_runtime_Gate_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__diagsMask xdc_runtime_Gate_Module__diagsMask__C = ((CT__xdc_runtime_Gate_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__gateObj__C, ".const:xdc_runtime_Gate_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__gateObj xdc_runtime_Gate_Module__gateObj__C = ((CT__xdc_runtime_Gate_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__gatePrms__C, ".const:xdc_runtime_Gate_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__gatePrms xdc_runtime_Gate_Module__gatePrms__C = ((CT__xdc_runtime_Gate_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__id__C, ".const:xdc_runtime_Gate_Module__id__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__id xdc_runtime_Gate_Module__id__C = (xdc_Bits16)0x8007; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerDefined__C, ".const:xdc_runtime_Gate_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerDefined xdc_runtime_Gate_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerObj__C, ".const:xdc_runtime_Gate_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerObj xdc_runtime_Gate_Module__loggerObj__C = ((CT__xdc_runtime_Gate_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerFxn0__C, ".const:xdc_runtime_Gate_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerFxn0 xdc_runtime_Gate_Module__loggerFxn0__C = ((CT__xdc_runtime_Gate_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerFxn1__C, ".const:xdc_runtime_Gate_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerFxn1 xdc_runtime_Gate_Module__loggerFxn1__C = ((CT__xdc_runtime_Gate_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerFxn2__C, ".const:xdc_runtime_Gate_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerFxn2 xdc_runtime_Gate_Module__loggerFxn2__C = ((CT__xdc_runtime_Gate_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerFxn4__C, ".const:xdc_runtime_Gate_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerFxn4 xdc_runtime_Gate_Module__loggerFxn4__C = ((CT__xdc_runtime_Gate_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__loggerFxn8__C, ".const:xdc_runtime_Gate_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__loggerFxn8 xdc_runtime_Gate_Module__loggerFxn8__C = ((CT__xdc_runtime_Gate_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Module__startupDoneFxn__C, ".const:xdc_runtime_Gate_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Gate_Module__startupDoneFxn xdc_runtime_Gate_Module__startupDoneFxn__C = ((CT__xdc_runtime_Gate_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Object__count__C, ".const:xdc_runtime_Gate_Object__count__C"); -__FAR__ const CT__xdc_runtime_Gate_Object__count xdc_runtime_Gate_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Object__heap__C, ".const:xdc_runtime_Gate_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Gate_Object__heap xdc_runtime_Gate_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Object__sizeof__C, ".const:xdc_runtime_Gate_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Gate_Object__sizeof xdc_runtime_Gate_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Gate_Object__table__C, ".const:xdc_runtime_Gate_Object__table__C"); -__FAR__ const CT__xdc_runtime_Gate_Object__table xdc_runtime_Gate_Object__table__C = 0; - - -/* - * ======== xdc.runtime.HeapStd INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_HeapStd_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__PARAMS__C, ".const:xdc_runtime_HeapStd_Object__PARAMS__C"); -__FAR__ const xdc_runtime_HeapStd_Params xdc_runtime_HeapStd_Object__PARAMS__C = { - sizeof (xdc_runtime_HeapStd_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&xdc_runtime_HeapStd_Object__PARAMS__C.__iprms, /* instance */ - ((xdc_UArg)(0x0)), /* size */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -xdc_runtime_HeapStd_Module__ xdc_runtime_HeapStd_Module__root__V = { - {&xdc_runtime_HeapStd_Module__root__V.link, /* link.next */ - &xdc_runtime_HeapStd_Module__root__V.link}, /* link.prev */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_HeapStd_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_HeapStd_Module_State__ xdc_runtime_HeapStd_Module__state__V __attribute__ ((section(".data_xdc_runtime_HeapStd_Module__state__V"))); -#endif -#endif -xdc_runtime_HeapStd_Module_State__ xdc_runtime_HeapStd_Module__state__V = { - ((xdc_UArg)(0xc350)), /* remainRTSSize */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__diagsEnabled__C, ".const:xdc_runtime_HeapStd_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__diagsEnabled xdc_runtime_HeapStd_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__diagsIncluded__C, ".const:xdc_runtime_HeapStd_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__diagsIncluded xdc_runtime_HeapStd_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__diagsMask__C, ".const:xdc_runtime_HeapStd_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__diagsMask xdc_runtime_HeapStd_Module__diagsMask__C = ((CT__xdc_runtime_HeapStd_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__gateObj__C, ".const:xdc_runtime_HeapStd_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__gateObj xdc_runtime_HeapStd_Module__gateObj__C = ((CT__xdc_runtime_HeapStd_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__gatePrms__C, ".const:xdc_runtime_HeapStd_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__gatePrms xdc_runtime_HeapStd_Module__gatePrms__C = ((CT__xdc_runtime_HeapStd_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__id__C, ".const:xdc_runtime_HeapStd_Module__id__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__id xdc_runtime_HeapStd_Module__id__C = (xdc_Bits16)0x800b; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerDefined__C, ".const:xdc_runtime_HeapStd_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerDefined xdc_runtime_HeapStd_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerObj__C, ".const:xdc_runtime_HeapStd_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerObj xdc_runtime_HeapStd_Module__loggerObj__C = ((CT__xdc_runtime_HeapStd_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerFxn0__C, ".const:xdc_runtime_HeapStd_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerFxn0 xdc_runtime_HeapStd_Module__loggerFxn0__C = ((CT__xdc_runtime_HeapStd_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerFxn1__C, ".const:xdc_runtime_HeapStd_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerFxn1 xdc_runtime_HeapStd_Module__loggerFxn1__C = ((CT__xdc_runtime_HeapStd_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerFxn2__C, ".const:xdc_runtime_HeapStd_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerFxn2 xdc_runtime_HeapStd_Module__loggerFxn2__C = ((CT__xdc_runtime_HeapStd_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerFxn4__C, ".const:xdc_runtime_HeapStd_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerFxn4 xdc_runtime_HeapStd_Module__loggerFxn4__C = ((CT__xdc_runtime_HeapStd_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__loggerFxn8__C, ".const:xdc_runtime_HeapStd_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__loggerFxn8 xdc_runtime_HeapStd_Module__loggerFxn8__C = ((CT__xdc_runtime_HeapStd_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Module__startupDoneFxn__C, ".const:xdc_runtime_HeapStd_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Module__startupDoneFxn xdc_runtime_HeapStd_Module__startupDoneFxn__C = ((CT__xdc_runtime_HeapStd_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__count__C, ".const:xdc_runtime_HeapStd_Object__count__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Object__count xdc_runtime_HeapStd_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__heap__C, ".const:xdc_runtime_HeapStd_Object__heap__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Object__heap xdc_runtime_HeapStd_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__sizeof__C, ".const:xdc_runtime_HeapStd_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Object__sizeof xdc_runtime_HeapStd_Object__sizeof__C = sizeof(xdc_runtime_HeapStd_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__table__C, ".const:xdc_runtime_HeapStd_Object__table__C"); -__FAR__ const CT__xdc_runtime_HeapStd_Object__table xdc_runtime_HeapStd_Object__table__C = 0; - -/* E_noRTSMemory__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_E_noRTSMemory__C, ".const:xdc_runtime_HeapStd_E_noRTSMemory__C"); -__FAR__ const CT__xdc_runtime_HeapStd_E_noRTSMemory xdc_runtime_HeapStd_E_noRTSMemory__C = (((xdc_runtime_Error_Id)3832) << 16 | 0); - -/* A_zeroSize__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_A_zeroSize__C, ".const:xdc_runtime_HeapStd_A_zeroSize__C"); -__FAR__ const CT__xdc_runtime_HeapStd_A_zeroSize xdc_runtime_HeapStd_A_zeroSize__C = (((xdc_runtime_Assert_Id)95) << 16 | 16); - -/* A_align__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_A_align__C, ".const:xdc_runtime_HeapStd_A_align__C"); -__FAR__ const CT__xdc_runtime_HeapStd_A_align xdc_runtime_HeapStd_A_align__C = (((xdc_runtime_Assert_Id)140) << 16 | 16); - -/* A_invalidTotalFreeSize__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_A_invalidTotalFreeSize__C, ".const:xdc_runtime_HeapStd_A_invalidTotalFreeSize__C"); -__FAR__ const CT__xdc_runtime_HeapStd_A_invalidTotalFreeSize xdc_runtime_HeapStd_A_invalidTotalFreeSize__C = (((xdc_runtime_Assert_Id)185) << 16 | 16); - -/* A_invalidAlignment__C */ -#pragma DATA_SECTION(xdc_runtime_HeapStd_A_invalidAlignment__C, ".const:xdc_runtime_HeapStd_A_invalidAlignment__C"); -__FAR__ const CT__xdc_runtime_HeapStd_A_invalidAlignment xdc_runtime_HeapStd_A_invalidAlignment__C = (((xdc_runtime_Assert_Id)246) << 16 | 16); - - -/* - * ======== xdc.runtime.Log INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__diagsEnabled__C, ".const:xdc_runtime_Log_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Log_Module__diagsEnabled xdc_runtime_Log_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__diagsIncluded__C, ".const:xdc_runtime_Log_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Log_Module__diagsIncluded xdc_runtime_Log_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__diagsMask__C, ".const:xdc_runtime_Log_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Log_Module__diagsMask xdc_runtime_Log_Module__diagsMask__C = ((CT__xdc_runtime_Log_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__gateObj__C, ".const:xdc_runtime_Log_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Log_Module__gateObj xdc_runtime_Log_Module__gateObj__C = ((CT__xdc_runtime_Log_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__gatePrms__C, ".const:xdc_runtime_Log_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Log_Module__gatePrms xdc_runtime_Log_Module__gatePrms__C = ((CT__xdc_runtime_Log_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__id__C, ".const:xdc_runtime_Log_Module__id__C"); -__FAR__ const CT__xdc_runtime_Log_Module__id xdc_runtime_Log_Module__id__C = (xdc_Bits16)0x8008; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerDefined__C, ".const:xdc_runtime_Log_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerDefined xdc_runtime_Log_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerObj__C, ".const:xdc_runtime_Log_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerObj xdc_runtime_Log_Module__loggerObj__C = ((CT__xdc_runtime_Log_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerFxn0__C, ".const:xdc_runtime_Log_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerFxn0 xdc_runtime_Log_Module__loggerFxn0__C = ((CT__xdc_runtime_Log_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerFxn1__C, ".const:xdc_runtime_Log_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerFxn1 xdc_runtime_Log_Module__loggerFxn1__C = ((CT__xdc_runtime_Log_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerFxn2__C, ".const:xdc_runtime_Log_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerFxn2 xdc_runtime_Log_Module__loggerFxn2__C = ((CT__xdc_runtime_Log_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerFxn4__C, ".const:xdc_runtime_Log_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerFxn4 xdc_runtime_Log_Module__loggerFxn4__C = ((CT__xdc_runtime_Log_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__loggerFxn8__C, ".const:xdc_runtime_Log_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Log_Module__loggerFxn8 xdc_runtime_Log_Module__loggerFxn8__C = ((CT__xdc_runtime_Log_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Module__startupDoneFxn__C, ".const:xdc_runtime_Log_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Log_Module__startupDoneFxn xdc_runtime_Log_Module__startupDoneFxn__C = ((CT__xdc_runtime_Log_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Object__count__C, ".const:xdc_runtime_Log_Object__count__C"); -__FAR__ const CT__xdc_runtime_Log_Object__count xdc_runtime_Log_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Object__heap__C, ".const:xdc_runtime_Log_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Log_Object__heap xdc_runtime_Log_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Object__sizeof__C, ".const:xdc_runtime_Log_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Log_Object__sizeof xdc_runtime_Log_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Log_Object__table__C, ".const:xdc_runtime_Log_Object__table__C"); -__FAR__ const CT__xdc_runtime_Log_Object__table xdc_runtime_Log_Object__table__C = 0; - -/* L_construct__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_construct__C, ".const:xdc_runtime_Log_L_construct__C"); -__FAR__ const CT__xdc_runtime_Log_L_construct xdc_runtime_Log_L_construct__C = (((xdc_runtime_Log_Event)4953) << 16 | 4); - -/* L_create__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_create__C, ".const:xdc_runtime_Log_L_create__C"); -__FAR__ const CT__xdc_runtime_Log_L_create xdc_runtime_Log_L_create__C = (((xdc_runtime_Log_Event)4977) << 16 | 4); - -/* L_destruct__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_destruct__C, ".const:xdc_runtime_Log_L_destruct__C"); -__FAR__ const CT__xdc_runtime_Log_L_destruct xdc_runtime_Log_L_destruct__C = (((xdc_runtime_Log_Event)4998) << 16 | 4); - -/* L_delete__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_delete__C, ".const:xdc_runtime_Log_L_delete__C"); -__FAR__ const CT__xdc_runtime_Log_L_delete xdc_runtime_Log_L_delete__C = (((xdc_runtime_Log_Event)5017) << 16 | 4); - -/* L_error__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_error__C, ".const:xdc_runtime_Log_L_error__C"); -__FAR__ const CT__xdc_runtime_Log_L_error xdc_runtime_Log_L_error__C = (((xdc_runtime_Log_Event)5034) << 16 | 192); - -/* L_warning__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_warning__C, ".const:xdc_runtime_Log_L_warning__C"); -__FAR__ const CT__xdc_runtime_Log_L_warning xdc_runtime_Log_L_warning__C = (((xdc_runtime_Log_Event)5048) << 16 | 224); - -/* L_info__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_info__C, ".const:xdc_runtime_Log_L_info__C"); -__FAR__ const CT__xdc_runtime_Log_L_info xdc_runtime_Log_L_info__C = (((xdc_runtime_Log_Event)5064) << 16 | 16384); - -/* L_start__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_start__C, ".const:xdc_runtime_Log_L_start__C"); -__FAR__ const CT__xdc_runtime_Log_L_start xdc_runtime_Log_L_start__C = (((xdc_runtime_Log_Event)5071) << 16 | 32768); - -/* L_stop__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_stop__C, ".const:xdc_runtime_Log_L_stop__C"); -__FAR__ const CT__xdc_runtime_Log_L_stop xdc_runtime_Log_L_stop__C = (((xdc_runtime_Log_Event)5082) << 16 | 32768); - -/* L_startInstance__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_startInstance__C, ".const:xdc_runtime_Log_L_startInstance__C"); -__FAR__ const CT__xdc_runtime_Log_L_startInstance xdc_runtime_Log_L_startInstance__C = (((xdc_runtime_Log_Event)5092) << 16 | 32768); - -/* L_stopInstance__C */ -#pragma DATA_SECTION(xdc_runtime_Log_L_stopInstance__C, ".const:xdc_runtime_Log_L_stopInstance__C"); -__FAR__ const CT__xdc_runtime_Log_L_stopInstance xdc_runtime_Log_L_stopInstance__C = (((xdc_runtime_Log_Event)5111) << 16 | 32768); - - -/* - * ======== xdc.runtime.Main INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__diagsEnabled__C, ".const:xdc_runtime_Main_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Main_Module__diagsEnabled xdc_runtime_Main_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__diagsIncluded__C, ".const:xdc_runtime_Main_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Main_Module__diagsIncluded xdc_runtime_Main_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__diagsMask__C, ".const:xdc_runtime_Main_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Main_Module__diagsMask xdc_runtime_Main_Module__diagsMask__C = ((CT__xdc_runtime_Main_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__gateObj__C, ".const:xdc_runtime_Main_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Main_Module__gateObj xdc_runtime_Main_Module__gateObj__C = ((CT__xdc_runtime_Main_Module__gateObj)((void*)(xdc_runtime_IGateProvider_Handle)&ti_sysbios_gates_GateHwi_Object__table__V[0])); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__gatePrms__C, ".const:xdc_runtime_Main_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Main_Module__gatePrms xdc_runtime_Main_Module__gatePrms__C = ((CT__xdc_runtime_Main_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__id__C, ".const:xdc_runtime_Main_Module__id__C"); -__FAR__ const CT__xdc_runtime_Main_Module__id xdc_runtime_Main_Module__id__C = (xdc_Bits16)0x8009; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerDefined__C, ".const:xdc_runtime_Main_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerDefined xdc_runtime_Main_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerObj__C, ".const:xdc_runtime_Main_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerObj xdc_runtime_Main_Module__loggerObj__C = ((CT__xdc_runtime_Main_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerFxn0__C, ".const:xdc_runtime_Main_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerFxn0 xdc_runtime_Main_Module__loggerFxn0__C = ((CT__xdc_runtime_Main_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerFxn1__C, ".const:xdc_runtime_Main_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerFxn1 xdc_runtime_Main_Module__loggerFxn1__C = ((CT__xdc_runtime_Main_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerFxn2__C, ".const:xdc_runtime_Main_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerFxn2 xdc_runtime_Main_Module__loggerFxn2__C = ((CT__xdc_runtime_Main_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerFxn4__C, ".const:xdc_runtime_Main_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerFxn4 xdc_runtime_Main_Module__loggerFxn4__C = ((CT__xdc_runtime_Main_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__loggerFxn8__C, ".const:xdc_runtime_Main_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Main_Module__loggerFxn8 xdc_runtime_Main_Module__loggerFxn8__C = ((CT__xdc_runtime_Main_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Module__startupDoneFxn__C, ".const:xdc_runtime_Main_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Main_Module__startupDoneFxn xdc_runtime_Main_Module__startupDoneFxn__C = ((CT__xdc_runtime_Main_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Object__count__C, ".const:xdc_runtime_Main_Object__count__C"); -__FAR__ const CT__xdc_runtime_Main_Object__count xdc_runtime_Main_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Object__heap__C, ".const:xdc_runtime_Main_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Main_Object__heap xdc_runtime_Main_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Object__sizeof__C, ".const:xdc_runtime_Main_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Main_Object__sizeof xdc_runtime_Main_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Main_Object__table__C, ".const:xdc_runtime_Main_Object__table__C"); -__FAR__ const CT__xdc_runtime_Main_Object__table xdc_runtime_Main_Object__table__C = 0; - - -/* - * ======== xdc.runtime.Main_Module_GateProxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.Memory INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_Memory_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_Memory_Module_State__ xdc_runtime_Memory_Module__state__V __attribute__ ((section(".data_xdc_runtime_Memory_Module__state__V"))); -#endif -#endif -xdc_runtime_Memory_Module_State__ xdc_runtime_Memory_Module__state__V = { - (xdc_SizeT)0x8, /* maxDefaultTypeAlign */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__diagsEnabled__C, ".const:xdc_runtime_Memory_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__diagsEnabled xdc_runtime_Memory_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__diagsIncluded__C, ".const:xdc_runtime_Memory_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__diagsIncluded xdc_runtime_Memory_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__diagsMask__C, ".const:xdc_runtime_Memory_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__diagsMask xdc_runtime_Memory_Module__diagsMask__C = ((CT__xdc_runtime_Memory_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__gateObj__C, ".const:xdc_runtime_Memory_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__gateObj xdc_runtime_Memory_Module__gateObj__C = ((CT__xdc_runtime_Memory_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__gatePrms__C, ".const:xdc_runtime_Memory_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__gatePrms xdc_runtime_Memory_Module__gatePrms__C = ((CT__xdc_runtime_Memory_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__id__C, ".const:xdc_runtime_Memory_Module__id__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__id xdc_runtime_Memory_Module__id__C = (xdc_Bits16)0x800a; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerDefined__C, ".const:xdc_runtime_Memory_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerDefined xdc_runtime_Memory_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerObj__C, ".const:xdc_runtime_Memory_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerObj xdc_runtime_Memory_Module__loggerObj__C = ((CT__xdc_runtime_Memory_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerFxn0__C, ".const:xdc_runtime_Memory_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerFxn0 xdc_runtime_Memory_Module__loggerFxn0__C = ((CT__xdc_runtime_Memory_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerFxn1__C, ".const:xdc_runtime_Memory_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerFxn1 xdc_runtime_Memory_Module__loggerFxn1__C = ((CT__xdc_runtime_Memory_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerFxn2__C, ".const:xdc_runtime_Memory_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerFxn2 xdc_runtime_Memory_Module__loggerFxn2__C = ((CT__xdc_runtime_Memory_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerFxn4__C, ".const:xdc_runtime_Memory_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerFxn4 xdc_runtime_Memory_Module__loggerFxn4__C = ((CT__xdc_runtime_Memory_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__loggerFxn8__C, ".const:xdc_runtime_Memory_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__loggerFxn8 xdc_runtime_Memory_Module__loggerFxn8__C = ((CT__xdc_runtime_Memory_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Module__startupDoneFxn__C, ".const:xdc_runtime_Memory_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Memory_Module__startupDoneFxn xdc_runtime_Memory_Module__startupDoneFxn__C = ((CT__xdc_runtime_Memory_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Object__count__C, ".const:xdc_runtime_Memory_Object__count__C"); -__FAR__ const CT__xdc_runtime_Memory_Object__count xdc_runtime_Memory_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Object__heap__C, ".const:xdc_runtime_Memory_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Memory_Object__heap xdc_runtime_Memory_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Object__sizeof__C, ".const:xdc_runtime_Memory_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Memory_Object__sizeof xdc_runtime_Memory_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_Object__table__C, ".const:xdc_runtime_Memory_Object__table__C"); -__FAR__ const CT__xdc_runtime_Memory_Object__table xdc_runtime_Memory_Object__table__C = 0; - -/* defaultHeapInstance__C */ -#pragma DATA_SECTION(xdc_runtime_Memory_defaultHeapInstance__C, ".const:xdc_runtime_Memory_defaultHeapInstance__C"); -__FAR__ const CT__xdc_runtime_Memory_defaultHeapInstance xdc_runtime_Memory_defaultHeapInstance__C = (xdc_runtime_IHeap_Handle)&ti_sysbios_heaps_HeapMem_Object__table__V[0]; - - -/* - * ======== xdc.runtime.Memory_HeapProxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.Registry INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_Registry_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_Registry_Module_State__ xdc_runtime_Registry_Module__state__V __attribute__ ((section(".data_xdc_runtime_Registry_Module__state__V"))); -#endif -#endif -xdc_runtime_Registry_Module_State__ xdc_runtime_Registry_Module__state__V = { - ((xdc_runtime_Types_RegDesc*)0), /* listHead */ - (xdc_Bits16)0x7fff, /* curId */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__diagsEnabled__C, ".const:xdc_runtime_Registry_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__diagsEnabled xdc_runtime_Registry_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__diagsIncluded__C, ".const:xdc_runtime_Registry_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__diagsIncluded xdc_runtime_Registry_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__diagsMask__C, ".const:xdc_runtime_Registry_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__diagsMask xdc_runtime_Registry_Module__diagsMask__C = ((CT__xdc_runtime_Registry_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__gateObj__C, ".const:xdc_runtime_Registry_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__gateObj xdc_runtime_Registry_Module__gateObj__C = ((CT__xdc_runtime_Registry_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__gatePrms__C, ".const:xdc_runtime_Registry_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__gatePrms xdc_runtime_Registry_Module__gatePrms__C = ((CT__xdc_runtime_Registry_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__id__C, ".const:xdc_runtime_Registry_Module__id__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__id xdc_runtime_Registry_Module__id__C = (xdc_Bits16)0x800c; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerDefined__C, ".const:xdc_runtime_Registry_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerDefined xdc_runtime_Registry_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerObj__C, ".const:xdc_runtime_Registry_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerObj xdc_runtime_Registry_Module__loggerObj__C = ((CT__xdc_runtime_Registry_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerFxn0__C, ".const:xdc_runtime_Registry_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerFxn0 xdc_runtime_Registry_Module__loggerFxn0__C = ((CT__xdc_runtime_Registry_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerFxn1__C, ".const:xdc_runtime_Registry_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerFxn1 xdc_runtime_Registry_Module__loggerFxn1__C = ((CT__xdc_runtime_Registry_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerFxn2__C, ".const:xdc_runtime_Registry_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerFxn2 xdc_runtime_Registry_Module__loggerFxn2__C = ((CT__xdc_runtime_Registry_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerFxn4__C, ".const:xdc_runtime_Registry_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerFxn4 xdc_runtime_Registry_Module__loggerFxn4__C = ((CT__xdc_runtime_Registry_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__loggerFxn8__C, ".const:xdc_runtime_Registry_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__loggerFxn8 xdc_runtime_Registry_Module__loggerFxn8__C = ((CT__xdc_runtime_Registry_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Module__startupDoneFxn__C, ".const:xdc_runtime_Registry_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Registry_Module__startupDoneFxn xdc_runtime_Registry_Module__startupDoneFxn__C = ((CT__xdc_runtime_Registry_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Object__count__C, ".const:xdc_runtime_Registry_Object__count__C"); -__FAR__ const CT__xdc_runtime_Registry_Object__count xdc_runtime_Registry_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Object__heap__C, ".const:xdc_runtime_Registry_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Registry_Object__heap xdc_runtime_Registry_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Object__sizeof__C, ".const:xdc_runtime_Registry_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Registry_Object__sizeof xdc_runtime_Registry_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Registry_Object__table__C, ".const:xdc_runtime_Registry_Object__table__C"); -__FAR__ const CT__xdc_runtime_Registry_Object__table xdc_runtime_Registry_Object__table__C = 0; - - -/* - * ======== xdc.runtime.Startup INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_Startup_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_Startup_Module_State__ xdc_runtime_Startup_Module__state__V __attribute__ ((section(".data_xdc_runtime_Startup_Module__state__V"))); -#endif -#endif -xdc_runtime_Startup_Module_State__ xdc_runtime_Startup_Module__state__V = { - ((xdc_Int*)0), /* stateTab */ - 0, /* execFlag */ - 0, /* rtsDoneFlag */ -}; - -/* --> xdc_runtime_Startup_firstFxns__A */ -#pragma DATA_SECTION(xdc_runtime_Startup_firstFxns__A, ".const:xdc_runtime_Startup_firstFxns__A"); -const __T1_xdc_runtime_Startup_firstFxns xdc_runtime_Startup_firstFxns__A[6] = { - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_heaps_HeapMem_init__I)), /* [0] */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_catalog_arm_cortexm4_tiva_ce_Boot_init__I)), /* [1] */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_initNVIC__E)), /* [2] */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_hal_Hwi_initStack)), /* [3] */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_family_arm_lm4_TimestampProvider_initTimerHandle__I)), /* [4] */ - ((xdc_Void(*)(xdc_Void))((xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_enableTimers__I)), /* [5] */ -}; - -/* --> xdc_runtime_Startup_sfxnTab__A */ -#pragma DATA_SECTION(xdc_runtime_Startup_sfxnTab__A, ".const:xdc_runtime_Startup_sfxnTab__A"); -const __T1_xdc_runtime_Startup_sfxnTab xdc_runtime_Startup_sfxnTab__A[11] = { - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)xdc_runtime_System_Module_startup__E)), /* [0] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)xdc_runtime_SysMin_Module_startup__E)), /* [1] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Module_startup__E)), /* [2] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_knl_Clock_Module_startup__E)), /* [3] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_knl_Mailbox_Module_startup__E)), /* [4] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_knl_Swi_Module_startup__E)), /* [5] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_knl_Task_Module_startup__E)), /* [6] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_hal_Hwi_Module_startup__E)), /* [7] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_family_arm_lm4_TimestampProvider_Module_startup__E)), /* [8] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Module_startup__E)), /* [9] */ - ((xdc_Int(*)(xdc_Int))((xdc_Fxn)ti_sysbios_io_DEV_Module_startup__E)), /* [10] */ -}; - -/* --> xdc_runtime_Startup_sfxnRts__A */ -#pragma DATA_SECTION(xdc_runtime_Startup_sfxnRts__A, ".const:xdc_runtime_Startup_sfxnRts__A"); -const __T1_xdc_runtime_Startup_sfxnRts xdc_runtime_Startup_sfxnRts__A[11] = { - 1, /* [0] */ - 1, /* [1] */ - 0, /* [2] */ - 0, /* [3] */ - 0, /* [4] */ - 0, /* [5] */ - 0, /* [6] */ - 0, /* [7] */ - 1, /* [8] */ - 0, /* [9] */ - 0, /* [10] */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__diagsEnabled__C, ".const:xdc_runtime_Startup_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__diagsEnabled xdc_runtime_Startup_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__diagsIncluded__C, ".const:xdc_runtime_Startup_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__diagsIncluded xdc_runtime_Startup_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__diagsMask__C, ".const:xdc_runtime_Startup_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__diagsMask xdc_runtime_Startup_Module__diagsMask__C = ((CT__xdc_runtime_Startup_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__gateObj__C, ".const:xdc_runtime_Startup_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__gateObj xdc_runtime_Startup_Module__gateObj__C = ((CT__xdc_runtime_Startup_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__gatePrms__C, ".const:xdc_runtime_Startup_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__gatePrms xdc_runtime_Startup_Module__gatePrms__C = ((CT__xdc_runtime_Startup_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__id__C, ".const:xdc_runtime_Startup_Module__id__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__id xdc_runtime_Startup_Module__id__C = (xdc_Bits16)0x800d; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerDefined__C, ".const:xdc_runtime_Startup_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerDefined xdc_runtime_Startup_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerObj__C, ".const:xdc_runtime_Startup_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerObj xdc_runtime_Startup_Module__loggerObj__C = ((CT__xdc_runtime_Startup_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerFxn0__C, ".const:xdc_runtime_Startup_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerFxn0 xdc_runtime_Startup_Module__loggerFxn0__C = ((CT__xdc_runtime_Startup_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerFxn1__C, ".const:xdc_runtime_Startup_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerFxn1 xdc_runtime_Startup_Module__loggerFxn1__C = ((CT__xdc_runtime_Startup_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerFxn2__C, ".const:xdc_runtime_Startup_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerFxn2 xdc_runtime_Startup_Module__loggerFxn2__C = ((CT__xdc_runtime_Startup_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerFxn4__C, ".const:xdc_runtime_Startup_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerFxn4 xdc_runtime_Startup_Module__loggerFxn4__C = ((CT__xdc_runtime_Startup_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__loggerFxn8__C, ".const:xdc_runtime_Startup_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__loggerFxn8 xdc_runtime_Startup_Module__loggerFxn8__C = ((CT__xdc_runtime_Startup_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Module__startupDoneFxn__C, ".const:xdc_runtime_Startup_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Startup_Module__startupDoneFxn xdc_runtime_Startup_Module__startupDoneFxn__C = ((CT__xdc_runtime_Startup_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Object__count__C, ".const:xdc_runtime_Startup_Object__count__C"); -__FAR__ const CT__xdc_runtime_Startup_Object__count xdc_runtime_Startup_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Object__heap__C, ".const:xdc_runtime_Startup_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Startup_Object__heap xdc_runtime_Startup_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Object__sizeof__C, ".const:xdc_runtime_Startup_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Startup_Object__sizeof xdc_runtime_Startup_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_Object__table__C, ".const:xdc_runtime_Startup_Object__table__C"); -__FAR__ const CT__xdc_runtime_Startup_Object__table xdc_runtime_Startup_Object__table__C = 0; - -/* maxPasses__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_maxPasses__C, ".const:xdc_runtime_Startup_maxPasses__C"); -__FAR__ const CT__xdc_runtime_Startup_maxPasses xdc_runtime_Startup_maxPasses__C = (xdc_Int)0x20; - -/* firstFxns__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_firstFxns__C, ".const:xdc_runtime_Startup_firstFxns__C"); -__FAR__ const CT__xdc_runtime_Startup_firstFxns xdc_runtime_Startup_firstFxns__C = {6, ((__T1_xdc_runtime_Startup_firstFxns*)xdc_runtime_Startup_firstFxns__A)}; - -/* lastFxns__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_lastFxns__C, ".const:xdc_runtime_Startup_lastFxns__C"); -__FAR__ const CT__xdc_runtime_Startup_lastFxns xdc_runtime_Startup_lastFxns__C = {0, 0}; - -/* startModsFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_startModsFxn__C, ".const:xdc_runtime_Startup_startModsFxn__C"); -__FAR__ const CT__xdc_runtime_Startup_startModsFxn xdc_runtime_Startup_startModsFxn__C = ((CT__xdc_runtime_Startup_startModsFxn)((xdc_Fxn)xdc_runtime_Startup_startMods__I)); - -/* execImpl__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_execImpl__C, ".const:xdc_runtime_Startup_execImpl__C"); -__FAR__ const CT__xdc_runtime_Startup_execImpl xdc_runtime_Startup_execImpl__C = ((CT__xdc_runtime_Startup_execImpl)((xdc_Fxn)xdc_runtime_Startup_exec__I)); - -/* sfxnTab__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_sfxnTab__C, ".const:xdc_runtime_Startup_sfxnTab__C"); -__FAR__ const CT__xdc_runtime_Startup_sfxnTab xdc_runtime_Startup_sfxnTab__C = ((CT__xdc_runtime_Startup_sfxnTab)xdc_runtime_Startup_sfxnTab__A); - -/* sfxnRts__C */ -#pragma DATA_SECTION(xdc_runtime_Startup_sfxnRts__C, ".const:xdc_runtime_Startup_sfxnRts__C"); -__FAR__ const CT__xdc_runtime_Startup_sfxnRts xdc_runtime_Startup_sfxnRts__C = ((CT__xdc_runtime_Startup_sfxnRts)xdc_runtime_Startup_sfxnRts__A); - - -/* - * ======== xdc.runtime.SysMin INITIALIZERS ======== - */ - -/* --> xdc_runtime_SysMin_Module_State_0_outbuf__A */ -__T1_xdc_runtime_SysMin_Module_State__outbuf xdc_runtime_SysMin_Module_State_0_outbuf__A[1024]; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_SysMin_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_SysMin_Module_State__ xdc_runtime_SysMin_Module__state__V __attribute__ ((section(".data_xdc_runtime_SysMin_Module__state__V"))); -#endif -#endif -xdc_runtime_SysMin_Module_State__ xdc_runtime_SysMin_Module__state__V = { - ((void*)xdc_runtime_SysMin_Module_State_0_outbuf__A), /* outbuf */ - (xdc_UInt)0x0, /* outidx */ - 0, /* wrapped */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__diagsEnabled__C, ".const:xdc_runtime_SysMin_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__diagsEnabled xdc_runtime_SysMin_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__diagsIncluded__C, ".const:xdc_runtime_SysMin_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__diagsIncluded xdc_runtime_SysMin_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__diagsMask__C, ".const:xdc_runtime_SysMin_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__diagsMask xdc_runtime_SysMin_Module__diagsMask__C = ((CT__xdc_runtime_SysMin_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__gateObj__C, ".const:xdc_runtime_SysMin_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__gateObj xdc_runtime_SysMin_Module__gateObj__C = ((CT__xdc_runtime_SysMin_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__gatePrms__C, ".const:xdc_runtime_SysMin_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__gatePrms xdc_runtime_SysMin_Module__gatePrms__C = ((CT__xdc_runtime_SysMin_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__id__C, ".const:xdc_runtime_SysMin_Module__id__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__id xdc_runtime_SysMin_Module__id__C = (xdc_Bits16)0x800f; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerDefined__C, ".const:xdc_runtime_SysMin_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerDefined xdc_runtime_SysMin_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerObj__C, ".const:xdc_runtime_SysMin_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerObj xdc_runtime_SysMin_Module__loggerObj__C = ((CT__xdc_runtime_SysMin_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerFxn0__C, ".const:xdc_runtime_SysMin_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerFxn0 xdc_runtime_SysMin_Module__loggerFxn0__C = ((CT__xdc_runtime_SysMin_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerFxn1__C, ".const:xdc_runtime_SysMin_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerFxn1 xdc_runtime_SysMin_Module__loggerFxn1__C = ((CT__xdc_runtime_SysMin_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerFxn2__C, ".const:xdc_runtime_SysMin_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerFxn2 xdc_runtime_SysMin_Module__loggerFxn2__C = ((CT__xdc_runtime_SysMin_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerFxn4__C, ".const:xdc_runtime_SysMin_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerFxn4 xdc_runtime_SysMin_Module__loggerFxn4__C = ((CT__xdc_runtime_SysMin_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__loggerFxn8__C, ".const:xdc_runtime_SysMin_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__loggerFxn8 xdc_runtime_SysMin_Module__loggerFxn8__C = ((CT__xdc_runtime_SysMin_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Module__startupDoneFxn__C, ".const:xdc_runtime_SysMin_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_SysMin_Module__startupDoneFxn xdc_runtime_SysMin_Module__startupDoneFxn__C = ((CT__xdc_runtime_SysMin_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Object__count__C, ".const:xdc_runtime_SysMin_Object__count__C"); -__FAR__ const CT__xdc_runtime_SysMin_Object__count xdc_runtime_SysMin_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Object__heap__C, ".const:xdc_runtime_SysMin_Object__heap__C"); -__FAR__ const CT__xdc_runtime_SysMin_Object__heap xdc_runtime_SysMin_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Object__sizeof__C, ".const:xdc_runtime_SysMin_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_SysMin_Object__sizeof xdc_runtime_SysMin_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_Object__table__C, ".const:xdc_runtime_SysMin_Object__table__C"); -__FAR__ const CT__xdc_runtime_SysMin_Object__table xdc_runtime_SysMin_Object__table__C = 0; - -/* bufSize__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_bufSize__C, ".const:xdc_runtime_SysMin_bufSize__C"); -__FAR__ const CT__xdc_runtime_SysMin_bufSize xdc_runtime_SysMin_bufSize__C = (xdc_SizeT)0x400; - -/* flushAtExit__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_flushAtExit__C, ".const:xdc_runtime_SysMin_flushAtExit__C"); -__FAR__ const CT__xdc_runtime_SysMin_flushAtExit xdc_runtime_SysMin_flushAtExit__C = 1; - -/* outputFxn__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_outputFxn__C, ".const:xdc_runtime_SysMin_outputFxn__C"); -__FAR__ const CT__xdc_runtime_SysMin_outputFxn xdc_runtime_SysMin_outputFxn__C = ((CT__xdc_runtime_SysMin_outputFxn)0); - -/* outputFunc__C */ -#pragma DATA_SECTION(xdc_runtime_SysMin_outputFunc__C, ".const:xdc_runtime_SysMin_outputFunc__C"); -__FAR__ const CT__xdc_runtime_SysMin_outputFunc xdc_runtime_SysMin_outputFunc__C = ((CT__xdc_runtime_SysMin_outputFunc)((xdc_Fxn)xdc_runtime_SysMin_output__I)); - - -/* - * ======== xdc.runtime.System INITIALIZERS ======== - */ - -/* --> xdc_runtime_System_Module_State_0_atexitHandlers__A */ -__T1_xdc_runtime_System_Module_State__atexitHandlers xdc_runtime_System_Module_State_0_atexitHandlers__A[2] = { - ((xdc_Void(*)(xdc_Int))0), /* [0] */ - ((xdc_Void(*)(xdc_Int))0), /* [1] */ -}; - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_System_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_System_Module_State__ xdc_runtime_System_Module__state__V __attribute__ ((section(".data_xdc_runtime_System_Module__state__V"))); -#endif -#endif -xdc_runtime_System_Module_State__ xdc_runtime_System_Module__state__V = { - ((void*)xdc_runtime_System_Module_State_0_atexitHandlers__A), /* atexitHandlers */ - (xdc_Int)0x0, /* numAtexitHandlers */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__diagsEnabled__C, ".const:xdc_runtime_System_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_System_Module__diagsEnabled xdc_runtime_System_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__diagsIncluded__C, ".const:xdc_runtime_System_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_System_Module__diagsIncluded xdc_runtime_System_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__diagsMask__C, ".const:xdc_runtime_System_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_System_Module__diagsMask xdc_runtime_System_Module__diagsMask__C = ((CT__xdc_runtime_System_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__gateObj__C, ".const:xdc_runtime_System_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_System_Module__gateObj xdc_runtime_System_Module__gateObj__C = ((CT__xdc_runtime_System_Module__gateObj)((void*)(xdc_runtime_IGateProvider_Handle)&ti_sysbios_gates_GateHwi_Object__table__V[0])); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__gatePrms__C, ".const:xdc_runtime_System_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_System_Module__gatePrms xdc_runtime_System_Module__gatePrms__C = ((CT__xdc_runtime_System_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__id__C, ".const:xdc_runtime_System_Module__id__C"); -__FAR__ const CT__xdc_runtime_System_Module__id xdc_runtime_System_Module__id__C = (xdc_Bits16)0x800e; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerDefined__C, ".const:xdc_runtime_System_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerDefined xdc_runtime_System_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerObj__C, ".const:xdc_runtime_System_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerObj xdc_runtime_System_Module__loggerObj__C = ((CT__xdc_runtime_System_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerFxn0__C, ".const:xdc_runtime_System_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerFxn0 xdc_runtime_System_Module__loggerFxn0__C = ((CT__xdc_runtime_System_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerFxn1__C, ".const:xdc_runtime_System_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerFxn1 xdc_runtime_System_Module__loggerFxn1__C = ((CT__xdc_runtime_System_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerFxn2__C, ".const:xdc_runtime_System_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerFxn2 xdc_runtime_System_Module__loggerFxn2__C = ((CT__xdc_runtime_System_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerFxn4__C, ".const:xdc_runtime_System_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerFxn4 xdc_runtime_System_Module__loggerFxn4__C = ((CT__xdc_runtime_System_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__loggerFxn8__C, ".const:xdc_runtime_System_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_System_Module__loggerFxn8 xdc_runtime_System_Module__loggerFxn8__C = ((CT__xdc_runtime_System_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_System_Module__startupDoneFxn__C, ".const:xdc_runtime_System_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_System_Module__startupDoneFxn xdc_runtime_System_Module__startupDoneFxn__C = ((CT__xdc_runtime_System_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_System_Object__count__C, ".const:xdc_runtime_System_Object__count__C"); -__FAR__ const CT__xdc_runtime_System_Object__count xdc_runtime_System_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_System_Object__heap__C, ".const:xdc_runtime_System_Object__heap__C"); -__FAR__ const CT__xdc_runtime_System_Object__heap xdc_runtime_System_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_System_Object__sizeof__C, ".const:xdc_runtime_System_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_System_Object__sizeof xdc_runtime_System_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_System_Object__table__C, ".const:xdc_runtime_System_Object__table__C"); -__FAR__ const CT__xdc_runtime_System_Object__table xdc_runtime_System_Object__table__C = 0; - -/* A_cannotFitIntoArg__C */ -#pragma DATA_SECTION(xdc_runtime_System_A_cannotFitIntoArg__C, ".const:xdc_runtime_System_A_cannotFitIntoArg__C"); -__FAR__ const CT__xdc_runtime_System_A_cannotFitIntoArg xdc_runtime_System_A_cannotFitIntoArg__C = (((xdc_runtime_Assert_Id)352) << 16 | 16); - -/* maxAtexitHandlers__C */ -#pragma DATA_SECTION(xdc_runtime_System_maxAtexitHandlers__C, ".const:xdc_runtime_System_maxAtexitHandlers__C"); -__FAR__ const CT__xdc_runtime_System_maxAtexitHandlers xdc_runtime_System_maxAtexitHandlers__C = (xdc_Int)0x2; - -/* abortFxn__C */ -#pragma DATA_SECTION(xdc_runtime_System_abortFxn__C, ".const:xdc_runtime_System_abortFxn__C"); -__FAR__ const CT__xdc_runtime_System_abortFxn xdc_runtime_System_abortFxn__C = ((CT__xdc_runtime_System_abortFxn)((xdc_Fxn)xdc_runtime_System_abortStd__E)); - -/* exitFxn__C */ -#pragma DATA_SECTION(xdc_runtime_System_exitFxn__C, ".const:xdc_runtime_System_exitFxn__C"); -__FAR__ const CT__xdc_runtime_System_exitFxn xdc_runtime_System_exitFxn__C = ((CT__xdc_runtime_System_exitFxn)((xdc_Fxn)xdc_runtime_System_exitStd__E)); - -/* extendFxn__C */ -#pragma DATA_SECTION(xdc_runtime_System_extendFxn__C, ".const:xdc_runtime_System_extendFxn__C"); -__FAR__ const CT__xdc_runtime_System_extendFxn xdc_runtime_System_extendFxn__C = ((CT__xdc_runtime_System_extendFxn)((xdc_Fxn)xdc_runtime_System_printfExtend__I)); - - -/* - * ======== xdc.runtime.System_Module_GateProxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.System_SupportProxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.Text INITIALIZERS ======== - */ - -/* Module__state__V */ -#if defined (__ICCARM__) -#pragma location = ".data_xdc_runtime_Text_Module__state__V" -#endif -#if defined(__GNUC__) && !(defined(__MACH__) && defined(__APPLE__)) -#ifndef __TI_COMPILER_VERSION__ -xdc_runtime_Text_Module_State__ xdc_runtime_Text_Module__state__V __attribute__ ((section(".data_xdc_runtime_Text_Module__state__V"))); -#endif -#endif -xdc_runtime_Text_Module_State__ xdc_runtime_Text_Module__state__V = { - ((xdc_Ptr)((void*)&xdc_runtime_Text_charTab__A[0])), /* charBase */ - ((xdc_Ptr)((void*)&xdc_runtime_Text_nodeTab__A[0])), /* nodeBase */ -}; - -/* --> xdc_runtime_Text_charTab__A */ -#pragma DATA_SECTION(xdc_runtime_Text_charTab__A, ".const:xdc_runtime_Text_charTab__A"); -const __T1_xdc_runtime_Text_charTab xdc_runtime_Text_charTab__A[6893] = { - (xdc_Char)0x0, /* [0] */ - (xdc_Char)0x41, /* [1] */ - (xdc_Char)0x5f, /* [2] */ - (xdc_Char)0x69, /* [3] */ - (xdc_Char)0x6e, /* [4] */ - (xdc_Char)0x69, /* [5] */ - (xdc_Char)0x74, /* [6] */ - (xdc_Char)0x69, /* [7] */ - (xdc_Char)0x61, /* [8] */ - (xdc_Char)0x6c, /* [9] */ - (xdc_Char)0x69, /* [10] */ - (xdc_Char)0x7a, /* [11] */ - (xdc_Char)0x65, /* [12] */ - (xdc_Char)0x64, /* [13] */ - (xdc_Char)0x50, /* [14] */ - (xdc_Char)0x61, /* [15] */ - (xdc_Char)0x72, /* [16] */ - (xdc_Char)0x61, /* [17] */ - (xdc_Char)0x6d, /* [18] */ - (xdc_Char)0x73, /* [19] */ - (xdc_Char)0x3a, /* [20] */ - (xdc_Char)0x20, /* [21] */ - (xdc_Char)0x75, /* [22] */ - (xdc_Char)0x6e, /* [23] */ - (xdc_Char)0x69, /* [24] */ - (xdc_Char)0x6e, /* [25] */ - (xdc_Char)0x69, /* [26] */ - (xdc_Char)0x74, /* [27] */ - (xdc_Char)0x69, /* [28] */ - (xdc_Char)0x61, /* [29] */ - (xdc_Char)0x6c, /* [30] */ - (xdc_Char)0x69, /* [31] */ - (xdc_Char)0x7a, /* [32] */ - (xdc_Char)0x65, /* [33] */ - (xdc_Char)0x64, /* [34] */ - (xdc_Char)0x20, /* [35] */ - (xdc_Char)0x50, /* [36] */ - (xdc_Char)0x61, /* [37] */ - (xdc_Char)0x72, /* [38] */ - (xdc_Char)0x61, /* [39] */ - (xdc_Char)0x6d, /* [40] */ - (xdc_Char)0x73, /* [41] */ - (xdc_Char)0x20, /* [42] */ - (xdc_Char)0x73, /* [43] */ - (xdc_Char)0x74, /* [44] */ - (xdc_Char)0x72, /* [45] */ - (xdc_Char)0x75, /* [46] */ - (xdc_Char)0x63, /* [47] */ - (xdc_Char)0x74, /* [48] */ - (xdc_Char)0x0, /* [49] */ - (xdc_Char)0x48, /* [50] */ - (xdc_Char)0x65, /* [51] */ - (xdc_Char)0x61, /* [52] */ - (xdc_Char)0x70, /* [53] */ - (xdc_Char)0x4d, /* [54] */ - (xdc_Char)0x69, /* [55] */ - (xdc_Char)0x6e, /* [56] */ - (xdc_Char)0x5f, /* [57] */ - (xdc_Char)0x63, /* [58] */ - (xdc_Char)0x72, /* [59] */ - (xdc_Char)0x65, /* [60] */ - (xdc_Char)0x61, /* [61] */ - (xdc_Char)0x74, /* [62] */ - (xdc_Char)0x65, /* [63] */ - (xdc_Char)0x20, /* [64] */ - (xdc_Char)0x63, /* [65] */ - (xdc_Char)0x61, /* [66] */ - (xdc_Char)0x6e, /* [67] */ - (xdc_Char)0x6e, /* [68] */ - (xdc_Char)0x6f, /* [69] */ - (xdc_Char)0x74, /* [70] */ - (xdc_Char)0x20, /* [71] */ - (xdc_Char)0x68, /* [72] */ - (xdc_Char)0x61, /* [73] */ - (xdc_Char)0x76, /* [74] */ - (xdc_Char)0x65, /* [75] */ - (xdc_Char)0x20, /* [76] */ - (xdc_Char)0x61, /* [77] */ - (xdc_Char)0x20, /* [78] */ - (xdc_Char)0x7a, /* [79] */ - (xdc_Char)0x65, /* [80] */ - (xdc_Char)0x72, /* [81] */ - (xdc_Char)0x6f, /* [82] */ - (xdc_Char)0x20, /* [83] */ - (xdc_Char)0x73, /* [84] */ - (xdc_Char)0x69, /* [85] */ - (xdc_Char)0x7a, /* [86] */ - (xdc_Char)0x65, /* [87] */ - (xdc_Char)0x20, /* [88] */ - (xdc_Char)0x76, /* [89] */ - (xdc_Char)0x61, /* [90] */ - (xdc_Char)0x6c, /* [91] */ - (xdc_Char)0x75, /* [92] */ - (xdc_Char)0x65, /* [93] */ - (xdc_Char)0x0, /* [94] */ - (xdc_Char)0x48, /* [95] */ - (xdc_Char)0x65, /* [96] */ - (xdc_Char)0x61, /* [97] */ - (xdc_Char)0x70, /* [98] */ - (xdc_Char)0x53, /* [99] */ - (xdc_Char)0x74, /* [100] */ - (xdc_Char)0x64, /* [101] */ - (xdc_Char)0x5f, /* [102] */ - (xdc_Char)0x63, /* [103] */ - (xdc_Char)0x72, /* [104] */ - (xdc_Char)0x65, /* [105] */ - (xdc_Char)0x61, /* [106] */ - (xdc_Char)0x74, /* [107] */ - (xdc_Char)0x65, /* [108] */ - (xdc_Char)0x20, /* [109] */ - (xdc_Char)0x63, /* [110] */ - (xdc_Char)0x61, /* [111] */ - (xdc_Char)0x6e, /* [112] */ - (xdc_Char)0x6e, /* [113] */ - (xdc_Char)0x6f, /* [114] */ - (xdc_Char)0x74, /* [115] */ - (xdc_Char)0x20, /* [116] */ - (xdc_Char)0x68, /* [117] */ - (xdc_Char)0x61, /* [118] */ - (xdc_Char)0x76, /* [119] */ - (xdc_Char)0x65, /* [120] */ - (xdc_Char)0x20, /* [121] */ - (xdc_Char)0x61, /* [122] */ - (xdc_Char)0x20, /* [123] */ - (xdc_Char)0x7a, /* [124] */ - (xdc_Char)0x65, /* [125] */ - (xdc_Char)0x72, /* [126] */ - (xdc_Char)0x6f, /* [127] */ - (xdc_Char)0x20, /* [128] */ - (xdc_Char)0x73, /* [129] */ - (xdc_Char)0x69, /* [130] */ - (xdc_Char)0x7a, /* [131] */ - (xdc_Char)0x65, /* [132] */ - (xdc_Char)0x20, /* [133] */ - (xdc_Char)0x76, /* [134] */ - (xdc_Char)0x61, /* [135] */ - (xdc_Char)0x6c, /* [136] */ - (xdc_Char)0x75, /* [137] */ - (xdc_Char)0x65, /* [138] */ - (xdc_Char)0x0, /* [139] */ - (xdc_Char)0x48, /* [140] */ - (xdc_Char)0x65, /* [141] */ - (xdc_Char)0x61, /* [142] */ - (xdc_Char)0x70, /* [143] */ - (xdc_Char)0x53, /* [144] */ - (xdc_Char)0x74, /* [145] */ - (xdc_Char)0x64, /* [146] */ - (xdc_Char)0x5f, /* [147] */ - (xdc_Char)0x61, /* [148] */ - (xdc_Char)0x6c, /* [149] */ - (xdc_Char)0x6c, /* [150] */ - (xdc_Char)0x6f, /* [151] */ - (xdc_Char)0x63, /* [152] */ - (xdc_Char)0x20, /* [153] */ - (xdc_Char)0x61, /* [154] */ - (xdc_Char)0x6c, /* [155] */ - (xdc_Char)0x69, /* [156] */ - (xdc_Char)0x67, /* [157] */ - (xdc_Char)0x6e, /* [158] */ - (xdc_Char)0x6d, /* [159] */ - (xdc_Char)0x65, /* [160] */ - (xdc_Char)0x6e, /* [161] */ - (xdc_Char)0x74, /* [162] */ - (xdc_Char)0x20, /* [163] */ - (xdc_Char)0x6d, /* [164] */ - (xdc_Char)0x75, /* [165] */ - (xdc_Char)0x73, /* [166] */ - (xdc_Char)0x74, /* [167] */ - (xdc_Char)0x20, /* [168] */ - (xdc_Char)0x62, /* [169] */ - (xdc_Char)0x65, /* [170] */ - (xdc_Char)0x20, /* [171] */ - (xdc_Char)0x61, /* [172] */ - (xdc_Char)0x20, /* [173] */ - (xdc_Char)0x70, /* [174] */ - (xdc_Char)0x6f, /* [175] */ - (xdc_Char)0x77, /* [176] */ - (xdc_Char)0x65, /* [177] */ - (xdc_Char)0x72, /* [178] */ - (xdc_Char)0x20, /* [179] */ - (xdc_Char)0x6f, /* [180] */ - (xdc_Char)0x66, /* [181] */ - (xdc_Char)0x20, /* [182] */ - (xdc_Char)0x32, /* [183] */ - (xdc_Char)0x0, /* [184] */ - (xdc_Char)0x48, /* [185] */ - (xdc_Char)0x65, /* [186] */ - (xdc_Char)0x61, /* [187] */ - (xdc_Char)0x70, /* [188] */ - (xdc_Char)0x53, /* [189] */ - (xdc_Char)0x74, /* [190] */ - (xdc_Char)0x64, /* [191] */ - (xdc_Char)0x20, /* [192] */ - (xdc_Char)0x69, /* [193] */ - (xdc_Char)0x6e, /* [194] */ - (xdc_Char)0x73, /* [195] */ - (xdc_Char)0x74, /* [196] */ - (xdc_Char)0x61, /* [197] */ - (xdc_Char)0x6e, /* [198] */ - (xdc_Char)0x63, /* [199] */ - (xdc_Char)0x65, /* [200] */ - (xdc_Char)0x20, /* [201] */ - (xdc_Char)0x74, /* [202] */ - (xdc_Char)0x6f, /* [203] */ - (xdc_Char)0x74, /* [204] */ - (xdc_Char)0x61, /* [205] */ - (xdc_Char)0x6c, /* [206] */ - (xdc_Char)0x46, /* [207] */ - (xdc_Char)0x72, /* [208] */ - (xdc_Char)0x65, /* [209] */ - (xdc_Char)0x65, /* [210] */ - (xdc_Char)0x53, /* [211] */ - (xdc_Char)0x69, /* [212] */ - (xdc_Char)0x7a, /* [213] */ - (xdc_Char)0x65, /* [214] */ - (xdc_Char)0x20, /* [215] */ - (xdc_Char)0x69, /* [216] */ - (xdc_Char)0x73, /* [217] */ - (xdc_Char)0x20, /* [218] */ - (xdc_Char)0x67, /* [219] */ - (xdc_Char)0x72, /* [220] */ - (xdc_Char)0x65, /* [221] */ - (xdc_Char)0x61, /* [222] */ - (xdc_Char)0x74, /* [223] */ - (xdc_Char)0x65, /* [224] */ - (xdc_Char)0x72, /* [225] */ - (xdc_Char)0x20, /* [226] */ - (xdc_Char)0x74, /* [227] */ - (xdc_Char)0x68, /* [228] */ - (xdc_Char)0x61, /* [229] */ - (xdc_Char)0x6e, /* [230] */ - (xdc_Char)0x20, /* [231] */ - (xdc_Char)0x73, /* [232] */ - (xdc_Char)0x74, /* [233] */ - (xdc_Char)0x61, /* [234] */ - (xdc_Char)0x72, /* [235] */ - (xdc_Char)0x74, /* [236] */ - (xdc_Char)0x69, /* [237] */ - (xdc_Char)0x6e, /* [238] */ - (xdc_Char)0x67, /* [239] */ - (xdc_Char)0x20, /* [240] */ - (xdc_Char)0x73, /* [241] */ - (xdc_Char)0x69, /* [242] */ - (xdc_Char)0x7a, /* [243] */ - (xdc_Char)0x65, /* [244] */ - (xdc_Char)0x0, /* [245] */ - (xdc_Char)0x48, /* [246] */ - (xdc_Char)0x65, /* [247] */ - (xdc_Char)0x61, /* [248] */ - (xdc_Char)0x70, /* [249] */ - (xdc_Char)0x53, /* [250] */ - (xdc_Char)0x74, /* [251] */ - (xdc_Char)0x64, /* [252] */ - (xdc_Char)0x5f, /* [253] */ - (xdc_Char)0x61, /* [254] */ - (xdc_Char)0x6c, /* [255] */ - (xdc_Char)0x6c, /* [256] */ - (xdc_Char)0x6f, /* [257] */ - (xdc_Char)0x63, /* [258] */ - (xdc_Char)0x20, /* [259] */ - (xdc_Char)0x2d, /* [260] */ - (xdc_Char)0x20, /* [261] */ - (xdc_Char)0x72, /* [262] */ - (xdc_Char)0x65, /* [263] */ - (xdc_Char)0x71, /* [264] */ - (xdc_Char)0x75, /* [265] */ - (xdc_Char)0x65, /* [266] */ - (xdc_Char)0x73, /* [267] */ - (xdc_Char)0x74, /* [268] */ - (xdc_Char)0x65, /* [269] */ - (xdc_Char)0x64, /* [270] */ - (xdc_Char)0x20, /* [271] */ - (xdc_Char)0x61, /* [272] */ - (xdc_Char)0x6c, /* [273] */ - (xdc_Char)0x69, /* [274] */ - (xdc_Char)0x67, /* [275] */ - (xdc_Char)0x6e, /* [276] */ - (xdc_Char)0x6d, /* [277] */ - (xdc_Char)0x65, /* [278] */ - (xdc_Char)0x6e, /* [279] */ - (xdc_Char)0x74, /* [280] */ - (xdc_Char)0x20, /* [281] */ - (xdc_Char)0x69, /* [282] */ - (xdc_Char)0x73, /* [283] */ - (xdc_Char)0x20, /* [284] */ - (xdc_Char)0x67, /* [285] */ - (xdc_Char)0x72, /* [286] */ - (xdc_Char)0x65, /* [287] */ - (xdc_Char)0x61, /* [288] */ - (xdc_Char)0x74, /* [289] */ - (xdc_Char)0x65, /* [290] */ - (xdc_Char)0x72, /* [291] */ - (xdc_Char)0x20, /* [292] */ - (xdc_Char)0x74, /* [293] */ - (xdc_Char)0x68, /* [294] */ - (xdc_Char)0x61, /* [295] */ - (xdc_Char)0x6e, /* [296] */ - (xdc_Char)0x20, /* [297] */ - (xdc_Char)0x61, /* [298] */ - (xdc_Char)0x6c, /* [299] */ - (xdc_Char)0x6c, /* [300] */ - (xdc_Char)0x6f, /* [301] */ - (xdc_Char)0x77, /* [302] */ - (xdc_Char)0x65, /* [303] */ - (xdc_Char)0x64, /* [304] */ - (xdc_Char)0x0, /* [305] */ - (xdc_Char)0x41, /* [306] */ - (xdc_Char)0x5f, /* [307] */ - (xdc_Char)0x69, /* [308] */ - (xdc_Char)0x6e, /* [309] */ - (xdc_Char)0x76, /* [310] */ - (xdc_Char)0x61, /* [311] */ - (xdc_Char)0x6c, /* [312] */ - (xdc_Char)0x69, /* [313] */ - (xdc_Char)0x64, /* [314] */ - (xdc_Char)0x4c, /* [315] */ - (xdc_Char)0x6f, /* [316] */ - (xdc_Char)0x67, /* [317] */ - (xdc_Char)0x67, /* [318] */ - (xdc_Char)0x65, /* [319] */ - (xdc_Char)0x72, /* [320] */ - (xdc_Char)0x3a, /* [321] */ - (xdc_Char)0x20, /* [322] */ - (xdc_Char)0x54, /* [323] */ - (xdc_Char)0x68, /* [324] */ - (xdc_Char)0x65, /* [325] */ - (xdc_Char)0x20, /* [326] */ - (xdc_Char)0x6c, /* [327] */ - (xdc_Char)0x6f, /* [328] */ - (xdc_Char)0x67, /* [329] */ - (xdc_Char)0x67, /* [330] */ - (xdc_Char)0x65, /* [331] */ - (xdc_Char)0x72, /* [332] */ - (xdc_Char)0x20, /* [333] */ - (xdc_Char)0x69, /* [334] */ - (xdc_Char)0x64, /* [335] */ - (xdc_Char)0x20, /* [336] */ - (xdc_Char)0x25, /* [337] */ - (xdc_Char)0x64, /* [338] */ - (xdc_Char)0x20, /* [339] */ - (xdc_Char)0x69, /* [340] */ - (xdc_Char)0x73, /* [341] */ - (xdc_Char)0x20, /* [342] */ - (xdc_Char)0x69, /* [343] */ - (xdc_Char)0x6e, /* [344] */ - (xdc_Char)0x76, /* [345] */ - (xdc_Char)0x61, /* [346] */ - (xdc_Char)0x6c, /* [347] */ - (xdc_Char)0x69, /* [348] */ - (xdc_Char)0x64, /* [349] */ - (xdc_Char)0x2e, /* [350] */ - (xdc_Char)0x0, /* [351] */ - (xdc_Char)0x41, /* [352] */ - (xdc_Char)0x5f, /* [353] */ - (xdc_Char)0x63, /* [354] */ - (xdc_Char)0x61, /* [355] */ - (xdc_Char)0x6e, /* [356] */ - (xdc_Char)0x6e, /* [357] */ - (xdc_Char)0x6f, /* [358] */ - (xdc_Char)0x74, /* [359] */ - (xdc_Char)0x46, /* [360] */ - (xdc_Char)0x69, /* [361] */ - (xdc_Char)0x74, /* [362] */ - (xdc_Char)0x49, /* [363] */ - (xdc_Char)0x6e, /* [364] */ - (xdc_Char)0x74, /* [365] */ - (xdc_Char)0x6f, /* [366] */ - (xdc_Char)0x41, /* [367] */ - (xdc_Char)0x72, /* [368] */ - (xdc_Char)0x67, /* [369] */ - (xdc_Char)0x3a, /* [370] */ - (xdc_Char)0x20, /* [371] */ - (xdc_Char)0x73, /* [372] */ - (xdc_Char)0x69, /* [373] */ - (xdc_Char)0x7a, /* [374] */ - (xdc_Char)0x65, /* [375] */ - (xdc_Char)0x6f, /* [376] */ - (xdc_Char)0x66, /* [377] */ - (xdc_Char)0x28, /* [378] */ - (xdc_Char)0x46, /* [379] */ - (xdc_Char)0x6c, /* [380] */ - (xdc_Char)0x6f, /* [381] */ - (xdc_Char)0x61, /* [382] */ - (xdc_Char)0x74, /* [383] */ - (xdc_Char)0x29, /* [384] */ - (xdc_Char)0x20, /* [385] */ - (xdc_Char)0x3e, /* [386] */ - (xdc_Char)0x20, /* [387] */ - (xdc_Char)0x73, /* [388] */ - (xdc_Char)0x69, /* [389] */ - (xdc_Char)0x7a, /* [390] */ - (xdc_Char)0x65, /* [391] */ - (xdc_Char)0x6f, /* [392] */ - (xdc_Char)0x66, /* [393] */ - (xdc_Char)0x28, /* [394] */ - (xdc_Char)0x41, /* [395] */ - (xdc_Char)0x72, /* [396] */ - (xdc_Char)0x67, /* [397] */ - (xdc_Char)0x29, /* [398] */ - (xdc_Char)0x0, /* [399] */ - (xdc_Char)0x41, /* [400] */ - (xdc_Char)0x5f, /* [401] */ - (xdc_Char)0x6d, /* [402] */ - (xdc_Char)0x75, /* [403] */ - (xdc_Char)0x73, /* [404] */ - (xdc_Char)0x74, /* [405] */ - (xdc_Char)0x55, /* [406] */ - (xdc_Char)0x73, /* [407] */ - (xdc_Char)0x65, /* [408] */ - (xdc_Char)0x45, /* [409] */ - (xdc_Char)0x6e, /* [410] */ - (xdc_Char)0x68, /* [411] */ - (xdc_Char)0x61, /* [412] */ - (xdc_Char)0x6e, /* [413] */ - (xdc_Char)0x63, /* [414] */ - (xdc_Char)0x65, /* [415] */ - (xdc_Char)0x64, /* [416] */ - (xdc_Char)0x43, /* [417] */ - (xdc_Char)0x6c, /* [418] */ - (xdc_Char)0x6f, /* [419] */ - (xdc_Char)0x63, /* [420] */ - (xdc_Char)0x6b, /* [421] */ - (xdc_Char)0x4d, /* [422] */ - (xdc_Char)0x6f, /* [423] */ - (xdc_Char)0x64, /* [424] */ - (xdc_Char)0x65, /* [425] */ - (xdc_Char)0x3a, /* [426] */ - (xdc_Char)0x20, /* [427] */ - (xdc_Char)0x54, /* [428] */ - (xdc_Char)0x68, /* [429] */ - (xdc_Char)0x69, /* [430] */ - (xdc_Char)0x73, /* [431] */ - (xdc_Char)0x20, /* [432] */ - (xdc_Char)0x64, /* [433] */ - (xdc_Char)0x65, /* [434] */ - (xdc_Char)0x76, /* [435] */ - (xdc_Char)0x69, /* [436] */ - (xdc_Char)0x63, /* [437] */ - (xdc_Char)0x65, /* [438] */ - (xdc_Char)0x20, /* [439] */ - (xdc_Char)0x72, /* [440] */ - (xdc_Char)0x65, /* [441] */ - (xdc_Char)0x71, /* [442] */ - (xdc_Char)0x75, /* [443] */ - (xdc_Char)0x69, /* [444] */ - (xdc_Char)0x72, /* [445] */ - (xdc_Char)0x65, /* [446] */ - (xdc_Char)0x73, /* [447] */ - (xdc_Char)0x20, /* [448] */ - (xdc_Char)0x74, /* [449] */ - (xdc_Char)0x68, /* [450] */ - (xdc_Char)0x65, /* [451] */ - (xdc_Char)0x20, /* [452] */ - (xdc_Char)0x45, /* [453] */ - (xdc_Char)0x6e, /* [454] */ - (xdc_Char)0x68, /* [455] */ - (xdc_Char)0x61, /* [456] */ - (xdc_Char)0x6e, /* [457] */ - (xdc_Char)0x63, /* [458] */ - (xdc_Char)0x65, /* [459] */ - (xdc_Char)0x64, /* [460] */ - (xdc_Char)0x20, /* [461] */ - (xdc_Char)0x43, /* [462] */ - (xdc_Char)0x6c, /* [463] */ - (xdc_Char)0x6f, /* [464] */ - (xdc_Char)0x63, /* [465] */ - (xdc_Char)0x6b, /* [466] */ - (xdc_Char)0x20, /* [467] */ - (xdc_Char)0x4d, /* [468] */ - (xdc_Char)0x6f, /* [469] */ - (xdc_Char)0x64, /* [470] */ - (xdc_Char)0x65, /* [471] */ - (xdc_Char)0x2e, /* [472] */ - (xdc_Char)0x0, /* [473] */ - (xdc_Char)0x41, /* [474] */ - (xdc_Char)0x5f, /* [475] */ - (xdc_Char)0x6d, /* [476] */ - (xdc_Char)0x75, /* [477] */ - (xdc_Char)0x73, /* [478] */ - (xdc_Char)0x74, /* [479] */ - (xdc_Char)0x4e, /* [480] */ - (xdc_Char)0x6f, /* [481] */ - (xdc_Char)0x74, /* [482] */ - (xdc_Char)0x55, /* [483] */ - (xdc_Char)0x73, /* [484] */ - (xdc_Char)0x65, /* [485] */ - (xdc_Char)0x45, /* [486] */ - (xdc_Char)0x6e, /* [487] */ - (xdc_Char)0x68, /* [488] */ - (xdc_Char)0x61, /* [489] */ - (xdc_Char)0x6e, /* [490] */ - (xdc_Char)0x63, /* [491] */ - (xdc_Char)0x65, /* [492] */ - (xdc_Char)0x64, /* [493] */ - (xdc_Char)0x43, /* [494] */ - (xdc_Char)0x6c, /* [495] */ - (xdc_Char)0x6f, /* [496] */ - (xdc_Char)0x63, /* [497] */ - (xdc_Char)0x6b, /* [498] */ - (xdc_Char)0x4d, /* [499] */ - (xdc_Char)0x6f, /* [500] */ - (xdc_Char)0x64, /* [501] */ - (xdc_Char)0x65, /* [502] */ - (xdc_Char)0x3a, /* [503] */ - (xdc_Char)0x20, /* [504] */ - (xdc_Char)0x54, /* [505] */ - (xdc_Char)0x68, /* [506] */ - (xdc_Char)0x69, /* [507] */ - (xdc_Char)0x73, /* [508] */ - (xdc_Char)0x20, /* [509] */ - (xdc_Char)0x64, /* [510] */ - (xdc_Char)0x65, /* [511] */ - (xdc_Char)0x76, /* [512] */ - (xdc_Char)0x69, /* [513] */ - (xdc_Char)0x63, /* [514] */ - (xdc_Char)0x65, /* [515] */ - (xdc_Char)0x20, /* [516] */ - (xdc_Char)0x64, /* [517] */ - (xdc_Char)0x6f, /* [518] */ - (xdc_Char)0x65, /* [519] */ - (xdc_Char)0x73, /* [520] */ - (xdc_Char)0x20, /* [521] */ - (xdc_Char)0x6e, /* [522] */ - (xdc_Char)0x6f, /* [523] */ - (xdc_Char)0x74, /* [524] */ - (xdc_Char)0x20, /* [525] */ - (xdc_Char)0x73, /* [526] */ - (xdc_Char)0x75, /* [527] */ - (xdc_Char)0x70, /* [528] */ - (xdc_Char)0x70, /* [529] */ - (xdc_Char)0x6f, /* [530] */ - (xdc_Char)0x72, /* [531] */ - (xdc_Char)0x74, /* [532] */ - (xdc_Char)0x20, /* [533] */ - (xdc_Char)0x74, /* [534] */ - (xdc_Char)0x68, /* [535] */ - (xdc_Char)0x65, /* [536] */ - (xdc_Char)0x20, /* [537] */ - (xdc_Char)0x45, /* [538] */ - (xdc_Char)0x6e, /* [539] */ - (xdc_Char)0x68, /* [540] */ - (xdc_Char)0x61, /* [541] */ - (xdc_Char)0x6e, /* [542] */ - (xdc_Char)0x63, /* [543] */ - (xdc_Char)0x65, /* [544] */ - (xdc_Char)0x64, /* [545] */ - (xdc_Char)0x20, /* [546] */ - (xdc_Char)0x43, /* [547] */ - (xdc_Char)0x6c, /* [548] */ - (xdc_Char)0x6f, /* [549] */ - (xdc_Char)0x63, /* [550] */ - (xdc_Char)0x6b, /* [551] */ - (xdc_Char)0x20, /* [552] */ - (xdc_Char)0x4d, /* [553] */ - (xdc_Char)0x6f, /* [554] */ - (xdc_Char)0x64, /* [555] */ - (xdc_Char)0x65, /* [556] */ - (xdc_Char)0x2e, /* [557] */ - (xdc_Char)0x0, /* [558] */ - (xdc_Char)0x41, /* [559] */ - (xdc_Char)0x5f, /* [560] */ - (xdc_Char)0x6e, /* [561] */ - (xdc_Char)0x75, /* [562] */ - (xdc_Char)0x6c, /* [563] */ - (xdc_Char)0x6c, /* [564] */ - (xdc_Char)0x50, /* [565] */ - (xdc_Char)0x6f, /* [566] */ - (xdc_Char)0x69, /* [567] */ - (xdc_Char)0x6e, /* [568] */ - (xdc_Char)0x74, /* [569] */ - (xdc_Char)0x65, /* [570] */ - (xdc_Char)0x72, /* [571] */ - (xdc_Char)0x3a, /* [572] */ - (xdc_Char)0x20, /* [573] */ - (xdc_Char)0x50, /* [574] */ - (xdc_Char)0x6f, /* [575] */ - (xdc_Char)0x69, /* [576] */ - (xdc_Char)0x6e, /* [577] */ - (xdc_Char)0x74, /* [578] */ - (xdc_Char)0x65, /* [579] */ - (xdc_Char)0x72, /* [580] */ - (xdc_Char)0x20, /* [581] */ - (xdc_Char)0x69, /* [582] */ - (xdc_Char)0x73, /* [583] */ - (xdc_Char)0x20, /* [584] */ - (xdc_Char)0x6e, /* [585] */ - (xdc_Char)0x75, /* [586] */ - (xdc_Char)0x6c, /* [587] */ - (xdc_Char)0x6c, /* [588] */ - (xdc_Char)0x0, /* [589] */ - (xdc_Char)0x41, /* [590] */ - (xdc_Char)0x5f, /* [591] */ - (xdc_Char)0x69, /* [592] */ - (xdc_Char)0x6e, /* [593] */ - (xdc_Char)0x76, /* [594] */ - (xdc_Char)0x61, /* [595] */ - (xdc_Char)0x6c, /* [596] */ - (xdc_Char)0x69, /* [597] */ - (xdc_Char)0x64, /* [598] */ - (xdc_Char)0x52, /* [599] */ - (xdc_Char)0x65, /* [600] */ - (xdc_Char)0x67, /* [601] */ - (xdc_Char)0x69, /* [602] */ - (xdc_Char)0x6f, /* [603] */ - (xdc_Char)0x6e, /* [604] */ - (xdc_Char)0x49, /* [605] */ - (xdc_Char)0x64, /* [606] */ - (xdc_Char)0x3a, /* [607] */ - (xdc_Char)0x20, /* [608] */ - (xdc_Char)0x4d, /* [609] */ - (xdc_Char)0x50, /* [610] */ - (xdc_Char)0x55, /* [611] */ - (xdc_Char)0x20, /* [612] */ - (xdc_Char)0x52, /* [613] */ - (xdc_Char)0x65, /* [614] */ - (xdc_Char)0x67, /* [615] */ - (xdc_Char)0x69, /* [616] */ - (xdc_Char)0x6f, /* [617] */ - (xdc_Char)0x6e, /* [618] */ - (xdc_Char)0x20, /* [619] */ - (xdc_Char)0x6e, /* [620] */ - (xdc_Char)0x75, /* [621] */ - (xdc_Char)0x6d, /* [622] */ - (xdc_Char)0x62, /* [623] */ - (xdc_Char)0x65, /* [624] */ - (xdc_Char)0x72, /* [625] */ - (xdc_Char)0x20, /* [626] */ - (xdc_Char)0x70, /* [627] */ - (xdc_Char)0x61, /* [628] */ - (xdc_Char)0x73, /* [629] */ - (xdc_Char)0x73, /* [630] */ - (xdc_Char)0x65, /* [631] */ - (xdc_Char)0x64, /* [632] */ - (xdc_Char)0x20, /* [633] */ - (xdc_Char)0x69, /* [634] */ - (xdc_Char)0x73, /* [635] */ - (xdc_Char)0x20, /* [636] */ - (xdc_Char)0x69, /* [637] */ - (xdc_Char)0x6e, /* [638] */ - (xdc_Char)0x76, /* [639] */ - (xdc_Char)0x61, /* [640] */ - (xdc_Char)0x6c, /* [641] */ - (xdc_Char)0x69, /* [642] */ - (xdc_Char)0x64, /* [643] */ - (xdc_Char)0x2e, /* [644] */ - (xdc_Char)0x0, /* [645] */ - (xdc_Char)0x41, /* [646] */ - (xdc_Char)0x5f, /* [647] */ - (xdc_Char)0x75, /* [648] */ - (xdc_Char)0x6e, /* [649] */ - (xdc_Char)0x61, /* [650] */ - (xdc_Char)0x6c, /* [651] */ - (xdc_Char)0x69, /* [652] */ - (xdc_Char)0x67, /* [653] */ - (xdc_Char)0x6e, /* [654] */ - (xdc_Char)0x65, /* [655] */ - (xdc_Char)0x64, /* [656] */ - (xdc_Char)0x42, /* [657] */ - (xdc_Char)0x61, /* [658] */ - (xdc_Char)0x73, /* [659] */ - (xdc_Char)0x65, /* [660] */ - (xdc_Char)0x41, /* [661] */ - (xdc_Char)0x64, /* [662] */ - (xdc_Char)0x64, /* [663] */ - (xdc_Char)0x72, /* [664] */ - (xdc_Char)0x3a, /* [665] */ - (xdc_Char)0x20, /* [666] */ - (xdc_Char)0x4d, /* [667] */ - (xdc_Char)0x50, /* [668] */ - (xdc_Char)0x55, /* [669] */ - (xdc_Char)0x20, /* [670] */ - (xdc_Char)0x72, /* [671] */ - (xdc_Char)0x65, /* [672] */ - (xdc_Char)0x67, /* [673] */ - (xdc_Char)0x69, /* [674] */ - (xdc_Char)0x6f, /* [675] */ - (xdc_Char)0x6e, /* [676] */ - (xdc_Char)0x20, /* [677] */ - (xdc_Char)0x62, /* [678] */ - (xdc_Char)0x61, /* [679] */ - (xdc_Char)0x73, /* [680] */ - (xdc_Char)0x65, /* [681] */ - (xdc_Char)0x20, /* [682] */ - (xdc_Char)0x61, /* [683] */ - (xdc_Char)0x64, /* [684] */ - (xdc_Char)0x64, /* [685] */ - (xdc_Char)0x72, /* [686] */ - (xdc_Char)0x65, /* [687] */ - (xdc_Char)0x73, /* [688] */ - (xdc_Char)0x73, /* [689] */ - (xdc_Char)0x20, /* [690] */ - (xdc_Char)0x6e, /* [691] */ - (xdc_Char)0x6f, /* [692] */ - (xdc_Char)0x74, /* [693] */ - (xdc_Char)0x20, /* [694] */ - (xdc_Char)0x61, /* [695] */ - (xdc_Char)0x6c, /* [696] */ - (xdc_Char)0x69, /* [697] */ - (xdc_Char)0x67, /* [698] */ - (xdc_Char)0x6e, /* [699] */ - (xdc_Char)0x65, /* [700] */ - (xdc_Char)0x64, /* [701] */ - (xdc_Char)0x20, /* [702] */ - (xdc_Char)0x74, /* [703] */ - (xdc_Char)0x6f, /* [704] */ - (xdc_Char)0x20, /* [705] */ - (xdc_Char)0x73, /* [706] */ - (xdc_Char)0x69, /* [707] */ - (xdc_Char)0x7a, /* [708] */ - (xdc_Char)0x65, /* [709] */ - (xdc_Char)0x2e, /* [710] */ - (xdc_Char)0x0, /* [711] */ - (xdc_Char)0x41, /* [712] */ - (xdc_Char)0x5f, /* [713] */ - (xdc_Char)0x75, /* [714] */ - (xdc_Char)0x6e, /* [715] */ - (xdc_Char)0x73, /* [716] */ - (xdc_Char)0x75, /* [717] */ - (xdc_Char)0x70, /* [718] */ - (xdc_Char)0x70, /* [719] */ - (xdc_Char)0x6f, /* [720] */ - (xdc_Char)0x72, /* [721] */ - (xdc_Char)0x74, /* [722] */ - (xdc_Char)0x65, /* [723] */ - (xdc_Char)0x64, /* [724] */ - (xdc_Char)0x4d, /* [725] */ - (xdc_Char)0x61, /* [726] */ - (xdc_Char)0x73, /* [727] */ - (xdc_Char)0x6b, /* [728] */ - (xdc_Char)0x69, /* [729] */ - (xdc_Char)0x6e, /* [730] */ - (xdc_Char)0x67, /* [731] */ - (xdc_Char)0x4f, /* [732] */ - (xdc_Char)0x70, /* [733] */ - (xdc_Char)0x74, /* [734] */ - (xdc_Char)0x69, /* [735] */ - (xdc_Char)0x6f, /* [736] */ - (xdc_Char)0x6e, /* [737] */ - (xdc_Char)0x3a, /* [738] */ - (xdc_Char)0x20, /* [739] */ - (xdc_Char)0x75, /* [740] */ - (xdc_Char)0x6e, /* [741] */ - (xdc_Char)0x73, /* [742] */ - (xdc_Char)0x75, /* [743] */ - (xdc_Char)0x70, /* [744] */ - (xdc_Char)0x70, /* [745] */ - (xdc_Char)0x6f, /* [746] */ - (xdc_Char)0x72, /* [747] */ - (xdc_Char)0x74, /* [748] */ - (xdc_Char)0x65, /* [749] */ - (xdc_Char)0x64, /* [750] */ - (xdc_Char)0x20, /* [751] */ - (xdc_Char)0x6d, /* [752] */ - (xdc_Char)0x61, /* [753] */ - (xdc_Char)0x73, /* [754] */ - (xdc_Char)0x6b, /* [755] */ - (xdc_Char)0x53, /* [756] */ - (xdc_Char)0x65, /* [757] */ - (xdc_Char)0x74, /* [758] */ - (xdc_Char)0x74, /* [759] */ - (xdc_Char)0x69, /* [760] */ - (xdc_Char)0x6e, /* [761] */ - (xdc_Char)0x67, /* [762] */ - (xdc_Char)0x2e, /* [763] */ - (xdc_Char)0x0, /* [764] */ - (xdc_Char)0x41, /* [765] */ - (xdc_Char)0x5f, /* [766] */ - (xdc_Char)0x63, /* [767] */ - (xdc_Char)0x6c, /* [768] */ - (xdc_Char)0x6f, /* [769] */ - (xdc_Char)0x63, /* [770] */ - (xdc_Char)0x6b, /* [771] */ - (xdc_Char)0x44, /* [772] */ - (xdc_Char)0x69, /* [773] */ - (xdc_Char)0x73, /* [774] */ - (xdc_Char)0x61, /* [775] */ - (xdc_Char)0x62, /* [776] */ - (xdc_Char)0x6c, /* [777] */ - (xdc_Char)0x65, /* [778] */ - (xdc_Char)0x64, /* [779] */ - (xdc_Char)0x3a, /* [780] */ - (xdc_Char)0x20, /* [781] */ - (xdc_Char)0x43, /* [782] */ - (xdc_Char)0x61, /* [783] */ - (xdc_Char)0x6e, /* [784] */ - (xdc_Char)0x6e, /* [785] */ - (xdc_Char)0x6f, /* [786] */ - (xdc_Char)0x74, /* [787] */ - (xdc_Char)0x20, /* [788] */ - (xdc_Char)0x63, /* [789] */ - (xdc_Char)0x72, /* [790] */ - (xdc_Char)0x65, /* [791] */ - (xdc_Char)0x61, /* [792] */ - (xdc_Char)0x74, /* [793] */ - (xdc_Char)0x65, /* [794] */ - (xdc_Char)0x20, /* [795] */ - (xdc_Char)0x61, /* [796] */ - (xdc_Char)0x20, /* [797] */ - (xdc_Char)0x63, /* [798] */ - (xdc_Char)0x6c, /* [799] */ - (xdc_Char)0x6f, /* [800] */ - (xdc_Char)0x63, /* [801] */ - (xdc_Char)0x6b, /* [802] */ - (xdc_Char)0x20, /* [803] */ - (xdc_Char)0x69, /* [804] */ - (xdc_Char)0x6e, /* [805] */ - (xdc_Char)0x73, /* [806] */ - (xdc_Char)0x74, /* [807] */ - (xdc_Char)0x61, /* [808] */ - (xdc_Char)0x6e, /* [809] */ - (xdc_Char)0x63, /* [810] */ - (xdc_Char)0x65, /* [811] */ - (xdc_Char)0x20, /* [812] */ - (xdc_Char)0x77, /* [813] */ - (xdc_Char)0x68, /* [814] */ - (xdc_Char)0x65, /* [815] */ - (xdc_Char)0x6e, /* [816] */ - (xdc_Char)0x20, /* [817] */ - (xdc_Char)0x42, /* [818] */ - (xdc_Char)0x49, /* [819] */ - (xdc_Char)0x4f, /* [820] */ - (xdc_Char)0x53, /* [821] */ - (xdc_Char)0x2e, /* [822] */ - (xdc_Char)0x63, /* [823] */ - (xdc_Char)0x6c, /* [824] */ - (xdc_Char)0x6f, /* [825] */ - (xdc_Char)0x63, /* [826] */ - (xdc_Char)0x6b, /* [827] */ - (xdc_Char)0x45, /* [828] */ - (xdc_Char)0x6e, /* [829] */ - (xdc_Char)0x61, /* [830] */ - (xdc_Char)0x62, /* [831] */ - (xdc_Char)0x6c, /* [832] */ - (xdc_Char)0x65, /* [833] */ - (xdc_Char)0x64, /* [834] */ - (xdc_Char)0x20, /* [835] */ - (xdc_Char)0x69, /* [836] */ - (xdc_Char)0x73, /* [837] */ - (xdc_Char)0x20, /* [838] */ - (xdc_Char)0x66, /* [839] */ - (xdc_Char)0x61, /* [840] */ - (xdc_Char)0x6c, /* [841] */ - (xdc_Char)0x73, /* [842] */ - (xdc_Char)0x65, /* [843] */ - (xdc_Char)0x2e, /* [844] */ - (xdc_Char)0x0, /* [845] */ - (xdc_Char)0x41, /* [846] */ - (xdc_Char)0x5f, /* [847] */ - (xdc_Char)0x62, /* [848] */ - (xdc_Char)0x61, /* [849] */ - (xdc_Char)0x64, /* [850] */ - (xdc_Char)0x54, /* [851] */ - (xdc_Char)0x68, /* [852] */ - (xdc_Char)0x72, /* [853] */ - (xdc_Char)0x65, /* [854] */ - (xdc_Char)0x61, /* [855] */ - (xdc_Char)0x64, /* [856] */ - (xdc_Char)0x54, /* [857] */ - (xdc_Char)0x79, /* [858] */ - (xdc_Char)0x70, /* [859] */ - (xdc_Char)0x65, /* [860] */ - (xdc_Char)0x3a, /* [861] */ - (xdc_Char)0x20, /* [862] */ - (xdc_Char)0x43, /* [863] */ - (xdc_Char)0x61, /* [864] */ - (xdc_Char)0x6e, /* [865] */ - (xdc_Char)0x6e, /* [866] */ - (xdc_Char)0x6f, /* [867] */ - (xdc_Char)0x74, /* [868] */ - (xdc_Char)0x20, /* [869] */ - (xdc_Char)0x63, /* [870] */ - (xdc_Char)0x72, /* [871] */ - (xdc_Char)0x65, /* [872] */ - (xdc_Char)0x61, /* [873] */ - (xdc_Char)0x74, /* [874] */ - (xdc_Char)0x65, /* [875] */ - (xdc_Char)0x2f, /* [876] */ - (xdc_Char)0x64, /* [877] */ - (xdc_Char)0x65, /* [878] */ - (xdc_Char)0x6c, /* [879] */ - (xdc_Char)0x65, /* [880] */ - (xdc_Char)0x74, /* [881] */ - (xdc_Char)0x65, /* [882] */ - (xdc_Char)0x20, /* [883] */ - (xdc_Char)0x61, /* [884] */ - (xdc_Char)0x20, /* [885] */ - (xdc_Char)0x43, /* [886] */ - (xdc_Char)0x6c, /* [887] */ - (xdc_Char)0x6f, /* [888] */ - (xdc_Char)0x63, /* [889] */ - (xdc_Char)0x6b, /* [890] */ - (xdc_Char)0x20, /* [891] */ - (xdc_Char)0x66, /* [892] */ - (xdc_Char)0x72, /* [893] */ - (xdc_Char)0x6f, /* [894] */ - (xdc_Char)0x6d, /* [895] */ - (xdc_Char)0x20, /* [896] */ - (xdc_Char)0x48, /* [897] */ - (xdc_Char)0x77, /* [898] */ - (xdc_Char)0x69, /* [899] */ - (xdc_Char)0x20, /* [900] */ - (xdc_Char)0x6f, /* [901] */ - (xdc_Char)0x72, /* [902] */ - (xdc_Char)0x20, /* [903] */ - (xdc_Char)0x53, /* [904] */ - (xdc_Char)0x77, /* [905] */ - (xdc_Char)0x69, /* [906] */ - (xdc_Char)0x20, /* [907] */ - (xdc_Char)0x74, /* [908] */ - (xdc_Char)0x68, /* [909] */ - (xdc_Char)0x72, /* [910] */ - (xdc_Char)0x65, /* [911] */ - (xdc_Char)0x61, /* [912] */ - (xdc_Char)0x64, /* [913] */ - (xdc_Char)0x2e, /* [914] */ - (xdc_Char)0x0, /* [915] */ - (xdc_Char)0x41, /* [916] */ - (xdc_Char)0x5f, /* [917] */ - (xdc_Char)0x6e, /* [918] */ - (xdc_Char)0x75, /* [919] */ - (xdc_Char)0x6c, /* [920] */ - (xdc_Char)0x6c, /* [921] */ - (xdc_Char)0x45, /* [922] */ - (xdc_Char)0x76, /* [923] */ - (xdc_Char)0x65, /* [924] */ - (xdc_Char)0x6e, /* [925] */ - (xdc_Char)0x74, /* [926] */ - (xdc_Char)0x4d, /* [927] */ - (xdc_Char)0x61, /* [928] */ - (xdc_Char)0x73, /* [929] */ - (xdc_Char)0x6b, /* [930] */ - (xdc_Char)0x73, /* [931] */ - (xdc_Char)0x3a, /* [932] */ - (xdc_Char)0x20, /* [933] */ - (xdc_Char)0x6f, /* [934] */ - (xdc_Char)0x72, /* [935] */ - (xdc_Char)0x4d, /* [936] */ - (xdc_Char)0x61, /* [937] */ - (xdc_Char)0x73, /* [938] */ - (xdc_Char)0x6b, /* [939] */ - (xdc_Char)0x20, /* [940] */ - (xdc_Char)0x61, /* [941] */ - (xdc_Char)0x6e, /* [942] */ - (xdc_Char)0x64, /* [943] */ - (xdc_Char)0x20, /* [944] */ - (xdc_Char)0x61, /* [945] */ - (xdc_Char)0x6e, /* [946] */ - (xdc_Char)0x64, /* [947] */ - (xdc_Char)0x4d, /* [948] */ - (xdc_Char)0x61, /* [949] */ - (xdc_Char)0x73, /* [950] */ - (xdc_Char)0x6b, /* [951] */ - (xdc_Char)0x20, /* [952] */ - (xdc_Char)0x61, /* [953] */ - (xdc_Char)0x72, /* [954] */ - (xdc_Char)0x65, /* [955] */ - (xdc_Char)0x20, /* [956] */ - (xdc_Char)0x6e, /* [957] */ - (xdc_Char)0x75, /* [958] */ - (xdc_Char)0x6c, /* [959] */ - (xdc_Char)0x6c, /* [960] */ - (xdc_Char)0x2e, /* [961] */ - (xdc_Char)0x0, /* [962] */ - (xdc_Char)0x41, /* [963] */ - (xdc_Char)0x5f, /* [964] */ - (xdc_Char)0x6e, /* [965] */ - (xdc_Char)0x75, /* [966] */ - (xdc_Char)0x6c, /* [967] */ - (xdc_Char)0x6c, /* [968] */ - (xdc_Char)0x45, /* [969] */ - (xdc_Char)0x76, /* [970] */ - (xdc_Char)0x65, /* [971] */ - (xdc_Char)0x6e, /* [972] */ - (xdc_Char)0x74, /* [973] */ - (xdc_Char)0x49, /* [974] */ - (xdc_Char)0x64, /* [975] */ - (xdc_Char)0x3a, /* [976] */ - (xdc_Char)0x20, /* [977] */ - (xdc_Char)0x70, /* [978] */ - (xdc_Char)0x6f, /* [979] */ - (xdc_Char)0x73, /* [980] */ - (xdc_Char)0x74, /* [981] */ - (xdc_Char)0x65, /* [982] */ - (xdc_Char)0x64, /* [983] */ - (xdc_Char)0x20, /* [984] */ - (xdc_Char)0x65, /* [985] */ - (xdc_Char)0x76, /* [986] */ - (xdc_Char)0x65, /* [987] */ - (xdc_Char)0x6e, /* [988] */ - (xdc_Char)0x74, /* [989] */ - (xdc_Char)0x49, /* [990] */ - (xdc_Char)0x64, /* [991] */ - (xdc_Char)0x20, /* [992] */ - (xdc_Char)0x69, /* [993] */ - (xdc_Char)0x73, /* [994] */ - (xdc_Char)0x20, /* [995] */ - (xdc_Char)0x6e, /* [996] */ - (xdc_Char)0x75, /* [997] */ - (xdc_Char)0x6c, /* [998] */ - (xdc_Char)0x6c, /* [999] */ - (xdc_Char)0x2e, /* [1000] */ - (xdc_Char)0x0, /* [1001] */ - (xdc_Char)0x41, /* [1002] */ - (xdc_Char)0x5f, /* [1003] */ - (xdc_Char)0x65, /* [1004] */ - (xdc_Char)0x76, /* [1005] */ - (xdc_Char)0x65, /* [1006] */ - (xdc_Char)0x6e, /* [1007] */ - (xdc_Char)0x74, /* [1008] */ - (xdc_Char)0x49, /* [1009] */ - (xdc_Char)0x6e, /* [1010] */ - (xdc_Char)0x55, /* [1011] */ - (xdc_Char)0x73, /* [1012] */ - (xdc_Char)0x65, /* [1013] */ - (xdc_Char)0x3a, /* [1014] */ - (xdc_Char)0x20, /* [1015] */ - (xdc_Char)0x45, /* [1016] */ - (xdc_Char)0x76, /* [1017] */ - (xdc_Char)0x65, /* [1018] */ - (xdc_Char)0x6e, /* [1019] */ - (xdc_Char)0x74, /* [1020] */ - (xdc_Char)0x20, /* [1021] */ - (xdc_Char)0x6f, /* [1022] */ - (xdc_Char)0x62, /* [1023] */ - (xdc_Char)0x6a, /* [1024] */ - (xdc_Char)0x65, /* [1025] */ - (xdc_Char)0x63, /* [1026] */ - (xdc_Char)0x74, /* [1027] */ - (xdc_Char)0x20, /* [1028] */ - (xdc_Char)0x61, /* [1029] */ - (xdc_Char)0x6c, /* [1030] */ - (xdc_Char)0x72, /* [1031] */ - (xdc_Char)0x65, /* [1032] */ - (xdc_Char)0x61, /* [1033] */ - (xdc_Char)0x64, /* [1034] */ - (xdc_Char)0x79, /* [1035] */ - (xdc_Char)0x20, /* [1036] */ - (xdc_Char)0x69, /* [1037] */ - (xdc_Char)0x6e, /* [1038] */ - (xdc_Char)0x20, /* [1039] */ - (xdc_Char)0x75, /* [1040] */ - (xdc_Char)0x73, /* [1041] */ - (xdc_Char)0x65, /* [1042] */ - (xdc_Char)0x2e, /* [1043] */ - (xdc_Char)0x0, /* [1044] */ - (xdc_Char)0x41, /* [1045] */ - (xdc_Char)0x5f, /* [1046] */ - (xdc_Char)0x62, /* [1047] */ - (xdc_Char)0x61, /* [1048] */ - (xdc_Char)0x64, /* [1049] */ - (xdc_Char)0x43, /* [1050] */ - (xdc_Char)0x6f, /* [1051] */ - (xdc_Char)0x6e, /* [1052] */ - (xdc_Char)0x74, /* [1053] */ - (xdc_Char)0x65, /* [1054] */ - (xdc_Char)0x78, /* [1055] */ - (xdc_Char)0x74, /* [1056] */ - (xdc_Char)0x3a, /* [1057] */ - (xdc_Char)0x20, /* [1058] */ - (xdc_Char)0x62, /* [1059] */ - (xdc_Char)0x61, /* [1060] */ - (xdc_Char)0x64, /* [1061] */ - (xdc_Char)0x20, /* [1062] */ - (xdc_Char)0x63, /* [1063] */ - (xdc_Char)0x61, /* [1064] */ - (xdc_Char)0x6c, /* [1065] */ - (xdc_Char)0x6c, /* [1066] */ - (xdc_Char)0x69, /* [1067] */ - (xdc_Char)0x6e, /* [1068] */ - (xdc_Char)0x67, /* [1069] */ - (xdc_Char)0x20, /* [1070] */ - (xdc_Char)0x63, /* [1071] */ - (xdc_Char)0x6f, /* [1072] */ - (xdc_Char)0x6e, /* [1073] */ - (xdc_Char)0x74, /* [1074] */ - (xdc_Char)0x65, /* [1075] */ - (xdc_Char)0x78, /* [1076] */ - (xdc_Char)0x74, /* [1077] */ - (xdc_Char)0x2e, /* [1078] */ - (xdc_Char)0x20, /* [1079] */ - (xdc_Char)0x4d, /* [1080] */ - (xdc_Char)0x75, /* [1081] */ - (xdc_Char)0x73, /* [1082] */ - (xdc_Char)0x74, /* [1083] */ - (xdc_Char)0x20, /* [1084] */ - (xdc_Char)0x62, /* [1085] */ - (xdc_Char)0x65, /* [1086] */ - (xdc_Char)0x20, /* [1087] */ - (xdc_Char)0x63, /* [1088] */ - (xdc_Char)0x61, /* [1089] */ - (xdc_Char)0x6c, /* [1090] */ - (xdc_Char)0x6c, /* [1091] */ - (xdc_Char)0x65, /* [1092] */ - (xdc_Char)0x64, /* [1093] */ - (xdc_Char)0x20, /* [1094] */ - (xdc_Char)0x66, /* [1095] */ - (xdc_Char)0x72, /* [1096] */ - (xdc_Char)0x6f, /* [1097] */ - (xdc_Char)0x6d, /* [1098] */ - (xdc_Char)0x20, /* [1099] */ - (xdc_Char)0x61, /* [1100] */ - (xdc_Char)0x20, /* [1101] */ - (xdc_Char)0x54, /* [1102] */ - (xdc_Char)0x61, /* [1103] */ - (xdc_Char)0x73, /* [1104] */ - (xdc_Char)0x6b, /* [1105] */ - (xdc_Char)0x2e, /* [1106] */ - (xdc_Char)0x0, /* [1107] */ - (xdc_Char)0x41, /* [1108] */ - (xdc_Char)0x5f, /* [1109] */ - (xdc_Char)0x70, /* [1110] */ - (xdc_Char)0x65, /* [1111] */ - (xdc_Char)0x6e, /* [1112] */ - (xdc_Char)0x64, /* [1113] */ - (xdc_Char)0x54, /* [1114] */ - (xdc_Char)0x61, /* [1115] */ - (xdc_Char)0x73, /* [1116] */ - (xdc_Char)0x6b, /* [1117] */ - (xdc_Char)0x44, /* [1118] */ - (xdc_Char)0x69, /* [1119] */ - (xdc_Char)0x73, /* [1120] */ - (xdc_Char)0x61, /* [1121] */ - (xdc_Char)0x62, /* [1122] */ - (xdc_Char)0x6c, /* [1123] */ - (xdc_Char)0x65, /* [1124] */ - (xdc_Char)0x64, /* [1125] */ - (xdc_Char)0x3a, /* [1126] */ - (xdc_Char)0x20, /* [1127] */ - (xdc_Char)0x43, /* [1128] */ - (xdc_Char)0x61, /* [1129] */ - (xdc_Char)0x6e, /* [1130] */ - (xdc_Char)0x6e, /* [1131] */ - (xdc_Char)0x6f, /* [1132] */ - (xdc_Char)0x74, /* [1133] */ - (xdc_Char)0x20, /* [1134] */ - (xdc_Char)0x63, /* [1135] */ - (xdc_Char)0x61, /* [1136] */ - (xdc_Char)0x6c, /* [1137] */ - (xdc_Char)0x6c, /* [1138] */ - (xdc_Char)0x20, /* [1139] */ - (xdc_Char)0x45, /* [1140] */ - (xdc_Char)0x76, /* [1141] */ - (xdc_Char)0x65, /* [1142] */ - (xdc_Char)0x6e, /* [1143] */ - (xdc_Char)0x74, /* [1144] */ - (xdc_Char)0x5f, /* [1145] */ - (xdc_Char)0x70, /* [1146] */ - (xdc_Char)0x65, /* [1147] */ - (xdc_Char)0x6e, /* [1148] */ - (xdc_Char)0x64, /* [1149] */ - (xdc_Char)0x28, /* [1150] */ - (xdc_Char)0x29, /* [1151] */ - (xdc_Char)0x20, /* [1152] */ - (xdc_Char)0x77, /* [1153] */ - (xdc_Char)0x68, /* [1154] */ - (xdc_Char)0x69, /* [1155] */ - (xdc_Char)0x6c, /* [1156] */ - (xdc_Char)0x65, /* [1157] */ - (xdc_Char)0x20, /* [1158] */ - (xdc_Char)0x74, /* [1159] */ - (xdc_Char)0x68, /* [1160] */ - (xdc_Char)0x65, /* [1161] */ - (xdc_Char)0x20, /* [1162] */ - (xdc_Char)0x54, /* [1163] */ - (xdc_Char)0x61, /* [1164] */ - (xdc_Char)0x73, /* [1165] */ - (xdc_Char)0x6b, /* [1166] */ - (xdc_Char)0x20, /* [1167] */ - (xdc_Char)0x6f, /* [1168] */ - (xdc_Char)0x72, /* [1169] */ - (xdc_Char)0x20, /* [1170] */ - (xdc_Char)0x53, /* [1171] */ - (xdc_Char)0x77, /* [1172] */ - (xdc_Char)0x69, /* [1173] */ - (xdc_Char)0x20, /* [1174] */ - (xdc_Char)0x73, /* [1175] */ - (xdc_Char)0x63, /* [1176] */ - (xdc_Char)0x68, /* [1177] */ - (xdc_Char)0x65, /* [1178] */ - (xdc_Char)0x64, /* [1179] */ - (xdc_Char)0x75, /* [1180] */ - (xdc_Char)0x6c, /* [1181] */ - (xdc_Char)0x65, /* [1182] */ - (xdc_Char)0x72, /* [1183] */ - (xdc_Char)0x20, /* [1184] */ - (xdc_Char)0x69, /* [1185] */ - (xdc_Char)0x73, /* [1186] */ - (xdc_Char)0x20, /* [1187] */ - (xdc_Char)0x64, /* [1188] */ - (xdc_Char)0x69, /* [1189] */ - (xdc_Char)0x73, /* [1190] */ - (xdc_Char)0x61, /* [1191] */ - (xdc_Char)0x62, /* [1192] */ - (xdc_Char)0x6c, /* [1193] */ - (xdc_Char)0x65, /* [1194] */ - (xdc_Char)0x64, /* [1195] */ - (xdc_Char)0x2e, /* [1196] */ - (xdc_Char)0x0, /* [1197] */ - (xdc_Char)0x4d, /* [1198] */ - (xdc_Char)0x61, /* [1199] */ - (xdc_Char)0x69, /* [1200] */ - (xdc_Char)0x6c, /* [1201] */ - (xdc_Char)0x62, /* [1202] */ - (xdc_Char)0x6f, /* [1203] */ - (xdc_Char)0x78, /* [1204] */ - (xdc_Char)0x5f, /* [1205] */ - (xdc_Char)0x63, /* [1206] */ - (xdc_Char)0x72, /* [1207] */ - (xdc_Char)0x65, /* [1208] */ - (xdc_Char)0x61, /* [1209] */ - (xdc_Char)0x74, /* [1210] */ - (xdc_Char)0x65, /* [1211] */ - (xdc_Char)0x27, /* [1212] */ - (xdc_Char)0x73, /* [1213] */ - (xdc_Char)0x20, /* [1214] */ - (xdc_Char)0x62, /* [1215] */ - (xdc_Char)0x75, /* [1216] */ - (xdc_Char)0x66, /* [1217] */ - (xdc_Char)0x53, /* [1218] */ - (xdc_Char)0x69, /* [1219] */ - (xdc_Char)0x7a, /* [1220] */ - (xdc_Char)0x65, /* [1221] */ - (xdc_Char)0x20, /* [1222] */ - (xdc_Char)0x70, /* [1223] */ - (xdc_Char)0x61, /* [1224] */ - (xdc_Char)0x72, /* [1225] */ - (xdc_Char)0x61, /* [1226] */ - (xdc_Char)0x6d, /* [1227] */ - (xdc_Char)0x65, /* [1228] */ - (xdc_Char)0x74, /* [1229] */ - (xdc_Char)0x65, /* [1230] */ - (xdc_Char)0x72, /* [1231] */ - (xdc_Char)0x20, /* [1232] */ - (xdc_Char)0x69, /* [1233] */ - (xdc_Char)0x73, /* [1234] */ - (xdc_Char)0x20, /* [1235] */ - (xdc_Char)0x69, /* [1236] */ - (xdc_Char)0x6e, /* [1237] */ - (xdc_Char)0x76, /* [1238] */ - (xdc_Char)0x61, /* [1239] */ - (xdc_Char)0x6c, /* [1240] */ - (xdc_Char)0x69, /* [1241] */ - (xdc_Char)0x64, /* [1242] */ - (xdc_Char)0x20, /* [1243] */ - (xdc_Char)0x28, /* [1244] */ - (xdc_Char)0x74, /* [1245] */ - (xdc_Char)0x6f, /* [1246] */ - (xdc_Char)0x6f, /* [1247] */ - (xdc_Char)0x20, /* [1248] */ - (xdc_Char)0x73, /* [1249] */ - (xdc_Char)0x6d, /* [1250] */ - (xdc_Char)0x61, /* [1251] */ - (xdc_Char)0x6c, /* [1252] */ - (xdc_Char)0x6c, /* [1253] */ - (xdc_Char)0x29, /* [1254] */ - (xdc_Char)0x0, /* [1255] */ - (xdc_Char)0x41, /* [1256] */ - (xdc_Char)0x5f, /* [1257] */ - (xdc_Char)0x6e, /* [1258] */ - (xdc_Char)0x6f, /* [1259] */ - (xdc_Char)0x45, /* [1260] */ - (xdc_Char)0x76, /* [1261] */ - (xdc_Char)0x65, /* [1262] */ - (xdc_Char)0x6e, /* [1263] */ - (xdc_Char)0x74, /* [1264] */ - (xdc_Char)0x73, /* [1265] */ - (xdc_Char)0x3a, /* [1266] */ - (xdc_Char)0x20, /* [1267] */ - (xdc_Char)0x54, /* [1268] */ - (xdc_Char)0x68, /* [1269] */ - (xdc_Char)0x65, /* [1270] */ - (xdc_Char)0x20, /* [1271] */ - (xdc_Char)0x45, /* [1272] */ - (xdc_Char)0x76, /* [1273] */ - (xdc_Char)0x65, /* [1274] */ - (xdc_Char)0x6e, /* [1275] */ - (xdc_Char)0x74, /* [1276] */ - (xdc_Char)0x2e, /* [1277] */ - (xdc_Char)0x73, /* [1278] */ - (xdc_Char)0x75, /* [1279] */ - (xdc_Char)0x70, /* [1280] */ - (xdc_Char)0x70, /* [1281] */ - (xdc_Char)0x6f, /* [1282] */ - (xdc_Char)0x72, /* [1283] */ - (xdc_Char)0x74, /* [1284] */ - (xdc_Char)0x73, /* [1285] */ - (xdc_Char)0x45, /* [1286] */ - (xdc_Char)0x76, /* [1287] */ - (xdc_Char)0x65, /* [1288] */ - (xdc_Char)0x6e, /* [1289] */ - (xdc_Char)0x74, /* [1290] */ - (xdc_Char)0x73, /* [1291] */ - (xdc_Char)0x20, /* [1292] */ - (xdc_Char)0x66, /* [1293] */ - (xdc_Char)0x6c, /* [1294] */ - (xdc_Char)0x61, /* [1295] */ - (xdc_Char)0x67, /* [1296] */ - (xdc_Char)0x20, /* [1297] */ - (xdc_Char)0x69, /* [1298] */ - (xdc_Char)0x73, /* [1299] */ - (xdc_Char)0x20, /* [1300] */ - (xdc_Char)0x64, /* [1301] */ - (xdc_Char)0x69, /* [1302] */ - (xdc_Char)0x73, /* [1303] */ - (xdc_Char)0x61, /* [1304] */ - (xdc_Char)0x62, /* [1305] */ - (xdc_Char)0x6c, /* [1306] */ - (xdc_Char)0x65, /* [1307] */ - (xdc_Char)0x64, /* [1308] */ - (xdc_Char)0x2e, /* [1309] */ - (xdc_Char)0x0, /* [1310] */ - (xdc_Char)0x41, /* [1311] */ - (xdc_Char)0x5f, /* [1312] */ - (xdc_Char)0x69, /* [1313] */ - (xdc_Char)0x6e, /* [1314] */ - (xdc_Char)0x76, /* [1315] */ - (xdc_Char)0x54, /* [1316] */ - (xdc_Char)0x69, /* [1317] */ - (xdc_Char)0x6d, /* [1318] */ - (xdc_Char)0x65, /* [1319] */ - (xdc_Char)0x6f, /* [1320] */ - (xdc_Char)0x75, /* [1321] */ - (xdc_Char)0x74, /* [1322] */ - (xdc_Char)0x3a, /* [1323] */ - (xdc_Char)0x20, /* [1324] */ - (xdc_Char)0x43, /* [1325] */ - (xdc_Char)0x61, /* [1326] */ - (xdc_Char)0x6e, /* [1327] */ - (xdc_Char)0x27, /* [1328] */ - (xdc_Char)0x74, /* [1329] */ - (xdc_Char)0x20, /* [1330] */ - (xdc_Char)0x75, /* [1331] */ - (xdc_Char)0x73, /* [1332] */ - (xdc_Char)0x65, /* [1333] */ - (xdc_Char)0x20, /* [1334] */ - (xdc_Char)0x42, /* [1335] */ - (xdc_Char)0x49, /* [1336] */ - (xdc_Char)0x4f, /* [1337] */ - (xdc_Char)0x53, /* [1338] */ - (xdc_Char)0x5f, /* [1339] */ - (xdc_Char)0x45, /* [1340] */ - (xdc_Char)0x56, /* [1341] */ - (xdc_Char)0x45, /* [1342] */ - (xdc_Char)0x4e, /* [1343] */ - (xdc_Char)0x54, /* [1344] */ - (xdc_Char)0x5f, /* [1345] */ - (xdc_Char)0x41, /* [1346] */ - (xdc_Char)0x43, /* [1347] */ - (xdc_Char)0x51, /* [1348] */ - (xdc_Char)0x55, /* [1349] */ - (xdc_Char)0x49, /* [1350] */ - (xdc_Char)0x52, /* [1351] */ - (xdc_Char)0x45, /* [1352] */ - (xdc_Char)0x44, /* [1353] */ - (xdc_Char)0x20, /* [1354] */ - (xdc_Char)0x77, /* [1355] */ - (xdc_Char)0x69, /* [1356] */ - (xdc_Char)0x74, /* [1357] */ - (xdc_Char)0x68, /* [1358] */ - (xdc_Char)0x20, /* [1359] */ - (xdc_Char)0x74, /* [1360] */ - (xdc_Char)0x68, /* [1361] */ - (xdc_Char)0x69, /* [1362] */ - (xdc_Char)0x73, /* [1363] */ - (xdc_Char)0x20, /* [1364] */ - (xdc_Char)0x53, /* [1365] */ - (xdc_Char)0x65, /* [1366] */ - (xdc_Char)0x6d, /* [1367] */ - (xdc_Char)0x61, /* [1368] */ - (xdc_Char)0x70, /* [1369] */ - (xdc_Char)0x68, /* [1370] */ - (xdc_Char)0x6f, /* [1371] */ - (xdc_Char)0x72, /* [1372] */ - (xdc_Char)0x65, /* [1373] */ - (xdc_Char)0x2e, /* [1374] */ - (xdc_Char)0x0, /* [1375] */ - (xdc_Char)0x41, /* [1376] */ - (xdc_Char)0x5f, /* [1377] */ - (xdc_Char)0x6f, /* [1378] */ - (xdc_Char)0x76, /* [1379] */ - (xdc_Char)0x65, /* [1380] */ - (xdc_Char)0x72, /* [1381] */ - (xdc_Char)0x66, /* [1382] */ - (xdc_Char)0x6c, /* [1383] */ - (xdc_Char)0x6f, /* [1384] */ - (xdc_Char)0x77, /* [1385] */ - (xdc_Char)0x3a, /* [1386] */ - (xdc_Char)0x20, /* [1387] */ - (xdc_Char)0x43, /* [1388] */ - (xdc_Char)0x6f, /* [1389] */ - (xdc_Char)0x75, /* [1390] */ - (xdc_Char)0x6e, /* [1391] */ - (xdc_Char)0x74, /* [1392] */ - (xdc_Char)0x20, /* [1393] */ - (xdc_Char)0x68, /* [1394] */ - (xdc_Char)0x61, /* [1395] */ - (xdc_Char)0x73, /* [1396] */ - (xdc_Char)0x20, /* [1397] */ - (xdc_Char)0x65, /* [1398] */ - (xdc_Char)0x78, /* [1399] */ - (xdc_Char)0x63, /* [1400] */ - (xdc_Char)0x65, /* [1401] */ - (xdc_Char)0x65, /* [1402] */ - (xdc_Char)0x64, /* [1403] */ - (xdc_Char)0x65, /* [1404] */ - (xdc_Char)0x64, /* [1405] */ - (xdc_Char)0x20, /* [1406] */ - (xdc_Char)0x36, /* [1407] */ - (xdc_Char)0x35, /* [1408] */ - (xdc_Char)0x35, /* [1409] */ - (xdc_Char)0x33, /* [1410] */ - (xdc_Char)0x35, /* [1411] */ - (xdc_Char)0x20, /* [1412] */ - (xdc_Char)0x61, /* [1413] */ - (xdc_Char)0x6e, /* [1414] */ - (xdc_Char)0x64, /* [1415] */ - (xdc_Char)0x20, /* [1416] */ - (xdc_Char)0x72, /* [1417] */ - (xdc_Char)0x6f, /* [1418] */ - (xdc_Char)0x6c, /* [1419] */ - (xdc_Char)0x6c, /* [1420] */ - (xdc_Char)0x65, /* [1421] */ - (xdc_Char)0x64, /* [1422] */ - (xdc_Char)0x20, /* [1423] */ - (xdc_Char)0x6f, /* [1424] */ - (xdc_Char)0x76, /* [1425] */ - (xdc_Char)0x65, /* [1426] */ - (xdc_Char)0x72, /* [1427] */ - (xdc_Char)0x2e, /* [1428] */ - (xdc_Char)0x0, /* [1429] */ - (xdc_Char)0x41, /* [1430] */ - (xdc_Char)0x5f, /* [1431] */ - (xdc_Char)0x70, /* [1432] */ - (xdc_Char)0x65, /* [1433] */ - (xdc_Char)0x6e, /* [1434] */ - (xdc_Char)0x64, /* [1435] */ - (xdc_Char)0x54, /* [1436] */ - (xdc_Char)0x61, /* [1437] */ - (xdc_Char)0x73, /* [1438] */ - (xdc_Char)0x6b, /* [1439] */ - (xdc_Char)0x44, /* [1440] */ - (xdc_Char)0x69, /* [1441] */ - (xdc_Char)0x73, /* [1442] */ - (xdc_Char)0x61, /* [1443] */ - (xdc_Char)0x62, /* [1444] */ - (xdc_Char)0x6c, /* [1445] */ - (xdc_Char)0x65, /* [1446] */ - (xdc_Char)0x64, /* [1447] */ - (xdc_Char)0x3a, /* [1448] */ - (xdc_Char)0x20, /* [1449] */ - (xdc_Char)0x43, /* [1450] */ - (xdc_Char)0x61, /* [1451] */ - (xdc_Char)0x6e, /* [1452] */ - (xdc_Char)0x6e, /* [1453] */ - (xdc_Char)0x6f, /* [1454] */ - (xdc_Char)0x74, /* [1455] */ - (xdc_Char)0x20, /* [1456] */ - (xdc_Char)0x63, /* [1457] */ - (xdc_Char)0x61, /* [1458] */ - (xdc_Char)0x6c, /* [1459] */ - (xdc_Char)0x6c, /* [1460] */ - (xdc_Char)0x20, /* [1461] */ - (xdc_Char)0x53, /* [1462] */ - (xdc_Char)0x65, /* [1463] */ - (xdc_Char)0x6d, /* [1464] */ - (xdc_Char)0x61, /* [1465] */ - (xdc_Char)0x70, /* [1466] */ - (xdc_Char)0x68, /* [1467] */ - (xdc_Char)0x6f, /* [1468] */ - (xdc_Char)0x72, /* [1469] */ - (xdc_Char)0x65, /* [1470] */ - (xdc_Char)0x5f, /* [1471] */ - (xdc_Char)0x70, /* [1472] */ - (xdc_Char)0x65, /* [1473] */ - (xdc_Char)0x6e, /* [1474] */ - (xdc_Char)0x64, /* [1475] */ - (xdc_Char)0x28, /* [1476] */ - (xdc_Char)0x29, /* [1477] */ - (xdc_Char)0x20, /* [1478] */ - (xdc_Char)0x77, /* [1479] */ - (xdc_Char)0x68, /* [1480] */ - (xdc_Char)0x69, /* [1481] */ - (xdc_Char)0x6c, /* [1482] */ - (xdc_Char)0x65, /* [1483] */ - (xdc_Char)0x20, /* [1484] */ - (xdc_Char)0x74, /* [1485] */ - (xdc_Char)0x68, /* [1486] */ - (xdc_Char)0x65, /* [1487] */ - (xdc_Char)0x20, /* [1488] */ - (xdc_Char)0x54, /* [1489] */ - (xdc_Char)0x61, /* [1490] */ - (xdc_Char)0x73, /* [1491] */ - (xdc_Char)0x6b, /* [1492] */ - (xdc_Char)0x20, /* [1493] */ - (xdc_Char)0x6f, /* [1494] */ - (xdc_Char)0x72, /* [1495] */ - (xdc_Char)0x20, /* [1496] */ - (xdc_Char)0x53, /* [1497] */ - (xdc_Char)0x77, /* [1498] */ - (xdc_Char)0x69, /* [1499] */ - (xdc_Char)0x20, /* [1500] */ - (xdc_Char)0x73, /* [1501] */ - (xdc_Char)0x63, /* [1502] */ - (xdc_Char)0x68, /* [1503] */ - (xdc_Char)0x65, /* [1504] */ - (xdc_Char)0x64, /* [1505] */ - (xdc_Char)0x75, /* [1506] */ - (xdc_Char)0x6c, /* [1507] */ - (xdc_Char)0x65, /* [1508] */ - (xdc_Char)0x72, /* [1509] */ - (xdc_Char)0x20, /* [1510] */ - (xdc_Char)0x69, /* [1511] */ - (xdc_Char)0x73, /* [1512] */ - (xdc_Char)0x20, /* [1513] */ - (xdc_Char)0x64, /* [1514] */ - (xdc_Char)0x69, /* [1515] */ - (xdc_Char)0x73, /* [1516] */ - (xdc_Char)0x61, /* [1517] */ - (xdc_Char)0x62, /* [1518] */ - (xdc_Char)0x6c, /* [1519] */ - (xdc_Char)0x65, /* [1520] */ - (xdc_Char)0x64, /* [1521] */ - (xdc_Char)0x2e, /* [1522] */ - (xdc_Char)0x0, /* [1523] */ - (xdc_Char)0x41, /* [1524] */ - (xdc_Char)0x5f, /* [1525] */ - (xdc_Char)0x73, /* [1526] */ - (xdc_Char)0x77, /* [1527] */ - (xdc_Char)0x69, /* [1528] */ - (xdc_Char)0x44, /* [1529] */ - (xdc_Char)0x69, /* [1530] */ - (xdc_Char)0x73, /* [1531] */ - (xdc_Char)0x61, /* [1532] */ - (xdc_Char)0x62, /* [1533] */ - (xdc_Char)0x6c, /* [1534] */ - (xdc_Char)0x65, /* [1535] */ - (xdc_Char)0x64, /* [1536] */ - (xdc_Char)0x3a, /* [1537] */ - (xdc_Char)0x20, /* [1538] */ - (xdc_Char)0x43, /* [1539] */ - (xdc_Char)0x61, /* [1540] */ - (xdc_Char)0x6e, /* [1541] */ - (xdc_Char)0x6e, /* [1542] */ - (xdc_Char)0x6f, /* [1543] */ - (xdc_Char)0x74, /* [1544] */ - (xdc_Char)0x20, /* [1545] */ - (xdc_Char)0x63, /* [1546] */ - (xdc_Char)0x72, /* [1547] */ - (xdc_Char)0x65, /* [1548] */ - (xdc_Char)0x61, /* [1549] */ - (xdc_Char)0x74, /* [1550] */ - (xdc_Char)0x65, /* [1551] */ - (xdc_Char)0x20, /* [1552] */ - (xdc_Char)0x61, /* [1553] */ - (xdc_Char)0x20, /* [1554] */ - (xdc_Char)0x53, /* [1555] */ - (xdc_Char)0x77, /* [1556] */ - (xdc_Char)0x69, /* [1557] */ - (xdc_Char)0x20, /* [1558] */ - (xdc_Char)0x77, /* [1559] */ - (xdc_Char)0x68, /* [1560] */ - (xdc_Char)0x65, /* [1561] */ - (xdc_Char)0x6e, /* [1562] */ - (xdc_Char)0x20, /* [1563] */ - (xdc_Char)0x53, /* [1564] */ - (xdc_Char)0x77, /* [1565] */ - (xdc_Char)0x69, /* [1566] */ - (xdc_Char)0x20, /* [1567] */ - (xdc_Char)0x69, /* [1568] */ - (xdc_Char)0x73, /* [1569] */ - (xdc_Char)0x20, /* [1570] */ - (xdc_Char)0x64, /* [1571] */ - (xdc_Char)0x69, /* [1572] */ - (xdc_Char)0x73, /* [1573] */ - (xdc_Char)0x61, /* [1574] */ - (xdc_Char)0x62, /* [1575] */ - (xdc_Char)0x6c, /* [1576] */ - (xdc_Char)0x65, /* [1577] */ - (xdc_Char)0x64, /* [1578] */ - (xdc_Char)0x2e, /* [1579] */ - (xdc_Char)0x0, /* [1580] */ - (xdc_Char)0x41, /* [1581] */ - (xdc_Char)0x5f, /* [1582] */ - (xdc_Char)0x62, /* [1583] */ - (xdc_Char)0x61, /* [1584] */ - (xdc_Char)0x64, /* [1585] */ - (xdc_Char)0x50, /* [1586] */ - (xdc_Char)0x72, /* [1587] */ - (xdc_Char)0x69, /* [1588] */ - (xdc_Char)0x6f, /* [1589] */ - (xdc_Char)0x72, /* [1590] */ - (xdc_Char)0x69, /* [1591] */ - (xdc_Char)0x74, /* [1592] */ - (xdc_Char)0x79, /* [1593] */ - (xdc_Char)0x3a, /* [1594] */ - (xdc_Char)0x20, /* [1595] */ - (xdc_Char)0x41, /* [1596] */ - (xdc_Char)0x6e, /* [1597] */ - (xdc_Char)0x20, /* [1598] */ - (xdc_Char)0x69, /* [1599] */ - (xdc_Char)0x6e, /* [1600] */ - (xdc_Char)0x76, /* [1601] */ - (xdc_Char)0x61, /* [1602] */ - (xdc_Char)0x6c, /* [1603] */ - (xdc_Char)0x69, /* [1604] */ - (xdc_Char)0x64, /* [1605] */ - (xdc_Char)0x20, /* [1606] */ - (xdc_Char)0x53, /* [1607] */ - (xdc_Char)0x77, /* [1608] */ - (xdc_Char)0x69, /* [1609] */ - (xdc_Char)0x20, /* [1610] */ - (xdc_Char)0x70, /* [1611] */ - (xdc_Char)0x72, /* [1612] */ - (xdc_Char)0x69, /* [1613] */ - (xdc_Char)0x6f, /* [1614] */ - (xdc_Char)0x72, /* [1615] */ - (xdc_Char)0x69, /* [1616] */ - (xdc_Char)0x74, /* [1617] */ - (xdc_Char)0x79, /* [1618] */ - (xdc_Char)0x20, /* [1619] */ - (xdc_Char)0x77, /* [1620] */ - (xdc_Char)0x61, /* [1621] */ - (xdc_Char)0x73, /* [1622] */ - (xdc_Char)0x20, /* [1623] */ - (xdc_Char)0x75, /* [1624] */ - (xdc_Char)0x73, /* [1625] */ - (xdc_Char)0x65, /* [1626] */ - (xdc_Char)0x64, /* [1627] */ - (xdc_Char)0x2e, /* [1628] */ - (xdc_Char)0x0, /* [1629] */ - (xdc_Char)0x41, /* [1630] */ - (xdc_Char)0x5f, /* [1631] */ - (xdc_Char)0x62, /* [1632] */ - (xdc_Char)0x61, /* [1633] */ - (xdc_Char)0x64, /* [1634] */ - (xdc_Char)0x54, /* [1635] */ - (xdc_Char)0x68, /* [1636] */ - (xdc_Char)0x72, /* [1637] */ - (xdc_Char)0x65, /* [1638] */ - (xdc_Char)0x61, /* [1639] */ - (xdc_Char)0x64, /* [1640] */ - (xdc_Char)0x54, /* [1641] */ - (xdc_Char)0x79, /* [1642] */ - (xdc_Char)0x70, /* [1643] */ - (xdc_Char)0x65, /* [1644] */ - (xdc_Char)0x3a, /* [1645] */ - (xdc_Char)0x20, /* [1646] */ - (xdc_Char)0x43, /* [1647] */ - (xdc_Char)0x61, /* [1648] */ - (xdc_Char)0x6e, /* [1649] */ - (xdc_Char)0x6e, /* [1650] */ - (xdc_Char)0x6f, /* [1651] */ - (xdc_Char)0x74, /* [1652] */ - (xdc_Char)0x20, /* [1653] */ - (xdc_Char)0x63, /* [1654] */ - (xdc_Char)0x72, /* [1655] */ - (xdc_Char)0x65, /* [1656] */ - (xdc_Char)0x61, /* [1657] */ - (xdc_Char)0x74, /* [1658] */ - (xdc_Char)0x65, /* [1659] */ - (xdc_Char)0x2f, /* [1660] */ - (xdc_Char)0x64, /* [1661] */ - (xdc_Char)0x65, /* [1662] */ - (xdc_Char)0x6c, /* [1663] */ - (xdc_Char)0x65, /* [1664] */ - (xdc_Char)0x74, /* [1665] */ - (xdc_Char)0x65, /* [1666] */ - (xdc_Char)0x20, /* [1667] */ - (xdc_Char)0x61, /* [1668] */ - (xdc_Char)0x20, /* [1669] */ - (xdc_Char)0x74, /* [1670] */ - (xdc_Char)0x61, /* [1671] */ - (xdc_Char)0x73, /* [1672] */ - (xdc_Char)0x6b, /* [1673] */ - (xdc_Char)0x20, /* [1674] */ - (xdc_Char)0x66, /* [1675] */ - (xdc_Char)0x72, /* [1676] */ - (xdc_Char)0x6f, /* [1677] */ - (xdc_Char)0x6d, /* [1678] */ - (xdc_Char)0x20, /* [1679] */ - (xdc_Char)0x48, /* [1680] */ - (xdc_Char)0x77, /* [1681] */ - (xdc_Char)0x69, /* [1682] */ - (xdc_Char)0x20, /* [1683] */ - (xdc_Char)0x6f, /* [1684] */ - (xdc_Char)0x72, /* [1685] */ - (xdc_Char)0x20, /* [1686] */ - (xdc_Char)0x53, /* [1687] */ - (xdc_Char)0x77, /* [1688] */ - (xdc_Char)0x69, /* [1689] */ - (xdc_Char)0x20, /* [1690] */ - (xdc_Char)0x74, /* [1691] */ - (xdc_Char)0x68, /* [1692] */ - (xdc_Char)0x72, /* [1693] */ - (xdc_Char)0x65, /* [1694] */ - (xdc_Char)0x61, /* [1695] */ - (xdc_Char)0x64, /* [1696] */ - (xdc_Char)0x2e, /* [1697] */ - (xdc_Char)0x0, /* [1698] */ - (xdc_Char)0x41, /* [1699] */ - (xdc_Char)0x5f, /* [1700] */ - (xdc_Char)0x62, /* [1701] */ - (xdc_Char)0x61, /* [1702] */ - (xdc_Char)0x64, /* [1703] */ - (xdc_Char)0x54, /* [1704] */ - (xdc_Char)0x61, /* [1705] */ - (xdc_Char)0x73, /* [1706] */ - (xdc_Char)0x6b, /* [1707] */ - (xdc_Char)0x53, /* [1708] */ - (xdc_Char)0x74, /* [1709] */ - (xdc_Char)0x61, /* [1710] */ - (xdc_Char)0x74, /* [1711] */ - (xdc_Char)0x65, /* [1712] */ - (xdc_Char)0x3a, /* [1713] */ - (xdc_Char)0x20, /* [1714] */ - (xdc_Char)0x43, /* [1715] */ - (xdc_Char)0x61, /* [1716] */ - (xdc_Char)0x6e, /* [1717] */ - (xdc_Char)0x27, /* [1718] */ - (xdc_Char)0x74, /* [1719] */ - (xdc_Char)0x20, /* [1720] */ - (xdc_Char)0x64, /* [1721] */ - (xdc_Char)0x65, /* [1722] */ - (xdc_Char)0x6c, /* [1723] */ - (xdc_Char)0x65, /* [1724] */ - (xdc_Char)0x74, /* [1725] */ - (xdc_Char)0x65, /* [1726] */ - (xdc_Char)0x20, /* [1727] */ - (xdc_Char)0x61, /* [1728] */ - (xdc_Char)0x20, /* [1729] */ - (xdc_Char)0x74, /* [1730] */ - (xdc_Char)0x61, /* [1731] */ - (xdc_Char)0x73, /* [1732] */ - (xdc_Char)0x6b, /* [1733] */ - (xdc_Char)0x20, /* [1734] */ - (xdc_Char)0x69, /* [1735] */ - (xdc_Char)0x6e, /* [1736] */ - (xdc_Char)0x20, /* [1737] */ - (xdc_Char)0x52, /* [1738] */ - (xdc_Char)0x55, /* [1739] */ - (xdc_Char)0x4e, /* [1740] */ - (xdc_Char)0x4e, /* [1741] */ - (xdc_Char)0x49, /* [1742] */ - (xdc_Char)0x4e, /* [1743] */ - (xdc_Char)0x47, /* [1744] */ - (xdc_Char)0x20, /* [1745] */ - (xdc_Char)0x73, /* [1746] */ - (xdc_Char)0x74, /* [1747] */ - (xdc_Char)0x61, /* [1748] */ - (xdc_Char)0x74, /* [1749] */ - (xdc_Char)0x65, /* [1750] */ - (xdc_Char)0x2e, /* [1751] */ - (xdc_Char)0x0, /* [1752] */ - (xdc_Char)0x41, /* [1753] */ - (xdc_Char)0x5f, /* [1754] */ - (xdc_Char)0x6e, /* [1755] */ - (xdc_Char)0x6f, /* [1756] */ - (xdc_Char)0x50, /* [1757] */ - (xdc_Char)0x65, /* [1758] */ - (xdc_Char)0x6e, /* [1759] */ - (xdc_Char)0x64, /* [1760] */ - (xdc_Char)0x45, /* [1761] */ - (xdc_Char)0x6c, /* [1762] */ - (xdc_Char)0x65, /* [1763] */ - (xdc_Char)0x6d, /* [1764] */ - (xdc_Char)0x3a, /* [1765] */ - (xdc_Char)0x20, /* [1766] */ - (xdc_Char)0x4e, /* [1767] */ - (xdc_Char)0x6f, /* [1768] */ - (xdc_Char)0x74, /* [1769] */ - (xdc_Char)0x20, /* [1770] */ - (xdc_Char)0x65, /* [1771] */ - (xdc_Char)0x6e, /* [1772] */ - (xdc_Char)0x6f, /* [1773] */ - (xdc_Char)0x75, /* [1774] */ - (xdc_Char)0x67, /* [1775] */ - (xdc_Char)0x68, /* [1776] */ - (xdc_Char)0x20, /* [1777] */ - (xdc_Char)0x69, /* [1778] */ - (xdc_Char)0x6e, /* [1779] */ - (xdc_Char)0x66, /* [1780] */ - (xdc_Char)0x6f, /* [1781] */ - (xdc_Char)0x20, /* [1782] */ - (xdc_Char)0x74, /* [1783] */ - (xdc_Char)0x6f, /* [1784] */ - (xdc_Char)0x20, /* [1785] */ - (xdc_Char)0x64, /* [1786] */ - (xdc_Char)0x65, /* [1787] */ - (xdc_Char)0x6c, /* [1788] */ - (xdc_Char)0x65, /* [1789] */ - (xdc_Char)0x74, /* [1790] */ - (xdc_Char)0x65, /* [1791] */ - (xdc_Char)0x20, /* [1792] */ - (xdc_Char)0x42, /* [1793] */ - (xdc_Char)0x4c, /* [1794] */ - (xdc_Char)0x4f, /* [1795] */ - (xdc_Char)0x43, /* [1796] */ - (xdc_Char)0x4b, /* [1797] */ - (xdc_Char)0x45, /* [1798] */ - (xdc_Char)0x44, /* [1799] */ - (xdc_Char)0x20, /* [1800] */ - (xdc_Char)0x74, /* [1801] */ - (xdc_Char)0x61, /* [1802] */ - (xdc_Char)0x73, /* [1803] */ - (xdc_Char)0x6b, /* [1804] */ - (xdc_Char)0x2e, /* [1805] */ - (xdc_Char)0x0, /* [1806] */ - (xdc_Char)0x41, /* [1807] */ - (xdc_Char)0x5f, /* [1808] */ - (xdc_Char)0x74, /* [1809] */ - (xdc_Char)0x61, /* [1810] */ - (xdc_Char)0x73, /* [1811] */ - (xdc_Char)0x6b, /* [1812] */ - (xdc_Char)0x44, /* [1813] */ - (xdc_Char)0x69, /* [1814] */ - (xdc_Char)0x73, /* [1815] */ - (xdc_Char)0x61, /* [1816] */ - (xdc_Char)0x62, /* [1817] */ - (xdc_Char)0x6c, /* [1818] */ - (xdc_Char)0x65, /* [1819] */ - (xdc_Char)0x64, /* [1820] */ - (xdc_Char)0x3a, /* [1821] */ - (xdc_Char)0x20, /* [1822] */ - (xdc_Char)0x43, /* [1823] */ - (xdc_Char)0x61, /* [1824] */ - (xdc_Char)0x6e, /* [1825] */ - (xdc_Char)0x6e, /* [1826] */ - (xdc_Char)0x6f, /* [1827] */ - (xdc_Char)0x74, /* [1828] */ - (xdc_Char)0x20, /* [1829] */ - (xdc_Char)0x63, /* [1830] */ - (xdc_Char)0x72, /* [1831] */ - (xdc_Char)0x65, /* [1832] */ - (xdc_Char)0x61, /* [1833] */ - (xdc_Char)0x74, /* [1834] */ - (xdc_Char)0x65, /* [1835] */ - (xdc_Char)0x20, /* [1836] */ - (xdc_Char)0x61, /* [1837] */ - (xdc_Char)0x20, /* [1838] */ - (xdc_Char)0x74, /* [1839] */ - (xdc_Char)0x61, /* [1840] */ - (xdc_Char)0x73, /* [1841] */ - (xdc_Char)0x6b, /* [1842] */ - (xdc_Char)0x20, /* [1843] */ - (xdc_Char)0x77, /* [1844] */ - (xdc_Char)0x68, /* [1845] */ - (xdc_Char)0x65, /* [1846] */ - (xdc_Char)0x6e, /* [1847] */ - (xdc_Char)0x20, /* [1848] */ - (xdc_Char)0x74, /* [1849] */ - (xdc_Char)0x61, /* [1850] */ - (xdc_Char)0x73, /* [1851] */ - (xdc_Char)0x6b, /* [1852] */ - (xdc_Char)0x69, /* [1853] */ - (xdc_Char)0x6e, /* [1854] */ - (xdc_Char)0x67, /* [1855] */ - (xdc_Char)0x20, /* [1856] */ - (xdc_Char)0x69, /* [1857] */ - (xdc_Char)0x73, /* [1858] */ - (xdc_Char)0x20, /* [1859] */ - (xdc_Char)0x64, /* [1860] */ - (xdc_Char)0x69, /* [1861] */ - (xdc_Char)0x73, /* [1862] */ - (xdc_Char)0x61, /* [1863] */ - (xdc_Char)0x62, /* [1864] */ - (xdc_Char)0x6c, /* [1865] */ - (xdc_Char)0x65, /* [1866] */ - (xdc_Char)0x64, /* [1867] */ - (xdc_Char)0x2e, /* [1868] */ - (xdc_Char)0x0, /* [1869] */ - (xdc_Char)0x41, /* [1870] */ - (xdc_Char)0x5f, /* [1871] */ - (xdc_Char)0x62, /* [1872] */ - (xdc_Char)0x61, /* [1873] */ - (xdc_Char)0x64, /* [1874] */ - (xdc_Char)0x50, /* [1875] */ - (xdc_Char)0x72, /* [1876] */ - (xdc_Char)0x69, /* [1877] */ - (xdc_Char)0x6f, /* [1878] */ - (xdc_Char)0x72, /* [1879] */ - (xdc_Char)0x69, /* [1880] */ - (xdc_Char)0x74, /* [1881] */ - (xdc_Char)0x79, /* [1882] */ - (xdc_Char)0x3a, /* [1883] */ - (xdc_Char)0x20, /* [1884] */ - (xdc_Char)0x41, /* [1885] */ - (xdc_Char)0x6e, /* [1886] */ - (xdc_Char)0x20, /* [1887] */ - (xdc_Char)0x69, /* [1888] */ - (xdc_Char)0x6e, /* [1889] */ - (xdc_Char)0x76, /* [1890] */ - (xdc_Char)0x61, /* [1891] */ - (xdc_Char)0x6c, /* [1892] */ - (xdc_Char)0x69, /* [1893] */ - (xdc_Char)0x64, /* [1894] */ - (xdc_Char)0x20, /* [1895] */ - (xdc_Char)0x74, /* [1896] */ - (xdc_Char)0x61, /* [1897] */ - (xdc_Char)0x73, /* [1898] */ - (xdc_Char)0x6b, /* [1899] */ - (xdc_Char)0x20, /* [1900] */ - (xdc_Char)0x70, /* [1901] */ - (xdc_Char)0x72, /* [1902] */ - (xdc_Char)0x69, /* [1903] */ - (xdc_Char)0x6f, /* [1904] */ - (xdc_Char)0x72, /* [1905] */ - (xdc_Char)0x69, /* [1906] */ - (xdc_Char)0x74, /* [1907] */ - (xdc_Char)0x79, /* [1908] */ - (xdc_Char)0x20, /* [1909] */ - (xdc_Char)0x77, /* [1910] */ - (xdc_Char)0x61, /* [1911] */ - (xdc_Char)0x73, /* [1912] */ - (xdc_Char)0x20, /* [1913] */ - (xdc_Char)0x75, /* [1914] */ - (xdc_Char)0x73, /* [1915] */ - (xdc_Char)0x65, /* [1916] */ - (xdc_Char)0x64, /* [1917] */ - (xdc_Char)0x2e, /* [1918] */ - (xdc_Char)0x0, /* [1919] */ - (xdc_Char)0x41, /* [1920] */ - (xdc_Char)0x5f, /* [1921] */ - (xdc_Char)0x62, /* [1922] */ - (xdc_Char)0x61, /* [1923] */ - (xdc_Char)0x64, /* [1924] */ - (xdc_Char)0x54, /* [1925] */ - (xdc_Char)0x69, /* [1926] */ - (xdc_Char)0x6d, /* [1927] */ - (xdc_Char)0x65, /* [1928] */ - (xdc_Char)0x6f, /* [1929] */ - (xdc_Char)0x75, /* [1930] */ - (xdc_Char)0x74, /* [1931] */ - (xdc_Char)0x3a, /* [1932] */ - (xdc_Char)0x20, /* [1933] */ - (xdc_Char)0x43, /* [1934] */ - (xdc_Char)0x61, /* [1935] */ - (xdc_Char)0x6e, /* [1936] */ - (xdc_Char)0x27, /* [1937] */ - (xdc_Char)0x74, /* [1938] */ - (xdc_Char)0x20, /* [1939] */ - (xdc_Char)0x73, /* [1940] */ - (xdc_Char)0x6c, /* [1941] */ - (xdc_Char)0x65, /* [1942] */ - (xdc_Char)0x65, /* [1943] */ - (xdc_Char)0x70, /* [1944] */ - (xdc_Char)0x20, /* [1945] */ - (xdc_Char)0x46, /* [1946] */ - (xdc_Char)0x4f, /* [1947] */ - (xdc_Char)0x52, /* [1948] */ - (xdc_Char)0x45, /* [1949] */ - (xdc_Char)0x56, /* [1950] */ - (xdc_Char)0x45, /* [1951] */ - (xdc_Char)0x52, /* [1952] */ - (xdc_Char)0x2e, /* [1953] */ - (xdc_Char)0x0, /* [1954] */ - (xdc_Char)0x41, /* [1955] */ - (xdc_Char)0x5f, /* [1956] */ - (xdc_Char)0x62, /* [1957] */ - (xdc_Char)0x61, /* [1958] */ - (xdc_Char)0x64, /* [1959] */ - (xdc_Char)0x41, /* [1960] */ - (xdc_Char)0x66, /* [1961] */ - (xdc_Char)0x66, /* [1962] */ - (xdc_Char)0x69, /* [1963] */ - (xdc_Char)0x6e, /* [1964] */ - (xdc_Char)0x69, /* [1965] */ - (xdc_Char)0x74, /* [1966] */ - (xdc_Char)0x79, /* [1967] */ - (xdc_Char)0x3a, /* [1968] */ - (xdc_Char)0x20, /* [1969] */ - (xdc_Char)0x49, /* [1970] */ - (xdc_Char)0x6e, /* [1971] */ - (xdc_Char)0x76, /* [1972] */ - (xdc_Char)0x61, /* [1973] */ - (xdc_Char)0x6c, /* [1974] */ - (xdc_Char)0x69, /* [1975] */ - (xdc_Char)0x64, /* [1976] */ - (xdc_Char)0x20, /* [1977] */ - (xdc_Char)0x61, /* [1978] */ - (xdc_Char)0x66, /* [1979] */ - (xdc_Char)0x66, /* [1980] */ - (xdc_Char)0x69, /* [1981] */ - (xdc_Char)0x6e, /* [1982] */ - (xdc_Char)0x69, /* [1983] */ - (xdc_Char)0x74, /* [1984] */ - (xdc_Char)0x79, /* [1985] */ - (xdc_Char)0x2e, /* [1986] */ - (xdc_Char)0x0, /* [1987] */ - (xdc_Char)0x41, /* [1988] */ - (xdc_Char)0x5f, /* [1989] */ - (xdc_Char)0x73, /* [1990] */ - (xdc_Char)0x6c, /* [1991] */ - (xdc_Char)0x65, /* [1992] */ - (xdc_Char)0x65, /* [1993] */ - (xdc_Char)0x70, /* [1994] */ - (xdc_Char)0x54, /* [1995] */ - (xdc_Char)0x61, /* [1996] */ - (xdc_Char)0x73, /* [1997] */ - (xdc_Char)0x6b, /* [1998] */ - (xdc_Char)0x44, /* [1999] */ - (xdc_Char)0x69, /* [2000] */ - (xdc_Char)0x73, /* [2001] */ - (xdc_Char)0x61, /* [2002] */ - (xdc_Char)0x62, /* [2003] */ - (xdc_Char)0x6c, /* [2004] */ - (xdc_Char)0x65, /* [2005] */ - (xdc_Char)0x64, /* [2006] */ - (xdc_Char)0x3a, /* [2007] */ - (xdc_Char)0x20, /* [2008] */ - (xdc_Char)0x43, /* [2009] */ - (xdc_Char)0x61, /* [2010] */ - (xdc_Char)0x6e, /* [2011] */ - (xdc_Char)0x6e, /* [2012] */ - (xdc_Char)0x6f, /* [2013] */ - (xdc_Char)0x74, /* [2014] */ - (xdc_Char)0x20, /* [2015] */ - (xdc_Char)0x63, /* [2016] */ - (xdc_Char)0x61, /* [2017] */ - (xdc_Char)0x6c, /* [2018] */ - (xdc_Char)0x6c, /* [2019] */ - (xdc_Char)0x20, /* [2020] */ - (xdc_Char)0x54, /* [2021] */ - (xdc_Char)0x61, /* [2022] */ - (xdc_Char)0x73, /* [2023] */ - (xdc_Char)0x6b, /* [2024] */ - (xdc_Char)0x5f, /* [2025] */ - (xdc_Char)0x73, /* [2026] */ - (xdc_Char)0x6c, /* [2027] */ - (xdc_Char)0x65, /* [2028] */ - (xdc_Char)0x65, /* [2029] */ - (xdc_Char)0x70, /* [2030] */ - (xdc_Char)0x28, /* [2031] */ - (xdc_Char)0x29, /* [2032] */ - (xdc_Char)0x20, /* [2033] */ - (xdc_Char)0x77, /* [2034] */ - (xdc_Char)0x68, /* [2035] */ - (xdc_Char)0x69, /* [2036] */ - (xdc_Char)0x6c, /* [2037] */ - (xdc_Char)0x65, /* [2038] */ - (xdc_Char)0x20, /* [2039] */ - (xdc_Char)0x74, /* [2040] */ - (xdc_Char)0x68, /* [2041] */ - (xdc_Char)0x65, /* [2042] */ - (xdc_Char)0x20, /* [2043] */ - (xdc_Char)0x54, /* [2044] */ - (xdc_Char)0x61, /* [2045] */ - (xdc_Char)0x73, /* [2046] */ - (xdc_Char)0x6b, /* [2047] */ - (xdc_Char)0x20, /* [2048] */ - (xdc_Char)0x73, /* [2049] */ - (xdc_Char)0x63, /* [2050] */ - (xdc_Char)0x68, /* [2051] */ - (xdc_Char)0x65, /* [2052] */ - (xdc_Char)0x64, /* [2053] */ - (xdc_Char)0x75, /* [2054] */ - (xdc_Char)0x6c, /* [2055] */ - (xdc_Char)0x65, /* [2056] */ - (xdc_Char)0x72, /* [2057] */ - (xdc_Char)0x20, /* [2058] */ - (xdc_Char)0x69, /* [2059] */ - (xdc_Char)0x73, /* [2060] */ - (xdc_Char)0x20, /* [2061] */ - (xdc_Char)0x64, /* [2062] */ - (xdc_Char)0x69, /* [2063] */ - (xdc_Char)0x73, /* [2064] */ - (xdc_Char)0x61, /* [2065] */ - (xdc_Char)0x62, /* [2066] */ - (xdc_Char)0x6c, /* [2067] */ - (xdc_Char)0x65, /* [2068] */ - (xdc_Char)0x64, /* [2069] */ - (xdc_Char)0x2e, /* [2070] */ - (xdc_Char)0x0, /* [2071] */ - (xdc_Char)0x41, /* [2072] */ - (xdc_Char)0x5f, /* [2073] */ - (xdc_Char)0x69, /* [2074] */ - (xdc_Char)0x6e, /* [2075] */ - (xdc_Char)0x76, /* [2076] */ - (xdc_Char)0x61, /* [2077] */ - (xdc_Char)0x6c, /* [2078] */ - (xdc_Char)0x69, /* [2079] */ - (xdc_Char)0x64, /* [2080] */ - (xdc_Char)0x43, /* [2081] */ - (xdc_Char)0x6f, /* [2082] */ - (xdc_Char)0x72, /* [2083] */ - (xdc_Char)0x65, /* [2084] */ - (xdc_Char)0x49, /* [2085] */ - (xdc_Char)0x64, /* [2086] */ - (xdc_Char)0x3a, /* [2087] */ - (xdc_Char)0x20, /* [2088] */ - (xdc_Char)0x43, /* [2089] */ - (xdc_Char)0x61, /* [2090] */ - (xdc_Char)0x6e, /* [2091] */ - (xdc_Char)0x6e, /* [2092] */ - (xdc_Char)0x6f, /* [2093] */ - (xdc_Char)0x74, /* [2094] */ - (xdc_Char)0x20, /* [2095] */ - (xdc_Char)0x70, /* [2096] */ - (xdc_Char)0x61, /* [2097] */ - (xdc_Char)0x73, /* [2098] */ - (xdc_Char)0x73, /* [2099] */ - (xdc_Char)0x20, /* [2100] */ - (xdc_Char)0x61, /* [2101] */ - (xdc_Char)0x20, /* [2102] */ - (xdc_Char)0x6e, /* [2103] */ - (xdc_Char)0x6f, /* [2104] */ - (xdc_Char)0x6e, /* [2105] */ - (xdc_Char)0x2d, /* [2106] */ - (xdc_Char)0x7a, /* [2107] */ - (xdc_Char)0x65, /* [2108] */ - (xdc_Char)0x72, /* [2109] */ - (xdc_Char)0x6f, /* [2110] */ - (xdc_Char)0x20, /* [2111] */ - (xdc_Char)0x43, /* [2112] */ - (xdc_Char)0x6f, /* [2113] */ - (xdc_Char)0x72, /* [2114] */ - (xdc_Char)0x65, /* [2115] */ - (xdc_Char)0x49, /* [2116] */ - (xdc_Char)0x64, /* [2117] */ - (xdc_Char)0x20, /* [2118] */ - (xdc_Char)0x69, /* [2119] */ - (xdc_Char)0x6e, /* [2120] */ - (xdc_Char)0x20, /* [2121] */ - (xdc_Char)0x61, /* [2122] */ - (xdc_Char)0x20, /* [2123] */ - (xdc_Char)0x6e, /* [2124] */ - (xdc_Char)0x6f, /* [2125] */ - (xdc_Char)0x6e, /* [2126] */ - (xdc_Char)0x2d, /* [2127] */ - (xdc_Char)0x53, /* [2128] */ - (xdc_Char)0x4d, /* [2129] */ - (xdc_Char)0x50, /* [2130] */ - (xdc_Char)0x20, /* [2131] */ - (xdc_Char)0x61, /* [2132] */ - (xdc_Char)0x70, /* [2133] */ - (xdc_Char)0x70, /* [2134] */ - (xdc_Char)0x6c, /* [2135] */ - (xdc_Char)0x69, /* [2136] */ - (xdc_Char)0x63, /* [2137] */ - (xdc_Char)0x61, /* [2138] */ - (xdc_Char)0x74, /* [2139] */ - (xdc_Char)0x69, /* [2140] */ - (xdc_Char)0x6f, /* [2141] */ - (xdc_Char)0x6e, /* [2142] */ - (xdc_Char)0x2e, /* [2143] */ - (xdc_Char)0x0, /* [2144] */ - (xdc_Char)0x41, /* [2145] */ - (xdc_Char)0x5f, /* [2146] */ - (xdc_Char)0x7a, /* [2147] */ - (xdc_Char)0x65, /* [2148] */ - (xdc_Char)0x72, /* [2149] */ - (xdc_Char)0x6f, /* [2150] */ - (xdc_Char)0x54, /* [2151] */ - (xdc_Char)0x69, /* [2152] */ - (xdc_Char)0x6d, /* [2153] */ - (xdc_Char)0x65, /* [2154] */ - (xdc_Char)0x6f, /* [2155] */ - (xdc_Char)0x75, /* [2156] */ - (xdc_Char)0x74, /* [2157] */ - (xdc_Char)0x3a, /* [2158] */ - (xdc_Char)0x20, /* [2159] */ - (xdc_Char)0x54, /* [2160] */ - (xdc_Char)0x69, /* [2161] */ - (xdc_Char)0x6d, /* [2162] */ - (xdc_Char)0x65, /* [2163] */ - (xdc_Char)0x6f, /* [2164] */ - (xdc_Char)0x75, /* [2165] */ - (xdc_Char)0x74, /* [2166] */ - (xdc_Char)0x20, /* [2167] */ - (xdc_Char)0x76, /* [2168] */ - (xdc_Char)0x61, /* [2169] */ - (xdc_Char)0x6c, /* [2170] */ - (xdc_Char)0x75, /* [2171] */ - (xdc_Char)0x65, /* [2172] */ - (xdc_Char)0x20, /* [2173] */ - (xdc_Char)0x61, /* [2174] */ - (xdc_Char)0x6e, /* [2175] */ - (xdc_Char)0x6e, /* [2176] */ - (xdc_Char)0x6f, /* [2177] */ - (xdc_Char)0x74, /* [2178] */ - (xdc_Char)0x20, /* [2179] */ - (xdc_Char)0x62, /* [2180] */ - (xdc_Char)0x65, /* [2181] */ - (xdc_Char)0x20, /* [2182] */ - (xdc_Char)0x7a, /* [2183] */ - (xdc_Char)0x65, /* [2184] */ - (xdc_Char)0x72, /* [2185] */ - (xdc_Char)0x6f, /* [2186] */ - (xdc_Char)0x0, /* [2187] */ - (xdc_Char)0x41, /* [2188] */ - (xdc_Char)0x5f, /* [2189] */ - (xdc_Char)0x69, /* [2190] */ - (xdc_Char)0x6e, /* [2191] */ - (xdc_Char)0x76, /* [2192] */ - (xdc_Char)0x61, /* [2193] */ - (xdc_Char)0x6c, /* [2194] */ - (xdc_Char)0x69, /* [2195] */ - (xdc_Char)0x64, /* [2196] */ - (xdc_Char)0x4b, /* [2197] */ - (xdc_Char)0x65, /* [2198] */ - (xdc_Char)0x79, /* [2199] */ - (xdc_Char)0x3a, /* [2200] */ - (xdc_Char)0x20, /* [2201] */ - (xdc_Char)0x74, /* [2202] */ - (xdc_Char)0x68, /* [2203] */ - (xdc_Char)0x65, /* [2204] */ - (xdc_Char)0x20, /* [2205] */ - (xdc_Char)0x6b, /* [2206] */ - (xdc_Char)0x65, /* [2207] */ - (xdc_Char)0x79, /* [2208] */ - (xdc_Char)0x20, /* [2209] */ - (xdc_Char)0x6d, /* [2210] */ - (xdc_Char)0x75, /* [2211] */ - (xdc_Char)0x73, /* [2212] */ - (xdc_Char)0x74, /* [2213] */ - (xdc_Char)0x20, /* [2214] */ - (xdc_Char)0x62, /* [2215] */ - (xdc_Char)0x65, /* [2216] */ - (xdc_Char)0x20, /* [2217] */ - (xdc_Char)0x73, /* [2218] */ - (xdc_Char)0x65, /* [2219] */ - (xdc_Char)0x74, /* [2220] */ - (xdc_Char)0x20, /* [2221] */ - (xdc_Char)0x74, /* [2222] */ - (xdc_Char)0x6f, /* [2223] */ - (xdc_Char)0x20, /* [2224] */ - (xdc_Char)0x61, /* [2225] */ - (xdc_Char)0x20, /* [2226] */ - (xdc_Char)0x6e, /* [2227] */ - (xdc_Char)0x6f, /* [2228] */ - (xdc_Char)0x6e, /* [2229] */ - (xdc_Char)0x2d, /* [2230] */ - (xdc_Char)0x64, /* [2231] */ - (xdc_Char)0x65, /* [2232] */ - (xdc_Char)0x66, /* [2233] */ - (xdc_Char)0x61, /* [2234] */ - (xdc_Char)0x75, /* [2235] */ - (xdc_Char)0x6c, /* [2236] */ - (xdc_Char)0x74, /* [2237] */ - (xdc_Char)0x20, /* [2238] */ - (xdc_Char)0x76, /* [2239] */ - (xdc_Char)0x61, /* [2240] */ - (xdc_Char)0x6c, /* [2241] */ - (xdc_Char)0x75, /* [2242] */ - (xdc_Char)0x65, /* [2243] */ - (xdc_Char)0x0, /* [2244] */ - (xdc_Char)0x41, /* [2245] */ - (xdc_Char)0x5f, /* [2246] */ - (xdc_Char)0x62, /* [2247] */ - (xdc_Char)0x61, /* [2248] */ - (xdc_Char)0x64, /* [2249] */ - (xdc_Char)0x4d, /* [2250] */ - (xdc_Char)0x6f, /* [2251] */ - (xdc_Char)0x64, /* [2252] */ - (xdc_Char)0x65, /* [2253] */ - (xdc_Char)0x6c, /* [2254] */ - (xdc_Char)0x3a, /* [2255] */ - (xdc_Char)0x20, /* [2256] */ - (xdc_Char)0x69, /* [2257] */ - (xdc_Char)0x6e, /* [2258] */ - (xdc_Char)0x76, /* [2259] */ - (xdc_Char)0x61, /* [2260] */ - (xdc_Char)0x6c, /* [2261] */ - (xdc_Char)0x69, /* [2262] */ - (xdc_Char)0x64, /* [2263] */ - (xdc_Char)0x20, /* [2264] */ - (xdc_Char)0x75, /* [2265] */ - (xdc_Char)0x73, /* [2266] */ - (xdc_Char)0x65, /* [2267] */ - (xdc_Char)0x20, /* [2268] */ - (xdc_Char)0x6f, /* [2269] */ - (xdc_Char)0x66, /* [2270] */ - (xdc_Char)0x20, /* [2271] */ - (xdc_Char)0x41, /* [2272] */ - (xdc_Char)0x50, /* [2273] */ - (xdc_Char)0x49, /* [2274] */ - (xdc_Char)0x20, /* [2275] */ - (xdc_Char)0x66, /* [2276] */ - (xdc_Char)0x6f, /* [2277] */ - (xdc_Char)0x72, /* [2278] */ - (xdc_Char)0x20, /* [2279] */ - (xdc_Char)0x63, /* [2280] */ - (xdc_Char)0x75, /* [2281] */ - (xdc_Char)0x72, /* [2282] */ - (xdc_Char)0x72, /* [2283] */ - (xdc_Char)0x65, /* [2284] */ - (xdc_Char)0x6e, /* [2285] */ - (xdc_Char)0x74, /* [2286] */ - (xdc_Char)0x20, /* [2287] */ - (xdc_Char)0x49, /* [2288] */ - (xdc_Char)0x2f, /* [2289] */ - (xdc_Char)0x4f, /* [2290] */ - (xdc_Char)0x20, /* [2291] */ - (xdc_Char)0x6d, /* [2292] */ - (xdc_Char)0x6f, /* [2293] */ - (xdc_Char)0x64, /* [2294] */ - (xdc_Char)0x65, /* [2295] */ - (xdc_Char)0x6c, /* [2296] */ - (xdc_Char)0x0, /* [2297] */ - (xdc_Char)0x41, /* [2298] */ - (xdc_Char)0x5f, /* [2299] */ - (xdc_Char)0x62, /* [2300] */ - (xdc_Char)0x61, /* [2301] */ - (xdc_Char)0x64, /* [2302] */ - (xdc_Char)0x43, /* [2303] */ - (xdc_Char)0x6f, /* [2304] */ - (xdc_Char)0x6e, /* [2305] */ - (xdc_Char)0x74, /* [2306] */ - (xdc_Char)0x65, /* [2307] */ - (xdc_Char)0x78, /* [2308] */ - (xdc_Char)0x74, /* [2309] */ - (xdc_Char)0x3a, /* [2310] */ - (xdc_Char)0x20, /* [2311] */ - (xdc_Char)0x62, /* [2312] */ - (xdc_Char)0x61, /* [2313] */ - (xdc_Char)0x64, /* [2314] */ - (xdc_Char)0x20, /* [2315] */ - (xdc_Char)0x63, /* [2316] */ - (xdc_Char)0x61, /* [2317] */ - (xdc_Char)0x6c, /* [2318] */ - (xdc_Char)0x6c, /* [2319] */ - (xdc_Char)0x69, /* [2320] */ - (xdc_Char)0x6e, /* [2321] */ - (xdc_Char)0x67, /* [2322] */ - (xdc_Char)0x20, /* [2323] */ - (xdc_Char)0x63, /* [2324] */ - (xdc_Char)0x6f, /* [2325] */ - (xdc_Char)0x6e, /* [2326] */ - (xdc_Char)0x74, /* [2327] */ - (xdc_Char)0x65, /* [2328] */ - (xdc_Char)0x78, /* [2329] */ - (xdc_Char)0x74, /* [2330] */ - (xdc_Char)0x2e, /* [2331] */ - (xdc_Char)0x20, /* [2332] */ - (xdc_Char)0x4d, /* [2333] */ - (xdc_Char)0x61, /* [2334] */ - (xdc_Char)0x79, /* [2335] */ - (xdc_Char)0x20, /* [2336] */ - (xdc_Char)0x6e, /* [2337] */ - (xdc_Char)0x6f, /* [2338] */ - (xdc_Char)0x74, /* [2339] */ - (xdc_Char)0x20, /* [2340] */ - (xdc_Char)0x62, /* [2341] */ - (xdc_Char)0x65, /* [2342] */ - (xdc_Char)0x20, /* [2343] */ - (xdc_Char)0x65, /* [2344] */ - (xdc_Char)0x6e, /* [2345] */ - (xdc_Char)0x74, /* [2346] */ - (xdc_Char)0x65, /* [2347] */ - (xdc_Char)0x72, /* [2348] */ - (xdc_Char)0x65, /* [2349] */ - (xdc_Char)0x64, /* [2350] */ - (xdc_Char)0x20, /* [2351] */ - (xdc_Char)0x66, /* [2352] */ - (xdc_Char)0x72, /* [2353] */ - (xdc_Char)0x6f, /* [2354] */ - (xdc_Char)0x6d, /* [2355] */ - (xdc_Char)0x20, /* [2356] */ - (xdc_Char)0x61, /* [2357] */ - (xdc_Char)0x20, /* [2358] */ - (xdc_Char)0x68, /* [2359] */ - (xdc_Char)0x61, /* [2360] */ - (xdc_Char)0x72, /* [2361] */ - (xdc_Char)0x64, /* [2362] */ - (xdc_Char)0x77, /* [2363] */ - (xdc_Char)0x61, /* [2364] */ - (xdc_Char)0x72, /* [2365] */ - (xdc_Char)0x65, /* [2366] */ - (xdc_Char)0x20, /* [2367] */ - (xdc_Char)0x69, /* [2368] */ - (xdc_Char)0x6e, /* [2369] */ - (xdc_Char)0x74, /* [2370] */ - (xdc_Char)0x65, /* [2371] */ - (xdc_Char)0x72, /* [2372] */ - (xdc_Char)0x72, /* [2373] */ - (xdc_Char)0x75, /* [2374] */ - (xdc_Char)0x70, /* [2375] */ - (xdc_Char)0x74, /* [2376] */ - (xdc_Char)0x20, /* [2377] */ - (xdc_Char)0x74, /* [2378] */ - (xdc_Char)0x68, /* [2379] */ - (xdc_Char)0x72, /* [2380] */ - (xdc_Char)0x65, /* [2381] */ - (xdc_Char)0x61, /* [2382] */ - (xdc_Char)0x64, /* [2383] */ - (xdc_Char)0x2e, /* [2384] */ - (xdc_Char)0x0, /* [2385] */ - (xdc_Char)0x41, /* [2386] */ - (xdc_Char)0x5f, /* [2387] */ - (xdc_Char)0x62, /* [2388] */ - (xdc_Char)0x61, /* [2389] */ - (xdc_Char)0x64, /* [2390] */ - (xdc_Char)0x43, /* [2391] */ - (xdc_Char)0x6f, /* [2392] */ - (xdc_Char)0x6e, /* [2393] */ - (xdc_Char)0x74, /* [2394] */ - (xdc_Char)0x65, /* [2395] */ - (xdc_Char)0x78, /* [2396] */ - (xdc_Char)0x74, /* [2397] */ - (xdc_Char)0x3a, /* [2398] */ - (xdc_Char)0x20, /* [2399] */ - (xdc_Char)0x62, /* [2400] */ - (xdc_Char)0x61, /* [2401] */ - (xdc_Char)0x64, /* [2402] */ - (xdc_Char)0x20, /* [2403] */ - (xdc_Char)0x63, /* [2404] */ - (xdc_Char)0x61, /* [2405] */ - (xdc_Char)0x6c, /* [2406] */ - (xdc_Char)0x6c, /* [2407] */ - (xdc_Char)0x69, /* [2408] */ - (xdc_Char)0x6e, /* [2409] */ - (xdc_Char)0x67, /* [2410] */ - (xdc_Char)0x20, /* [2411] */ - (xdc_Char)0x63, /* [2412] */ - (xdc_Char)0x6f, /* [2413] */ - (xdc_Char)0x6e, /* [2414] */ - (xdc_Char)0x74, /* [2415] */ - (xdc_Char)0x65, /* [2416] */ - (xdc_Char)0x78, /* [2417] */ - (xdc_Char)0x74, /* [2418] */ - (xdc_Char)0x2e, /* [2419] */ - (xdc_Char)0x20, /* [2420] */ - (xdc_Char)0x4d, /* [2421] */ - (xdc_Char)0x61, /* [2422] */ - (xdc_Char)0x79, /* [2423] */ - (xdc_Char)0x20, /* [2424] */ - (xdc_Char)0x6e, /* [2425] */ - (xdc_Char)0x6f, /* [2426] */ - (xdc_Char)0x74, /* [2427] */ - (xdc_Char)0x20, /* [2428] */ - (xdc_Char)0x62, /* [2429] */ - (xdc_Char)0x65, /* [2430] */ - (xdc_Char)0x20, /* [2431] */ - (xdc_Char)0x65, /* [2432] */ - (xdc_Char)0x6e, /* [2433] */ - (xdc_Char)0x74, /* [2434] */ - (xdc_Char)0x65, /* [2435] */ - (xdc_Char)0x72, /* [2436] */ - (xdc_Char)0x65, /* [2437] */ - (xdc_Char)0x64, /* [2438] */ - (xdc_Char)0x20, /* [2439] */ - (xdc_Char)0x66, /* [2440] */ - (xdc_Char)0x72, /* [2441] */ - (xdc_Char)0x6f, /* [2442] */ - (xdc_Char)0x6d, /* [2443] */ - (xdc_Char)0x20, /* [2444] */ - (xdc_Char)0x61, /* [2445] */ - (xdc_Char)0x20, /* [2446] */ - (xdc_Char)0x73, /* [2447] */ - (xdc_Char)0x6f, /* [2448] */ - (xdc_Char)0x66, /* [2449] */ - (xdc_Char)0x74, /* [2450] */ - (xdc_Char)0x77, /* [2451] */ - (xdc_Char)0x61, /* [2452] */ - (xdc_Char)0x72, /* [2453] */ - (xdc_Char)0x65, /* [2454] */ - (xdc_Char)0x20, /* [2455] */ - (xdc_Char)0x6f, /* [2456] */ - (xdc_Char)0x72, /* [2457] */ - (xdc_Char)0x20, /* [2458] */ - (xdc_Char)0x68, /* [2459] */ - (xdc_Char)0x61, /* [2460] */ - (xdc_Char)0x72, /* [2461] */ - (xdc_Char)0x64, /* [2462] */ - (xdc_Char)0x77, /* [2463] */ - (xdc_Char)0x61, /* [2464] */ - (xdc_Char)0x72, /* [2465] */ - (xdc_Char)0x65, /* [2466] */ - (xdc_Char)0x20, /* [2467] */ - (xdc_Char)0x69, /* [2468] */ - (xdc_Char)0x6e, /* [2469] */ - (xdc_Char)0x74, /* [2470] */ - (xdc_Char)0x65, /* [2471] */ - (xdc_Char)0x72, /* [2472] */ - (xdc_Char)0x72, /* [2473] */ - (xdc_Char)0x75, /* [2474] */ - (xdc_Char)0x70, /* [2475] */ - (xdc_Char)0x74, /* [2476] */ - (xdc_Char)0x20, /* [2477] */ - (xdc_Char)0x74, /* [2478] */ - (xdc_Char)0x68, /* [2479] */ - (xdc_Char)0x72, /* [2480] */ - (xdc_Char)0x65, /* [2481] */ - (xdc_Char)0x61, /* [2482] */ - (xdc_Char)0x64, /* [2483] */ - (xdc_Char)0x2e, /* [2484] */ - (xdc_Char)0x0, /* [2485] */ - (xdc_Char)0x41, /* [2486] */ - (xdc_Char)0x5f, /* [2487] */ - (xdc_Char)0x62, /* [2488] */ - (xdc_Char)0x61, /* [2489] */ - (xdc_Char)0x64, /* [2490] */ - (xdc_Char)0x43, /* [2491] */ - (xdc_Char)0x6f, /* [2492] */ - (xdc_Char)0x6e, /* [2493] */ - (xdc_Char)0x74, /* [2494] */ - (xdc_Char)0x65, /* [2495] */ - (xdc_Char)0x78, /* [2496] */ - (xdc_Char)0x74, /* [2497] */ - (xdc_Char)0x3a, /* [2498] */ - (xdc_Char)0x20, /* [2499] */ - (xdc_Char)0x62, /* [2500] */ - (xdc_Char)0x61, /* [2501] */ - (xdc_Char)0x64, /* [2502] */ - (xdc_Char)0x20, /* [2503] */ - (xdc_Char)0x63, /* [2504] */ - (xdc_Char)0x61, /* [2505] */ - (xdc_Char)0x6c, /* [2506] */ - (xdc_Char)0x6c, /* [2507] */ - (xdc_Char)0x69, /* [2508] */ - (xdc_Char)0x6e, /* [2509] */ - (xdc_Char)0x67, /* [2510] */ - (xdc_Char)0x20, /* [2511] */ - (xdc_Char)0x63, /* [2512] */ - (xdc_Char)0x6f, /* [2513] */ - (xdc_Char)0x6e, /* [2514] */ - (xdc_Char)0x74, /* [2515] */ - (xdc_Char)0x65, /* [2516] */ - (xdc_Char)0x78, /* [2517] */ - (xdc_Char)0x74, /* [2518] */ - (xdc_Char)0x2e, /* [2519] */ - (xdc_Char)0x20, /* [2520] */ - (xdc_Char)0x53, /* [2521] */ - (xdc_Char)0x65, /* [2522] */ - (xdc_Char)0x65, /* [2523] */ - (xdc_Char)0x20, /* [2524] */ - (xdc_Char)0x47, /* [2525] */ - (xdc_Char)0x61, /* [2526] */ - (xdc_Char)0x74, /* [2527] */ - (xdc_Char)0x65, /* [2528] */ - (xdc_Char)0x4d, /* [2529] */ - (xdc_Char)0x75, /* [2530] */ - (xdc_Char)0x74, /* [2531] */ - (xdc_Char)0x65, /* [2532] */ - (xdc_Char)0x78, /* [2533] */ - (xdc_Char)0x50, /* [2534] */ - (xdc_Char)0x72, /* [2535] */ - (xdc_Char)0x69, /* [2536] */ - (xdc_Char)0x20, /* [2537] */ - (xdc_Char)0x41, /* [2538] */ - (xdc_Char)0x50, /* [2539] */ - (xdc_Char)0x49, /* [2540] */ - (xdc_Char)0x20, /* [2541] */ - (xdc_Char)0x64, /* [2542] */ - (xdc_Char)0x6f, /* [2543] */ - (xdc_Char)0x63, /* [2544] */ - (xdc_Char)0x20, /* [2545] */ - (xdc_Char)0x66, /* [2546] */ - (xdc_Char)0x6f, /* [2547] */ - (xdc_Char)0x72, /* [2548] */ - (xdc_Char)0x20, /* [2549] */ - (xdc_Char)0x64, /* [2550] */ - (xdc_Char)0x65, /* [2551] */ - (xdc_Char)0x74, /* [2552] */ - (xdc_Char)0x61, /* [2553] */ - (xdc_Char)0x69, /* [2554] */ - (xdc_Char)0x6c, /* [2555] */ - (xdc_Char)0x73, /* [2556] */ - (xdc_Char)0x2e, /* [2557] */ - (xdc_Char)0x0, /* [2558] */ - (xdc_Char)0x41, /* [2559] */ - (xdc_Char)0x5f, /* [2560] */ - (xdc_Char)0x65, /* [2561] */ - (xdc_Char)0x6e, /* [2562] */ - (xdc_Char)0x74, /* [2563] */ - (xdc_Char)0x65, /* [2564] */ - (xdc_Char)0x72, /* [2565] */ - (xdc_Char)0x54, /* [2566] */ - (xdc_Char)0x61, /* [2567] */ - (xdc_Char)0x73, /* [2568] */ - (xdc_Char)0x6b, /* [2569] */ - (xdc_Char)0x44, /* [2570] */ - (xdc_Char)0x69, /* [2571] */ - (xdc_Char)0x73, /* [2572] */ - (xdc_Char)0x61, /* [2573] */ - (xdc_Char)0x62, /* [2574] */ - (xdc_Char)0x6c, /* [2575] */ - (xdc_Char)0x65, /* [2576] */ - (xdc_Char)0x64, /* [2577] */ - (xdc_Char)0x3a, /* [2578] */ - (xdc_Char)0x20, /* [2579] */ - (xdc_Char)0x43, /* [2580] */ - (xdc_Char)0x61, /* [2581] */ - (xdc_Char)0x6e, /* [2582] */ - (xdc_Char)0x6e, /* [2583] */ - (xdc_Char)0x6f, /* [2584] */ - (xdc_Char)0x74, /* [2585] */ - (xdc_Char)0x20, /* [2586] */ - (xdc_Char)0x63, /* [2587] */ - (xdc_Char)0x61, /* [2588] */ - (xdc_Char)0x6c, /* [2589] */ - (xdc_Char)0x6c, /* [2590] */ - (xdc_Char)0x20, /* [2591] */ - (xdc_Char)0x47, /* [2592] */ - (xdc_Char)0x61, /* [2593] */ - (xdc_Char)0x74, /* [2594] */ - (xdc_Char)0x65, /* [2595] */ - (xdc_Char)0x4d, /* [2596] */ - (xdc_Char)0x75, /* [2597] */ - (xdc_Char)0x74, /* [2598] */ - (xdc_Char)0x65, /* [2599] */ - (xdc_Char)0x78, /* [2600] */ - (xdc_Char)0x50, /* [2601] */ - (xdc_Char)0x72, /* [2602] */ - (xdc_Char)0x69, /* [2603] */ - (xdc_Char)0x5f, /* [2604] */ - (xdc_Char)0x65, /* [2605] */ - (xdc_Char)0x6e, /* [2606] */ - (xdc_Char)0x74, /* [2607] */ - (xdc_Char)0x65, /* [2608] */ - (xdc_Char)0x72, /* [2609] */ - (xdc_Char)0x28, /* [2610] */ - (xdc_Char)0x29, /* [2611] */ - (xdc_Char)0x20, /* [2612] */ - (xdc_Char)0x77, /* [2613] */ - (xdc_Char)0x68, /* [2614] */ - (xdc_Char)0x69, /* [2615] */ - (xdc_Char)0x6c, /* [2616] */ - (xdc_Char)0x65, /* [2617] */ - (xdc_Char)0x20, /* [2618] */ - (xdc_Char)0x74, /* [2619] */ - (xdc_Char)0x68, /* [2620] */ - (xdc_Char)0x65, /* [2621] */ - (xdc_Char)0x20, /* [2622] */ - (xdc_Char)0x54, /* [2623] */ - (xdc_Char)0x61, /* [2624] */ - (xdc_Char)0x73, /* [2625] */ - (xdc_Char)0x6b, /* [2626] */ - (xdc_Char)0x20, /* [2627] */ - (xdc_Char)0x6f, /* [2628] */ - (xdc_Char)0x72, /* [2629] */ - (xdc_Char)0x20, /* [2630] */ - (xdc_Char)0x53, /* [2631] */ - (xdc_Char)0x77, /* [2632] */ - (xdc_Char)0x69, /* [2633] */ - (xdc_Char)0x20, /* [2634] */ - (xdc_Char)0x73, /* [2635] */ - (xdc_Char)0x63, /* [2636] */ - (xdc_Char)0x68, /* [2637] */ - (xdc_Char)0x65, /* [2638] */ - (xdc_Char)0x64, /* [2639] */ - (xdc_Char)0x75, /* [2640] */ - (xdc_Char)0x6c, /* [2641] */ - (xdc_Char)0x65, /* [2642] */ - (xdc_Char)0x72, /* [2643] */ - (xdc_Char)0x20, /* [2644] */ - (xdc_Char)0x69, /* [2645] */ - (xdc_Char)0x73, /* [2646] */ - (xdc_Char)0x20, /* [2647] */ - (xdc_Char)0x64, /* [2648] */ - (xdc_Char)0x69, /* [2649] */ - (xdc_Char)0x73, /* [2650] */ - (xdc_Char)0x61, /* [2651] */ - (xdc_Char)0x62, /* [2652] */ - (xdc_Char)0x6c, /* [2653] */ - (xdc_Char)0x65, /* [2654] */ - (xdc_Char)0x64, /* [2655] */ - (xdc_Char)0x2e, /* [2656] */ - (xdc_Char)0x0, /* [2657] */ - (xdc_Char)0x41, /* [2658] */ - (xdc_Char)0x5f, /* [2659] */ - (xdc_Char)0x62, /* [2660] */ - (xdc_Char)0x61, /* [2661] */ - (xdc_Char)0x64, /* [2662] */ - (xdc_Char)0x43, /* [2663] */ - (xdc_Char)0x6f, /* [2664] */ - (xdc_Char)0x6e, /* [2665] */ - (xdc_Char)0x74, /* [2666] */ - (xdc_Char)0x65, /* [2667] */ - (xdc_Char)0x78, /* [2668] */ - (xdc_Char)0x74, /* [2669] */ - (xdc_Char)0x3a, /* [2670] */ - (xdc_Char)0x20, /* [2671] */ - (xdc_Char)0x62, /* [2672] */ - (xdc_Char)0x61, /* [2673] */ - (xdc_Char)0x64, /* [2674] */ - (xdc_Char)0x20, /* [2675] */ - (xdc_Char)0x63, /* [2676] */ - (xdc_Char)0x61, /* [2677] */ - (xdc_Char)0x6c, /* [2678] */ - (xdc_Char)0x6c, /* [2679] */ - (xdc_Char)0x69, /* [2680] */ - (xdc_Char)0x6e, /* [2681] */ - (xdc_Char)0x67, /* [2682] */ - (xdc_Char)0x20, /* [2683] */ - (xdc_Char)0x63, /* [2684] */ - (xdc_Char)0x6f, /* [2685] */ - (xdc_Char)0x6e, /* [2686] */ - (xdc_Char)0x74, /* [2687] */ - (xdc_Char)0x65, /* [2688] */ - (xdc_Char)0x78, /* [2689] */ - (xdc_Char)0x74, /* [2690] */ - (xdc_Char)0x2e, /* [2691] */ - (xdc_Char)0x20, /* [2692] */ - (xdc_Char)0x53, /* [2693] */ - (xdc_Char)0x65, /* [2694] */ - (xdc_Char)0x65, /* [2695] */ - (xdc_Char)0x20, /* [2696] */ - (xdc_Char)0x47, /* [2697] */ - (xdc_Char)0x61, /* [2698] */ - (xdc_Char)0x74, /* [2699] */ - (xdc_Char)0x65, /* [2700] */ - (xdc_Char)0x4d, /* [2701] */ - (xdc_Char)0x75, /* [2702] */ - (xdc_Char)0x74, /* [2703] */ - (xdc_Char)0x65, /* [2704] */ - (xdc_Char)0x78, /* [2705] */ - (xdc_Char)0x20, /* [2706] */ - (xdc_Char)0x41, /* [2707] */ - (xdc_Char)0x50, /* [2708] */ - (xdc_Char)0x49, /* [2709] */ - (xdc_Char)0x20, /* [2710] */ - (xdc_Char)0x64, /* [2711] */ - (xdc_Char)0x6f, /* [2712] */ - (xdc_Char)0x63, /* [2713] */ - (xdc_Char)0x20, /* [2714] */ - (xdc_Char)0x66, /* [2715] */ - (xdc_Char)0x6f, /* [2716] */ - (xdc_Char)0x72, /* [2717] */ - (xdc_Char)0x20, /* [2718] */ - (xdc_Char)0x64, /* [2719] */ - (xdc_Char)0x65, /* [2720] */ - (xdc_Char)0x74, /* [2721] */ - (xdc_Char)0x61, /* [2722] */ - (xdc_Char)0x69, /* [2723] */ - (xdc_Char)0x6c, /* [2724] */ - (xdc_Char)0x73, /* [2725] */ - (xdc_Char)0x2e, /* [2726] */ - (xdc_Char)0x0, /* [2727] */ - (xdc_Char)0x41, /* [2728] */ - (xdc_Char)0x5f, /* [2729] */ - (xdc_Char)0x62, /* [2730] */ - (xdc_Char)0x61, /* [2731] */ - (xdc_Char)0x64, /* [2732] */ - (xdc_Char)0x43, /* [2733] */ - (xdc_Char)0x6f, /* [2734] */ - (xdc_Char)0x6e, /* [2735] */ - (xdc_Char)0x74, /* [2736] */ - (xdc_Char)0x65, /* [2737] */ - (xdc_Char)0x78, /* [2738] */ - (xdc_Char)0x74, /* [2739] */ - (xdc_Char)0x3a, /* [2740] */ - (xdc_Char)0x20, /* [2741] */ - (xdc_Char)0x62, /* [2742] */ - (xdc_Char)0x61, /* [2743] */ - (xdc_Char)0x64, /* [2744] */ - (xdc_Char)0x20, /* [2745] */ - (xdc_Char)0x63, /* [2746] */ - (xdc_Char)0x61, /* [2747] */ - (xdc_Char)0x6c, /* [2748] */ - (xdc_Char)0x6c, /* [2749] */ - (xdc_Char)0x69, /* [2750] */ - (xdc_Char)0x6e, /* [2751] */ - (xdc_Char)0x67, /* [2752] */ - (xdc_Char)0x20, /* [2753] */ - (xdc_Char)0x63, /* [2754] */ - (xdc_Char)0x6f, /* [2755] */ - (xdc_Char)0x6e, /* [2756] */ - (xdc_Char)0x74, /* [2757] */ - (xdc_Char)0x65, /* [2758] */ - (xdc_Char)0x78, /* [2759] */ - (xdc_Char)0x74, /* [2760] */ - (xdc_Char)0x2e, /* [2761] */ - (xdc_Char)0x20, /* [2762] */ - (xdc_Char)0x53, /* [2763] */ - (xdc_Char)0x65, /* [2764] */ - (xdc_Char)0x65, /* [2765] */ - (xdc_Char)0x20, /* [2766] */ - (xdc_Char)0x47, /* [2767] */ - (xdc_Char)0x61, /* [2768] */ - (xdc_Char)0x74, /* [2769] */ - (xdc_Char)0x65, /* [2770] */ - (xdc_Char)0x53, /* [2771] */ - (xdc_Char)0x70, /* [2772] */ - (xdc_Char)0x69, /* [2773] */ - (xdc_Char)0x6e, /* [2774] */ - (xdc_Char)0x6c, /* [2775] */ - (xdc_Char)0x6f, /* [2776] */ - (xdc_Char)0x63, /* [2777] */ - (xdc_Char)0x6b, /* [2778] */ - (xdc_Char)0x20, /* [2779] */ - (xdc_Char)0x41, /* [2780] */ - (xdc_Char)0x50, /* [2781] */ - (xdc_Char)0x49, /* [2782] */ - (xdc_Char)0x20, /* [2783] */ - (xdc_Char)0x64, /* [2784] */ - (xdc_Char)0x6f, /* [2785] */ - (xdc_Char)0x63, /* [2786] */ - (xdc_Char)0x20, /* [2787] */ - (xdc_Char)0x66, /* [2788] */ - (xdc_Char)0x6f, /* [2789] */ - (xdc_Char)0x72, /* [2790] */ - (xdc_Char)0x20, /* [2791] */ - (xdc_Char)0x64, /* [2792] */ - (xdc_Char)0x65, /* [2793] */ - (xdc_Char)0x74, /* [2794] */ - (xdc_Char)0x61, /* [2795] */ - (xdc_Char)0x69, /* [2796] */ - (xdc_Char)0x6c, /* [2797] */ - (xdc_Char)0x73, /* [2798] */ - (xdc_Char)0x2e, /* [2799] */ - (xdc_Char)0x0, /* [2800] */ - (xdc_Char)0x41, /* [2801] */ - (xdc_Char)0x5f, /* [2802] */ - (xdc_Char)0x69, /* [2803] */ - (xdc_Char)0x6e, /* [2804] */ - (xdc_Char)0x76, /* [2805] */ - (xdc_Char)0x61, /* [2806] */ - (xdc_Char)0x6c, /* [2807] */ - (xdc_Char)0x69, /* [2808] */ - (xdc_Char)0x64, /* [2809] */ - (xdc_Char)0x51, /* [2810] */ - (xdc_Char)0x75, /* [2811] */ - (xdc_Char)0x61, /* [2812] */ - (xdc_Char)0x6c, /* [2813] */ - (xdc_Char)0x69, /* [2814] */ - (xdc_Char)0x74, /* [2815] */ - (xdc_Char)0x79, /* [2816] */ - (xdc_Char)0x3a, /* [2817] */ - (xdc_Char)0x20, /* [2818] */ - (xdc_Char)0x53, /* [2819] */ - (xdc_Char)0x65, /* [2820] */ - (xdc_Char)0x65, /* [2821] */ - (xdc_Char)0x20, /* [2822] */ - (xdc_Char)0x47, /* [2823] */ - (xdc_Char)0x61, /* [2824] */ - (xdc_Char)0x74, /* [2825] */ - (xdc_Char)0x65, /* [2826] */ - (xdc_Char)0x53, /* [2827] */ - (xdc_Char)0x70, /* [2828] */ - (xdc_Char)0x69, /* [2829] */ - (xdc_Char)0x6e, /* [2830] */ - (xdc_Char)0x6c, /* [2831] */ - (xdc_Char)0x6f, /* [2832] */ - (xdc_Char)0x63, /* [2833] */ - (xdc_Char)0x6b, /* [2834] */ - (xdc_Char)0x20, /* [2835] */ - (xdc_Char)0x41, /* [2836] */ - (xdc_Char)0x50, /* [2837] */ - (xdc_Char)0x49, /* [2838] */ - (xdc_Char)0x20, /* [2839] */ - (xdc_Char)0x64, /* [2840] */ - (xdc_Char)0x6f, /* [2841] */ - (xdc_Char)0x63, /* [2842] */ - (xdc_Char)0x20, /* [2843] */ - (xdc_Char)0x66, /* [2844] */ - (xdc_Char)0x6f, /* [2845] */ - (xdc_Char)0x72, /* [2846] */ - (xdc_Char)0x20, /* [2847] */ - (xdc_Char)0x64, /* [2848] */ - (xdc_Char)0x65, /* [2849] */ - (xdc_Char)0x74, /* [2850] */ - (xdc_Char)0x61, /* [2851] */ - (xdc_Char)0x69, /* [2852] */ - (xdc_Char)0x6c, /* [2853] */ - (xdc_Char)0x73, /* [2854] */ - (xdc_Char)0x2e, /* [2855] */ - (xdc_Char)0x0, /* [2856] */ - (xdc_Char)0x62, /* [2857] */ - (xdc_Char)0x75, /* [2858] */ - (xdc_Char)0x66, /* [2859] */ - (xdc_Char)0x20, /* [2860] */ - (xdc_Char)0x70, /* [2861] */ - (xdc_Char)0x61, /* [2862] */ - (xdc_Char)0x72, /* [2863] */ - (xdc_Char)0x61, /* [2864] */ - (xdc_Char)0x6d, /* [2865] */ - (xdc_Char)0x65, /* [2866] */ - (xdc_Char)0x74, /* [2867] */ - (xdc_Char)0x65, /* [2868] */ - (xdc_Char)0x72, /* [2869] */ - (xdc_Char)0x20, /* [2870] */ - (xdc_Char)0x63, /* [2871] */ - (xdc_Char)0x61, /* [2872] */ - (xdc_Char)0x6e, /* [2873] */ - (xdc_Char)0x6e, /* [2874] */ - (xdc_Char)0x6f, /* [2875] */ - (xdc_Char)0x74, /* [2876] */ - (xdc_Char)0x20, /* [2877] */ - (xdc_Char)0x62, /* [2878] */ - (xdc_Char)0x65, /* [2879] */ - (xdc_Char)0x20, /* [2880] */ - (xdc_Char)0x6e, /* [2881] */ - (xdc_Char)0x75, /* [2882] */ - (xdc_Char)0x6c, /* [2883] */ - (xdc_Char)0x6c, /* [2884] */ - (xdc_Char)0x0, /* [2885] */ - (xdc_Char)0x62, /* [2886] */ - (xdc_Char)0x75, /* [2887] */ - (xdc_Char)0x66, /* [2888] */ - (xdc_Char)0x20, /* [2889] */ - (xdc_Char)0x6e, /* [2890] */ - (xdc_Char)0x6f, /* [2891] */ - (xdc_Char)0x74, /* [2892] */ - (xdc_Char)0x20, /* [2893] */ - (xdc_Char)0x70, /* [2894] */ - (xdc_Char)0x72, /* [2895] */ - (xdc_Char)0x6f, /* [2896] */ - (xdc_Char)0x70, /* [2897] */ - (xdc_Char)0x65, /* [2898] */ - (xdc_Char)0x72, /* [2899] */ - (xdc_Char)0x6c, /* [2900] */ - (xdc_Char)0x79, /* [2901] */ - (xdc_Char)0x20, /* [2902] */ - (xdc_Char)0x61, /* [2903] */ - (xdc_Char)0x6c, /* [2904] */ - (xdc_Char)0x69, /* [2905] */ - (xdc_Char)0x67, /* [2906] */ - (xdc_Char)0x6e, /* [2907] */ - (xdc_Char)0x65, /* [2908] */ - (xdc_Char)0x64, /* [2909] */ - (xdc_Char)0x0, /* [2910] */ - (xdc_Char)0x61, /* [2911] */ - (xdc_Char)0x6c, /* [2912] */ - (xdc_Char)0x69, /* [2913] */ - (xdc_Char)0x67, /* [2914] */ - (xdc_Char)0x6e, /* [2915] */ - (xdc_Char)0x20, /* [2916] */ - (xdc_Char)0x70, /* [2917] */ - (xdc_Char)0x61, /* [2918] */ - (xdc_Char)0x72, /* [2919] */ - (xdc_Char)0x61, /* [2920] */ - (xdc_Char)0x6d, /* [2921] */ - (xdc_Char)0x65, /* [2922] */ - (xdc_Char)0x74, /* [2923] */ - (xdc_Char)0x65, /* [2924] */ - (xdc_Char)0x72, /* [2925] */ - (xdc_Char)0x20, /* [2926] */ - (xdc_Char)0x6d, /* [2927] */ - (xdc_Char)0x75, /* [2928] */ - (xdc_Char)0x73, /* [2929] */ - (xdc_Char)0x74, /* [2930] */ - (xdc_Char)0x20, /* [2931] */ - (xdc_Char)0x62, /* [2932] */ - (xdc_Char)0x65, /* [2933] */ - (xdc_Char)0x20, /* [2934] */ - (xdc_Char)0x30, /* [2935] */ - (xdc_Char)0x20, /* [2936] */ - (xdc_Char)0x6f, /* [2937] */ - (xdc_Char)0x72, /* [2938] */ - (xdc_Char)0x20, /* [2939] */ - (xdc_Char)0x61, /* [2940] */ - (xdc_Char)0x20, /* [2941] */ - (xdc_Char)0x70, /* [2942] */ - (xdc_Char)0x6f, /* [2943] */ - (xdc_Char)0x77, /* [2944] */ - (xdc_Char)0x65, /* [2945] */ - (xdc_Char)0x72, /* [2946] */ - (xdc_Char)0x20, /* [2947] */ - (xdc_Char)0x6f, /* [2948] */ - (xdc_Char)0x66, /* [2949] */ - (xdc_Char)0x20, /* [2950] */ - (xdc_Char)0x32, /* [2951] */ - (xdc_Char)0x20, /* [2952] */ - (xdc_Char)0x3e, /* [2953] */ - (xdc_Char)0x3d, /* [2954] */ - (xdc_Char)0x20, /* [2955] */ - (xdc_Char)0x74, /* [2956] */ - (xdc_Char)0x68, /* [2957] */ - (xdc_Char)0x65, /* [2958] */ - (xdc_Char)0x20, /* [2959] */ - (xdc_Char)0x76, /* [2960] */ - (xdc_Char)0x61, /* [2961] */ - (xdc_Char)0x6c, /* [2962] */ - (xdc_Char)0x75, /* [2963] */ - (xdc_Char)0x65, /* [2964] */ - (xdc_Char)0x20, /* [2965] */ - (xdc_Char)0x6f, /* [2966] */ - (xdc_Char)0x66, /* [2967] */ - (xdc_Char)0x20, /* [2968] */ - (xdc_Char)0x4d, /* [2969] */ - (xdc_Char)0x65, /* [2970] */ - (xdc_Char)0x6d, /* [2971] */ - (xdc_Char)0x6f, /* [2972] */ - (xdc_Char)0x72, /* [2973] */ - (xdc_Char)0x79, /* [2974] */ - (xdc_Char)0x5f, /* [2975] */ - (xdc_Char)0x67, /* [2976] */ - (xdc_Char)0x65, /* [2977] */ - (xdc_Char)0x74, /* [2978] */ - (xdc_Char)0x4d, /* [2979] */ - (xdc_Char)0x61, /* [2980] */ - (xdc_Char)0x78, /* [2981] */ - (xdc_Char)0x44, /* [2982] */ - (xdc_Char)0x65, /* [2983] */ - (xdc_Char)0x66, /* [2984] */ - (xdc_Char)0x61, /* [2985] */ - (xdc_Char)0x75, /* [2986] */ - (xdc_Char)0x6c, /* [2987] */ - (xdc_Char)0x74, /* [2988] */ - (xdc_Char)0x54, /* [2989] */ - (xdc_Char)0x79, /* [2990] */ - (xdc_Char)0x70, /* [2991] */ - (xdc_Char)0x65, /* [2992] */ - (xdc_Char)0x41, /* [2993] */ - (xdc_Char)0x6c, /* [2994] */ - (xdc_Char)0x69, /* [2995] */ - (xdc_Char)0x67, /* [2996] */ - (xdc_Char)0x6e, /* [2997] */ - (xdc_Char)0x28, /* [2998] */ - (xdc_Char)0x29, /* [2999] */ - (xdc_Char)0x0, /* [3000] */ - (xdc_Char)0x61, /* [3001] */ - (xdc_Char)0x6c, /* [3002] */ - (xdc_Char)0x69, /* [3003] */ - (xdc_Char)0x67, /* [3004] */ - (xdc_Char)0x6e, /* [3005] */ - (xdc_Char)0x20, /* [3006] */ - (xdc_Char)0x70, /* [3007] */ - (xdc_Char)0x61, /* [3008] */ - (xdc_Char)0x72, /* [3009] */ - (xdc_Char)0x61, /* [3010] */ - (xdc_Char)0x6d, /* [3011] */ - (xdc_Char)0x65, /* [3012] */ - (xdc_Char)0x74, /* [3013] */ - (xdc_Char)0x65, /* [3014] */ - (xdc_Char)0x72, /* [3015] */ - (xdc_Char)0x20, /* [3016] */ - (xdc_Char)0x31, /* [3017] */ - (xdc_Char)0x29, /* [3018] */ - (xdc_Char)0x20, /* [3019] */ - (xdc_Char)0x6d, /* [3020] */ - (xdc_Char)0x75, /* [3021] */ - (xdc_Char)0x73, /* [3022] */ - (xdc_Char)0x74, /* [3023] */ - (xdc_Char)0x20, /* [3024] */ - (xdc_Char)0x62, /* [3025] */ - (xdc_Char)0x65, /* [3026] */ - (xdc_Char)0x20, /* [3027] */ - (xdc_Char)0x30, /* [3028] */ - (xdc_Char)0x20, /* [3029] */ - (xdc_Char)0x6f, /* [3030] */ - (xdc_Char)0x72, /* [3031] */ - (xdc_Char)0x20, /* [3032] */ - (xdc_Char)0x61, /* [3033] */ - (xdc_Char)0x20, /* [3034] */ - (xdc_Char)0x70, /* [3035] */ - (xdc_Char)0x6f, /* [3036] */ - (xdc_Char)0x77, /* [3037] */ - (xdc_Char)0x65, /* [3038] */ - (xdc_Char)0x72, /* [3039] */ - (xdc_Char)0x20, /* [3040] */ - (xdc_Char)0x6f, /* [3041] */ - (xdc_Char)0x66, /* [3042] */ - (xdc_Char)0x20, /* [3043] */ - (xdc_Char)0x32, /* [3044] */ - (xdc_Char)0x20, /* [3045] */ - (xdc_Char)0x61, /* [3046] */ - (xdc_Char)0x6e, /* [3047] */ - (xdc_Char)0x64, /* [3048] */ - (xdc_Char)0x20, /* [3049] */ - (xdc_Char)0x32, /* [3050] */ - (xdc_Char)0x29, /* [3051] */ - (xdc_Char)0x20, /* [3052] */ - (xdc_Char)0x6e, /* [3053] */ - (xdc_Char)0x6f, /* [3054] */ - (xdc_Char)0x74, /* [3055] */ - (xdc_Char)0x20, /* [3056] */ - (xdc_Char)0x67, /* [3057] */ - (xdc_Char)0x72, /* [3058] */ - (xdc_Char)0x65, /* [3059] */ - (xdc_Char)0x61, /* [3060] */ - (xdc_Char)0x74, /* [3061] */ - (xdc_Char)0x65, /* [3062] */ - (xdc_Char)0x72, /* [3063] */ - (xdc_Char)0x20, /* [3064] */ - (xdc_Char)0x74, /* [3065] */ - (xdc_Char)0x68, /* [3066] */ - (xdc_Char)0x61, /* [3067] */ - (xdc_Char)0x6e, /* [3068] */ - (xdc_Char)0x20, /* [3069] */ - (xdc_Char)0x74, /* [3070] */ - (xdc_Char)0x68, /* [3071] */ - (xdc_Char)0x65, /* [3072] */ - (xdc_Char)0x20, /* [3073] */ - (xdc_Char)0x68, /* [3074] */ - (xdc_Char)0x65, /* [3075] */ - (xdc_Char)0x61, /* [3076] */ - (xdc_Char)0x70, /* [3077] */ - (xdc_Char)0x73, /* [3078] */ - (xdc_Char)0x20, /* [3079] */ - (xdc_Char)0x61, /* [3080] */ - (xdc_Char)0x6c, /* [3081] */ - (xdc_Char)0x69, /* [3082] */ - (xdc_Char)0x67, /* [3083] */ - (xdc_Char)0x6e, /* [3084] */ - (xdc_Char)0x6d, /* [3085] */ - (xdc_Char)0x65, /* [3086] */ - (xdc_Char)0x6e, /* [3087] */ - (xdc_Char)0x74, /* [3088] */ - (xdc_Char)0x0, /* [3089] */ - (xdc_Char)0x62, /* [3090] */ - (xdc_Char)0x6c, /* [3091] */ - (xdc_Char)0x6f, /* [3092] */ - (xdc_Char)0x63, /* [3093] */ - (xdc_Char)0x6b, /* [3094] */ - (xdc_Char)0x53, /* [3095] */ - (xdc_Char)0x69, /* [3096] */ - (xdc_Char)0x7a, /* [3097] */ - (xdc_Char)0x65, /* [3098] */ - (xdc_Char)0x20, /* [3099] */ - (xdc_Char)0x6d, /* [3100] */ - (xdc_Char)0x75, /* [3101] */ - (xdc_Char)0x73, /* [3102] */ - (xdc_Char)0x74, /* [3103] */ - (xdc_Char)0x20, /* [3104] */ - (xdc_Char)0x62, /* [3105] */ - (xdc_Char)0x65, /* [3106] */ - (xdc_Char)0x20, /* [3107] */ - (xdc_Char)0x6c, /* [3108] */ - (xdc_Char)0x61, /* [3109] */ - (xdc_Char)0x72, /* [3110] */ - (xdc_Char)0x67, /* [3111] */ - (xdc_Char)0x65, /* [3112] */ - (xdc_Char)0x20, /* [3113] */ - (xdc_Char)0x65, /* [3114] */ - (xdc_Char)0x6e, /* [3115] */ - (xdc_Char)0x6f, /* [3116] */ - (xdc_Char)0x75, /* [3117] */ - (xdc_Char)0x67, /* [3118] */ - (xdc_Char)0x68, /* [3119] */ - (xdc_Char)0x20, /* [3120] */ - (xdc_Char)0x74, /* [3121] */ - (xdc_Char)0x6f, /* [3122] */ - (xdc_Char)0x20, /* [3123] */ - (xdc_Char)0x68, /* [3124] */ - (xdc_Char)0x6f, /* [3125] */ - (xdc_Char)0x6c, /* [3126] */ - (xdc_Char)0x64, /* [3127] */ - (xdc_Char)0x20, /* [3128] */ - (xdc_Char)0x61, /* [3129] */ - (xdc_Char)0x74, /* [3130] */ - (xdc_Char)0x6c, /* [3131] */ - (xdc_Char)0x65, /* [3132] */ - (xdc_Char)0x61, /* [3133] */ - (xdc_Char)0x73, /* [3134] */ - (xdc_Char)0x74, /* [3135] */ - (xdc_Char)0x20, /* [3136] */ - (xdc_Char)0x74, /* [3137] */ - (xdc_Char)0x77, /* [3138] */ - (xdc_Char)0x6f, /* [3139] */ - (xdc_Char)0x20, /* [3140] */ - (xdc_Char)0x70, /* [3141] */ - (xdc_Char)0x6f, /* [3142] */ - (xdc_Char)0x69, /* [3143] */ - (xdc_Char)0x6e, /* [3144] */ - (xdc_Char)0x74, /* [3145] */ - (xdc_Char)0x65, /* [3146] */ - (xdc_Char)0x72, /* [3147] */ - (xdc_Char)0x73, /* [3148] */ - (xdc_Char)0x0, /* [3149] */ - (xdc_Char)0x6e, /* [3150] */ - (xdc_Char)0x75, /* [3151] */ - (xdc_Char)0x6d, /* [3152] */ - (xdc_Char)0x42, /* [3153] */ - (xdc_Char)0x6c, /* [3154] */ - (xdc_Char)0x6f, /* [3155] */ - (xdc_Char)0x63, /* [3156] */ - (xdc_Char)0x6b, /* [3157] */ - (xdc_Char)0x73, /* [3158] */ - (xdc_Char)0x20, /* [3159] */ - (xdc_Char)0x63, /* [3160] */ - (xdc_Char)0x61, /* [3161] */ - (xdc_Char)0x6e, /* [3162] */ - (xdc_Char)0x6e, /* [3163] */ - (xdc_Char)0x6f, /* [3164] */ - (xdc_Char)0x74, /* [3165] */ - (xdc_Char)0x20, /* [3166] */ - (xdc_Char)0x62, /* [3167] */ - (xdc_Char)0x65, /* [3168] */ - (xdc_Char)0x20, /* [3169] */ - (xdc_Char)0x7a, /* [3170] */ - (xdc_Char)0x65, /* [3171] */ - (xdc_Char)0x72, /* [3172] */ - (xdc_Char)0x6f, /* [3173] */ - (xdc_Char)0x0, /* [3174] */ - (xdc_Char)0x62, /* [3175] */ - (xdc_Char)0x75, /* [3176] */ - (xdc_Char)0x66, /* [3177] */ - (xdc_Char)0x53, /* [3178] */ - (xdc_Char)0x69, /* [3179] */ - (xdc_Char)0x7a, /* [3180] */ - (xdc_Char)0x65, /* [3181] */ - (xdc_Char)0x20, /* [3182] */ - (xdc_Char)0x63, /* [3183] */ - (xdc_Char)0x61, /* [3184] */ - (xdc_Char)0x6e, /* [3185] */ - (xdc_Char)0x6e, /* [3186] */ - (xdc_Char)0x6f, /* [3187] */ - (xdc_Char)0x74, /* [3188] */ - (xdc_Char)0x20, /* [3189] */ - (xdc_Char)0x62, /* [3190] */ - (xdc_Char)0x65, /* [3191] */ - (xdc_Char)0x20, /* [3192] */ - (xdc_Char)0x7a, /* [3193] */ - (xdc_Char)0x65, /* [3194] */ - (xdc_Char)0x72, /* [3195] */ - (xdc_Char)0x6f, /* [3196] */ - (xdc_Char)0x0, /* [3197] */ - (xdc_Char)0x48, /* [3198] */ - (xdc_Char)0x65, /* [3199] */ - (xdc_Char)0x61, /* [3200] */ - (xdc_Char)0x70, /* [3201] */ - (xdc_Char)0x42, /* [3202] */ - (xdc_Char)0x75, /* [3203] */ - (xdc_Char)0x66, /* [3204] */ - (xdc_Char)0x5f, /* [3205] */ - (xdc_Char)0x63, /* [3206] */ - (xdc_Char)0x72, /* [3207] */ - (xdc_Char)0x65, /* [3208] */ - (xdc_Char)0x61, /* [3209] */ - (xdc_Char)0x74, /* [3210] */ - (xdc_Char)0x65, /* [3211] */ - (xdc_Char)0x27, /* [3212] */ - (xdc_Char)0x73, /* [3213] */ - (xdc_Char)0x20, /* [3214] */ - (xdc_Char)0x62, /* [3215] */ - (xdc_Char)0x75, /* [3216] */ - (xdc_Char)0x66, /* [3217] */ - (xdc_Char)0x53, /* [3218] */ - (xdc_Char)0x69, /* [3219] */ - (xdc_Char)0x7a, /* [3220] */ - (xdc_Char)0x65, /* [3221] */ - (xdc_Char)0x20, /* [3222] */ - (xdc_Char)0x70, /* [3223] */ - (xdc_Char)0x61, /* [3224] */ - (xdc_Char)0x72, /* [3225] */ - (xdc_Char)0x61, /* [3226] */ - (xdc_Char)0x6d, /* [3227] */ - (xdc_Char)0x65, /* [3228] */ - (xdc_Char)0x74, /* [3229] */ - (xdc_Char)0x65, /* [3230] */ - (xdc_Char)0x72, /* [3231] */ - (xdc_Char)0x20, /* [3232] */ - (xdc_Char)0x69, /* [3233] */ - (xdc_Char)0x73, /* [3234] */ - (xdc_Char)0x20, /* [3235] */ - (xdc_Char)0x69, /* [3236] */ - (xdc_Char)0x6e, /* [3237] */ - (xdc_Char)0x76, /* [3238] */ - (xdc_Char)0x61, /* [3239] */ - (xdc_Char)0x6c, /* [3240] */ - (xdc_Char)0x69, /* [3241] */ - (xdc_Char)0x64, /* [3242] */ - (xdc_Char)0x20, /* [3243] */ - (xdc_Char)0x28, /* [3244] */ - (xdc_Char)0x74, /* [3245] */ - (xdc_Char)0x6f, /* [3246] */ - (xdc_Char)0x6f, /* [3247] */ - (xdc_Char)0x20, /* [3248] */ - (xdc_Char)0x73, /* [3249] */ - (xdc_Char)0x6d, /* [3250] */ - (xdc_Char)0x61, /* [3251] */ - (xdc_Char)0x6c, /* [3252] */ - (xdc_Char)0x6c, /* [3253] */ - (xdc_Char)0x29, /* [3254] */ - (xdc_Char)0x0, /* [3255] */ - (xdc_Char)0x43, /* [3256] */ - (xdc_Char)0x61, /* [3257] */ - (xdc_Char)0x6e, /* [3258] */ - (xdc_Char)0x6e, /* [3259] */ - (xdc_Char)0x6f, /* [3260] */ - (xdc_Char)0x74, /* [3261] */ - (xdc_Char)0x20, /* [3262] */ - (xdc_Char)0x63, /* [3263] */ - (xdc_Char)0x61, /* [3264] */ - (xdc_Char)0x6c, /* [3265] */ - (xdc_Char)0x6c, /* [3266] */ - (xdc_Char)0x20, /* [3267] */ - (xdc_Char)0x48, /* [3268] */ - (xdc_Char)0x65, /* [3269] */ - (xdc_Char)0x61, /* [3270] */ - (xdc_Char)0x70, /* [3271] */ - (xdc_Char)0x42, /* [3272] */ - (xdc_Char)0x75, /* [3273] */ - (xdc_Char)0x66, /* [3274] */ - (xdc_Char)0x5f, /* [3275] */ - (xdc_Char)0x66, /* [3276] */ - (xdc_Char)0x72, /* [3277] */ - (xdc_Char)0x65, /* [3278] */ - (xdc_Char)0x65, /* [3279] */ - (xdc_Char)0x20, /* [3280] */ - (xdc_Char)0x77, /* [3281] */ - (xdc_Char)0x68, /* [3282] */ - (xdc_Char)0x65, /* [3283] */ - (xdc_Char)0x6e, /* [3284] */ - (xdc_Char)0x20, /* [3285] */ - (xdc_Char)0x6e, /* [3286] */ - (xdc_Char)0x6f, /* [3287] */ - (xdc_Char)0x20, /* [3288] */ - (xdc_Char)0x62, /* [3289] */ - (xdc_Char)0x6c, /* [3290] */ - (xdc_Char)0x6f, /* [3291] */ - (xdc_Char)0x63, /* [3292] */ - (xdc_Char)0x6b, /* [3293] */ - (xdc_Char)0x73, /* [3294] */ - (xdc_Char)0x20, /* [3295] */ - (xdc_Char)0x68, /* [3296] */ - (xdc_Char)0x61, /* [3297] */ - (xdc_Char)0x76, /* [3298] */ - (xdc_Char)0x65, /* [3299] */ - (xdc_Char)0x20, /* [3300] */ - (xdc_Char)0x62, /* [3301] */ - (xdc_Char)0x65, /* [3302] */ - (xdc_Char)0x65, /* [3303] */ - (xdc_Char)0x6e, /* [3304] */ - (xdc_Char)0x20, /* [3305] */ - (xdc_Char)0x61, /* [3306] */ - (xdc_Char)0x6c, /* [3307] */ - (xdc_Char)0x6c, /* [3308] */ - (xdc_Char)0x6f, /* [3309] */ - (xdc_Char)0x63, /* [3310] */ - (xdc_Char)0x61, /* [3311] */ - (xdc_Char)0x74, /* [3312] */ - (xdc_Char)0x65, /* [3313] */ - (xdc_Char)0x64, /* [3314] */ - (xdc_Char)0x0, /* [3315] */ - (xdc_Char)0x41, /* [3316] */ - (xdc_Char)0x5f, /* [3317] */ - (xdc_Char)0x69, /* [3318] */ - (xdc_Char)0x6e, /* [3319] */ - (xdc_Char)0x76, /* [3320] */ - (xdc_Char)0x61, /* [3321] */ - (xdc_Char)0x6c, /* [3322] */ - (xdc_Char)0x69, /* [3323] */ - (xdc_Char)0x64, /* [3324] */ - (xdc_Char)0x46, /* [3325] */ - (xdc_Char)0x72, /* [3326] */ - (xdc_Char)0x65, /* [3327] */ - (xdc_Char)0x65, /* [3328] */ - (xdc_Char)0x3a, /* [3329] */ - (xdc_Char)0x20, /* [3330] */ - (xdc_Char)0x49, /* [3331] */ - (xdc_Char)0x6e, /* [3332] */ - (xdc_Char)0x76, /* [3333] */ - (xdc_Char)0x61, /* [3334] */ - (xdc_Char)0x6c, /* [3335] */ - (xdc_Char)0x69, /* [3336] */ - (xdc_Char)0x64, /* [3337] */ - (xdc_Char)0x20, /* [3338] */ - (xdc_Char)0x66, /* [3339] */ - (xdc_Char)0x72, /* [3340] */ - (xdc_Char)0x65, /* [3341] */ - (xdc_Char)0x65, /* [3342] */ - (xdc_Char)0x0, /* [3343] */ - (xdc_Char)0x41, /* [3344] */ - (xdc_Char)0x5f, /* [3345] */ - (xdc_Char)0x7a, /* [3346] */ - (xdc_Char)0x65, /* [3347] */ - (xdc_Char)0x72, /* [3348] */ - (xdc_Char)0x6f, /* [3349] */ - (xdc_Char)0x42, /* [3350] */ - (xdc_Char)0x6c, /* [3351] */ - (xdc_Char)0x6f, /* [3352] */ - (xdc_Char)0x63, /* [3353] */ - (xdc_Char)0x6b, /* [3354] */ - (xdc_Char)0x3a, /* [3355] */ - (xdc_Char)0x20, /* [3356] */ - (xdc_Char)0x43, /* [3357] */ - (xdc_Char)0x61, /* [3358] */ - (xdc_Char)0x6e, /* [3359] */ - (xdc_Char)0x6e, /* [3360] */ - (xdc_Char)0x6f, /* [3361] */ - (xdc_Char)0x74, /* [3362] */ - (xdc_Char)0x20, /* [3363] */ - (xdc_Char)0x61, /* [3364] */ - (xdc_Char)0x6c, /* [3365] */ - (xdc_Char)0x6c, /* [3366] */ - (xdc_Char)0x6f, /* [3367] */ - (xdc_Char)0x63, /* [3368] */ - (xdc_Char)0x61, /* [3369] */ - (xdc_Char)0x74, /* [3370] */ - (xdc_Char)0x65, /* [3371] */ - (xdc_Char)0x20, /* [3372] */ - (xdc_Char)0x73, /* [3373] */ - (xdc_Char)0x69, /* [3374] */ - (xdc_Char)0x7a, /* [3375] */ - (xdc_Char)0x65, /* [3376] */ - (xdc_Char)0x20, /* [3377] */ - (xdc_Char)0x30, /* [3378] */ - (xdc_Char)0x0, /* [3379] */ - (xdc_Char)0x41, /* [3380] */ - (xdc_Char)0x5f, /* [3381] */ - (xdc_Char)0x68, /* [3382] */ - (xdc_Char)0x65, /* [3383] */ - (xdc_Char)0x61, /* [3384] */ - (xdc_Char)0x70, /* [3385] */ - (xdc_Char)0x53, /* [3386] */ - (xdc_Char)0x69, /* [3387] */ - (xdc_Char)0x7a, /* [3388] */ - (xdc_Char)0x65, /* [3389] */ - (xdc_Char)0x3a, /* [3390] */ - (xdc_Char)0x20, /* [3391] */ - (xdc_Char)0x52, /* [3392] */ - (xdc_Char)0x65, /* [3393] */ - (xdc_Char)0x71, /* [3394] */ - (xdc_Char)0x75, /* [3395] */ - (xdc_Char)0x65, /* [3396] */ - (xdc_Char)0x73, /* [3397] */ - (xdc_Char)0x74, /* [3398] */ - (xdc_Char)0x65, /* [3399] */ - (xdc_Char)0x64, /* [3400] */ - (xdc_Char)0x20, /* [3401] */ - (xdc_Char)0x68, /* [3402] */ - (xdc_Char)0x65, /* [3403] */ - (xdc_Char)0x61, /* [3404] */ - (xdc_Char)0x70, /* [3405] */ - (xdc_Char)0x20, /* [3406] */ - (xdc_Char)0x73, /* [3407] */ - (xdc_Char)0x69, /* [3408] */ - (xdc_Char)0x7a, /* [3409] */ - (xdc_Char)0x65, /* [3410] */ - (xdc_Char)0x20, /* [3411] */ - (xdc_Char)0x69, /* [3412] */ - (xdc_Char)0x73, /* [3413] */ - (xdc_Char)0x20, /* [3414] */ - (xdc_Char)0x74, /* [3415] */ - (xdc_Char)0x6f, /* [3416] */ - (xdc_Char)0x6f, /* [3417] */ - (xdc_Char)0x20, /* [3418] */ - (xdc_Char)0x73, /* [3419] */ - (xdc_Char)0x6d, /* [3420] */ - (xdc_Char)0x61, /* [3421] */ - (xdc_Char)0x6c, /* [3422] */ - (xdc_Char)0x6c, /* [3423] */ - (xdc_Char)0x0, /* [3424] */ - (xdc_Char)0x41, /* [3425] */ - (xdc_Char)0x5f, /* [3426] */ - (xdc_Char)0x61, /* [3427] */ - (xdc_Char)0x6c, /* [3428] */ - (xdc_Char)0x69, /* [3429] */ - (xdc_Char)0x67, /* [3430] */ - (xdc_Char)0x6e, /* [3431] */ - (xdc_Char)0x3a, /* [3432] */ - (xdc_Char)0x20, /* [3433] */ - (xdc_Char)0x52, /* [3434] */ - (xdc_Char)0x65, /* [3435] */ - (xdc_Char)0x71, /* [3436] */ - (xdc_Char)0x75, /* [3437] */ - (xdc_Char)0x65, /* [3438] */ - (xdc_Char)0x73, /* [3439] */ - (xdc_Char)0x74, /* [3440] */ - (xdc_Char)0x65, /* [3441] */ - (xdc_Char)0x64, /* [3442] */ - (xdc_Char)0x20, /* [3443] */ - (xdc_Char)0x61, /* [3444] */ - (xdc_Char)0x6c, /* [3445] */ - (xdc_Char)0x69, /* [3446] */ - (xdc_Char)0x67, /* [3447] */ - (xdc_Char)0x6e, /* [3448] */ - (xdc_Char)0x20, /* [3449] */ - (xdc_Char)0x69, /* [3450] */ - (xdc_Char)0x73, /* [3451] */ - (xdc_Char)0x20, /* [3452] */ - (xdc_Char)0x6e, /* [3453] */ - (xdc_Char)0x6f, /* [3454] */ - (xdc_Char)0x74, /* [3455] */ - (xdc_Char)0x20, /* [3456] */ - (xdc_Char)0x61, /* [3457] */ - (xdc_Char)0x20, /* [3458] */ - (xdc_Char)0x70, /* [3459] */ - (xdc_Char)0x6f, /* [3460] */ - (xdc_Char)0x77, /* [3461] */ - (xdc_Char)0x65, /* [3462] */ - (xdc_Char)0x72, /* [3463] */ - (xdc_Char)0x20, /* [3464] */ - (xdc_Char)0x6f, /* [3465] */ - (xdc_Char)0x66, /* [3466] */ - (xdc_Char)0x20, /* [3467] */ - (xdc_Char)0x32, /* [3468] */ - (xdc_Char)0x0, /* [3469] */ - (xdc_Char)0x49, /* [3470] */ - (xdc_Char)0x6e, /* [3471] */ - (xdc_Char)0x76, /* [3472] */ - (xdc_Char)0x61, /* [3473] */ - (xdc_Char)0x6c, /* [3474] */ - (xdc_Char)0x69, /* [3475] */ - (xdc_Char)0x64, /* [3476] */ - (xdc_Char)0x20, /* [3477] */ - (xdc_Char)0x62, /* [3478] */ - (xdc_Char)0x6c, /* [3479] */ - (xdc_Char)0x6f, /* [3480] */ - (xdc_Char)0x63, /* [3481] */ - (xdc_Char)0x6b, /* [3482] */ - (xdc_Char)0x20, /* [3483] */ - (xdc_Char)0x61, /* [3484] */ - (xdc_Char)0x64, /* [3485] */ - (xdc_Char)0x64, /* [3486] */ - (xdc_Char)0x72, /* [3487] */ - (xdc_Char)0x65, /* [3488] */ - (xdc_Char)0x73, /* [3489] */ - (xdc_Char)0x73, /* [3490] */ - (xdc_Char)0x20, /* [3491] */ - (xdc_Char)0x6f, /* [3492] */ - (xdc_Char)0x6e, /* [3493] */ - (xdc_Char)0x20, /* [3494] */ - (xdc_Char)0x74, /* [3495] */ - (xdc_Char)0x68, /* [3496] */ - (xdc_Char)0x65, /* [3497] */ - (xdc_Char)0x20, /* [3498] */ - (xdc_Char)0x66, /* [3499] */ - (xdc_Char)0x72, /* [3500] */ - (xdc_Char)0x65, /* [3501] */ - (xdc_Char)0x65, /* [3502] */ - (xdc_Char)0x2e, /* [3503] */ - (xdc_Char)0x20, /* [3504] */ - (xdc_Char)0x46, /* [3505] */ - (xdc_Char)0x61, /* [3506] */ - (xdc_Char)0x69, /* [3507] */ - (xdc_Char)0x6c, /* [3508] */ - (xdc_Char)0x65, /* [3509] */ - (xdc_Char)0x64, /* [3510] */ - (xdc_Char)0x20, /* [3511] */ - (xdc_Char)0x74, /* [3512] */ - (xdc_Char)0x6f, /* [3513] */ - (xdc_Char)0x20, /* [3514] */ - (xdc_Char)0x66, /* [3515] */ - (xdc_Char)0x72, /* [3516] */ - (xdc_Char)0x65, /* [3517] */ - (xdc_Char)0x65, /* [3518] */ - (xdc_Char)0x20, /* [3519] */ - (xdc_Char)0x62, /* [3520] */ - (xdc_Char)0x6c, /* [3521] */ - (xdc_Char)0x6f, /* [3522] */ - (xdc_Char)0x63, /* [3523] */ - (xdc_Char)0x6b, /* [3524] */ - (xdc_Char)0x20, /* [3525] */ - (xdc_Char)0x62, /* [3526] */ - (xdc_Char)0x61, /* [3527] */ - (xdc_Char)0x63, /* [3528] */ - (xdc_Char)0x6b, /* [3529] */ - (xdc_Char)0x20, /* [3530] */ - (xdc_Char)0x74, /* [3531] */ - (xdc_Char)0x6f, /* [3532] */ - (xdc_Char)0x20, /* [3533] */ - (xdc_Char)0x68, /* [3534] */ - (xdc_Char)0x65, /* [3535] */ - (xdc_Char)0x61, /* [3536] */ - (xdc_Char)0x70, /* [3537] */ - (xdc_Char)0x2e, /* [3538] */ - (xdc_Char)0x0, /* [3539] */ - (xdc_Char)0x41, /* [3540] */ - (xdc_Char)0x5f, /* [3541] */ - (xdc_Char)0x64, /* [3542] */ - (xdc_Char)0x6f, /* [3543] */ - (xdc_Char)0x75, /* [3544] */ - (xdc_Char)0x62, /* [3545] */ - (xdc_Char)0x6c, /* [3546] */ - (xdc_Char)0x65, /* [3547] */ - (xdc_Char)0x46, /* [3548] */ - (xdc_Char)0x72, /* [3549] */ - (xdc_Char)0x65, /* [3550] */ - (xdc_Char)0x65, /* [3551] */ - (xdc_Char)0x3a, /* [3552] */ - (xdc_Char)0x20, /* [3553] */ - (xdc_Char)0x42, /* [3554] */ - (xdc_Char)0x75, /* [3555] */ - (xdc_Char)0x66, /* [3556] */ - (xdc_Char)0x66, /* [3557] */ - (xdc_Char)0x65, /* [3558] */ - (xdc_Char)0x72, /* [3559] */ - (xdc_Char)0x20, /* [3560] */ - (xdc_Char)0x61, /* [3561] */ - (xdc_Char)0x6c, /* [3562] */ - (xdc_Char)0x72, /* [3563] */ - (xdc_Char)0x65, /* [3564] */ - (xdc_Char)0x61, /* [3565] */ - (xdc_Char)0x64, /* [3566] */ - (xdc_Char)0x79, /* [3567] */ - (xdc_Char)0x20, /* [3568] */ - (xdc_Char)0x66, /* [3569] */ - (xdc_Char)0x72, /* [3570] */ - (xdc_Char)0x65, /* [3571] */ - (xdc_Char)0x65, /* [3572] */ - (xdc_Char)0x0, /* [3573] */ - (xdc_Char)0x41, /* [3574] */ - (xdc_Char)0x5f, /* [3575] */ - (xdc_Char)0x62, /* [3576] */ - (xdc_Char)0x75, /* [3577] */ - (xdc_Char)0x66, /* [3578] */ - (xdc_Char)0x4f, /* [3579] */ - (xdc_Char)0x76, /* [3580] */ - (xdc_Char)0x65, /* [3581] */ - (xdc_Char)0x72, /* [3582] */ - (xdc_Char)0x66, /* [3583] */ - (xdc_Char)0x6c, /* [3584] */ - (xdc_Char)0x6f, /* [3585] */ - (xdc_Char)0x77, /* [3586] */ - (xdc_Char)0x3a, /* [3587] */ - (xdc_Char)0x20, /* [3588] */ - (xdc_Char)0x42, /* [3589] */ - (xdc_Char)0x75, /* [3590] */ - (xdc_Char)0x66, /* [3591] */ - (xdc_Char)0x66, /* [3592] */ - (xdc_Char)0x65, /* [3593] */ - (xdc_Char)0x72, /* [3594] */ - (xdc_Char)0x20, /* [3595] */ - (xdc_Char)0x6f, /* [3596] */ - (xdc_Char)0x76, /* [3597] */ - (xdc_Char)0x65, /* [3598] */ - (xdc_Char)0x72, /* [3599] */ - (xdc_Char)0x66, /* [3600] */ - (xdc_Char)0x6c, /* [3601] */ - (xdc_Char)0x6f, /* [3602] */ - (xdc_Char)0x77, /* [3603] */ - (xdc_Char)0x0, /* [3604] */ - (xdc_Char)0x41, /* [3605] */ - (xdc_Char)0x5f, /* [3606] */ - (xdc_Char)0x6e, /* [3607] */ - (xdc_Char)0x6f, /* [3608] */ - (xdc_Char)0x74, /* [3609] */ - (xdc_Char)0x45, /* [3610] */ - (xdc_Char)0x6d, /* [3611] */ - (xdc_Char)0x70, /* [3612] */ - (xdc_Char)0x74, /* [3613] */ - (xdc_Char)0x79, /* [3614] */ - (xdc_Char)0x3a, /* [3615] */ - (xdc_Char)0x20, /* [3616] */ - (xdc_Char)0x48, /* [3617] */ - (xdc_Char)0x65, /* [3618] */ - (xdc_Char)0x61, /* [3619] */ - (xdc_Char)0x70, /* [3620] */ - (xdc_Char)0x20, /* [3621] */ - (xdc_Char)0x6e, /* [3622] */ - (xdc_Char)0x6f, /* [3623] */ - (xdc_Char)0x74, /* [3624] */ - (xdc_Char)0x20, /* [3625] */ - (xdc_Char)0x65, /* [3626] */ - (xdc_Char)0x6d, /* [3627] */ - (xdc_Char)0x70, /* [3628] */ - (xdc_Char)0x74, /* [3629] */ - (xdc_Char)0x79, /* [3630] */ - (xdc_Char)0x0, /* [3631] */ - (xdc_Char)0x41, /* [3632] */ - (xdc_Char)0x5f, /* [3633] */ - (xdc_Char)0x6e, /* [3634] */ - (xdc_Char)0x75, /* [3635] */ - (xdc_Char)0x6c, /* [3636] */ - (xdc_Char)0x6c, /* [3637] */ - (xdc_Char)0x4f, /* [3638] */ - (xdc_Char)0x62, /* [3639] */ - (xdc_Char)0x6a, /* [3640] */ - (xdc_Char)0x65, /* [3641] */ - (xdc_Char)0x63, /* [3642] */ - (xdc_Char)0x74, /* [3643] */ - (xdc_Char)0x3a, /* [3644] */ - (xdc_Char)0x20, /* [3645] */ - (xdc_Char)0x48, /* [3646] */ - (xdc_Char)0x65, /* [3647] */ - (xdc_Char)0x61, /* [3648] */ - (xdc_Char)0x70, /* [3649] */ - (xdc_Char)0x54, /* [3650] */ - (xdc_Char)0x72, /* [3651] */ - (xdc_Char)0x61, /* [3652] */ - (xdc_Char)0x63, /* [3653] */ - (xdc_Char)0x6b, /* [3654] */ - (xdc_Char)0x5f, /* [3655] */ - (xdc_Char)0x70, /* [3656] */ - (xdc_Char)0x72, /* [3657] */ - (xdc_Char)0x69, /* [3658] */ - (xdc_Char)0x6e, /* [3659] */ - (xdc_Char)0x74, /* [3660] */ - (xdc_Char)0x48, /* [3661] */ - (xdc_Char)0x65, /* [3662] */ - (xdc_Char)0x61, /* [3663] */ - (xdc_Char)0x70, /* [3664] */ - (xdc_Char)0x20, /* [3665] */ - (xdc_Char)0x63, /* [3666] */ - (xdc_Char)0x61, /* [3667] */ - (xdc_Char)0x6c, /* [3668] */ - (xdc_Char)0x6c, /* [3669] */ - (xdc_Char)0x65, /* [3670] */ - (xdc_Char)0x64, /* [3671] */ - (xdc_Char)0x20, /* [3672] */ - (xdc_Char)0x77, /* [3673] */ - (xdc_Char)0x69, /* [3674] */ - (xdc_Char)0x74, /* [3675] */ - (xdc_Char)0x68, /* [3676] */ - (xdc_Char)0x20, /* [3677] */ - (xdc_Char)0x6e, /* [3678] */ - (xdc_Char)0x75, /* [3679] */ - (xdc_Char)0x6c, /* [3680] */ - (xdc_Char)0x6c, /* [3681] */ - (xdc_Char)0x20, /* [3682] */ - (xdc_Char)0x6f, /* [3683] */ - (xdc_Char)0x62, /* [3684] */ - (xdc_Char)0x6a, /* [3685] */ - (xdc_Char)0x0, /* [3686] */ - (xdc_Char)0x61, /* [3687] */ - (xdc_Char)0x73, /* [3688] */ - (xdc_Char)0x73, /* [3689] */ - (xdc_Char)0x65, /* [3690] */ - (xdc_Char)0x72, /* [3691] */ - (xdc_Char)0x74, /* [3692] */ - (xdc_Char)0x69, /* [3693] */ - (xdc_Char)0x6f, /* [3694] */ - (xdc_Char)0x6e, /* [3695] */ - (xdc_Char)0x20, /* [3696] */ - (xdc_Char)0x66, /* [3697] */ - (xdc_Char)0x61, /* [3698] */ - (xdc_Char)0x69, /* [3699] */ - (xdc_Char)0x6c, /* [3700] */ - (xdc_Char)0x75, /* [3701] */ - (xdc_Char)0x72, /* [3702] */ - (xdc_Char)0x65, /* [3703] */ - (xdc_Char)0x25, /* [3704] */ - (xdc_Char)0x73, /* [3705] */ - (xdc_Char)0x25, /* [3706] */ - (xdc_Char)0x73, /* [3707] */ - (xdc_Char)0x0, /* [3708] */ - (xdc_Char)0x25, /* [3709] */ - (xdc_Char)0x24, /* [3710] */ - (xdc_Char)0x53, /* [3711] */ - (xdc_Char)0x0, /* [3712] */ - (xdc_Char)0x6f, /* [3713] */ - (xdc_Char)0x75, /* [3714] */ - (xdc_Char)0x74, /* [3715] */ - (xdc_Char)0x20, /* [3716] */ - (xdc_Char)0x6f, /* [3717] */ - (xdc_Char)0x66, /* [3718] */ - (xdc_Char)0x20, /* [3719] */ - (xdc_Char)0x6d, /* [3720] */ - (xdc_Char)0x65, /* [3721] */ - (xdc_Char)0x6d, /* [3722] */ - (xdc_Char)0x6f, /* [3723] */ - (xdc_Char)0x72, /* [3724] */ - (xdc_Char)0x79, /* [3725] */ - (xdc_Char)0x3a, /* [3726] */ - (xdc_Char)0x20, /* [3727] */ - (xdc_Char)0x68, /* [3728] */ - (xdc_Char)0x65, /* [3729] */ - (xdc_Char)0x61, /* [3730] */ - (xdc_Char)0x70, /* [3731] */ - (xdc_Char)0x3d, /* [3732] */ - (xdc_Char)0x30, /* [3733] */ - (xdc_Char)0x78, /* [3734] */ - (xdc_Char)0x25, /* [3735] */ - (xdc_Char)0x78, /* [3736] */ - (xdc_Char)0x2c, /* [3737] */ - (xdc_Char)0x20, /* [3738] */ - (xdc_Char)0x73, /* [3739] */ - (xdc_Char)0x69, /* [3740] */ - (xdc_Char)0x7a, /* [3741] */ - (xdc_Char)0x65, /* [3742] */ - (xdc_Char)0x3d, /* [3743] */ - (xdc_Char)0x25, /* [3744] */ - (xdc_Char)0x75, /* [3745] */ - (xdc_Char)0x0, /* [3746] */ - (xdc_Char)0x25, /* [3747] */ - (xdc_Char)0x73, /* [3748] */ - (xdc_Char)0x20, /* [3749] */ - (xdc_Char)0x30, /* [3750] */ - (xdc_Char)0x78, /* [3751] */ - (xdc_Char)0x25, /* [3752] */ - (xdc_Char)0x78, /* [3753] */ - (xdc_Char)0x0, /* [3754] */ - (xdc_Char)0x45, /* [3755] */ - (xdc_Char)0x5f, /* [3756] */ - (xdc_Char)0x62, /* [3757] */ - (xdc_Char)0x61, /* [3758] */ - (xdc_Char)0x64, /* [3759] */ - (xdc_Char)0x4c, /* [3760] */ - (xdc_Char)0x65, /* [3761] */ - (xdc_Char)0x76, /* [3762] */ - (xdc_Char)0x65, /* [3763] */ - (xdc_Char)0x6c, /* [3764] */ - (xdc_Char)0x3a, /* [3765] */ - (xdc_Char)0x20, /* [3766] */ - (xdc_Char)0x42, /* [3767] */ - (xdc_Char)0x61, /* [3768] */ - (xdc_Char)0x64, /* [3769] */ - (xdc_Char)0x20, /* [3770] */ - (xdc_Char)0x66, /* [3771] */ - (xdc_Char)0x69, /* [3772] */ - (xdc_Char)0x6c, /* [3773] */ - (xdc_Char)0x74, /* [3774] */ - (xdc_Char)0x65, /* [3775] */ - (xdc_Char)0x72, /* [3776] */ - (xdc_Char)0x20, /* [3777] */ - (xdc_Char)0x6c, /* [3778] */ - (xdc_Char)0x65, /* [3779] */ - (xdc_Char)0x76, /* [3780] */ - (xdc_Char)0x65, /* [3781] */ - (xdc_Char)0x6c, /* [3782] */ - (xdc_Char)0x20, /* [3783] */ - (xdc_Char)0x76, /* [3784] */ - (xdc_Char)0x61, /* [3785] */ - (xdc_Char)0x6c, /* [3786] */ - (xdc_Char)0x75, /* [3787] */ - (xdc_Char)0x65, /* [3788] */ - (xdc_Char)0x3a, /* [3789] */ - (xdc_Char)0x20, /* [3790] */ - (xdc_Char)0x25, /* [3791] */ - (xdc_Char)0x64, /* [3792] */ - (xdc_Char)0x0, /* [3793] */ - (xdc_Char)0x66, /* [3794] */ - (xdc_Char)0x72, /* [3795] */ - (xdc_Char)0x65, /* [3796] */ - (xdc_Char)0x65, /* [3797] */ - (xdc_Char)0x28, /* [3798] */ - (xdc_Char)0x29, /* [3799] */ - (xdc_Char)0x20, /* [3800] */ - (xdc_Char)0x69, /* [3801] */ - (xdc_Char)0x6e, /* [3802] */ - (xdc_Char)0x76, /* [3803] */ - (xdc_Char)0x61, /* [3804] */ - (xdc_Char)0x6c, /* [3805] */ - (xdc_Char)0x69, /* [3806] */ - (xdc_Char)0x64, /* [3807] */ - (xdc_Char)0x20, /* [3808] */ - (xdc_Char)0x69, /* [3809] */ - (xdc_Char)0x6e, /* [3810] */ - (xdc_Char)0x20, /* [3811] */ - (xdc_Char)0x67, /* [3812] */ - (xdc_Char)0x72, /* [3813] */ - (xdc_Char)0x6f, /* [3814] */ - (xdc_Char)0x77, /* [3815] */ - (xdc_Char)0x74, /* [3816] */ - (xdc_Char)0x68, /* [3817] */ - (xdc_Char)0x2d, /* [3818] */ - (xdc_Char)0x6f, /* [3819] */ - (xdc_Char)0x6e, /* [3820] */ - (xdc_Char)0x6c, /* [3821] */ - (xdc_Char)0x79, /* [3822] */ - (xdc_Char)0x20, /* [3823] */ - (xdc_Char)0x48, /* [3824] */ - (xdc_Char)0x65, /* [3825] */ - (xdc_Char)0x61, /* [3826] */ - (xdc_Char)0x70, /* [3827] */ - (xdc_Char)0x4d, /* [3828] */ - (xdc_Char)0x69, /* [3829] */ - (xdc_Char)0x6e, /* [3830] */ - (xdc_Char)0x0, /* [3831] */ - (xdc_Char)0x54, /* [3832] */ - (xdc_Char)0x68, /* [3833] */ - (xdc_Char)0x65, /* [3834] */ - (xdc_Char)0x20, /* [3835] */ - (xdc_Char)0x52, /* [3836] */ - (xdc_Char)0x54, /* [3837] */ - (xdc_Char)0x53, /* [3838] */ - (xdc_Char)0x20, /* [3839] */ - (xdc_Char)0x68, /* [3840] */ - (xdc_Char)0x65, /* [3841] */ - (xdc_Char)0x61, /* [3842] */ - (xdc_Char)0x70, /* [3843] */ - (xdc_Char)0x20, /* [3844] */ - (xdc_Char)0x69, /* [3845] */ - (xdc_Char)0x73, /* [3846] */ - (xdc_Char)0x20, /* [3847] */ - (xdc_Char)0x75, /* [3848] */ - (xdc_Char)0x73, /* [3849] */ - (xdc_Char)0x65, /* [3850] */ - (xdc_Char)0x64, /* [3851] */ - (xdc_Char)0x20, /* [3852] */ - (xdc_Char)0x75, /* [3853] */ - (xdc_Char)0x70, /* [3854] */ - (xdc_Char)0x2e, /* [3855] */ - (xdc_Char)0x20, /* [3856] */ - (xdc_Char)0x45, /* [3857] */ - (xdc_Char)0x78, /* [3858] */ - (xdc_Char)0x61, /* [3859] */ - (xdc_Char)0x6d, /* [3860] */ - (xdc_Char)0x69, /* [3861] */ - (xdc_Char)0x6e, /* [3862] */ - (xdc_Char)0x65, /* [3863] */ - (xdc_Char)0x20, /* [3864] */ - (xdc_Char)0x50, /* [3865] */ - (xdc_Char)0x72, /* [3866] */ - (xdc_Char)0x6f, /* [3867] */ - (xdc_Char)0x67, /* [3868] */ - (xdc_Char)0x72, /* [3869] */ - (xdc_Char)0x61, /* [3870] */ - (xdc_Char)0x6d, /* [3871] */ - (xdc_Char)0x2e, /* [3872] */ - (xdc_Char)0x68, /* [3873] */ - (xdc_Char)0x65, /* [3874] */ - (xdc_Char)0x61, /* [3875] */ - (xdc_Char)0x70, /* [3876] */ - (xdc_Char)0x2e, /* [3877] */ - (xdc_Char)0x0, /* [3878] */ - (xdc_Char)0x45, /* [3879] */ - (xdc_Char)0x5f, /* [3880] */ - (xdc_Char)0x62, /* [3881] */ - (xdc_Char)0x61, /* [3882] */ - (xdc_Char)0x64, /* [3883] */ - (xdc_Char)0x43, /* [3884] */ - (xdc_Char)0x6f, /* [3885] */ - (xdc_Char)0x6d, /* [3886] */ - (xdc_Char)0x6d, /* [3887] */ - (xdc_Char)0x61, /* [3888] */ - (xdc_Char)0x6e, /* [3889] */ - (xdc_Char)0x64, /* [3890] */ - (xdc_Char)0x3a, /* [3891] */ - (xdc_Char)0x20, /* [3892] */ - (xdc_Char)0x52, /* [3893] */ - (xdc_Char)0x65, /* [3894] */ - (xdc_Char)0x63, /* [3895] */ - (xdc_Char)0x65, /* [3896] */ - (xdc_Char)0x69, /* [3897] */ - (xdc_Char)0x76, /* [3898] */ - (xdc_Char)0x65, /* [3899] */ - (xdc_Char)0x64, /* [3900] */ - (xdc_Char)0x20, /* [3901] */ - (xdc_Char)0x69, /* [3902] */ - (xdc_Char)0x6e, /* [3903] */ - (xdc_Char)0x76, /* [3904] */ - (xdc_Char)0x61, /* [3905] */ - (xdc_Char)0x6c, /* [3906] */ - (xdc_Char)0x69, /* [3907] */ - (xdc_Char)0x64, /* [3908] */ - (xdc_Char)0x20, /* [3909] */ - (xdc_Char)0x63, /* [3910] */ - (xdc_Char)0x6f, /* [3911] */ - (xdc_Char)0x6d, /* [3912] */ - (xdc_Char)0x6d, /* [3913] */ - (xdc_Char)0x61, /* [3914] */ - (xdc_Char)0x6e, /* [3915] */ - (xdc_Char)0x64, /* [3916] */ - (xdc_Char)0x2c, /* [3917] */ - (xdc_Char)0x20, /* [3918] */ - (xdc_Char)0x69, /* [3919] */ - (xdc_Char)0x64, /* [3920] */ - (xdc_Char)0x3a, /* [3921] */ - (xdc_Char)0x20, /* [3922] */ - (xdc_Char)0x25, /* [3923] */ - (xdc_Char)0x64, /* [3924] */ - (xdc_Char)0x2e, /* [3925] */ - (xdc_Char)0x0, /* [3926] */ - (xdc_Char)0x45, /* [3927] */ - (xdc_Char)0x5f, /* [3928] */ - (xdc_Char)0x61, /* [3929] */ - (xdc_Char)0x6c, /* [3930] */ - (xdc_Char)0x72, /* [3931] */ - (xdc_Char)0x65, /* [3932] */ - (xdc_Char)0x61, /* [3933] */ - (xdc_Char)0x64, /* [3934] */ - (xdc_Char)0x79, /* [3935] */ - (xdc_Char)0x44, /* [3936] */ - (xdc_Char)0x65, /* [3937] */ - (xdc_Char)0x66, /* [3938] */ - (xdc_Char)0x69, /* [3939] */ - (xdc_Char)0x6e, /* [3940] */ - (xdc_Char)0x65, /* [3941] */ - (xdc_Char)0x64, /* [3942] */ - (xdc_Char)0x3a, /* [3943] */ - (xdc_Char)0x20, /* [3944] */ - (xdc_Char)0x48, /* [3945] */ - (xdc_Char)0x77, /* [3946] */ - (xdc_Char)0x69, /* [3947] */ - (xdc_Char)0x20, /* [3948] */ - (xdc_Char)0x61, /* [3949] */ - (xdc_Char)0x6c, /* [3950] */ - (xdc_Char)0x72, /* [3951] */ - (xdc_Char)0x65, /* [3952] */ - (xdc_Char)0x61, /* [3953] */ - (xdc_Char)0x64, /* [3954] */ - (xdc_Char)0x79, /* [3955] */ - (xdc_Char)0x20, /* [3956] */ - (xdc_Char)0x64, /* [3957] */ - (xdc_Char)0x65, /* [3958] */ - (xdc_Char)0x66, /* [3959] */ - (xdc_Char)0x69, /* [3960] */ - (xdc_Char)0x6e, /* [3961] */ - (xdc_Char)0x65, /* [3962] */ - (xdc_Char)0x64, /* [3963] */ - (xdc_Char)0x3a, /* [3964] */ - (xdc_Char)0x20, /* [3965] */ - (xdc_Char)0x69, /* [3966] */ - (xdc_Char)0x6e, /* [3967] */ - (xdc_Char)0x74, /* [3968] */ - (xdc_Char)0x72, /* [3969] */ - (xdc_Char)0x23, /* [3970] */ - (xdc_Char)0x20, /* [3971] */ - (xdc_Char)0x25, /* [3972] */ - (xdc_Char)0x64, /* [3973] */ - (xdc_Char)0x0, /* [3974] */ - (xdc_Char)0x45, /* [3975] */ - (xdc_Char)0x5f, /* [3976] */ - (xdc_Char)0x68, /* [3977] */ - (xdc_Char)0x77, /* [3978] */ - (xdc_Char)0x69, /* [3979] */ - (xdc_Char)0x4c, /* [3980] */ - (xdc_Char)0x69, /* [3981] */ - (xdc_Char)0x6d, /* [3982] */ - (xdc_Char)0x69, /* [3983] */ - (xdc_Char)0x74, /* [3984] */ - (xdc_Char)0x45, /* [3985] */ - (xdc_Char)0x78, /* [3986] */ - (xdc_Char)0x63, /* [3987] */ - (xdc_Char)0x65, /* [3988] */ - (xdc_Char)0x65, /* [3989] */ - (xdc_Char)0x64, /* [3990] */ - (xdc_Char)0x65, /* [3991] */ - (xdc_Char)0x64, /* [3992] */ - (xdc_Char)0x3a, /* [3993] */ - (xdc_Char)0x20, /* [3994] */ - (xdc_Char)0x54, /* [3995] */ - (xdc_Char)0x6f, /* [3996] */ - (xdc_Char)0x6f, /* [3997] */ - (xdc_Char)0x20, /* [3998] */ - (xdc_Char)0x6d, /* [3999] */ - (xdc_Char)0x61, /* [4000] */ - (xdc_Char)0x6e, /* [4001] */ - (xdc_Char)0x79, /* [4002] */ - (xdc_Char)0x20, /* [4003] */ - (xdc_Char)0x69, /* [4004] */ - (xdc_Char)0x6e, /* [4005] */ - (xdc_Char)0x74, /* [4006] */ - (xdc_Char)0x65, /* [4007] */ - (xdc_Char)0x72, /* [4008] */ - (xdc_Char)0x72, /* [4009] */ - (xdc_Char)0x75, /* [4010] */ - (xdc_Char)0x70, /* [4011] */ - (xdc_Char)0x74, /* [4012] */ - (xdc_Char)0x73, /* [4013] */ - (xdc_Char)0x20, /* [4014] */ - (xdc_Char)0x64, /* [4015] */ - (xdc_Char)0x65, /* [4016] */ - (xdc_Char)0x66, /* [4017] */ - (xdc_Char)0x69, /* [4018] */ - (xdc_Char)0x6e, /* [4019] */ - (xdc_Char)0x65, /* [4020] */ - (xdc_Char)0x64, /* [4021] */ - (xdc_Char)0x0, /* [4022] */ - (xdc_Char)0x45, /* [4023] */ - (xdc_Char)0x5f, /* [4024] */ - (xdc_Char)0x65, /* [4025] */ - (xdc_Char)0x78, /* [4026] */ - (xdc_Char)0x63, /* [4027] */ - (xdc_Char)0x65, /* [4028] */ - (xdc_Char)0x70, /* [4029] */ - (xdc_Char)0x74, /* [4030] */ - (xdc_Char)0x69, /* [4031] */ - (xdc_Char)0x6f, /* [4032] */ - (xdc_Char)0x6e, /* [4033] */ - (xdc_Char)0x3a, /* [4034] */ - (xdc_Char)0x20, /* [4035] */ - (xdc_Char)0x69, /* [4036] */ - (xdc_Char)0x64, /* [4037] */ - (xdc_Char)0x20, /* [4038] */ - (xdc_Char)0x3d, /* [4039] */ - (xdc_Char)0x20, /* [4040] */ - (xdc_Char)0x25, /* [4041] */ - (xdc_Char)0x64, /* [4042] */ - (xdc_Char)0x2c, /* [4043] */ - (xdc_Char)0x20, /* [4044] */ - (xdc_Char)0x70, /* [4045] */ - (xdc_Char)0x63, /* [4046] */ - (xdc_Char)0x20, /* [4047] */ - (xdc_Char)0x3d, /* [4048] */ - (xdc_Char)0x20, /* [4049] */ - (xdc_Char)0x25, /* [4050] */ - (xdc_Char)0x30, /* [4051] */ - (xdc_Char)0x38, /* [4052] */ - (xdc_Char)0x78, /* [4053] */ - (xdc_Char)0x2e, /* [4054] */ - (xdc_Char)0xa, /* [4055] */ - (xdc_Char)0x54, /* [4056] */ - (xdc_Char)0x6f, /* [4057] */ - (xdc_Char)0x20, /* [4058] */ - (xdc_Char)0x73, /* [4059] */ - (xdc_Char)0x65, /* [4060] */ - (xdc_Char)0x65, /* [4061] */ - (xdc_Char)0x20, /* [4062] */ - (xdc_Char)0x6d, /* [4063] */ - (xdc_Char)0x6f, /* [4064] */ - (xdc_Char)0x72, /* [4065] */ - (xdc_Char)0x65, /* [4066] */ - (xdc_Char)0x20, /* [4067] */ - (xdc_Char)0x65, /* [4068] */ - (xdc_Char)0x78, /* [4069] */ - (xdc_Char)0x63, /* [4070] */ - (xdc_Char)0x65, /* [4071] */ - (xdc_Char)0x70, /* [4072] */ - (xdc_Char)0x74, /* [4073] */ - (xdc_Char)0x69, /* [4074] */ - (xdc_Char)0x6f, /* [4075] */ - (xdc_Char)0x6e, /* [4076] */ - (xdc_Char)0x20, /* [4077] */ - (xdc_Char)0x64, /* [4078] */ - (xdc_Char)0x65, /* [4079] */ - (xdc_Char)0x74, /* [4080] */ - (xdc_Char)0x61, /* [4081] */ - (xdc_Char)0x69, /* [4082] */ - (xdc_Char)0x6c, /* [4083] */ - (xdc_Char)0x2c, /* [4084] */ - (xdc_Char)0x20, /* [4085] */ - (xdc_Char)0x73, /* [4086] */ - (xdc_Char)0x65, /* [4087] */ - (xdc_Char)0x74, /* [4088] */ - (xdc_Char)0x20, /* [4089] */ - (xdc_Char)0x74, /* [4090] */ - (xdc_Char)0x69, /* [4091] */ - (xdc_Char)0x2e, /* [4092] */ - (xdc_Char)0x73, /* [4093] */ - (xdc_Char)0x79, /* [4094] */ - (xdc_Char)0x73, /* [4095] */ - (xdc_Char)0x62, /* [4096] */ - (xdc_Char)0x69, /* [4097] */ - (xdc_Char)0x6f, /* [4098] */ - (xdc_Char)0x73, /* [4099] */ - (xdc_Char)0x2e, /* [4100] */ - (xdc_Char)0x66, /* [4101] */ - (xdc_Char)0x61, /* [4102] */ - (xdc_Char)0x6d, /* [4103] */ - (xdc_Char)0x69, /* [4104] */ - (xdc_Char)0x6c, /* [4105] */ - (xdc_Char)0x79, /* [4106] */ - (xdc_Char)0x2e, /* [4107] */ - (xdc_Char)0x61, /* [4108] */ - (xdc_Char)0x72, /* [4109] */ - (xdc_Char)0x6d, /* [4110] */ - (xdc_Char)0x2e, /* [4111] */ - (xdc_Char)0x6d, /* [4112] */ - (xdc_Char)0x33, /* [4113] */ - (xdc_Char)0x2e, /* [4114] */ - (xdc_Char)0x48, /* [4115] */ - (xdc_Char)0x77, /* [4116] */ - (xdc_Char)0x69, /* [4117] */ - (xdc_Char)0x2e, /* [4118] */ - (xdc_Char)0x65, /* [4119] */ - (xdc_Char)0x6e, /* [4120] */ - (xdc_Char)0x61, /* [4121] */ - (xdc_Char)0x62, /* [4122] */ - (xdc_Char)0x6c, /* [4123] */ - (xdc_Char)0x65, /* [4124] */ - (xdc_Char)0x45, /* [4125] */ - (xdc_Char)0x78, /* [4126] */ - (xdc_Char)0x63, /* [4127] */ - (xdc_Char)0x65, /* [4128] */ - (xdc_Char)0x70, /* [4129] */ - (xdc_Char)0x74, /* [4130] */ - (xdc_Char)0x69, /* [4131] */ - (xdc_Char)0x6f, /* [4132] */ - (xdc_Char)0x6e, /* [4133] */ - (xdc_Char)0x20, /* [4134] */ - (xdc_Char)0x3d, /* [4135] */ - (xdc_Char)0x20, /* [4136] */ - (xdc_Char)0x74, /* [4137] */ - (xdc_Char)0x72, /* [4138] */ - (xdc_Char)0x75, /* [4139] */ - (xdc_Char)0x65, /* [4140] */ - (xdc_Char)0x20, /* [4141] */ - (xdc_Char)0x6f, /* [4142] */ - (xdc_Char)0x72, /* [4143] */ - (xdc_Char)0x2c, /* [4144] */ - (xdc_Char)0xa, /* [4145] */ - (xdc_Char)0x65, /* [4146] */ - (xdc_Char)0x78, /* [4147] */ - (xdc_Char)0x61, /* [4148] */ - (xdc_Char)0x6d, /* [4149] */ - (xdc_Char)0x69, /* [4150] */ - (xdc_Char)0x6e, /* [4151] */ - (xdc_Char)0x65, /* [4152] */ - (xdc_Char)0x20, /* [4153] */ - (xdc_Char)0x74, /* [4154] */ - (xdc_Char)0x68, /* [4155] */ - (xdc_Char)0x65, /* [4156] */ - (xdc_Char)0x20, /* [4157] */ - (xdc_Char)0x45, /* [4158] */ - (xdc_Char)0x78, /* [4159] */ - (xdc_Char)0x63, /* [4160] */ - (xdc_Char)0x65, /* [4161] */ - (xdc_Char)0x70, /* [4162] */ - (xdc_Char)0x74, /* [4163] */ - (xdc_Char)0x69, /* [4164] */ - (xdc_Char)0x6f, /* [4165] */ - (xdc_Char)0x6e, /* [4166] */ - (xdc_Char)0x20, /* [4167] */ - (xdc_Char)0x76, /* [4168] */ - (xdc_Char)0x69, /* [4169] */ - (xdc_Char)0x65, /* [4170] */ - (xdc_Char)0x77, /* [4171] */ - (xdc_Char)0x20, /* [4172] */ - (xdc_Char)0x66, /* [4173] */ - (xdc_Char)0x6f, /* [4174] */ - (xdc_Char)0x72, /* [4175] */ - (xdc_Char)0x20, /* [4176] */ - (xdc_Char)0x74, /* [4177] */ - (xdc_Char)0x68, /* [4178] */ - (xdc_Char)0x65, /* [4179] */ - (xdc_Char)0x20, /* [4180] */ - (xdc_Char)0x74, /* [4181] */ - (xdc_Char)0x69, /* [4182] */ - (xdc_Char)0x2e, /* [4183] */ - (xdc_Char)0x73, /* [4184] */ - (xdc_Char)0x79, /* [4185] */ - (xdc_Char)0x73, /* [4186] */ - (xdc_Char)0x62, /* [4187] */ - (xdc_Char)0x69, /* [4188] */ - (xdc_Char)0x6f, /* [4189] */ - (xdc_Char)0x73, /* [4190] */ - (xdc_Char)0x2e, /* [4191] */ - (xdc_Char)0x66, /* [4192] */ - (xdc_Char)0x61, /* [4193] */ - (xdc_Char)0x6d, /* [4194] */ - (xdc_Char)0x69, /* [4195] */ - (xdc_Char)0x6c, /* [4196] */ - (xdc_Char)0x79, /* [4197] */ - (xdc_Char)0x2e, /* [4198] */ - (xdc_Char)0x61, /* [4199] */ - (xdc_Char)0x72, /* [4200] */ - (xdc_Char)0x6d, /* [4201] */ - (xdc_Char)0x2e, /* [4202] */ - (xdc_Char)0x6d, /* [4203] */ - (xdc_Char)0x33, /* [4204] */ - (xdc_Char)0x2e, /* [4205] */ - (xdc_Char)0x48, /* [4206] */ - (xdc_Char)0x77, /* [4207] */ - (xdc_Char)0x69, /* [4208] */ - (xdc_Char)0x20, /* [4209] */ - (xdc_Char)0x6d, /* [4210] */ - (xdc_Char)0x6f, /* [4211] */ - (xdc_Char)0x64, /* [4212] */ - (xdc_Char)0x75, /* [4213] */ - (xdc_Char)0x6c, /* [4214] */ - (xdc_Char)0x65, /* [4215] */ - (xdc_Char)0x20, /* [4216] */ - (xdc_Char)0x75, /* [4217] */ - (xdc_Char)0x73, /* [4218] */ - (xdc_Char)0x69, /* [4219] */ - (xdc_Char)0x6e, /* [4220] */ - (xdc_Char)0x67, /* [4221] */ - (xdc_Char)0x20, /* [4222] */ - (xdc_Char)0x52, /* [4223] */ - (xdc_Char)0x4f, /* [4224] */ - (xdc_Char)0x56, /* [4225] */ - (xdc_Char)0x2e, /* [4226] */ - (xdc_Char)0x0, /* [4227] */ - (xdc_Char)0x45, /* [4228] */ - (xdc_Char)0x5f, /* [4229] */ - (xdc_Char)0x6e, /* [4230] */ - (xdc_Char)0x6f, /* [4231] */ - (xdc_Char)0x49, /* [4232] */ - (xdc_Char)0x73, /* [4233] */ - (xdc_Char)0x72, /* [4234] */ - (xdc_Char)0x3a, /* [4235] */ - (xdc_Char)0x20, /* [4236] */ - (xdc_Char)0x69, /* [4237] */ - (xdc_Char)0x64, /* [4238] */ - (xdc_Char)0x20, /* [4239] */ - (xdc_Char)0x3d, /* [4240] */ - (xdc_Char)0x20, /* [4241] */ - (xdc_Char)0x25, /* [4242] */ - (xdc_Char)0x64, /* [4243] */ - (xdc_Char)0x2c, /* [4244] */ - (xdc_Char)0x20, /* [4245] */ - (xdc_Char)0x70, /* [4246] */ - (xdc_Char)0x63, /* [4247] */ - (xdc_Char)0x20, /* [4248] */ - (xdc_Char)0x3d, /* [4249] */ - (xdc_Char)0x20, /* [4250] */ - (xdc_Char)0x25, /* [4251] */ - (xdc_Char)0x30, /* [4252] */ - (xdc_Char)0x38, /* [4253] */ - (xdc_Char)0x78, /* [4254] */ - (xdc_Char)0x0, /* [4255] */ - (xdc_Char)0x45, /* [4256] */ - (xdc_Char)0x5f, /* [4257] */ - (xdc_Char)0x4e, /* [4258] */ - (xdc_Char)0x4d, /* [4259] */ - (xdc_Char)0x49, /* [4260] */ - (xdc_Char)0x3a, /* [4261] */ - (xdc_Char)0x20, /* [4262] */ - (xdc_Char)0x25, /* [4263] */ - (xdc_Char)0x73, /* [4264] */ - (xdc_Char)0x0, /* [4265] */ - (xdc_Char)0x45, /* [4266] */ - (xdc_Char)0x5f, /* [4267] */ - (xdc_Char)0x68, /* [4268] */ - (xdc_Char)0x61, /* [4269] */ - (xdc_Char)0x72, /* [4270] */ - (xdc_Char)0x64, /* [4271] */ - (xdc_Char)0x46, /* [4272] */ - (xdc_Char)0x61, /* [4273] */ - (xdc_Char)0x75, /* [4274] */ - (xdc_Char)0x6c, /* [4275] */ - (xdc_Char)0x74, /* [4276] */ - (xdc_Char)0x3a, /* [4277] */ - (xdc_Char)0x20, /* [4278] */ - (xdc_Char)0x25, /* [4279] */ - (xdc_Char)0x73, /* [4280] */ - (xdc_Char)0x0, /* [4281] */ - (xdc_Char)0x45, /* [4282] */ - (xdc_Char)0x5f, /* [4283] */ - (xdc_Char)0x6d, /* [4284] */ - (xdc_Char)0x65, /* [4285] */ - (xdc_Char)0x6d, /* [4286] */ - (xdc_Char)0x46, /* [4287] */ - (xdc_Char)0x61, /* [4288] */ - (xdc_Char)0x75, /* [4289] */ - (xdc_Char)0x6c, /* [4290] */ - (xdc_Char)0x74, /* [4291] */ - (xdc_Char)0x3a, /* [4292] */ - (xdc_Char)0x20, /* [4293] */ - (xdc_Char)0x25, /* [4294] */ - (xdc_Char)0x73, /* [4295] */ - (xdc_Char)0x2c, /* [4296] */ - (xdc_Char)0x20, /* [4297] */ - (xdc_Char)0x61, /* [4298] */ - (xdc_Char)0x64, /* [4299] */ - (xdc_Char)0x64, /* [4300] */ - (xdc_Char)0x72, /* [4301] */ - (xdc_Char)0x65, /* [4302] */ - (xdc_Char)0x73, /* [4303] */ - (xdc_Char)0x73, /* [4304] */ - (xdc_Char)0x3a, /* [4305] */ - (xdc_Char)0x20, /* [4306] */ - (xdc_Char)0x25, /* [4307] */ - (xdc_Char)0x30, /* [4308] */ - (xdc_Char)0x38, /* [4309] */ - (xdc_Char)0x78, /* [4310] */ - (xdc_Char)0x0, /* [4311] */ - (xdc_Char)0x45, /* [4312] */ - (xdc_Char)0x5f, /* [4313] */ - (xdc_Char)0x62, /* [4314] */ - (xdc_Char)0x75, /* [4315] */ - (xdc_Char)0x73, /* [4316] */ - (xdc_Char)0x46, /* [4317] */ - (xdc_Char)0x61, /* [4318] */ - (xdc_Char)0x75, /* [4319] */ - (xdc_Char)0x6c, /* [4320] */ - (xdc_Char)0x74, /* [4321] */ - (xdc_Char)0x3a, /* [4322] */ - (xdc_Char)0x20, /* [4323] */ - (xdc_Char)0x25, /* [4324] */ - (xdc_Char)0x73, /* [4325] */ - (xdc_Char)0x2c, /* [4326] */ - (xdc_Char)0x20, /* [4327] */ - (xdc_Char)0x61, /* [4328] */ - (xdc_Char)0x64, /* [4329] */ - (xdc_Char)0x64, /* [4330] */ - (xdc_Char)0x72, /* [4331] */ - (xdc_Char)0x65, /* [4332] */ - (xdc_Char)0x73, /* [4333] */ - (xdc_Char)0x73, /* [4334] */ - (xdc_Char)0x3a, /* [4335] */ - (xdc_Char)0x20, /* [4336] */ - (xdc_Char)0x25, /* [4337] */ - (xdc_Char)0x30, /* [4338] */ - (xdc_Char)0x38, /* [4339] */ - (xdc_Char)0x78, /* [4340] */ - (xdc_Char)0x0, /* [4341] */ - (xdc_Char)0x45, /* [4342] */ - (xdc_Char)0x5f, /* [4343] */ - (xdc_Char)0x75, /* [4344] */ - (xdc_Char)0x73, /* [4345] */ - (xdc_Char)0x61, /* [4346] */ - (xdc_Char)0x67, /* [4347] */ - (xdc_Char)0x65, /* [4348] */ - (xdc_Char)0x46, /* [4349] */ - (xdc_Char)0x61, /* [4350] */ - (xdc_Char)0x75, /* [4351] */ - (xdc_Char)0x6c, /* [4352] */ - (xdc_Char)0x74, /* [4353] */ - (xdc_Char)0x3a, /* [4354] */ - (xdc_Char)0x20, /* [4355] */ - (xdc_Char)0x25, /* [4356] */ - (xdc_Char)0x73, /* [4357] */ - (xdc_Char)0x0, /* [4358] */ - (xdc_Char)0x45, /* [4359] */ - (xdc_Char)0x5f, /* [4360] */ - (xdc_Char)0x73, /* [4361] */ - (xdc_Char)0x76, /* [4362] */ - (xdc_Char)0x43, /* [4363] */ - (xdc_Char)0x61, /* [4364] */ - (xdc_Char)0x6c, /* [4365] */ - (xdc_Char)0x6c, /* [4366] */ - (xdc_Char)0x3a, /* [4367] */ - (xdc_Char)0x20, /* [4368] */ - (xdc_Char)0x73, /* [4369] */ - (xdc_Char)0x76, /* [4370] */ - (xdc_Char)0x4e, /* [4371] */ - (xdc_Char)0x75, /* [4372] */ - (xdc_Char)0x6d, /* [4373] */ - (xdc_Char)0x20, /* [4374] */ - (xdc_Char)0x3d, /* [4375] */ - (xdc_Char)0x20, /* [4376] */ - (xdc_Char)0x25, /* [4377] */ - (xdc_Char)0x64, /* [4378] */ - (xdc_Char)0x0, /* [4379] */ - (xdc_Char)0x45, /* [4380] */ - (xdc_Char)0x5f, /* [4381] */ - (xdc_Char)0x64, /* [4382] */ - (xdc_Char)0x65, /* [4383] */ - (xdc_Char)0x62, /* [4384] */ - (xdc_Char)0x75, /* [4385] */ - (xdc_Char)0x67, /* [4386] */ - (xdc_Char)0x4d, /* [4387] */ - (xdc_Char)0x6f, /* [4388] */ - (xdc_Char)0x6e, /* [4389] */ - (xdc_Char)0x3a, /* [4390] */ - (xdc_Char)0x20, /* [4391] */ - (xdc_Char)0x25, /* [4392] */ - (xdc_Char)0x73, /* [4393] */ - (xdc_Char)0x0, /* [4394] */ - (xdc_Char)0x45, /* [4395] */ - (xdc_Char)0x5f, /* [4396] */ - (xdc_Char)0x72, /* [4397] */ - (xdc_Char)0x65, /* [4398] */ - (xdc_Char)0x73, /* [4399] */ - (xdc_Char)0x65, /* [4400] */ - (xdc_Char)0x72, /* [4401] */ - (xdc_Char)0x76, /* [4402] */ - (xdc_Char)0x65, /* [4403] */ - (xdc_Char)0x64, /* [4404] */ - (xdc_Char)0x3a, /* [4405] */ - (xdc_Char)0x20, /* [4406] */ - (xdc_Char)0x25, /* [4407] */ - (xdc_Char)0x73, /* [4408] */ - (xdc_Char)0x20, /* [4409] */ - (xdc_Char)0x25, /* [4410] */ - (xdc_Char)0x64, /* [4411] */ - (xdc_Char)0x0, /* [4412] */ - (xdc_Char)0x45, /* [4413] */ - (xdc_Char)0x5f, /* [4414] */ - (xdc_Char)0x69, /* [4415] */ - (xdc_Char)0x6e, /* [4416] */ - (xdc_Char)0x76, /* [4417] */ - (xdc_Char)0x61, /* [4418] */ - (xdc_Char)0x6c, /* [4419] */ - (xdc_Char)0x69, /* [4420] */ - (xdc_Char)0x64, /* [4421] */ - (xdc_Char)0x54, /* [4422] */ - (xdc_Char)0x69, /* [4423] */ - (xdc_Char)0x6d, /* [4424] */ - (xdc_Char)0x65, /* [4425] */ - (xdc_Char)0x72, /* [4426] */ - (xdc_Char)0x3a, /* [4427] */ - (xdc_Char)0x20, /* [4428] */ - (xdc_Char)0x49, /* [4429] */ - (xdc_Char)0x6e, /* [4430] */ - (xdc_Char)0x76, /* [4431] */ - (xdc_Char)0x61, /* [4432] */ - (xdc_Char)0x6c, /* [4433] */ - (xdc_Char)0x69, /* [4434] */ - (xdc_Char)0x64, /* [4435] */ - (xdc_Char)0x20, /* [4436] */ - (xdc_Char)0x54, /* [4437] */ - (xdc_Char)0x69, /* [4438] */ - (xdc_Char)0x6d, /* [4439] */ - (xdc_Char)0x65, /* [4440] */ - (xdc_Char)0x72, /* [4441] */ - (xdc_Char)0x20, /* [4442] */ - (xdc_Char)0x49, /* [4443] */ - (xdc_Char)0x64, /* [4444] */ - (xdc_Char)0x20, /* [4445] */ - (xdc_Char)0x25, /* [4446] */ - (xdc_Char)0x64, /* [4447] */ - (xdc_Char)0x0, /* [4448] */ - (xdc_Char)0x45, /* [4449] */ - (xdc_Char)0x5f, /* [4450] */ - (xdc_Char)0x6e, /* [4451] */ - (xdc_Char)0x6f, /* [4452] */ - (xdc_Char)0x74, /* [4453] */ - (xdc_Char)0x41, /* [4454] */ - (xdc_Char)0x76, /* [4455] */ - (xdc_Char)0x61, /* [4456] */ - (xdc_Char)0x69, /* [4457] */ - (xdc_Char)0x6c, /* [4458] */ - (xdc_Char)0x61, /* [4459] */ - (xdc_Char)0x62, /* [4460] */ - (xdc_Char)0x6c, /* [4461] */ - (xdc_Char)0x65, /* [4462] */ - (xdc_Char)0x3a, /* [4463] */ - (xdc_Char)0x20, /* [4464] */ - (xdc_Char)0x54, /* [4465] */ - (xdc_Char)0x69, /* [4466] */ - (xdc_Char)0x6d, /* [4467] */ - (xdc_Char)0x65, /* [4468] */ - (xdc_Char)0x72, /* [4469] */ - (xdc_Char)0x20, /* [4470] */ - (xdc_Char)0x6e, /* [4471] */ - (xdc_Char)0x6f, /* [4472] */ - (xdc_Char)0x74, /* [4473] */ - (xdc_Char)0x20, /* [4474] */ - (xdc_Char)0x61, /* [4475] */ - (xdc_Char)0x76, /* [4476] */ - (xdc_Char)0x61, /* [4477] */ - (xdc_Char)0x69, /* [4478] */ - (xdc_Char)0x6c, /* [4479] */ - (xdc_Char)0x61, /* [4480] */ - (xdc_Char)0x62, /* [4481] */ - (xdc_Char)0x6c, /* [4482] */ - (xdc_Char)0x65, /* [4483] */ - (xdc_Char)0x20, /* [4484] */ - (xdc_Char)0x25, /* [4485] */ - (xdc_Char)0x64, /* [4486] */ - (xdc_Char)0x0, /* [4487] */ - (xdc_Char)0x45, /* [4488] */ - (xdc_Char)0x5f, /* [4489] */ - (xdc_Char)0x63, /* [4490] */ - (xdc_Char)0x61, /* [4491] */ - (xdc_Char)0x6e, /* [4492] */ - (xdc_Char)0x6e, /* [4493] */ - (xdc_Char)0x6f, /* [4494] */ - (xdc_Char)0x74, /* [4495] */ - (xdc_Char)0x53, /* [4496] */ - (xdc_Char)0x75, /* [4497] */ - (xdc_Char)0x70, /* [4498] */ - (xdc_Char)0x70, /* [4499] */ - (xdc_Char)0x6f, /* [4500] */ - (xdc_Char)0x72, /* [4501] */ - (xdc_Char)0x74, /* [4502] */ - (xdc_Char)0x3a, /* [4503] */ - (xdc_Char)0x20, /* [4504] */ - (xdc_Char)0x54, /* [4505] */ - (xdc_Char)0x69, /* [4506] */ - (xdc_Char)0x6d, /* [4507] */ - (xdc_Char)0x65, /* [4508] */ - (xdc_Char)0x72, /* [4509] */ - (xdc_Char)0x20, /* [4510] */ - (xdc_Char)0x63, /* [4511] */ - (xdc_Char)0x61, /* [4512] */ - (xdc_Char)0x6e, /* [4513] */ - (xdc_Char)0x6e, /* [4514] */ - (xdc_Char)0x6f, /* [4515] */ - (xdc_Char)0x74, /* [4516] */ - (xdc_Char)0x20, /* [4517] */ - (xdc_Char)0x73, /* [4518] */ - (xdc_Char)0x75, /* [4519] */ - (xdc_Char)0x70, /* [4520] */ - (xdc_Char)0x70, /* [4521] */ - (xdc_Char)0x6f, /* [4522] */ - (xdc_Char)0x72, /* [4523] */ - (xdc_Char)0x74, /* [4524] */ - (xdc_Char)0x20, /* [4525] */ - (xdc_Char)0x72, /* [4526] */ - (xdc_Char)0x65, /* [4527] */ - (xdc_Char)0x71, /* [4528] */ - (xdc_Char)0x75, /* [4529] */ - (xdc_Char)0x65, /* [4530] */ - (xdc_Char)0x73, /* [4531] */ - (xdc_Char)0x74, /* [4532] */ - (xdc_Char)0x65, /* [4533] */ - (xdc_Char)0x64, /* [4534] */ - (xdc_Char)0x20, /* [4535] */ - (xdc_Char)0x70, /* [4536] */ - (xdc_Char)0x65, /* [4537] */ - (xdc_Char)0x72, /* [4538] */ - (xdc_Char)0x69, /* [4539] */ - (xdc_Char)0x6f, /* [4540] */ - (xdc_Char)0x64, /* [4541] */ - (xdc_Char)0x20, /* [4542] */ - (xdc_Char)0x25, /* [4543] */ - (xdc_Char)0x64, /* [4544] */ - (xdc_Char)0x0, /* [4545] */ - (xdc_Char)0x45, /* [4546] */ - (xdc_Char)0x5f, /* [4547] */ - (xdc_Char)0x73, /* [4548] */ - (xdc_Char)0x74, /* [4549] */ - (xdc_Char)0x61, /* [4550] */ - (xdc_Char)0x63, /* [4551] */ - (xdc_Char)0x6b, /* [4552] */ - (xdc_Char)0x4f, /* [4553] */ - (xdc_Char)0x76, /* [4554] */ - (xdc_Char)0x65, /* [4555] */ - (xdc_Char)0x72, /* [4556] */ - (xdc_Char)0x66, /* [4557] */ - (xdc_Char)0x6c, /* [4558] */ - (xdc_Char)0x6f, /* [4559] */ - (xdc_Char)0x77, /* [4560] */ - (xdc_Char)0x3a, /* [4561] */ - (xdc_Char)0x20, /* [4562] */ - (xdc_Char)0x54, /* [4563] */ - (xdc_Char)0x61, /* [4564] */ - (xdc_Char)0x73, /* [4565] */ - (xdc_Char)0x6b, /* [4566] */ - (xdc_Char)0x20, /* [4567] */ - (xdc_Char)0x30, /* [4568] */ - (xdc_Char)0x78, /* [4569] */ - (xdc_Char)0x25, /* [4570] */ - (xdc_Char)0x78, /* [4571] */ - (xdc_Char)0x20, /* [4572] */ - (xdc_Char)0x73, /* [4573] */ - (xdc_Char)0x74, /* [4574] */ - (xdc_Char)0x61, /* [4575] */ - (xdc_Char)0x63, /* [4576] */ - (xdc_Char)0x6b, /* [4577] */ - (xdc_Char)0x20, /* [4578] */ - (xdc_Char)0x6f, /* [4579] */ - (xdc_Char)0x76, /* [4580] */ - (xdc_Char)0x65, /* [4581] */ - (xdc_Char)0x72, /* [4582] */ - (xdc_Char)0x66, /* [4583] */ - (xdc_Char)0x6c, /* [4584] */ - (xdc_Char)0x6f, /* [4585] */ - (xdc_Char)0x77, /* [4586] */ - (xdc_Char)0x2e, /* [4587] */ - (xdc_Char)0x0, /* [4588] */ - (xdc_Char)0x45, /* [4589] */ - (xdc_Char)0x5f, /* [4590] */ - (xdc_Char)0x73, /* [4591] */ - (xdc_Char)0x70, /* [4592] */ - (xdc_Char)0x4f, /* [4593] */ - (xdc_Char)0x75, /* [4594] */ - (xdc_Char)0x74, /* [4595] */ - (xdc_Char)0x4f, /* [4596] */ - (xdc_Char)0x66, /* [4597] */ - (xdc_Char)0x42, /* [4598] */ - (xdc_Char)0x6f, /* [4599] */ - (xdc_Char)0x75, /* [4600] */ - (xdc_Char)0x6e, /* [4601] */ - (xdc_Char)0x64, /* [4602] */ - (xdc_Char)0x73, /* [4603] */ - (xdc_Char)0x3a, /* [4604] */ - (xdc_Char)0x20, /* [4605] */ - (xdc_Char)0x54, /* [4606] */ - (xdc_Char)0x61, /* [4607] */ - (xdc_Char)0x73, /* [4608] */ - (xdc_Char)0x6b, /* [4609] */ - (xdc_Char)0x20, /* [4610] */ - (xdc_Char)0x30, /* [4611] */ - (xdc_Char)0x78, /* [4612] */ - (xdc_Char)0x25, /* [4613] */ - (xdc_Char)0x78, /* [4614] */ - (xdc_Char)0x20, /* [4615] */ - (xdc_Char)0x73, /* [4616] */ - (xdc_Char)0x74, /* [4617] */ - (xdc_Char)0x61, /* [4618] */ - (xdc_Char)0x63, /* [4619] */ - (xdc_Char)0x6b, /* [4620] */ - (xdc_Char)0x20, /* [4621] */ - (xdc_Char)0x65, /* [4622] */ - (xdc_Char)0x72, /* [4623] */ - (xdc_Char)0x72, /* [4624] */ - (xdc_Char)0x6f, /* [4625] */ - (xdc_Char)0x72, /* [4626] */ - (xdc_Char)0x2c, /* [4627] */ - (xdc_Char)0x20, /* [4628] */ - (xdc_Char)0x53, /* [4629] */ - (xdc_Char)0x50, /* [4630] */ - (xdc_Char)0x20, /* [4631] */ - (xdc_Char)0x3d, /* [4632] */ - (xdc_Char)0x20, /* [4633] */ - (xdc_Char)0x30, /* [4634] */ - (xdc_Char)0x78, /* [4635] */ - (xdc_Char)0x25, /* [4636] */ - (xdc_Char)0x78, /* [4637] */ - (xdc_Char)0x2e, /* [4638] */ - (xdc_Char)0x0, /* [4639] */ - (xdc_Char)0x45, /* [4640] */ - (xdc_Char)0x5f, /* [4641] */ - (xdc_Char)0x64, /* [4642] */ - (xdc_Char)0x65, /* [4643] */ - (xdc_Char)0x6c, /* [4644] */ - (xdc_Char)0x65, /* [4645] */ - (xdc_Char)0x74, /* [4646] */ - (xdc_Char)0x65, /* [4647] */ - (xdc_Char)0x4e, /* [4648] */ - (xdc_Char)0x6f, /* [4649] */ - (xdc_Char)0x74, /* [4650] */ - (xdc_Char)0x41, /* [4651] */ - (xdc_Char)0x6c, /* [4652] */ - (xdc_Char)0x6c, /* [4653] */ - (xdc_Char)0x6f, /* [4654] */ - (xdc_Char)0x77, /* [4655] */ - (xdc_Char)0x65, /* [4656] */ - (xdc_Char)0x64, /* [4657] */ - (xdc_Char)0x3a, /* [4658] */ - (xdc_Char)0x20, /* [4659] */ - (xdc_Char)0x54, /* [4660] */ - (xdc_Char)0x61, /* [4661] */ - (xdc_Char)0x73, /* [4662] */ - (xdc_Char)0x6b, /* [4663] */ - (xdc_Char)0x20, /* [4664] */ - (xdc_Char)0x30, /* [4665] */ - (xdc_Char)0x78, /* [4666] */ - (xdc_Char)0x25, /* [4667] */ - (xdc_Char)0x78, /* [4668] */ - (xdc_Char)0x2e, /* [4669] */ - (xdc_Char)0x0, /* [4670] */ - (xdc_Char)0x45, /* [4671] */ - (xdc_Char)0x5f, /* [4672] */ - (xdc_Char)0x73, /* [4673] */ - (xdc_Char)0x74, /* [4674] */ - (xdc_Char)0x61, /* [4675] */ - (xdc_Char)0x63, /* [4676] */ - (xdc_Char)0x6b, /* [4677] */ - (xdc_Char)0x4f, /* [4678] */ - (xdc_Char)0x76, /* [4679] */ - (xdc_Char)0x65, /* [4680] */ - (xdc_Char)0x72, /* [4681] */ - (xdc_Char)0x66, /* [4682] */ - (xdc_Char)0x6c, /* [4683] */ - (xdc_Char)0x6f, /* [4684] */ - (xdc_Char)0x77, /* [4685] */ - (xdc_Char)0x3a, /* [4686] */ - (xdc_Char)0x20, /* [4687] */ - (xdc_Char)0x49, /* [4688] */ - (xdc_Char)0x53, /* [4689] */ - (xdc_Char)0x52, /* [4690] */ - (xdc_Char)0x20, /* [4691] */ - (xdc_Char)0x73, /* [4692] */ - (xdc_Char)0x74, /* [4693] */ - (xdc_Char)0x61, /* [4694] */ - (xdc_Char)0x63, /* [4695] */ - (xdc_Char)0x6b, /* [4696] */ - (xdc_Char)0x20, /* [4697] */ - (xdc_Char)0x6f, /* [4698] */ - (xdc_Char)0x76, /* [4699] */ - (xdc_Char)0x65, /* [4700] */ - (xdc_Char)0x72, /* [4701] */ - (xdc_Char)0x66, /* [4702] */ - (xdc_Char)0x6c, /* [4703] */ - (xdc_Char)0x6f, /* [4704] */ - (xdc_Char)0x77, /* [4705] */ - (xdc_Char)0x2e, /* [4706] */ - (xdc_Char)0x0, /* [4707] */ - (xdc_Char)0x45, /* [4708] */ - (xdc_Char)0x5f, /* [4709] */ - (xdc_Char)0x6e, /* [4710] */ - (xdc_Char)0x6f, /* [4711] */ - (xdc_Char)0x61, /* [4712] */ - (xdc_Char)0x6c, /* [4713] */ - (xdc_Char)0x74, /* [4714] */ - (xdc_Char)0x63, /* [4715] */ - (xdc_Char)0x6c, /* [4716] */ - (xdc_Char)0x6b, /* [4717] */ - (xdc_Char)0x3a, /* [4718] */ - (xdc_Char)0x20, /* [4719] */ - (xdc_Char)0x54, /* [4720] */ - (xdc_Char)0x69, /* [4721] */ - (xdc_Char)0x6d, /* [4722] */ - (xdc_Char)0x65, /* [4723] */ - (xdc_Char)0x72, /* [4724] */ - (xdc_Char)0x20, /* [4725] */ - (xdc_Char)0x64, /* [4726] */ - (xdc_Char)0x6f, /* [4727] */ - (xdc_Char)0x65, /* [4728] */ - (xdc_Char)0x73, /* [4729] */ - (xdc_Char)0x20, /* [4730] */ - (xdc_Char)0x6e, /* [4731] */ - (xdc_Char)0x6f, /* [4732] */ - (xdc_Char)0x74, /* [4733] */ - (xdc_Char)0x20, /* [4734] */ - (xdc_Char)0x73, /* [4735] */ - (xdc_Char)0x75, /* [4736] */ - (xdc_Char)0x70, /* [4737] */ - (xdc_Char)0x70, /* [4738] */ - (xdc_Char)0x6f, /* [4739] */ - (xdc_Char)0x72, /* [4740] */ - (xdc_Char)0x74, /* [4741] */ - (xdc_Char)0x20, /* [4742] */ - (xdc_Char)0x61, /* [4743] */ - (xdc_Char)0x6c, /* [4744] */ - (xdc_Char)0x74, /* [4745] */ - (xdc_Char)0x63, /* [4746] */ - (xdc_Char)0x6c, /* [4747] */ - (xdc_Char)0x6b, /* [4748] */ - (xdc_Char)0x0, /* [4749] */ - (xdc_Char)0x45, /* [4750] */ - (xdc_Char)0x5f, /* [4751] */ - (xdc_Char)0x6e, /* [4752] */ - (xdc_Char)0x6f, /* [4753] */ - (xdc_Char)0x74, /* [4754] */ - (xdc_Char)0x46, /* [4755] */ - (xdc_Char)0x6f, /* [4756] */ - (xdc_Char)0x75, /* [4757] */ - (xdc_Char)0x6e, /* [4758] */ - (xdc_Char)0x64, /* [4759] */ - (xdc_Char)0x3a, /* [4760] */ - (xdc_Char)0x20, /* [4761] */ - (xdc_Char)0x25, /* [4762] */ - (xdc_Char)0x73, /* [4763] */ - (xdc_Char)0x20, /* [4764] */ - (xdc_Char)0x6e, /* [4765] */ - (xdc_Char)0x61, /* [4766] */ - (xdc_Char)0x6d, /* [4767] */ - (xdc_Char)0x65, /* [4768] */ - (xdc_Char)0x20, /* [4769] */ - (xdc_Char)0x6e, /* [4770] */ - (xdc_Char)0x6f, /* [4771] */ - (xdc_Char)0x74, /* [4772] */ - (xdc_Char)0x20, /* [4773] */ - (xdc_Char)0x66, /* [4774] */ - (xdc_Char)0x6f, /* [4775] */ - (xdc_Char)0x75, /* [4776] */ - (xdc_Char)0x6e, /* [4777] */ - (xdc_Char)0x64, /* [4778] */ - (xdc_Char)0x0, /* [4779] */ - (xdc_Char)0x45, /* [4780] */ - (xdc_Char)0x5f, /* [4781] */ - (xdc_Char)0x63, /* [4782] */ - (xdc_Char)0x72, /* [4783] */ - (xdc_Char)0x65, /* [4784] */ - (xdc_Char)0x61, /* [4785] */ - (xdc_Char)0x74, /* [4786] */ - (xdc_Char)0x65, /* [4787] */ - (xdc_Char)0x46, /* [4788] */ - (xdc_Char)0x61, /* [4789] */ - (xdc_Char)0x69, /* [4790] */ - (xdc_Char)0x6c, /* [4791] */ - (xdc_Char)0x65, /* [4792] */ - (xdc_Char)0x64, /* [4793] */ - (xdc_Char)0x3a, /* [4794] */ - (xdc_Char)0x20, /* [4795] */ - (xdc_Char)0x6d, /* [4796] */ - (xdc_Char)0x64, /* [4797] */ - (xdc_Char)0x43, /* [4798] */ - (xdc_Char)0x72, /* [4799] */ - (xdc_Char)0x65, /* [4800] */ - (xdc_Char)0x61, /* [4801] */ - (xdc_Char)0x74, /* [4802] */ - (xdc_Char)0x65, /* [4803] */ - (xdc_Char)0x43, /* [4804] */ - (xdc_Char)0x68, /* [4805] */ - (xdc_Char)0x61, /* [4806] */ - (xdc_Char)0x6e, /* [4807] */ - (xdc_Char)0x20, /* [4808] */ - (xdc_Char)0x72, /* [4809] */ - (xdc_Char)0x65, /* [4810] */ - (xdc_Char)0x74, /* [4811] */ - (xdc_Char)0x75, /* [4812] */ - (xdc_Char)0x72, /* [4813] */ - (xdc_Char)0x6e, /* [4814] */ - (xdc_Char)0x65, /* [4815] */ - (xdc_Char)0x64, /* [4816] */ - (xdc_Char)0x20, /* [4817] */ - (xdc_Char)0x65, /* [4818] */ - (xdc_Char)0x72, /* [4819] */ - (xdc_Char)0x72, /* [4820] */ - (xdc_Char)0x6f, /* [4821] */ - (xdc_Char)0x72, /* [4822] */ - (xdc_Char)0x20, /* [4823] */ - (xdc_Char)0x25, /* [4824] */ - (xdc_Char)0x64, /* [4825] */ - (xdc_Char)0x0, /* [4826] */ - (xdc_Char)0x45, /* [4827] */ - (xdc_Char)0x5f, /* [4828] */ - (xdc_Char)0x70, /* [4829] */ - (xdc_Char)0x72, /* [4830] */ - (xdc_Char)0x69, /* [4831] */ - (xdc_Char)0x6f, /* [4832] */ - (xdc_Char)0x72, /* [4833] */ - (xdc_Char)0x69, /* [4834] */ - (xdc_Char)0x74, /* [4835] */ - (xdc_Char)0x79, /* [4836] */ - (xdc_Char)0x3a, /* [4837] */ - (xdc_Char)0x20, /* [4838] */ - (xdc_Char)0x54, /* [4839] */ - (xdc_Char)0x68, /* [4840] */ - (xdc_Char)0x72, /* [4841] */ - (xdc_Char)0x65, /* [4842] */ - (xdc_Char)0x61, /* [4843] */ - (xdc_Char)0x64, /* [4844] */ - (xdc_Char)0x20, /* [4845] */ - (xdc_Char)0x70, /* [4846] */ - (xdc_Char)0x72, /* [4847] */ - (xdc_Char)0x69, /* [4848] */ - (xdc_Char)0x6f, /* [4849] */ - (xdc_Char)0x72, /* [4850] */ - (xdc_Char)0x69, /* [4851] */ - (xdc_Char)0x74, /* [4852] */ - (xdc_Char)0x79, /* [4853] */ - (xdc_Char)0x20, /* [4854] */ - (xdc_Char)0x69, /* [4855] */ - (xdc_Char)0x73, /* [4856] */ - (xdc_Char)0x20, /* [4857] */ - (xdc_Char)0x69, /* [4858] */ - (xdc_Char)0x6e, /* [4859] */ - (xdc_Char)0x76, /* [4860] */ - (xdc_Char)0x61, /* [4861] */ - (xdc_Char)0x6c, /* [4862] */ - (xdc_Char)0x69, /* [4863] */ - (xdc_Char)0x64, /* [4864] */ - (xdc_Char)0x20, /* [4865] */ - (xdc_Char)0x25, /* [4866] */ - (xdc_Char)0x64, /* [4867] */ - (xdc_Char)0x0, /* [4868] */ - (xdc_Char)0x72, /* [4869] */ - (xdc_Char)0x65, /* [4870] */ - (xdc_Char)0x71, /* [4871] */ - (xdc_Char)0x75, /* [4872] */ - (xdc_Char)0x65, /* [4873] */ - (xdc_Char)0x73, /* [4874] */ - (xdc_Char)0x74, /* [4875] */ - (xdc_Char)0x65, /* [4876] */ - (xdc_Char)0x64, /* [4877] */ - (xdc_Char)0x20, /* [4878] */ - (xdc_Char)0x73, /* [4879] */ - (xdc_Char)0x69, /* [4880] */ - (xdc_Char)0x7a, /* [4881] */ - (xdc_Char)0x65, /* [4882] */ - (xdc_Char)0x20, /* [4883] */ - (xdc_Char)0x69, /* [4884] */ - (xdc_Char)0x73, /* [4885] */ - (xdc_Char)0x20, /* [4886] */ - (xdc_Char)0x74, /* [4887] */ - (xdc_Char)0x6f, /* [4888] */ - (xdc_Char)0x6f, /* [4889] */ - (xdc_Char)0x20, /* [4890] */ - (xdc_Char)0x62, /* [4891] */ - (xdc_Char)0x69, /* [4892] */ - (xdc_Char)0x67, /* [4893] */ - (xdc_Char)0x3a, /* [4894] */ - (xdc_Char)0x20, /* [4895] */ - (xdc_Char)0x68, /* [4896] */ - (xdc_Char)0x61, /* [4897] */ - (xdc_Char)0x6e, /* [4898] */ - (xdc_Char)0x64, /* [4899] */ - (xdc_Char)0x6c, /* [4900] */ - (xdc_Char)0x65, /* [4901] */ - (xdc_Char)0x3d, /* [4902] */ - (xdc_Char)0x30, /* [4903] */ - (xdc_Char)0x78, /* [4904] */ - (xdc_Char)0x25, /* [4905] */ - (xdc_Char)0x78, /* [4906] */ - (xdc_Char)0x2c, /* [4907] */ - (xdc_Char)0x20, /* [4908] */ - (xdc_Char)0x73, /* [4909] */ - (xdc_Char)0x69, /* [4910] */ - (xdc_Char)0x7a, /* [4911] */ - (xdc_Char)0x65, /* [4912] */ - (xdc_Char)0x3d, /* [4913] */ - (xdc_Char)0x25, /* [4914] */ - (xdc_Char)0x75, /* [4915] */ - (xdc_Char)0x0, /* [4916] */ - (xdc_Char)0x6f, /* [4917] */ - (xdc_Char)0x75, /* [4918] */ - (xdc_Char)0x74, /* [4919] */ - (xdc_Char)0x20, /* [4920] */ - (xdc_Char)0x6f, /* [4921] */ - (xdc_Char)0x66, /* [4922] */ - (xdc_Char)0x20, /* [4923] */ - (xdc_Char)0x6d, /* [4924] */ - (xdc_Char)0x65, /* [4925] */ - (xdc_Char)0x6d, /* [4926] */ - (xdc_Char)0x6f, /* [4927] */ - (xdc_Char)0x72, /* [4928] */ - (xdc_Char)0x79, /* [4929] */ - (xdc_Char)0x3a, /* [4930] */ - (xdc_Char)0x20, /* [4931] */ - (xdc_Char)0x68, /* [4932] */ - (xdc_Char)0x61, /* [4933] */ - (xdc_Char)0x6e, /* [4934] */ - (xdc_Char)0x64, /* [4935] */ - (xdc_Char)0x6c, /* [4936] */ - (xdc_Char)0x65, /* [4937] */ - (xdc_Char)0x3d, /* [4938] */ - (xdc_Char)0x30, /* [4939] */ - (xdc_Char)0x78, /* [4940] */ - (xdc_Char)0x25, /* [4941] */ - (xdc_Char)0x78, /* [4942] */ - (xdc_Char)0x2c, /* [4943] */ - (xdc_Char)0x20, /* [4944] */ - (xdc_Char)0x73, /* [4945] */ - (xdc_Char)0x69, /* [4946] */ - (xdc_Char)0x7a, /* [4947] */ - (xdc_Char)0x65, /* [4948] */ - (xdc_Char)0x3d, /* [4949] */ - (xdc_Char)0x25, /* [4950] */ - (xdc_Char)0x75, /* [4951] */ - (xdc_Char)0x0, /* [4952] */ - (xdc_Char)0x3c, /* [4953] */ - (xdc_Char)0x2d, /* [4954] */ - (xdc_Char)0x2d, /* [4955] */ - (xdc_Char)0x20, /* [4956] */ - (xdc_Char)0x63, /* [4957] */ - (xdc_Char)0x6f, /* [4958] */ - (xdc_Char)0x6e, /* [4959] */ - (xdc_Char)0x73, /* [4960] */ - (xdc_Char)0x74, /* [4961] */ - (xdc_Char)0x72, /* [4962] */ - (xdc_Char)0x75, /* [4963] */ - (xdc_Char)0x63, /* [4964] */ - (xdc_Char)0x74, /* [4965] */ - (xdc_Char)0x3a, /* [4966] */ - (xdc_Char)0x20, /* [4967] */ - (xdc_Char)0x25, /* [4968] */ - (xdc_Char)0x70, /* [4969] */ - (xdc_Char)0x28, /* [4970] */ - (xdc_Char)0x27, /* [4971] */ - (xdc_Char)0x25, /* [4972] */ - (xdc_Char)0x73, /* [4973] */ - (xdc_Char)0x27, /* [4974] */ - (xdc_Char)0x29, /* [4975] */ - (xdc_Char)0x0, /* [4976] */ - (xdc_Char)0x3c, /* [4977] */ - (xdc_Char)0x2d, /* [4978] */ - (xdc_Char)0x2d, /* [4979] */ - (xdc_Char)0x20, /* [4980] */ - (xdc_Char)0x63, /* [4981] */ - (xdc_Char)0x72, /* [4982] */ - (xdc_Char)0x65, /* [4983] */ - (xdc_Char)0x61, /* [4984] */ - (xdc_Char)0x74, /* [4985] */ - (xdc_Char)0x65, /* [4986] */ - (xdc_Char)0x3a, /* [4987] */ - (xdc_Char)0x20, /* [4988] */ - (xdc_Char)0x25, /* [4989] */ - (xdc_Char)0x70, /* [4990] */ - (xdc_Char)0x28, /* [4991] */ - (xdc_Char)0x27, /* [4992] */ - (xdc_Char)0x25, /* [4993] */ - (xdc_Char)0x73, /* [4994] */ - (xdc_Char)0x27, /* [4995] */ - (xdc_Char)0x29, /* [4996] */ - (xdc_Char)0x0, /* [4997] */ - (xdc_Char)0x2d, /* [4998] */ - (xdc_Char)0x2d, /* [4999] */ - (xdc_Char)0x3e, /* [5000] */ - (xdc_Char)0x20, /* [5001] */ - (xdc_Char)0x64, /* [5002] */ - (xdc_Char)0x65, /* [5003] */ - (xdc_Char)0x73, /* [5004] */ - (xdc_Char)0x74, /* [5005] */ - (xdc_Char)0x72, /* [5006] */ - (xdc_Char)0x75, /* [5007] */ - (xdc_Char)0x63, /* [5008] */ - (xdc_Char)0x74, /* [5009] */ - (xdc_Char)0x3a, /* [5010] */ - (xdc_Char)0x20, /* [5011] */ - (xdc_Char)0x28, /* [5012] */ - (xdc_Char)0x25, /* [5013] */ - (xdc_Char)0x70, /* [5014] */ - (xdc_Char)0x29, /* [5015] */ - (xdc_Char)0x0, /* [5016] */ - (xdc_Char)0x2d, /* [5017] */ - (xdc_Char)0x2d, /* [5018] */ - (xdc_Char)0x3e, /* [5019] */ - (xdc_Char)0x20, /* [5020] */ - (xdc_Char)0x64, /* [5021] */ - (xdc_Char)0x65, /* [5022] */ - (xdc_Char)0x6c, /* [5023] */ - (xdc_Char)0x65, /* [5024] */ - (xdc_Char)0x74, /* [5025] */ - (xdc_Char)0x65, /* [5026] */ - (xdc_Char)0x3a, /* [5027] */ - (xdc_Char)0x20, /* [5028] */ - (xdc_Char)0x28, /* [5029] */ - (xdc_Char)0x25, /* [5030] */ - (xdc_Char)0x70, /* [5031] */ - (xdc_Char)0x29, /* [5032] */ - (xdc_Char)0x0, /* [5033] */ - (xdc_Char)0x45, /* [5034] */ - (xdc_Char)0x52, /* [5035] */ - (xdc_Char)0x52, /* [5036] */ - (xdc_Char)0x4f, /* [5037] */ - (xdc_Char)0x52, /* [5038] */ - (xdc_Char)0x3a, /* [5039] */ - (xdc_Char)0x20, /* [5040] */ - (xdc_Char)0x25, /* [5041] */ - (xdc_Char)0x24, /* [5042] */ - (xdc_Char)0x46, /* [5043] */ - (xdc_Char)0x25, /* [5044] */ - (xdc_Char)0x24, /* [5045] */ - (xdc_Char)0x53, /* [5046] */ - (xdc_Char)0x0, /* [5047] */ - (xdc_Char)0x57, /* [5048] */ - (xdc_Char)0x41, /* [5049] */ - (xdc_Char)0x52, /* [5050] */ - (xdc_Char)0x4e, /* [5051] */ - (xdc_Char)0x49, /* [5052] */ - (xdc_Char)0x4e, /* [5053] */ - (xdc_Char)0x47, /* [5054] */ - (xdc_Char)0x3a, /* [5055] */ - (xdc_Char)0x20, /* [5056] */ - (xdc_Char)0x25, /* [5057] */ - (xdc_Char)0x24, /* [5058] */ - (xdc_Char)0x46, /* [5059] */ - (xdc_Char)0x25, /* [5060] */ - (xdc_Char)0x24, /* [5061] */ - (xdc_Char)0x53, /* [5062] */ - (xdc_Char)0x0, /* [5063] */ - (xdc_Char)0x25, /* [5064] */ - (xdc_Char)0x24, /* [5065] */ - (xdc_Char)0x46, /* [5066] */ - (xdc_Char)0x25, /* [5067] */ - (xdc_Char)0x24, /* [5068] */ - (xdc_Char)0x53, /* [5069] */ - (xdc_Char)0x0, /* [5070] */ - (xdc_Char)0x53, /* [5071] */ - (xdc_Char)0x74, /* [5072] */ - (xdc_Char)0x61, /* [5073] */ - (xdc_Char)0x72, /* [5074] */ - (xdc_Char)0x74, /* [5075] */ - (xdc_Char)0x3a, /* [5076] */ - (xdc_Char)0x20, /* [5077] */ - (xdc_Char)0x25, /* [5078] */ - (xdc_Char)0x24, /* [5079] */ - (xdc_Char)0x53, /* [5080] */ - (xdc_Char)0x0, /* [5081] */ - (xdc_Char)0x53, /* [5082] */ - (xdc_Char)0x74, /* [5083] */ - (xdc_Char)0x6f, /* [5084] */ - (xdc_Char)0x70, /* [5085] */ - (xdc_Char)0x3a, /* [5086] */ - (xdc_Char)0x20, /* [5087] */ - (xdc_Char)0x25, /* [5088] */ - (xdc_Char)0x24, /* [5089] */ - (xdc_Char)0x53, /* [5090] */ - (xdc_Char)0x0, /* [5091] */ - (xdc_Char)0x53, /* [5092] */ - (xdc_Char)0x74, /* [5093] */ - (xdc_Char)0x61, /* [5094] */ - (xdc_Char)0x72, /* [5095] */ - (xdc_Char)0x74, /* [5096] */ - (xdc_Char)0x49, /* [5097] */ - (xdc_Char)0x6e, /* [5098] */ - (xdc_Char)0x73, /* [5099] */ - (xdc_Char)0x74, /* [5100] */ - (xdc_Char)0x61, /* [5101] */ - (xdc_Char)0x6e, /* [5102] */ - (xdc_Char)0x63, /* [5103] */ - (xdc_Char)0x65, /* [5104] */ - (xdc_Char)0x3a, /* [5105] */ - (xdc_Char)0x20, /* [5106] */ - (xdc_Char)0x25, /* [5107] */ - (xdc_Char)0x24, /* [5108] */ - (xdc_Char)0x53, /* [5109] */ - (xdc_Char)0x0, /* [5110] */ - (xdc_Char)0x53, /* [5111] */ - (xdc_Char)0x74, /* [5112] */ - (xdc_Char)0x6f, /* [5113] */ - (xdc_Char)0x70, /* [5114] */ - (xdc_Char)0x49, /* [5115] */ - (xdc_Char)0x6e, /* [5116] */ - (xdc_Char)0x73, /* [5117] */ - (xdc_Char)0x74, /* [5118] */ - (xdc_Char)0x61, /* [5119] */ - (xdc_Char)0x6e, /* [5120] */ - (xdc_Char)0x63, /* [5121] */ - (xdc_Char)0x65, /* [5122] */ - (xdc_Char)0x3a, /* [5123] */ - (xdc_Char)0x20, /* [5124] */ - (xdc_Char)0x25, /* [5125] */ - (xdc_Char)0x24, /* [5126] */ - (xdc_Char)0x53, /* [5127] */ - (xdc_Char)0x0, /* [5128] */ - (xdc_Char)0x4c, /* [5129] */ - (xdc_Char)0x4d, /* [5130] */ - (xdc_Char)0x5f, /* [5131] */ - (xdc_Char)0x62, /* [5132] */ - (xdc_Char)0x65, /* [5133] */ - (xdc_Char)0x67, /* [5134] */ - (xdc_Char)0x69, /* [5135] */ - (xdc_Char)0x6e, /* [5136] */ - (xdc_Char)0x3a, /* [5137] */ - (xdc_Char)0x20, /* [5138] */ - (xdc_Char)0x68, /* [5139] */ - (xdc_Char)0x77, /* [5140] */ - (xdc_Char)0x69, /* [5141] */ - (xdc_Char)0x3a, /* [5142] */ - (xdc_Char)0x20, /* [5143] */ - (xdc_Char)0x30, /* [5144] */ - (xdc_Char)0x78, /* [5145] */ - (xdc_Char)0x25, /* [5146] */ - (xdc_Char)0x78, /* [5147] */ - (xdc_Char)0x2c, /* [5148] */ - (xdc_Char)0x20, /* [5149] */ - (xdc_Char)0x66, /* [5150] */ - (xdc_Char)0x75, /* [5151] */ - (xdc_Char)0x6e, /* [5152] */ - (xdc_Char)0x63, /* [5153] */ - (xdc_Char)0x3a, /* [5154] */ - (xdc_Char)0x20, /* [5155] */ - (xdc_Char)0x30, /* [5156] */ - (xdc_Char)0x78, /* [5157] */ - (xdc_Char)0x25, /* [5158] */ - (xdc_Char)0x78, /* [5159] */ - (xdc_Char)0x2c, /* [5160] */ - (xdc_Char)0x20, /* [5161] */ - (xdc_Char)0x70, /* [5162] */ - (xdc_Char)0x72, /* [5163] */ - (xdc_Char)0x65, /* [5164] */ - (xdc_Char)0x54, /* [5165] */ - (xdc_Char)0x68, /* [5166] */ - (xdc_Char)0x72, /* [5167] */ - (xdc_Char)0x65, /* [5168] */ - (xdc_Char)0x61, /* [5169] */ - (xdc_Char)0x64, /* [5170] */ - (xdc_Char)0x3a, /* [5171] */ - (xdc_Char)0x20, /* [5172] */ - (xdc_Char)0x25, /* [5173] */ - (xdc_Char)0x64, /* [5174] */ - (xdc_Char)0x2c, /* [5175] */ - (xdc_Char)0x20, /* [5176] */ - (xdc_Char)0x69, /* [5177] */ - (xdc_Char)0x6e, /* [5178] */ - (xdc_Char)0x74, /* [5179] */ - (xdc_Char)0x4e, /* [5180] */ - (xdc_Char)0x75, /* [5181] */ - (xdc_Char)0x6d, /* [5182] */ - (xdc_Char)0x3a, /* [5183] */ - (xdc_Char)0x20, /* [5184] */ - (xdc_Char)0x25, /* [5185] */ - (xdc_Char)0x64, /* [5186] */ - (xdc_Char)0x2c, /* [5187] */ - (xdc_Char)0x20, /* [5188] */ - (xdc_Char)0x69, /* [5189] */ - (xdc_Char)0x72, /* [5190] */ - (xdc_Char)0x70, /* [5191] */ - (xdc_Char)0x3a, /* [5192] */ - (xdc_Char)0x20, /* [5193] */ - (xdc_Char)0x30, /* [5194] */ - (xdc_Char)0x78, /* [5195] */ - (xdc_Char)0x25, /* [5196] */ - (xdc_Char)0x78, /* [5197] */ - (xdc_Char)0x0, /* [5198] */ - (xdc_Char)0x4c, /* [5199] */ - (xdc_Char)0x44, /* [5200] */ - (xdc_Char)0x5f, /* [5201] */ - (xdc_Char)0x65, /* [5202] */ - (xdc_Char)0x6e, /* [5203] */ - (xdc_Char)0x64, /* [5204] */ - (xdc_Char)0x3a, /* [5205] */ - (xdc_Char)0x20, /* [5206] */ - (xdc_Char)0x68, /* [5207] */ - (xdc_Char)0x77, /* [5208] */ - (xdc_Char)0x69, /* [5209] */ - (xdc_Char)0x3a, /* [5210] */ - (xdc_Char)0x20, /* [5211] */ - (xdc_Char)0x30, /* [5212] */ - (xdc_Char)0x78, /* [5213] */ - (xdc_Char)0x25, /* [5214] */ - (xdc_Char)0x78, /* [5215] */ - (xdc_Char)0x0, /* [5216] */ - (xdc_Char)0x4c, /* [5217] */ - (xdc_Char)0x57, /* [5218] */ - (xdc_Char)0x5f, /* [5219] */ - (xdc_Char)0x64, /* [5220] */ - (xdc_Char)0x65, /* [5221] */ - (xdc_Char)0x6c, /* [5222] */ - (xdc_Char)0x61, /* [5223] */ - (xdc_Char)0x79, /* [5224] */ - (xdc_Char)0x65, /* [5225] */ - (xdc_Char)0x64, /* [5226] */ - (xdc_Char)0x3a, /* [5227] */ - (xdc_Char)0x20, /* [5228] */ - (xdc_Char)0x64, /* [5229] */ - (xdc_Char)0x65, /* [5230] */ - (xdc_Char)0x6c, /* [5231] */ - (xdc_Char)0x61, /* [5232] */ - (xdc_Char)0x79, /* [5233] */ - (xdc_Char)0x3a, /* [5234] */ - (xdc_Char)0x20, /* [5235] */ - (xdc_Char)0x25, /* [5236] */ - (xdc_Char)0x64, /* [5237] */ - (xdc_Char)0x0, /* [5238] */ - (xdc_Char)0x4c, /* [5239] */ - (xdc_Char)0x4d, /* [5240] */ - (xdc_Char)0x5f, /* [5241] */ - (xdc_Char)0x74, /* [5242] */ - (xdc_Char)0x69, /* [5243] */ - (xdc_Char)0x63, /* [5244] */ - (xdc_Char)0x6b, /* [5245] */ - (xdc_Char)0x3a, /* [5246] */ - (xdc_Char)0x20, /* [5247] */ - (xdc_Char)0x74, /* [5248] */ - (xdc_Char)0x69, /* [5249] */ - (xdc_Char)0x63, /* [5250] */ - (xdc_Char)0x6b, /* [5251] */ - (xdc_Char)0x3a, /* [5252] */ - (xdc_Char)0x20, /* [5253] */ - (xdc_Char)0x25, /* [5254] */ - (xdc_Char)0x64, /* [5255] */ - (xdc_Char)0x0, /* [5256] */ - (xdc_Char)0x4c, /* [5257] */ - (xdc_Char)0x4d, /* [5258] */ - (xdc_Char)0x5f, /* [5259] */ - (xdc_Char)0x62, /* [5260] */ - (xdc_Char)0x65, /* [5261] */ - (xdc_Char)0x67, /* [5262] */ - (xdc_Char)0x69, /* [5263] */ - (xdc_Char)0x6e, /* [5264] */ - (xdc_Char)0x3a, /* [5265] */ - (xdc_Char)0x20, /* [5266] */ - (xdc_Char)0x63, /* [5267] */ - (xdc_Char)0x6c, /* [5268] */ - (xdc_Char)0x6b, /* [5269] */ - (xdc_Char)0x3a, /* [5270] */ - (xdc_Char)0x20, /* [5271] */ - (xdc_Char)0x30, /* [5272] */ - (xdc_Char)0x78, /* [5273] */ - (xdc_Char)0x25, /* [5274] */ - (xdc_Char)0x78, /* [5275] */ - (xdc_Char)0x2c, /* [5276] */ - (xdc_Char)0x20, /* [5277] */ - (xdc_Char)0x66, /* [5278] */ - (xdc_Char)0x75, /* [5279] */ - (xdc_Char)0x6e, /* [5280] */ - (xdc_Char)0x63, /* [5281] */ - (xdc_Char)0x3a, /* [5282] */ - (xdc_Char)0x20, /* [5283] */ - (xdc_Char)0x30, /* [5284] */ - (xdc_Char)0x78, /* [5285] */ - (xdc_Char)0x25, /* [5286] */ - (xdc_Char)0x78, /* [5287] */ - (xdc_Char)0x0, /* [5288] */ - (xdc_Char)0x4c, /* [5289] */ - (xdc_Char)0x4d, /* [5290] */ - (xdc_Char)0x5f, /* [5291] */ - (xdc_Char)0x70, /* [5292] */ - (xdc_Char)0x6f, /* [5293] */ - (xdc_Char)0x73, /* [5294] */ - (xdc_Char)0x74, /* [5295] */ - (xdc_Char)0x3a, /* [5296] */ - (xdc_Char)0x20, /* [5297] */ - (xdc_Char)0x65, /* [5298] */ - (xdc_Char)0x76, /* [5299] */ - (xdc_Char)0x65, /* [5300] */ - (xdc_Char)0x6e, /* [5301] */ - (xdc_Char)0x74, /* [5302] */ - (xdc_Char)0x3a, /* [5303] */ - (xdc_Char)0x20, /* [5304] */ - (xdc_Char)0x30, /* [5305] */ - (xdc_Char)0x78, /* [5306] */ - (xdc_Char)0x25, /* [5307] */ - (xdc_Char)0x78, /* [5308] */ - (xdc_Char)0x2c, /* [5309] */ - (xdc_Char)0x20, /* [5310] */ - (xdc_Char)0x63, /* [5311] */ - (xdc_Char)0x75, /* [5312] */ - (xdc_Char)0x72, /* [5313] */ - (xdc_Char)0x72, /* [5314] */ - (xdc_Char)0x45, /* [5315] */ - (xdc_Char)0x76, /* [5316] */ - (xdc_Char)0x65, /* [5317] */ - (xdc_Char)0x6e, /* [5318] */ - (xdc_Char)0x74, /* [5319] */ - (xdc_Char)0x73, /* [5320] */ - (xdc_Char)0x3a, /* [5321] */ - (xdc_Char)0x20, /* [5322] */ - (xdc_Char)0x30, /* [5323] */ - (xdc_Char)0x78, /* [5324] */ - (xdc_Char)0x25, /* [5325] */ - (xdc_Char)0x78, /* [5326] */ - (xdc_Char)0x2c, /* [5327] */ - (xdc_Char)0x20, /* [5328] */ - (xdc_Char)0x65, /* [5329] */ - (xdc_Char)0x76, /* [5330] */ - (xdc_Char)0x65, /* [5331] */ - (xdc_Char)0x6e, /* [5332] */ - (xdc_Char)0x74, /* [5333] */ - (xdc_Char)0x49, /* [5334] */ - (xdc_Char)0x64, /* [5335] */ - (xdc_Char)0x3a, /* [5336] */ - (xdc_Char)0x20, /* [5337] */ - (xdc_Char)0x30, /* [5338] */ - (xdc_Char)0x78, /* [5339] */ - (xdc_Char)0x25, /* [5340] */ - (xdc_Char)0x78, /* [5341] */ - (xdc_Char)0x0, /* [5342] */ - (xdc_Char)0x4c, /* [5343] */ - (xdc_Char)0x4d, /* [5344] */ - (xdc_Char)0x5f, /* [5345] */ - (xdc_Char)0x70, /* [5346] */ - (xdc_Char)0x65, /* [5347] */ - (xdc_Char)0x6e, /* [5348] */ - (xdc_Char)0x64, /* [5349] */ - (xdc_Char)0x3a, /* [5350] */ - (xdc_Char)0x20, /* [5351] */ - (xdc_Char)0x65, /* [5352] */ - (xdc_Char)0x76, /* [5353] */ - (xdc_Char)0x65, /* [5354] */ - (xdc_Char)0x6e, /* [5355] */ - (xdc_Char)0x74, /* [5356] */ - (xdc_Char)0x3a, /* [5357] */ - (xdc_Char)0x20, /* [5358] */ - (xdc_Char)0x30, /* [5359] */ - (xdc_Char)0x78, /* [5360] */ - (xdc_Char)0x25, /* [5361] */ - (xdc_Char)0x78, /* [5362] */ - (xdc_Char)0x2c, /* [5363] */ - (xdc_Char)0x20, /* [5364] */ - (xdc_Char)0x63, /* [5365] */ - (xdc_Char)0x75, /* [5366] */ - (xdc_Char)0x72, /* [5367] */ - (xdc_Char)0x72, /* [5368] */ - (xdc_Char)0x45, /* [5369] */ - (xdc_Char)0x76, /* [5370] */ - (xdc_Char)0x65, /* [5371] */ - (xdc_Char)0x6e, /* [5372] */ - (xdc_Char)0x74, /* [5373] */ - (xdc_Char)0x73, /* [5374] */ - (xdc_Char)0x3a, /* [5375] */ - (xdc_Char)0x20, /* [5376] */ - (xdc_Char)0x30, /* [5377] */ - (xdc_Char)0x78, /* [5378] */ - (xdc_Char)0x25, /* [5379] */ - (xdc_Char)0x78, /* [5380] */ - (xdc_Char)0x2c, /* [5381] */ - (xdc_Char)0x20, /* [5382] */ - (xdc_Char)0x61, /* [5383] */ - (xdc_Char)0x6e, /* [5384] */ - (xdc_Char)0x64, /* [5385] */ - (xdc_Char)0x4d, /* [5386] */ - (xdc_Char)0x61, /* [5387] */ - (xdc_Char)0x73, /* [5388] */ - (xdc_Char)0x6b, /* [5389] */ - (xdc_Char)0x3a, /* [5390] */ - (xdc_Char)0x20, /* [5391] */ - (xdc_Char)0x30, /* [5392] */ - (xdc_Char)0x78, /* [5393] */ - (xdc_Char)0x25, /* [5394] */ - (xdc_Char)0x78, /* [5395] */ - (xdc_Char)0x2c, /* [5396] */ - (xdc_Char)0x20, /* [5397] */ - (xdc_Char)0x6f, /* [5398] */ - (xdc_Char)0x72, /* [5399] */ - (xdc_Char)0x4d, /* [5400] */ - (xdc_Char)0x61, /* [5401] */ - (xdc_Char)0x73, /* [5402] */ - (xdc_Char)0x6b, /* [5403] */ - (xdc_Char)0x3a, /* [5404] */ - (xdc_Char)0x20, /* [5405] */ - (xdc_Char)0x30, /* [5406] */ - (xdc_Char)0x78, /* [5407] */ - (xdc_Char)0x25, /* [5408] */ - (xdc_Char)0x78, /* [5409] */ - (xdc_Char)0x2c, /* [5410] */ - (xdc_Char)0x20, /* [5411] */ - (xdc_Char)0x74, /* [5412] */ - (xdc_Char)0x69, /* [5413] */ - (xdc_Char)0x6d, /* [5414] */ - (xdc_Char)0x65, /* [5415] */ - (xdc_Char)0x6f, /* [5416] */ - (xdc_Char)0x75, /* [5417] */ - (xdc_Char)0x74, /* [5418] */ - (xdc_Char)0x3a, /* [5419] */ - (xdc_Char)0x20, /* [5420] */ - (xdc_Char)0x25, /* [5421] */ - (xdc_Char)0x64, /* [5422] */ - (xdc_Char)0x0, /* [5423] */ - (xdc_Char)0x4c, /* [5424] */ - (xdc_Char)0x4d, /* [5425] */ - (xdc_Char)0x5f, /* [5426] */ - (xdc_Char)0x70, /* [5427] */ - (xdc_Char)0x6f, /* [5428] */ - (xdc_Char)0x73, /* [5429] */ - (xdc_Char)0x74, /* [5430] */ - (xdc_Char)0x3a, /* [5431] */ - (xdc_Char)0x20, /* [5432] */ - (xdc_Char)0x73, /* [5433] */ - (xdc_Char)0x65, /* [5434] */ - (xdc_Char)0x6d, /* [5435] */ - (xdc_Char)0x3a, /* [5436] */ - (xdc_Char)0x20, /* [5437] */ - (xdc_Char)0x30, /* [5438] */ - (xdc_Char)0x78, /* [5439] */ - (xdc_Char)0x25, /* [5440] */ - (xdc_Char)0x78, /* [5441] */ - (xdc_Char)0x2c, /* [5442] */ - (xdc_Char)0x20, /* [5443] */ - (xdc_Char)0x63, /* [5444] */ - (xdc_Char)0x6f, /* [5445] */ - (xdc_Char)0x75, /* [5446] */ - (xdc_Char)0x6e, /* [5447] */ - (xdc_Char)0x74, /* [5448] */ - (xdc_Char)0x3a, /* [5449] */ - (xdc_Char)0x20, /* [5450] */ - (xdc_Char)0x25, /* [5451] */ - (xdc_Char)0x64, /* [5452] */ - (xdc_Char)0x0, /* [5453] */ - (xdc_Char)0x4c, /* [5454] */ - (xdc_Char)0x4d, /* [5455] */ - (xdc_Char)0x5f, /* [5456] */ - (xdc_Char)0x70, /* [5457] */ - (xdc_Char)0x65, /* [5458] */ - (xdc_Char)0x6e, /* [5459] */ - (xdc_Char)0x64, /* [5460] */ - (xdc_Char)0x3a, /* [5461] */ - (xdc_Char)0x20, /* [5462] */ - (xdc_Char)0x73, /* [5463] */ - (xdc_Char)0x65, /* [5464] */ - (xdc_Char)0x6d, /* [5465] */ - (xdc_Char)0x3a, /* [5466] */ - (xdc_Char)0x20, /* [5467] */ - (xdc_Char)0x30, /* [5468] */ - (xdc_Char)0x78, /* [5469] */ - (xdc_Char)0x25, /* [5470] */ - (xdc_Char)0x78, /* [5471] */ - (xdc_Char)0x2c, /* [5472] */ - (xdc_Char)0x20, /* [5473] */ - (xdc_Char)0x63, /* [5474] */ - (xdc_Char)0x6f, /* [5475] */ - (xdc_Char)0x75, /* [5476] */ - (xdc_Char)0x6e, /* [5477] */ - (xdc_Char)0x74, /* [5478] */ - (xdc_Char)0x3a, /* [5479] */ - (xdc_Char)0x20, /* [5480] */ - (xdc_Char)0x25, /* [5481] */ - (xdc_Char)0x64, /* [5482] */ - (xdc_Char)0x2c, /* [5483] */ - (xdc_Char)0x20, /* [5484] */ - (xdc_Char)0x74, /* [5485] */ - (xdc_Char)0x69, /* [5486] */ - (xdc_Char)0x6d, /* [5487] */ - (xdc_Char)0x65, /* [5488] */ - (xdc_Char)0x6f, /* [5489] */ - (xdc_Char)0x75, /* [5490] */ - (xdc_Char)0x74, /* [5491] */ - (xdc_Char)0x3a, /* [5492] */ - (xdc_Char)0x20, /* [5493] */ - (xdc_Char)0x25, /* [5494] */ - (xdc_Char)0x64, /* [5495] */ - (xdc_Char)0x0, /* [5496] */ - (xdc_Char)0x4c, /* [5497] */ - (xdc_Char)0x4d, /* [5498] */ - (xdc_Char)0x5f, /* [5499] */ - (xdc_Char)0x62, /* [5500] */ - (xdc_Char)0x65, /* [5501] */ - (xdc_Char)0x67, /* [5502] */ - (xdc_Char)0x69, /* [5503] */ - (xdc_Char)0x6e, /* [5504] */ - (xdc_Char)0x3a, /* [5505] */ - (xdc_Char)0x20, /* [5506] */ - (xdc_Char)0x73, /* [5507] */ - (xdc_Char)0x77, /* [5508] */ - (xdc_Char)0x69, /* [5509] */ - (xdc_Char)0x3a, /* [5510] */ - (xdc_Char)0x20, /* [5511] */ - (xdc_Char)0x30, /* [5512] */ - (xdc_Char)0x78, /* [5513] */ - (xdc_Char)0x25, /* [5514] */ - (xdc_Char)0x78, /* [5515] */ - (xdc_Char)0x2c, /* [5516] */ - (xdc_Char)0x20, /* [5517] */ - (xdc_Char)0x66, /* [5518] */ - (xdc_Char)0x75, /* [5519] */ - (xdc_Char)0x6e, /* [5520] */ - (xdc_Char)0x63, /* [5521] */ - (xdc_Char)0x3a, /* [5522] */ - (xdc_Char)0x20, /* [5523] */ - (xdc_Char)0x30, /* [5524] */ - (xdc_Char)0x78, /* [5525] */ - (xdc_Char)0x25, /* [5526] */ - (xdc_Char)0x78, /* [5527] */ - (xdc_Char)0x2c, /* [5528] */ - (xdc_Char)0x20, /* [5529] */ - (xdc_Char)0x70, /* [5530] */ - (xdc_Char)0x72, /* [5531] */ - (xdc_Char)0x65, /* [5532] */ - (xdc_Char)0x54, /* [5533] */ - (xdc_Char)0x68, /* [5534] */ - (xdc_Char)0x72, /* [5535] */ - (xdc_Char)0x65, /* [5536] */ - (xdc_Char)0x61, /* [5537] */ - (xdc_Char)0x64, /* [5538] */ - (xdc_Char)0x3a, /* [5539] */ - (xdc_Char)0x20, /* [5540] */ - (xdc_Char)0x25, /* [5541] */ - (xdc_Char)0x64, /* [5542] */ - (xdc_Char)0x0, /* [5543] */ - (xdc_Char)0x4c, /* [5544] */ - (xdc_Char)0x44, /* [5545] */ - (xdc_Char)0x5f, /* [5546] */ - (xdc_Char)0x65, /* [5547] */ - (xdc_Char)0x6e, /* [5548] */ - (xdc_Char)0x64, /* [5549] */ - (xdc_Char)0x3a, /* [5550] */ - (xdc_Char)0x20, /* [5551] */ - (xdc_Char)0x73, /* [5552] */ - (xdc_Char)0x77, /* [5553] */ - (xdc_Char)0x69, /* [5554] */ - (xdc_Char)0x3a, /* [5555] */ - (xdc_Char)0x20, /* [5556] */ - (xdc_Char)0x30, /* [5557] */ - (xdc_Char)0x78, /* [5558] */ - (xdc_Char)0x25, /* [5559] */ - (xdc_Char)0x78, /* [5560] */ - (xdc_Char)0x0, /* [5561] */ - (xdc_Char)0x4c, /* [5562] */ - (xdc_Char)0x4d, /* [5563] */ - (xdc_Char)0x5f, /* [5564] */ - (xdc_Char)0x70, /* [5565] */ - (xdc_Char)0x6f, /* [5566] */ - (xdc_Char)0x73, /* [5567] */ - (xdc_Char)0x74, /* [5568] */ - (xdc_Char)0x3a, /* [5569] */ - (xdc_Char)0x20, /* [5570] */ - (xdc_Char)0x73, /* [5571] */ - (xdc_Char)0x77, /* [5572] */ - (xdc_Char)0x69, /* [5573] */ - (xdc_Char)0x3a, /* [5574] */ - (xdc_Char)0x20, /* [5575] */ - (xdc_Char)0x30, /* [5576] */ - (xdc_Char)0x78, /* [5577] */ - (xdc_Char)0x25, /* [5578] */ - (xdc_Char)0x78, /* [5579] */ - (xdc_Char)0x2c, /* [5580] */ - (xdc_Char)0x20, /* [5581] */ - (xdc_Char)0x66, /* [5582] */ - (xdc_Char)0x75, /* [5583] */ - (xdc_Char)0x6e, /* [5584] */ - (xdc_Char)0x63, /* [5585] */ - (xdc_Char)0x3a, /* [5586] */ - (xdc_Char)0x20, /* [5587] */ - (xdc_Char)0x30, /* [5588] */ - (xdc_Char)0x78, /* [5589] */ - (xdc_Char)0x25, /* [5590] */ - (xdc_Char)0x78, /* [5591] */ - (xdc_Char)0x2c, /* [5592] */ - (xdc_Char)0x20, /* [5593] */ - (xdc_Char)0x70, /* [5594] */ - (xdc_Char)0x72, /* [5595] */ - (xdc_Char)0x69, /* [5596] */ - (xdc_Char)0x3a, /* [5597] */ - (xdc_Char)0x20, /* [5598] */ - (xdc_Char)0x25, /* [5599] */ - (xdc_Char)0x64, /* [5600] */ - (xdc_Char)0x0, /* [5601] */ - (xdc_Char)0x4c, /* [5602] */ - (xdc_Char)0x4d, /* [5603] */ - (xdc_Char)0x5f, /* [5604] */ - (xdc_Char)0x73, /* [5605] */ - (xdc_Char)0x77, /* [5606] */ - (xdc_Char)0x69, /* [5607] */ - (xdc_Char)0x74, /* [5608] */ - (xdc_Char)0x63, /* [5609] */ - (xdc_Char)0x68, /* [5610] */ - (xdc_Char)0x3a, /* [5611] */ - (xdc_Char)0x20, /* [5612] */ - (xdc_Char)0x6f, /* [5613] */ - (xdc_Char)0x6c, /* [5614] */ - (xdc_Char)0x64, /* [5615] */ - (xdc_Char)0x74, /* [5616] */ - (xdc_Char)0x73, /* [5617] */ - (xdc_Char)0x6b, /* [5618] */ - (xdc_Char)0x3a, /* [5619] */ - (xdc_Char)0x20, /* [5620] */ - (xdc_Char)0x30, /* [5621] */ - (xdc_Char)0x78, /* [5622] */ - (xdc_Char)0x25, /* [5623] */ - (xdc_Char)0x78, /* [5624] */ - (xdc_Char)0x2c, /* [5625] */ - (xdc_Char)0x20, /* [5626] */ - (xdc_Char)0x6f, /* [5627] */ - (xdc_Char)0x6c, /* [5628] */ - (xdc_Char)0x64, /* [5629] */ - (xdc_Char)0x66, /* [5630] */ - (xdc_Char)0x75, /* [5631] */ - (xdc_Char)0x6e, /* [5632] */ - (xdc_Char)0x63, /* [5633] */ - (xdc_Char)0x3a, /* [5634] */ - (xdc_Char)0x20, /* [5635] */ - (xdc_Char)0x30, /* [5636] */ - (xdc_Char)0x78, /* [5637] */ - (xdc_Char)0x25, /* [5638] */ - (xdc_Char)0x78, /* [5639] */ - (xdc_Char)0x2c, /* [5640] */ - (xdc_Char)0x20, /* [5641] */ - (xdc_Char)0x6e, /* [5642] */ - (xdc_Char)0x65, /* [5643] */ - (xdc_Char)0x77, /* [5644] */ - (xdc_Char)0x74, /* [5645] */ - (xdc_Char)0x73, /* [5646] */ - (xdc_Char)0x6b, /* [5647] */ - (xdc_Char)0x3a, /* [5648] */ - (xdc_Char)0x20, /* [5649] */ - (xdc_Char)0x30, /* [5650] */ - (xdc_Char)0x78, /* [5651] */ - (xdc_Char)0x25, /* [5652] */ - (xdc_Char)0x78, /* [5653] */ - (xdc_Char)0x2c, /* [5654] */ - (xdc_Char)0x20, /* [5655] */ - (xdc_Char)0x6e, /* [5656] */ - (xdc_Char)0x65, /* [5657] */ - (xdc_Char)0x77, /* [5658] */ - (xdc_Char)0x66, /* [5659] */ - (xdc_Char)0x75, /* [5660] */ - (xdc_Char)0x6e, /* [5661] */ - (xdc_Char)0x63, /* [5662] */ - (xdc_Char)0x3a, /* [5663] */ - (xdc_Char)0x20, /* [5664] */ - (xdc_Char)0x30, /* [5665] */ - (xdc_Char)0x78, /* [5666] */ - (xdc_Char)0x25, /* [5667] */ - (xdc_Char)0x78, /* [5668] */ - (xdc_Char)0x0, /* [5669] */ - (xdc_Char)0x4c, /* [5670] */ - (xdc_Char)0x4d, /* [5671] */ - (xdc_Char)0x5f, /* [5672] */ - (xdc_Char)0x73, /* [5673] */ - (xdc_Char)0x6c, /* [5674] */ - (xdc_Char)0x65, /* [5675] */ - (xdc_Char)0x65, /* [5676] */ - (xdc_Char)0x70, /* [5677] */ - (xdc_Char)0x3a, /* [5678] */ - (xdc_Char)0x20, /* [5679] */ - (xdc_Char)0x74, /* [5680] */ - (xdc_Char)0x73, /* [5681] */ - (xdc_Char)0x6b, /* [5682] */ - (xdc_Char)0x3a, /* [5683] */ - (xdc_Char)0x20, /* [5684] */ - (xdc_Char)0x30, /* [5685] */ - (xdc_Char)0x78, /* [5686] */ - (xdc_Char)0x25, /* [5687] */ - (xdc_Char)0x78, /* [5688] */ - (xdc_Char)0x2c, /* [5689] */ - (xdc_Char)0x20, /* [5690] */ - (xdc_Char)0x66, /* [5691] */ - (xdc_Char)0x75, /* [5692] */ - (xdc_Char)0x6e, /* [5693] */ - (xdc_Char)0x63, /* [5694] */ - (xdc_Char)0x3a, /* [5695] */ - (xdc_Char)0x20, /* [5696] */ - (xdc_Char)0x30, /* [5697] */ - (xdc_Char)0x78, /* [5698] */ - (xdc_Char)0x25, /* [5699] */ - (xdc_Char)0x78, /* [5700] */ - (xdc_Char)0x2c, /* [5701] */ - (xdc_Char)0x20, /* [5702] */ - (xdc_Char)0x74, /* [5703] */ - (xdc_Char)0x69, /* [5704] */ - (xdc_Char)0x6d, /* [5705] */ - (xdc_Char)0x65, /* [5706] */ - (xdc_Char)0x6f, /* [5707] */ - (xdc_Char)0x75, /* [5708] */ - (xdc_Char)0x74, /* [5709] */ - (xdc_Char)0x3a, /* [5710] */ - (xdc_Char)0x20, /* [5711] */ - (xdc_Char)0x25, /* [5712] */ - (xdc_Char)0x64, /* [5713] */ - (xdc_Char)0x0, /* [5714] */ - (xdc_Char)0x4c, /* [5715] */ - (xdc_Char)0x44, /* [5716] */ - (xdc_Char)0x5f, /* [5717] */ - (xdc_Char)0x72, /* [5718] */ - (xdc_Char)0x65, /* [5719] */ - (xdc_Char)0x61, /* [5720] */ - (xdc_Char)0x64, /* [5721] */ - (xdc_Char)0x79, /* [5722] */ - (xdc_Char)0x3a, /* [5723] */ - (xdc_Char)0x20, /* [5724] */ - (xdc_Char)0x74, /* [5725] */ - (xdc_Char)0x73, /* [5726] */ - (xdc_Char)0x6b, /* [5727] */ - (xdc_Char)0x3a, /* [5728] */ - (xdc_Char)0x20, /* [5729] */ - (xdc_Char)0x30, /* [5730] */ - (xdc_Char)0x78, /* [5731] */ - (xdc_Char)0x25, /* [5732] */ - (xdc_Char)0x78, /* [5733] */ - (xdc_Char)0x2c, /* [5734] */ - (xdc_Char)0x20, /* [5735] */ - (xdc_Char)0x66, /* [5736] */ - (xdc_Char)0x75, /* [5737] */ - (xdc_Char)0x6e, /* [5738] */ - (xdc_Char)0x63, /* [5739] */ - (xdc_Char)0x3a, /* [5740] */ - (xdc_Char)0x20, /* [5741] */ - (xdc_Char)0x30, /* [5742] */ - (xdc_Char)0x78, /* [5743] */ - (xdc_Char)0x25, /* [5744] */ - (xdc_Char)0x78, /* [5745] */ - (xdc_Char)0x2c, /* [5746] */ - (xdc_Char)0x20, /* [5747] */ - (xdc_Char)0x70, /* [5748] */ - (xdc_Char)0x72, /* [5749] */ - (xdc_Char)0x69, /* [5750] */ - (xdc_Char)0x3a, /* [5751] */ - (xdc_Char)0x20, /* [5752] */ - (xdc_Char)0x25, /* [5753] */ - (xdc_Char)0x64, /* [5754] */ - (xdc_Char)0x0, /* [5755] */ - (xdc_Char)0x4c, /* [5756] */ - (xdc_Char)0x44, /* [5757] */ - (xdc_Char)0x5f, /* [5758] */ - (xdc_Char)0x62, /* [5759] */ - (xdc_Char)0x6c, /* [5760] */ - (xdc_Char)0x6f, /* [5761] */ - (xdc_Char)0x63, /* [5762] */ - (xdc_Char)0x6b, /* [5763] */ - (xdc_Char)0x3a, /* [5764] */ - (xdc_Char)0x20, /* [5765] */ - (xdc_Char)0x74, /* [5766] */ - (xdc_Char)0x73, /* [5767] */ - (xdc_Char)0x6b, /* [5768] */ - (xdc_Char)0x3a, /* [5769] */ - (xdc_Char)0x20, /* [5770] */ - (xdc_Char)0x30, /* [5771] */ - (xdc_Char)0x78, /* [5772] */ - (xdc_Char)0x25, /* [5773] */ - (xdc_Char)0x78, /* [5774] */ - (xdc_Char)0x2c, /* [5775] */ - (xdc_Char)0x20, /* [5776] */ - (xdc_Char)0x66, /* [5777] */ - (xdc_Char)0x75, /* [5778] */ - (xdc_Char)0x6e, /* [5779] */ - (xdc_Char)0x63, /* [5780] */ - (xdc_Char)0x3a, /* [5781] */ - (xdc_Char)0x20, /* [5782] */ - (xdc_Char)0x30, /* [5783] */ - (xdc_Char)0x78, /* [5784] */ - (xdc_Char)0x25, /* [5785] */ - (xdc_Char)0x78, /* [5786] */ - (xdc_Char)0x0, /* [5787] */ - (xdc_Char)0x4c, /* [5788] */ - (xdc_Char)0x4d, /* [5789] */ - (xdc_Char)0x5f, /* [5790] */ - (xdc_Char)0x79, /* [5791] */ - (xdc_Char)0x69, /* [5792] */ - (xdc_Char)0x65, /* [5793] */ - (xdc_Char)0x6c, /* [5794] */ - (xdc_Char)0x64, /* [5795] */ - (xdc_Char)0x3a, /* [5796] */ - (xdc_Char)0x20, /* [5797] */ - (xdc_Char)0x74, /* [5798] */ - (xdc_Char)0x73, /* [5799] */ - (xdc_Char)0x6b, /* [5800] */ - (xdc_Char)0x3a, /* [5801] */ - (xdc_Char)0x20, /* [5802] */ - (xdc_Char)0x30, /* [5803] */ - (xdc_Char)0x78, /* [5804] */ - (xdc_Char)0x25, /* [5805] */ - (xdc_Char)0x78, /* [5806] */ - (xdc_Char)0x2c, /* [5807] */ - (xdc_Char)0x20, /* [5808] */ - (xdc_Char)0x66, /* [5809] */ - (xdc_Char)0x75, /* [5810] */ - (xdc_Char)0x6e, /* [5811] */ - (xdc_Char)0x63, /* [5812] */ - (xdc_Char)0x3a, /* [5813] */ - (xdc_Char)0x20, /* [5814] */ - (xdc_Char)0x30, /* [5815] */ - (xdc_Char)0x78, /* [5816] */ - (xdc_Char)0x25, /* [5817] */ - (xdc_Char)0x78, /* [5818] */ - (xdc_Char)0x2c, /* [5819] */ - (xdc_Char)0x20, /* [5820] */ - (xdc_Char)0x63, /* [5821] */ - (xdc_Char)0x75, /* [5822] */ - (xdc_Char)0x72, /* [5823] */ - (xdc_Char)0x72, /* [5824] */ - (xdc_Char)0x54, /* [5825] */ - (xdc_Char)0x68, /* [5826] */ - (xdc_Char)0x72, /* [5827] */ - (xdc_Char)0x65, /* [5828] */ - (xdc_Char)0x61, /* [5829] */ - (xdc_Char)0x64, /* [5830] */ - (xdc_Char)0x3a, /* [5831] */ - (xdc_Char)0x20, /* [5832] */ - (xdc_Char)0x25, /* [5833] */ - (xdc_Char)0x64, /* [5834] */ - (xdc_Char)0x0, /* [5835] */ - (xdc_Char)0x4c, /* [5836] */ - (xdc_Char)0x4d, /* [5837] */ - (xdc_Char)0x5f, /* [5838] */ - (xdc_Char)0x73, /* [5839] */ - (xdc_Char)0x65, /* [5840] */ - (xdc_Char)0x74, /* [5841] */ - (xdc_Char)0x50, /* [5842] */ - (xdc_Char)0x72, /* [5843] */ - (xdc_Char)0x69, /* [5844] */ - (xdc_Char)0x3a, /* [5845] */ - (xdc_Char)0x20, /* [5846] */ - (xdc_Char)0x74, /* [5847] */ - (xdc_Char)0x73, /* [5848] */ - (xdc_Char)0x6b, /* [5849] */ - (xdc_Char)0x3a, /* [5850] */ - (xdc_Char)0x20, /* [5851] */ - (xdc_Char)0x30, /* [5852] */ - (xdc_Char)0x78, /* [5853] */ - (xdc_Char)0x25, /* [5854] */ - (xdc_Char)0x78, /* [5855] */ - (xdc_Char)0x2c, /* [5856] */ - (xdc_Char)0x20, /* [5857] */ - (xdc_Char)0x66, /* [5858] */ - (xdc_Char)0x75, /* [5859] */ - (xdc_Char)0x6e, /* [5860] */ - (xdc_Char)0x63, /* [5861] */ - (xdc_Char)0x3a, /* [5862] */ - (xdc_Char)0x20, /* [5863] */ - (xdc_Char)0x30, /* [5864] */ - (xdc_Char)0x78, /* [5865] */ - (xdc_Char)0x25, /* [5866] */ - (xdc_Char)0x78, /* [5867] */ - (xdc_Char)0x2c, /* [5868] */ - (xdc_Char)0x20, /* [5869] */ - (xdc_Char)0x6f, /* [5870] */ - (xdc_Char)0x6c, /* [5871] */ - (xdc_Char)0x64, /* [5872] */ - (xdc_Char)0x50, /* [5873] */ - (xdc_Char)0x72, /* [5874] */ - (xdc_Char)0x69, /* [5875] */ - (xdc_Char)0x3a, /* [5876] */ - (xdc_Char)0x20, /* [5877] */ - (xdc_Char)0x25, /* [5878] */ - (xdc_Char)0x64, /* [5879] */ - (xdc_Char)0x2c, /* [5880] */ - (xdc_Char)0x20, /* [5881] */ - (xdc_Char)0x6e, /* [5882] */ - (xdc_Char)0x65, /* [5883] */ - (xdc_Char)0x77, /* [5884] */ - (xdc_Char)0x50, /* [5885] */ - (xdc_Char)0x72, /* [5886] */ - (xdc_Char)0x69, /* [5887] */ - (xdc_Char)0x20, /* [5888] */ - (xdc_Char)0x25, /* [5889] */ - (xdc_Char)0x64, /* [5890] */ - (xdc_Char)0x0, /* [5891] */ - (xdc_Char)0x4c, /* [5892] */ - (xdc_Char)0x44, /* [5893] */ - (xdc_Char)0x5f, /* [5894] */ - (xdc_Char)0x65, /* [5895] */ - (xdc_Char)0x78, /* [5896] */ - (xdc_Char)0x69, /* [5897] */ - (xdc_Char)0x74, /* [5898] */ - (xdc_Char)0x3a, /* [5899] */ - (xdc_Char)0x20, /* [5900] */ - (xdc_Char)0x74, /* [5901] */ - (xdc_Char)0x73, /* [5902] */ - (xdc_Char)0x6b, /* [5903] */ - (xdc_Char)0x3a, /* [5904] */ - (xdc_Char)0x20, /* [5905] */ - (xdc_Char)0x30, /* [5906] */ - (xdc_Char)0x78, /* [5907] */ - (xdc_Char)0x25, /* [5908] */ - (xdc_Char)0x78, /* [5909] */ - (xdc_Char)0x2c, /* [5910] */ - (xdc_Char)0x20, /* [5911] */ - (xdc_Char)0x66, /* [5912] */ - (xdc_Char)0x75, /* [5913] */ - (xdc_Char)0x6e, /* [5914] */ - (xdc_Char)0x63, /* [5915] */ - (xdc_Char)0x3a, /* [5916] */ - (xdc_Char)0x20, /* [5917] */ - (xdc_Char)0x30, /* [5918] */ - (xdc_Char)0x78, /* [5919] */ - (xdc_Char)0x25, /* [5920] */ - (xdc_Char)0x78, /* [5921] */ - (xdc_Char)0x0, /* [5922] */ - (xdc_Char)0x4c, /* [5923] */ - (xdc_Char)0x4d, /* [5924] */ - (xdc_Char)0x5f, /* [5925] */ - (xdc_Char)0x73, /* [5926] */ - (xdc_Char)0x65, /* [5927] */ - (xdc_Char)0x74, /* [5928] */ - (xdc_Char)0x41, /* [5929] */ - (xdc_Char)0x66, /* [5930] */ - (xdc_Char)0x66, /* [5931] */ - (xdc_Char)0x69, /* [5932] */ - (xdc_Char)0x6e, /* [5933] */ - (xdc_Char)0x69, /* [5934] */ - (xdc_Char)0x74, /* [5935] */ - (xdc_Char)0x79, /* [5936] */ - (xdc_Char)0x3a, /* [5937] */ - (xdc_Char)0x20, /* [5938] */ - (xdc_Char)0x74, /* [5939] */ - (xdc_Char)0x73, /* [5940] */ - (xdc_Char)0x6b, /* [5941] */ - (xdc_Char)0x3a, /* [5942] */ - (xdc_Char)0x20, /* [5943] */ - (xdc_Char)0x30, /* [5944] */ - (xdc_Char)0x78, /* [5945] */ - (xdc_Char)0x25, /* [5946] */ - (xdc_Char)0x78, /* [5947] */ - (xdc_Char)0x2c, /* [5948] */ - (xdc_Char)0x20, /* [5949] */ - (xdc_Char)0x66, /* [5950] */ - (xdc_Char)0x75, /* [5951] */ - (xdc_Char)0x6e, /* [5952] */ - (xdc_Char)0x63, /* [5953] */ - (xdc_Char)0x3a, /* [5954] */ - (xdc_Char)0x20, /* [5955] */ - (xdc_Char)0x30, /* [5956] */ - (xdc_Char)0x78, /* [5957] */ - (xdc_Char)0x25, /* [5958] */ - (xdc_Char)0x78, /* [5959] */ - (xdc_Char)0x2c, /* [5960] */ - (xdc_Char)0x20, /* [5961] */ - (xdc_Char)0x6f, /* [5962] */ - (xdc_Char)0x6c, /* [5963] */ - (xdc_Char)0x64, /* [5964] */ - (xdc_Char)0x43, /* [5965] */ - (xdc_Char)0x6f, /* [5966] */ - (xdc_Char)0x72, /* [5967] */ - (xdc_Char)0x65, /* [5968] */ - (xdc_Char)0x3a, /* [5969] */ - (xdc_Char)0x20, /* [5970] */ - (xdc_Char)0x25, /* [5971] */ - (xdc_Char)0x64, /* [5972] */ - (xdc_Char)0x2c, /* [5973] */ - (xdc_Char)0x20, /* [5974] */ - (xdc_Char)0x6f, /* [5975] */ - (xdc_Char)0x6c, /* [5976] */ - (xdc_Char)0x64, /* [5977] */ - (xdc_Char)0x41, /* [5978] */ - (xdc_Char)0x66, /* [5979] */ - (xdc_Char)0x66, /* [5980] */ - (xdc_Char)0x69, /* [5981] */ - (xdc_Char)0x6e, /* [5982] */ - (xdc_Char)0x69, /* [5983] */ - (xdc_Char)0x74, /* [5984] */ - (xdc_Char)0x79, /* [5985] */ - (xdc_Char)0x20, /* [5986] */ - (xdc_Char)0x25, /* [5987] */ - (xdc_Char)0x64, /* [5988] */ - (xdc_Char)0x2c, /* [5989] */ - (xdc_Char)0x20, /* [5990] */ - (xdc_Char)0x6e, /* [5991] */ - (xdc_Char)0x65, /* [5992] */ - (xdc_Char)0x77, /* [5993] */ - (xdc_Char)0x41, /* [5994] */ - (xdc_Char)0x66, /* [5995] */ - (xdc_Char)0x66, /* [5996] */ - (xdc_Char)0x69, /* [5997] */ - (xdc_Char)0x6e, /* [5998] */ - (xdc_Char)0x69, /* [5999] */ - (xdc_Char)0x74, /* [6000] */ - (xdc_Char)0x79, /* [6001] */ - (xdc_Char)0x20, /* [6002] */ - (xdc_Char)0x25, /* [6003] */ - (xdc_Char)0x64, /* [6004] */ - (xdc_Char)0x0, /* [6005] */ - (xdc_Char)0x4c, /* [6006] */ - (xdc_Char)0x44, /* [6007] */ - (xdc_Char)0x5f, /* [6008] */ - (xdc_Char)0x73, /* [6009] */ - (xdc_Char)0x63, /* [6010] */ - (xdc_Char)0x68, /* [6011] */ - (xdc_Char)0x65, /* [6012] */ - (xdc_Char)0x64, /* [6013] */ - (xdc_Char)0x75, /* [6014] */ - (xdc_Char)0x6c, /* [6015] */ - (xdc_Char)0x65, /* [6016] */ - (xdc_Char)0x3a, /* [6017] */ - (xdc_Char)0x20, /* [6018] */ - (xdc_Char)0x63, /* [6019] */ - (xdc_Char)0x6f, /* [6020] */ - (xdc_Char)0x72, /* [6021] */ - (xdc_Char)0x65, /* [6022] */ - (xdc_Char)0x49, /* [6023] */ - (xdc_Char)0x64, /* [6024] */ - (xdc_Char)0x3a, /* [6025] */ - (xdc_Char)0x20, /* [6026] */ - (xdc_Char)0x25, /* [6027] */ - (xdc_Char)0x64, /* [6028] */ - (xdc_Char)0x2c, /* [6029] */ - (xdc_Char)0x20, /* [6030] */ - (xdc_Char)0x77, /* [6031] */ - (xdc_Char)0x6f, /* [6032] */ - (xdc_Char)0x72, /* [6033] */ - (xdc_Char)0x6b, /* [6034] */ - (xdc_Char)0x46, /* [6035] */ - (xdc_Char)0x6c, /* [6036] */ - (xdc_Char)0x61, /* [6037] */ - (xdc_Char)0x67, /* [6038] */ - (xdc_Char)0x3a, /* [6039] */ - (xdc_Char)0x20, /* [6040] */ - (xdc_Char)0x25, /* [6041] */ - (xdc_Char)0x64, /* [6042] */ - (xdc_Char)0x2c, /* [6043] */ - (xdc_Char)0x20, /* [6044] */ - (xdc_Char)0x63, /* [6045] */ - (xdc_Char)0x75, /* [6046] */ - (xdc_Char)0x72, /* [6047] */ - (xdc_Char)0x53, /* [6048] */ - (xdc_Char)0x65, /* [6049] */ - (xdc_Char)0x74, /* [6050] */ - (xdc_Char)0x4c, /* [6051] */ - (xdc_Char)0x6f, /* [6052] */ - (xdc_Char)0x63, /* [6053] */ - (xdc_Char)0x61, /* [6054] */ - (xdc_Char)0x6c, /* [6055] */ - (xdc_Char)0x3a, /* [6056] */ - (xdc_Char)0x20, /* [6057] */ - (xdc_Char)0x25, /* [6058] */ - (xdc_Char)0x64, /* [6059] */ - (xdc_Char)0x2c, /* [6060] */ - (xdc_Char)0x20, /* [6061] */ - (xdc_Char)0x63, /* [6062] */ - (xdc_Char)0x75, /* [6063] */ - (xdc_Char)0x72, /* [6064] */ - (xdc_Char)0x53, /* [6065] */ - (xdc_Char)0x65, /* [6066] */ - (xdc_Char)0x74, /* [6067] */ - (xdc_Char)0x58, /* [6068] */ - (xdc_Char)0x3a, /* [6069] */ - (xdc_Char)0x20, /* [6070] */ - (xdc_Char)0x25, /* [6071] */ - (xdc_Char)0x64, /* [6072] */ - (xdc_Char)0x2c, /* [6073] */ - (xdc_Char)0x20, /* [6074] */ - (xdc_Char)0x63, /* [6075] */ - (xdc_Char)0x75, /* [6076] */ - (xdc_Char)0x72, /* [6077] */ - (xdc_Char)0x4d, /* [6078] */ - (xdc_Char)0x61, /* [6079] */ - (xdc_Char)0x73, /* [6080] */ - (xdc_Char)0x6b, /* [6081] */ - (xdc_Char)0x4c, /* [6082] */ - (xdc_Char)0x6f, /* [6083] */ - (xdc_Char)0x63, /* [6084] */ - (xdc_Char)0x61, /* [6085] */ - (xdc_Char)0x6c, /* [6086] */ - (xdc_Char)0x3a, /* [6087] */ - (xdc_Char)0x20, /* [6088] */ - (xdc_Char)0x25, /* [6089] */ - (xdc_Char)0x64, /* [6090] */ - (xdc_Char)0x0, /* [6091] */ - (xdc_Char)0x4c, /* [6092] */ - (xdc_Char)0x44, /* [6093] */ - (xdc_Char)0x5f, /* [6094] */ - (xdc_Char)0x6e, /* [6095] */ - (xdc_Char)0x6f, /* [6096] */ - (xdc_Char)0x57, /* [6097] */ - (xdc_Char)0x6f, /* [6098] */ - (xdc_Char)0x72, /* [6099] */ - (xdc_Char)0x6b, /* [6100] */ - (xdc_Char)0x3a, /* [6101] */ - (xdc_Char)0x20, /* [6102] */ - (xdc_Char)0x63, /* [6103] */ - (xdc_Char)0x6f, /* [6104] */ - (xdc_Char)0x72, /* [6105] */ - (xdc_Char)0x65, /* [6106] */ - (xdc_Char)0x49, /* [6107] */ - (xdc_Char)0x64, /* [6108] */ - (xdc_Char)0x3a, /* [6109] */ - (xdc_Char)0x20, /* [6110] */ - (xdc_Char)0x25, /* [6111] */ - (xdc_Char)0x64, /* [6112] */ - (xdc_Char)0x2c, /* [6113] */ - (xdc_Char)0x20, /* [6114] */ - (xdc_Char)0x63, /* [6115] */ - (xdc_Char)0x75, /* [6116] */ - (xdc_Char)0x72, /* [6117] */ - (xdc_Char)0x53, /* [6118] */ - (xdc_Char)0x65, /* [6119] */ - (xdc_Char)0x74, /* [6120] */ - (xdc_Char)0x4c, /* [6121] */ - (xdc_Char)0x6f, /* [6122] */ - (xdc_Char)0x63, /* [6123] */ - (xdc_Char)0x61, /* [6124] */ - (xdc_Char)0x6c, /* [6125] */ - (xdc_Char)0x3a, /* [6126] */ - (xdc_Char)0x20, /* [6127] */ - (xdc_Char)0x25, /* [6128] */ - (xdc_Char)0x64, /* [6129] */ - (xdc_Char)0x2c, /* [6130] */ - (xdc_Char)0x20, /* [6131] */ - (xdc_Char)0x63, /* [6132] */ - (xdc_Char)0x75, /* [6133] */ - (xdc_Char)0x72, /* [6134] */ - (xdc_Char)0x53, /* [6135] */ - (xdc_Char)0x65, /* [6136] */ - (xdc_Char)0x74, /* [6137] */ - (xdc_Char)0x58, /* [6138] */ - (xdc_Char)0x3a, /* [6139] */ - (xdc_Char)0x20, /* [6140] */ - (xdc_Char)0x25, /* [6141] */ - (xdc_Char)0x64, /* [6142] */ - (xdc_Char)0x2c, /* [6143] */ - (xdc_Char)0x20, /* [6144] */ - (xdc_Char)0x63, /* [6145] */ - (xdc_Char)0x75, /* [6146] */ - (xdc_Char)0x72, /* [6147] */ - (xdc_Char)0x4d, /* [6148] */ - (xdc_Char)0x61, /* [6149] */ - (xdc_Char)0x73, /* [6150] */ - (xdc_Char)0x6b, /* [6151] */ - (xdc_Char)0x4c, /* [6152] */ - (xdc_Char)0x6f, /* [6153] */ - (xdc_Char)0x63, /* [6154] */ - (xdc_Char)0x61, /* [6155] */ - (xdc_Char)0x6c, /* [6156] */ - (xdc_Char)0x3a, /* [6157] */ - (xdc_Char)0x20, /* [6158] */ - (xdc_Char)0x25, /* [6159] */ - (xdc_Char)0x64, /* [6160] */ - (xdc_Char)0x0, /* [6161] */ - (xdc_Char)0x78, /* [6162] */ - (xdc_Char)0x64, /* [6163] */ - (xdc_Char)0x63, /* [6164] */ - (xdc_Char)0x2e, /* [6165] */ - (xdc_Char)0x0, /* [6166] */ - (xdc_Char)0x72, /* [6167] */ - (xdc_Char)0x75, /* [6168] */ - (xdc_Char)0x6e, /* [6169] */ - (xdc_Char)0x74, /* [6170] */ - (xdc_Char)0x69, /* [6171] */ - (xdc_Char)0x6d, /* [6172] */ - (xdc_Char)0x65, /* [6173] */ - (xdc_Char)0x2e, /* [6174] */ - (xdc_Char)0x0, /* [6175] */ - (xdc_Char)0x41, /* [6176] */ - (xdc_Char)0x73, /* [6177] */ - (xdc_Char)0x73, /* [6178] */ - (xdc_Char)0x65, /* [6179] */ - (xdc_Char)0x72, /* [6180] */ - (xdc_Char)0x74, /* [6181] */ - (xdc_Char)0x0, /* [6182] */ - (xdc_Char)0x43, /* [6183] */ - (xdc_Char)0x6f, /* [6184] */ - (xdc_Char)0x72, /* [6185] */ - (xdc_Char)0x65, /* [6186] */ - (xdc_Char)0x0, /* [6187] */ - (xdc_Char)0x44, /* [6188] */ - (xdc_Char)0x65, /* [6189] */ - (xdc_Char)0x66, /* [6190] */ - (xdc_Char)0x61, /* [6191] */ - (xdc_Char)0x75, /* [6192] */ - (xdc_Char)0x6c, /* [6193] */ - (xdc_Char)0x74, /* [6194] */ - (xdc_Char)0x73, /* [6195] */ - (xdc_Char)0x0, /* [6196] */ - (xdc_Char)0x44, /* [6197] */ - (xdc_Char)0x69, /* [6198] */ - (xdc_Char)0x61, /* [6199] */ - (xdc_Char)0x67, /* [6200] */ - (xdc_Char)0x73, /* [6201] */ - (xdc_Char)0x0, /* [6202] */ - (xdc_Char)0x45, /* [6203] */ - (xdc_Char)0x72, /* [6204] */ - (xdc_Char)0x72, /* [6205] */ - (xdc_Char)0x6f, /* [6206] */ - (xdc_Char)0x72, /* [6207] */ - (xdc_Char)0x0, /* [6208] */ - (xdc_Char)0x47, /* [6209] */ - (xdc_Char)0x61, /* [6210] */ - (xdc_Char)0x74, /* [6211] */ - (xdc_Char)0x65, /* [6212] */ - (xdc_Char)0x0, /* [6213] */ - (xdc_Char)0x4c, /* [6214] */ - (xdc_Char)0x6f, /* [6215] */ - (xdc_Char)0x67, /* [6216] */ - (xdc_Char)0x0, /* [6217] */ - (xdc_Char)0x4d, /* [6218] */ - (xdc_Char)0x61, /* [6219] */ - (xdc_Char)0x69, /* [6220] */ - (xdc_Char)0x6e, /* [6221] */ - (xdc_Char)0x0, /* [6222] */ - (xdc_Char)0x4d, /* [6223] */ - (xdc_Char)0x65, /* [6224] */ - (xdc_Char)0x6d, /* [6225] */ - (xdc_Char)0x6f, /* [6226] */ - (xdc_Char)0x72, /* [6227] */ - (xdc_Char)0x79, /* [6228] */ - (xdc_Char)0x0, /* [6229] */ - (xdc_Char)0x48, /* [6230] */ - (xdc_Char)0x65, /* [6231] */ - (xdc_Char)0x61, /* [6232] */ - (xdc_Char)0x70, /* [6233] */ - (xdc_Char)0x53, /* [6234] */ - (xdc_Char)0x74, /* [6235] */ - (xdc_Char)0x64, /* [6236] */ - (xdc_Char)0x0, /* [6237] */ - (xdc_Char)0x52, /* [6238] */ - (xdc_Char)0x65, /* [6239] */ - (xdc_Char)0x67, /* [6240] */ - (xdc_Char)0x69, /* [6241] */ - (xdc_Char)0x73, /* [6242] */ - (xdc_Char)0x74, /* [6243] */ - (xdc_Char)0x72, /* [6244] */ - (xdc_Char)0x79, /* [6245] */ - (xdc_Char)0x0, /* [6246] */ - (xdc_Char)0x53, /* [6247] */ - (xdc_Char)0x74, /* [6248] */ - (xdc_Char)0x61, /* [6249] */ - (xdc_Char)0x72, /* [6250] */ - (xdc_Char)0x74, /* [6251] */ - (xdc_Char)0x75, /* [6252] */ - (xdc_Char)0x70, /* [6253] */ - (xdc_Char)0x0, /* [6254] */ - (xdc_Char)0x53, /* [6255] */ - (xdc_Char)0x79, /* [6256] */ - (xdc_Char)0x73, /* [6257] */ - (xdc_Char)0x74, /* [6258] */ - (xdc_Char)0x65, /* [6259] */ - (xdc_Char)0x6d, /* [6260] */ - (xdc_Char)0x0, /* [6261] */ - (xdc_Char)0x53, /* [6262] */ - (xdc_Char)0x79, /* [6263] */ - (xdc_Char)0x73, /* [6264] */ - (xdc_Char)0x4d, /* [6265] */ - (xdc_Char)0x69, /* [6266] */ - (xdc_Char)0x6e, /* [6267] */ - (xdc_Char)0x0, /* [6268] */ - (xdc_Char)0x54, /* [6269] */ - (xdc_Char)0x65, /* [6270] */ - (xdc_Char)0x78, /* [6271] */ - (xdc_Char)0x74, /* [6272] */ - (xdc_Char)0x0, /* [6273] */ - (xdc_Char)0x54, /* [6274] */ - (xdc_Char)0x69, /* [6275] */ - (xdc_Char)0x6d, /* [6276] */ - (xdc_Char)0x65, /* [6277] */ - (xdc_Char)0x73, /* [6278] */ - (xdc_Char)0x74, /* [6279] */ - (xdc_Char)0x61, /* [6280] */ - (xdc_Char)0x6d, /* [6281] */ - (xdc_Char)0x70, /* [6282] */ - (xdc_Char)0x0, /* [6283] */ - (xdc_Char)0x74, /* [6284] */ - (xdc_Char)0x69, /* [6285] */ - (xdc_Char)0x2e, /* [6286] */ - (xdc_Char)0x0, /* [6287] */ - (xdc_Char)0x63, /* [6288] */ - (xdc_Char)0x61, /* [6289] */ - (xdc_Char)0x74, /* [6290] */ - (xdc_Char)0x61, /* [6291] */ - (xdc_Char)0x6c, /* [6292] */ - (xdc_Char)0x6f, /* [6293] */ - (xdc_Char)0x67, /* [6294] */ - (xdc_Char)0x2e, /* [6295] */ - (xdc_Char)0x0, /* [6296] */ - (xdc_Char)0x61, /* [6297] */ - (xdc_Char)0x72, /* [6298] */ - (xdc_Char)0x6d, /* [6299] */ - (xdc_Char)0x2e, /* [6300] */ - (xdc_Char)0x0, /* [6301] */ - (xdc_Char)0x63, /* [6302] */ - (xdc_Char)0x6f, /* [6303] */ - (xdc_Char)0x72, /* [6304] */ - (xdc_Char)0x74, /* [6305] */ - (xdc_Char)0x65, /* [6306] */ - (xdc_Char)0x78, /* [6307] */ - (xdc_Char)0x6d, /* [6308] */ - (xdc_Char)0x34, /* [6309] */ - (xdc_Char)0x2e, /* [6310] */ - (xdc_Char)0x0, /* [6311] */ - (xdc_Char)0x74, /* [6312] */ - (xdc_Char)0x69, /* [6313] */ - (xdc_Char)0x76, /* [6314] */ - (xdc_Char)0x61, /* [6315] */ - (xdc_Char)0x2e, /* [6316] */ - (xdc_Char)0x0, /* [6317] */ - (xdc_Char)0x63, /* [6318] */ - (xdc_Char)0x65, /* [6319] */ - (xdc_Char)0x2e, /* [6320] */ - (xdc_Char)0x0, /* [6321] */ - (xdc_Char)0x42, /* [6322] */ - (xdc_Char)0x6f, /* [6323] */ - (xdc_Char)0x6f, /* [6324] */ - (xdc_Char)0x74, /* [6325] */ - (xdc_Char)0x0, /* [6326] */ - (xdc_Char)0x73, /* [6327] */ - (xdc_Char)0x79, /* [6328] */ - (xdc_Char)0x73, /* [6329] */ - (xdc_Char)0x62, /* [6330] */ - (xdc_Char)0x69, /* [6331] */ - (xdc_Char)0x6f, /* [6332] */ - (xdc_Char)0x73, /* [6333] */ - (xdc_Char)0x2e, /* [6334] */ - (xdc_Char)0x0, /* [6335] */ - (xdc_Char)0x42, /* [6336] */ - (xdc_Char)0x49, /* [6337] */ - (xdc_Char)0x4f, /* [6338] */ - (xdc_Char)0x53, /* [6339] */ - (xdc_Char)0x0, /* [6340] */ - (xdc_Char)0x66, /* [6341] */ - (xdc_Char)0x61, /* [6342] */ - (xdc_Char)0x6d, /* [6343] */ - (xdc_Char)0x69, /* [6344] */ - (xdc_Char)0x6c, /* [6345] */ - (xdc_Char)0x79, /* [6346] */ - (xdc_Char)0x2e, /* [6347] */ - (xdc_Char)0x0, /* [6348] */ - (xdc_Char)0x6d, /* [6349] */ - (xdc_Char)0x33, /* [6350] */ - (xdc_Char)0x2e, /* [6351] */ - (xdc_Char)0x0, /* [6352] */ - (xdc_Char)0x48, /* [6353] */ - (xdc_Char)0x77, /* [6354] */ - (xdc_Char)0x69, /* [6355] */ - (xdc_Char)0x0, /* [6356] */ - (xdc_Char)0x49, /* [6357] */ - (xdc_Char)0x6e, /* [6358] */ - (xdc_Char)0x74, /* [6359] */ - (xdc_Char)0x72, /* [6360] */ - (xdc_Char)0x69, /* [6361] */ - (xdc_Char)0x6e, /* [6362] */ - (xdc_Char)0x73, /* [6363] */ - (xdc_Char)0x69, /* [6364] */ - (xdc_Char)0x63, /* [6365] */ - (xdc_Char)0x73, /* [6366] */ - (xdc_Char)0x53, /* [6367] */ - (xdc_Char)0x75, /* [6368] */ - (xdc_Char)0x70, /* [6369] */ - (xdc_Char)0x70, /* [6370] */ - (xdc_Char)0x6f, /* [6371] */ - (xdc_Char)0x72, /* [6372] */ - (xdc_Char)0x74, /* [6373] */ - (xdc_Char)0x0, /* [6374] */ - (xdc_Char)0x54, /* [6375] */ - (xdc_Char)0x61, /* [6376] */ - (xdc_Char)0x73, /* [6377] */ - (xdc_Char)0x6b, /* [6378] */ - (xdc_Char)0x53, /* [6379] */ - (xdc_Char)0x75, /* [6380] */ - (xdc_Char)0x70, /* [6381] */ - (xdc_Char)0x70, /* [6382] */ - (xdc_Char)0x6f, /* [6383] */ - (xdc_Char)0x72, /* [6384] */ - (xdc_Char)0x74, /* [6385] */ - (xdc_Char)0x0, /* [6386] */ - (xdc_Char)0x6b, /* [6387] */ - (xdc_Char)0x6e, /* [6388] */ - (xdc_Char)0x6c, /* [6389] */ - (xdc_Char)0x2e, /* [6390] */ - (xdc_Char)0x0, /* [6391] */ - (xdc_Char)0x43, /* [6392] */ - (xdc_Char)0x6c, /* [6393] */ - (xdc_Char)0x6f, /* [6394] */ - (xdc_Char)0x63, /* [6395] */ - (xdc_Char)0x6b, /* [6396] */ - (xdc_Char)0x0, /* [6397] */ - (xdc_Char)0x49, /* [6398] */ - (xdc_Char)0x64, /* [6399] */ - (xdc_Char)0x6c, /* [6400] */ - (xdc_Char)0x65, /* [6401] */ - (xdc_Char)0x0, /* [6402] */ - (xdc_Char)0x49, /* [6403] */ - (xdc_Char)0x6e, /* [6404] */ - (xdc_Char)0x74, /* [6405] */ - (xdc_Char)0x72, /* [6406] */ - (xdc_Char)0x69, /* [6407] */ - (xdc_Char)0x6e, /* [6408] */ - (xdc_Char)0x73, /* [6409] */ - (xdc_Char)0x69, /* [6410] */ - (xdc_Char)0x63, /* [6411] */ - (xdc_Char)0x73, /* [6412] */ - (xdc_Char)0x0, /* [6413] */ - (xdc_Char)0x45, /* [6414] */ - (xdc_Char)0x76, /* [6415] */ - (xdc_Char)0x65, /* [6416] */ - (xdc_Char)0x6e, /* [6417] */ - (xdc_Char)0x74, /* [6418] */ - (xdc_Char)0x0, /* [6419] */ - (xdc_Char)0x4d, /* [6420] */ - (xdc_Char)0x61, /* [6421] */ - (xdc_Char)0x69, /* [6422] */ - (xdc_Char)0x6c, /* [6423] */ - (xdc_Char)0x62, /* [6424] */ - (xdc_Char)0x6f, /* [6425] */ - (xdc_Char)0x78, /* [6426] */ - (xdc_Char)0x0, /* [6427] */ - (xdc_Char)0x51, /* [6428] */ - (xdc_Char)0x75, /* [6429] */ - (xdc_Char)0x65, /* [6430] */ - (xdc_Char)0x75, /* [6431] */ - (xdc_Char)0x65, /* [6432] */ - (xdc_Char)0x0, /* [6433] */ - (xdc_Char)0x53, /* [6434] */ - (xdc_Char)0x65, /* [6435] */ - (xdc_Char)0x6d, /* [6436] */ - (xdc_Char)0x61, /* [6437] */ - (xdc_Char)0x70, /* [6438] */ - (xdc_Char)0x68, /* [6439] */ - (xdc_Char)0x6f, /* [6440] */ - (xdc_Char)0x72, /* [6441] */ - (xdc_Char)0x65, /* [6442] */ - (xdc_Char)0x0, /* [6443] */ - (xdc_Char)0x53, /* [6444] */ - (xdc_Char)0x77, /* [6445] */ - (xdc_Char)0x69, /* [6446] */ - (xdc_Char)0x0, /* [6447] */ - (xdc_Char)0x54, /* [6448] */ - (xdc_Char)0x61, /* [6449] */ - (xdc_Char)0x73, /* [6450] */ - (xdc_Char)0x6b, /* [6451] */ - (xdc_Char)0x0, /* [6452] */ - (xdc_Char)0x68, /* [6453] */ - (xdc_Char)0x61, /* [6454] */ - (xdc_Char)0x6c, /* [6455] */ - (xdc_Char)0x2e, /* [6456] */ - (xdc_Char)0x0, /* [6457] */ - (xdc_Char)0x53, /* [6458] */ - (xdc_Char)0x65, /* [6459] */ - (xdc_Char)0x63, /* [6460] */ - (xdc_Char)0x6f, /* [6461] */ - (xdc_Char)0x6e, /* [6462] */ - (xdc_Char)0x64, /* [6463] */ - (xdc_Char)0x73, /* [6464] */ - (xdc_Char)0x0, /* [6465] */ - (xdc_Char)0x6c, /* [6466] */ - (xdc_Char)0x6d, /* [6467] */ - (xdc_Char)0x34, /* [6468] */ - (xdc_Char)0x2e, /* [6469] */ - (xdc_Char)0x0, /* [6470] */ - (xdc_Char)0x54, /* [6471] */ - (xdc_Char)0x69, /* [6472] */ - (xdc_Char)0x6d, /* [6473] */ - (xdc_Char)0x65, /* [6474] */ - (xdc_Char)0x73, /* [6475] */ - (xdc_Char)0x74, /* [6476] */ - (xdc_Char)0x61, /* [6477] */ - (xdc_Char)0x6d, /* [6478] */ - (xdc_Char)0x70, /* [6479] */ - (xdc_Char)0x50, /* [6480] */ - (xdc_Char)0x72, /* [6481] */ - (xdc_Char)0x6f, /* [6482] */ - (xdc_Char)0x76, /* [6483] */ - (xdc_Char)0x69, /* [6484] */ - (xdc_Char)0x64, /* [6485] */ - (xdc_Char)0x65, /* [6486] */ - (xdc_Char)0x72, /* [6487] */ - (xdc_Char)0x0, /* [6488] */ - (xdc_Char)0x54, /* [6489] */ - (xdc_Char)0x69, /* [6490] */ - (xdc_Char)0x6d, /* [6491] */ - (xdc_Char)0x65, /* [6492] */ - (xdc_Char)0x72, /* [6493] */ - (xdc_Char)0x0, /* [6494] */ - (xdc_Char)0x53, /* [6495] */ - (xdc_Char)0x79, /* [6496] */ - (xdc_Char)0x6e, /* [6497] */ - (xdc_Char)0x63, /* [6498] */ - (xdc_Char)0x0, /* [6499] */ - (xdc_Char)0x53, /* [6500] */ - (xdc_Char)0x65, /* [6501] */ - (xdc_Char)0x6d, /* [6502] */ - (xdc_Char)0x54, /* [6503] */ - (xdc_Char)0x68, /* [6504] */ - (xdc_Char)0x72, /* [6505] */ - (xdc_Char)0x65, /* [6506] */ - (xdc_Char)0x61, /* [6507] */ - (xdc_Char)0x64, /* [6508] */ - (xdc_Char)0x0, /* [6509] */ - (xdc_Char)0x53, /* [6510] */ - (xdc_Char)0x79, /* [6511] */ - (xdc_Char)0x6e, /* [6512] */ - (xdc_Char)0x63, /* [6513] */ - (xdc_Char)0x47, /* [6514] */ - (xdc_Char)0x65, /* [6515] */ - (xdc_Char)0x6e, /* [6516] */ - (xdc_Char)0x65, /* [6517] */ - (xdc_Char)0x72, /* [6518] */ - (xdc_Char)0x69, /* [6519] */ - (xdc_Char)0x63, /* [6520] */ - (xdc_Char)0x0, /* [6521] */ - (xdc_Char)0x53, /* [6522] */ - (xdc_Char)0x79, /* [6523] */ - (xdc_Char)0x6e, /* [6524] */ - (xdc_Char)0x63, /* [6525] */ - (xdc_Char)0x4e, /* [6526] */ - (xdc_Char)0x75, /* [6527] */ - (xdc_Char)0x6c, /* [6528] */ - (xdc_Char)0x6c, /* [6529] */ - (xdc_Char)0x0, /* [6530] */ - (xdc_Char)0x53, /* [6531] */ - (xdc_Char)0x79, /* [6532] */ - (xdc_Char)0x6e, /* [6533] */ - (xdc_Char)0x63, /* [6534] */ - (xdc_Char)0x53, /* [6535] */ - (xdc_Char)0x65, /* [6536] */ - (xdc_Char)0x6d, /* [6537] */ - (xdc_Char)0x54, /* [6538] */ - (xdc_Char)0x68, /* [6539] */ - (xdc_Char)0x72, /* [6540] */ - (xdc_Char)0x65, /* [6541] */ - (xdc_Char)0x61, /* [6542] */ - (xdc_Char)0x64, /* [6543] */ - (xdc_Char)0x0, /* [6544] */ - (xdc_Char)0x69, /* [6545] */ - (xdc_Char)0x6f, /* [6546] */ - (xdc_Char)0x2e, /* [6547] */ - (xdc_Char)0x0, /* [6548] */ - (xdc_Char)0x44, /* [6549] */ - (xdc_Char)0x45, /* [6550] */ - (xdc_Char)0x56, /* [6551] */ - (xdc_Char)0x0, /* [6552] */ - (xdc_Char)0x47, /* [6553] */ - (xdc_Char)0x49, /* [6554] */ - (xdc_Char)0x4f, /* [6555] */ - (xdc_Char)0x0, /* [6556] */ - (xdc_Char)0x67, /* [6557] */ - (xdc_Char)0x61, /* [6558] */ - (xdc_Char)0x74, /* [6559] */ - (xdc_Char)0x65, /* [6560] */ - (xdc_Char)0x73, /* [6561] */ - (xdc_Char)0x2e, /* [6562] */ - (xdc_Char)0x0, /* [6563] */ - (xdc_Char)0x47, /* [6564] */ - (xdc_Char)0x61, /* [6565] */ - (xdc_Char)0x74, /* [6566] */ - (xdc_Char)0x65, /* [6567] */ - (xdc_Char)0x48, /* [6568] */ - (xdc_Char)0x77, /* [6569] */ - (xdc_Char)0x69, /* [6570] */ - (xdc_Char)0x0, /* [6571] */ - (xdc_Char)0x47, /* [6572] */ - (xdc_Char)0x61, /* [6573] */ - (xdc_Char)0x74, /* [6574] */ - (xdc_Char)0x65, /* [6575] */ - (xdc_Char)0x4d, /* [6576] */ - (xdc_Char)0x75, /* [6577] */ - (xdc_Char)0x74, /* [6578] */ - (xdc_Char)0x65, /* [6579] */ - (xdc_Char)0x78, /* [6580] */ - (xdc_Char)0x0, /* [6581] */ - (xdc_Char)0x78, /* [6582] */ - (xdc_Char)0x64, /* [6583] */ - (xdc_Char)0x63, /* [6584] */ - (xdc_Char)0x72, /* [6585] */ - (xdc_Char)0x75, /* [6586] */ - (xdc_Char)0x6e, /* [6587] */ - (xdc_Char)0x74, /* [6588] */ - (xdc_Char)0x69, /* [6589] */ - (xdc_Char)0x6d, /* [6590] */ - (xdc_Char)0x65, /* [6591] */ - (xdc_Char)0x2e, /* [6592] */ - (xdc_Char)0x0, /* [6593] */ - (xdc_Char)0x53, /* [6594] */ - (xdc_Char)0x65, /* [6595] */ - (xdc_Char)0x6d, /* [6596] */ - (xdc_Char)0x54, /* [6597] */ - (xdc_Char)0x68, /* [6598] */ - (xdc_Char)0x72, /* [6599] */ - (xdc_Char)0x65, /* [6600] */ - (xdc_Char)0x61, /* [6601] */ - (xdc_Char)0x64, /* [6602] */ - (xdc_Char)0x53, /* [6603] */ - (xdc_Char)0x75, /* [6604] */ - (xdc_Char)0x70, /* [6605] */ - (xdc_Char)0x70, /* [6606] */ - (xdc_Char)0x6f, /* [6607] */ - (xdc_Char)0x72, /* [6608] */ - (xdc_Char)0x74, /* [6609] */ - (xdc_Char)0x0, /* [6610] */ - (xdc_Char)0x68, /* [6611] */ - (xdc_Char)0x65, /* [6612] */ - (xdc_Char)0x61, /* [6613] */ - (xdc_Char)0x70, /* [6614] */ - (xdc_Char)0x73, /* [6615] */ - (xdc_Char)0x2e, /* [6616] */ - (xdc_Char)0x0, /* [6617] */ - (xdc_Char)0x48, /* [6618] */ - (xdc_Char)0x65, /* [6619] */ - (xdc_Char)0x61, /* [6620] */ - (xdc_Char)0x70, /* [6621] */ - (xdc_Char)0x4d, /* [6622] */ - (xdc_Char)0x65, /* [6623] */ - (xdc_Char)0x6d, /* [6624] */ - (xdc_Char)0x0, /* [6625] */ - (xdc_Char)0x61, /* [6626] */ - (xdc_Char)0x64, /* [6627] */ - (xdc_Char)0x63, /* [6628] */ - (xdc_Char)0x48, /* [6629] */ - (xdc_Char)0x77, /* [6630] */ - (xdc_Char)0x69, /* [6631] */ - (xdc_Char)0x0, /* [6632] */ - (xdc_Char)0x73, /* [6633] */ - (xdc_Char)0x79, /* [6634] */ - (xdc_Char)0x73, /* [6635] */ - (xdc_Char)0x54, /* [6636] */ - (xdc_Char)0x69, /* [6637] */ - (xdc_Char)0x63, /* [6638] */ - (xdc_Char)0x6b, /* [6639] */ - (xdc_Char)0x0, /* [6640] */ - (xdc_Char)0x70, /* [6641] */ - (xdc_Char)0x6f, /* [6642] */ - (xdc_Char)0x72, /* [6643] */ - (xdc_Char)0x74, /* [6644] */ - (xdc_Char)0x70, /* [6645] */ - (xdc_Char)0x69, /* [6646] */ - (xdc_Char)0x6e, /* [6647] */ - (xdc_Char)0x74, /* [6648] */ - (xdc_Char)0x0, /* [6649] */ - (xdc_Char)0x74, /* [6650] */ - (xdc_Char)0x69, /* [6651] */ - (xdc_Char)0x6d, /* [6652] */ - (xdc_Char)0x65, /* [6653] */ - (xdc_Char)0x72, /* [6654] */ - (xdc_Char)0x30, /* [6655] */ - (xdc_Char)0x0, /* [6656] */ - (xdc_Char)0x77, /* [6657] */ - (xdc_Char)0x61, /* [6658] */ - (xdc_Char)0x74, /* [6659] */ - (xdc_Char)0x63, /* [6660] */ - (xdc_Char)0x68, /* [6661] */ - (xdc_Char)0x64, /* [6662] */ - (xdc_Char)0x6f, /* [6663] */ - (xdc_Char)0x67, /* [6664] */ - (xdc_Char)0x0, /* [6665] */ - (xdc_Char)0x74, /* [6666] */ - (xdc_Char)0x69, /* [6667] */ - (xdc_Char)0x6d, /* [6668] */ - (xdc_Char)0x65, /* [6669] */ - (xdc_Char)0x72, /* [6670] */ - (xdc_Char)0x32, /* [6671] */ - (xdc_Char)0x0, /* [6672] */ - (xdc_Char)0x74, /* [6673] */ - (xdc_Char)0x69, /* [6674] */ - (xdc_Char)0x6d, /* [6675] */ - (xdc_Char)0x65, /* [6676] */ - (xdc_Char)0x72, /* [6677] */ - (xdc_Char)0x31, /* [6678] */ - (xdc_Char)0x0, /* [6679] */ - (xdc_Char)0x74, /* [6680] */ - (xdc_Char)0x69, /* [6681] */ - (xdc_Char)0x6d, /* [6682] */ - (xdc_Char)0x65, /* [6683] */ - (xdc_Char)0x72, /* [6684] */ - (xdc_Char)0x33, /* [6685] */ - (xdc_Char)0x0, /* [6686] */ - (xdc_Char)0x69, /* [6687] */ - (xdc_Char)0x6e, /* [6688] */ - (xdc_Char)0x69, /* [6689] */ - (xdc_Char)0x74, /* [6690] */ - (xdc_Char)0x43, /* [6691] */ - (xdc_Char)0x6f, /* [6692] */ - (xdc_Char)0x6e, /* [6693] */ - (xdc_Char)0x6e, /* [6694] */ - (xdc_Char)0x65, /* [6695] */ - (xdc_Char)0x63, /* [6696] */ - (xdc_Char)0x74, /* [6697] */ - (xdc_Char)0x69, /* [6698] */ - (xdc_Char)0x6f, /* [6699] */ - (xdc_Char)0x6e, /* [6700] */ - (xdc_Char)0x53, /* [6701] */ - (xdc_Char)0x65, /* [6702] */ - (xdc_Char)0x6d, /* [6703] */ - (xdc_Char)0x0, /* [6704] */ - (xdc_Char)0x61, /* [6705] */ - (xdc_Char)0x64, /* [6706] */ - (xdc_Char)0x63, /* [6707] */ - (xdc_Char)0x52, /* [6708] */ - (xdc_Char)0x65, /* [6709] */ - (xdc_Char)0x73, /* [6710] */ - (xdc_Char)0x75, /* [6711] */ - (xdc_Char)0x6c, /* [6712] */ - (xdc_Char)0x74, /* [6713] */ - (xdc_Char)0x53, /* [6714] */ - (xdc_Char)0x65, /* [6715] */ - (xdc_Char)0x6d, /* [6716] */ - (xdc_Char)0x0, /* [6717] */ - (xdc_Char)0x75, /* [6718] */ - (xdc_Char)0x70, /* [6719] */ - (xdc_Char)0x64, /* [6720] */ - (xdc_Char)0x61, /* [6721] */ - (xdc_Char)0x74, /* [6722] */ - (xdc_Char)0x65, /* [6723] */ - (xdc_Char)0x53, /* [6724] */ - (xdc_Char)0x65, /* [6725] */ - (xdc_Char)0x6d, /* [6726] */ - (xdc_Char)0x0, /* [6727] */ - (xdc_Char)0x52, /* [6728] */ - (xdc_Char)0x65, /* [6729] */ - (xdc_Char)0x63, /* [6730] */ - (xdc_Char)0x6f, /* [6731] */ - (xdc_Char)0x6e, /* [6732] */ - (xdc_Char)0x6e, /* [6733] */ - (xdc_Char)0x65, /* [6734] */ - (xdc_Char)0x63, /* [6735] */ - (xdc_Char)0x74, /* [6736] */ - (xdc_Char)0x53, /* [6737] */ - (xdc_Char)0x65, /* [6738] */ - (xdc_Char)0x6d, /* [6739] */ - (xdc_Char)0x0, /* [6740] */ - (xdc_Char)0x4d, /* [6741] */ - (xdc_Char)0x69, /* [6742] */ - (xdc_Char)0x6c, /* [6743] */ - (xdc_Char)0x6c, /* [6744] */ - (xdc_Char)0x69, /* [6745] */ - (xdc_Char)0x53, /* [6746] */ - (xdc_Char)0x65, /* [6747] */ - (xdc_Char)0x63, /* [6748] */ - (xdc_Char)0x6f, /* [6749] */ - (xdc_Char)0x6e, /* [6750] */ - (xdc_Char)0x64, /* [6751] */ - (xdc_Char)0x0, /* [6752] */ - (xdc_Char)0x63, /* [6753] */ - (xdc_Char)0x6f, /* [6754] */ - (xdc_Char)0x6e, /* [6755] */ - (xdc_Char)0x74, /* [6756] */ - (xdc_Char)0x72, /* [6757] */ - (xdc_Char)0x6f, /* [6758] */ - (xdc_Char)0x6c, /* [6759] */ - (xdc_Char)0x0, /* [6760] */ - (xdc_Char)0x41, /* [6761] */ - (xdc_Char)0x6c, /* [6762] */ - (xdc_Char)0x61, /* [6763] */ - (xdc_Char)0x72, /* [6764] */ - (xdc_Char)0x6d, /* [6765] */ - (xdc_Char)0x48, /* [6766] */ - (xdc_Char)0x61, /* [6767] */ - (xdc_Char)0x6e, /* [6768] */ - (xdc_Char)0x64, /* [6769] */ - (xdc_Char)0x6c, /* [6770] */ - (xdc_Char)0x69, /* [6771] */ - (xdc_Char)0x6e, /* [6772] */ - (xdc_Char)0x67, /* [6773] */ - (xdc_Char)0x0, /* [6774] */ - (xdc_Char)0x63, /* [6775] */ - (xdc_Char)0x6f, /* [6776] */ - (xdc_Char)0x6d, /* [6777] */ - (xdc_Char)0x6d, /* [6778] */ - (xdc_Char)0x75, /* [6779] */ - (xdc_Char)0x6e, /* [6780] */ - (xdc_Char)0x69, /* [6781] */ - (xdc_Char)0x63, /* [6782] */ - (xdc_Char)0x61, /* [6783] */ - (xdc_Char)0x74, /* [6784] */ - (xdc_Char)0x69, /* [6785] */ - (xdc_Char)0x6f, /* [6786] */ - (xdc_Char)0x6e, /* [6787] */ - (xdc_Char)0x54, /* [6788] */ - (xdc_Char)0x78, /* [6789] */ - (xdc_Char)0x0, /* [6790] */ - (xdc_Char)0x70, /* [6791] */ - (xdc_Char)0x72, /* [6792] */ - (xdc_Char)0x6f, /* [6793] */ - (xdc_Char)0x63, /* [6794] */ - (xdc_Char)0x65, /* [6795] */ - (xdc_Char)0x73, /* [6796] */ - (xdc_Char)0x73, /* [6797] */ - (xdc_Char)0x0, /* [6798] */ - (xdc_Char)0x48, /* [6799] */ - (xdc_Char)0x65, /* [6800] */ - (xdc_Char)0x61, /* [6801] */ - (xdc_Char)0x74, /* [6802] */ - (xdc_Char)0x65, /* [6803] */ - (xdc_Char)0x72, /* [6804] */ - (xdc_Char)0x73, /* [6805] */ - (xdc_Char)0x43, /* [6806] */ - (xdc_Char)0x6f, /* [6807] */ - (xdc_Char)0x6e, /* [6808] */ - (xdc_Char)0x74, /* [6809] */ - (xdc_Char)0x72, /* [6810] */ - (xdc_Char)0x6f, /* [6811] */ - (xdc_Char)0x6c, /* [6812] */ - (xdc_Char)0x0, /* [6813] */ - (xdc_Char)0x63, /* [6814] */ - (xdc_Char)0x6f, /* [6815] */ - (xdc_Char)0x6d, /* [6816] */ - (xdc_Char)0x6d, /* [6817] */ - (xdc_Char)0x75, /* [6818] */ - (xdc_Char)0x6e, /* [6819] */ - (xdc_Char)0x69, /* [6820] */ - (xdc_Char)0x63, /* [6821] */ - (xdc_Char)0x61, /* [6822] */ - (xdc_Char)0x74, /* [6823] */ - (xdc_Char)0x69, /* [6824] */ - (xdc_Char)0x6f, /* [6825] */ - (xdc_Char)0x6e, /* [6826] */ - (xdc_Char)0x52, /* [6827] */ - (xdc_Char)0x78, /* [6828] */ - (xdc_Char)0x0, /* [6829] */ - (xdc_Char)0x4d, /* [6830] */ - (xdc_Char)0x69, /* [6831] */ - (xdc_Char)0x6c, /* [6832] */ - (xdc_Char)0x6c, /* [6833] */ - (xdc_Char)0x69, /* [6834] */ - (xdc_Char)0x53, /* [6835] */ - (xdc_Char)0x65, /* [6836] */ - (xdc_Char)0x63, /* [6837] */ - (xdc_Char)0x6f, /* [6838] */ - (xdc_Char)0x6e, /* [6839] */ - (xdc_Char)0x64, /* [6840] */ - (xdc_Char)0x4c, /* [6841] */ - (xdc_Char)0x6f, /* [6842] */ - (xdc_Char)0x77, /* [6843] */ - (xdc_Char)0x0, /* [6844] */ - (xdc_Char)0x63, /* [6845] */ - (xdc_Char)0x6f, /* [6846] */ - (xdc_Char)0x6e, /* [6847] */ - (xdc_Char)0x74, /* [6848] */ - (xdc_Char)0x72, /* [6849] */ - (xdc_Char)0x6f, /* [6850] */ - (xdc_Char)0x6c, /* [6851] */ - (xdc_Char)0x4c, /* [6852] */ - (xdc_Char)0x6f, /* [6853] */ - (xdc_Char)0x77, /* [6854] */ - (xdc_Char)0x0, /* [6855] */ - (xdc_Char)0x44, /* [6856] */ - (xdc_Char)0x69, /* [6857] */ - (xdc_Char)0x61, /* [6858] */ - (xdc_Char)0x67, /* [6859] */ - (xdc_Char)0x6e, /* [6860] */ - (xdc_Char)0x6f, /* [6861] */ - (xdc_Char)0x73, /* [6862] */ - (xdc_Char)0x74, /* [6863] */ - (xdc_Char)0x69, /* [6864] */ - (xdc_Char)0x63, /* [6865] */ - (xdc_Char)0x73, /* [6866] */ - (xdc_Char)0x0, /* [6867] */ - (xdc_Char)0x61, /* [6868] */ - (xdc_Char)0x64, /* [6869] */ - (xdc_Char)0x63, /* [6870] */ - (xdc_Char)0x50, /* [6871] */ - (xdc_Char)0x72, /* [6872] */ - (xdc_Char)0x6f, /* [6873] */ - (xdc_Char)0x63, /* [6874] */ - (xdc_Char)0x65, /* [6875] */ - (xdc_Char)0x73, /* [6876] */ - (xdc_Char)0x73, /* [6877] */ - (xdc_Char)0x0, /* [6878] */ - (xdc_Char)0x72, /* [6879] */ - (xdc_Char)0x65, /* [6880] */ - (xdc_Char)0x70, /* [6881] */ - (xdc_Char)0x6f, /* [6882] */ - (xdc_Char)0x72, /* [6883] */ - (xdc_Char)0x74, /* [6884] */ - (xdc_Char)0x0, /* [6885] */ - (xdc_Char)0x75, /* [6886] */ - (xdc_Char)0x70, /* [6887] */ - (xdc_Char)0x64, /* [6888] */ - (xdc_Char)0x61, /* [6889] */ - (xdc_Char)0x74, /* [6890] */ - (xdc_Char)0x65, /* [6891] */ - (xdc_Char)0x0, /* [6892] */ -}; - -/* --> xdc_runtime_Text_nodeTab__A */ -#pragma DATA_SECTION(xdc_runtime_Text_nodeTab__A, ".const:xdc_runtime_Text_nodeTab__A"); -const __T1_xdc_runtime_Text_nodeTab xdc_runtime_Text_nodeTab__A[65] = { - { - (xdc_Bits16)0x0, /* left */ - (xdc_Bits16)0x0, /* right */ - }, /* [0] */ - { - (xdc_Bits16)0x1812, /* left */ - (xdc_Bits16)0x1817, /* right */ - }, /* [1] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1820, /* right */ - }, /* [2] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1827, /* right */ - }, /* [3] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x182c, /* right */ - }, /* [4] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1835, /* right */ - }, /* [5] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x183b, /* right */ - }, /* [6] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1841, /* right */ - }, /* [7] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1846, /* right */ - }, /* [8] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x184a, /* right */ - }, /* [9] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x184f, /* right */ - }, /* [10] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1856, /* right */ - }, /* [11] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x185e, /* right */ - }, /* [12] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1867, /* right */ - }, /* [13] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x186f, /* right */ - }, /* [14] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1876, /* right */ - }, /* [15] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x187d, /* right */ - }, /* [16] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x1882, /* right */ - }, /* [17] */ - { - (xdc_Bits16)0x188c, /* left */ - (xdc_Bits16)0x1890, /* right */ - }, /* [18] */ - { - (xdc_Bits16)0x8012, /* left */ - (xdc_Bits16)0x1899, /* right */ - }, /* [19] */ - { - (xdc_Bits16)0x8013, /* left */ - (xdc_Bits16)0x189e, /* right */ - }, /* [20] */ - { - (xdc_Bits16)0x8014, /* left */ - (xdc_Bits16)0x18a8, /* right */ - }, /* [21] */ - { - (xdc_Bits16)0x8015, /* left */ - (xdc_Bits16)0x18ae, /* right */ - }, /* [22] */ - { - (xdc_Bits16)0x8016, /* left */ - (xdc_Bits16)0x18b2, /* right */ - }, /* [23] */ - { - (xdc_Bits16)0x188c, /* left */ - (xdc_Bits16)0x18b7, /* right */ - }, /* [24] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x18c0, /* right */ - }, /* [25] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x18c5, /* right */ - }, /* [26] */ - { - (xdc_Bits16)0x801a, /* left */ - (xdc_Bits16)0x1899, /* right */ - }, /* [27] */ - { - (xdc_Bits16)0x801b, /* left */ - (xdc_Bits16)0x18cd, /* right */ - }, /* [28] */ - { - (xdc_Bits16)0x801c, /* left */ - (xdc_Bits16)0x18d1, /* right */ - }, /* [29] */ - { - (xdc_Bits16)0x801c, /* left */ - (xdc_Bits16)0x18d5, /* right */ - }, /* [30] */ - { - (xdc_Bits16)0x801c, /* left */ - (xdc_Bits16)0x18e7, /* right */ - }, /* [31] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x18f3, /* right */ - }, /* [32] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x18f8, /* right */ - }, /* [33] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x18fe, /* right */ - }, /* [34] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x1903, /* right */ - }, /* [35] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x190e, /* right */ - }, /* [36] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x1914, /* right */ - }, /* [37] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x191c, /* right */ - }, /* [38] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x1922, /* right */ - }, /* [39] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x192c, /* right */ - }, /* [40] */ - { - (xdc_Bits16)0x8020, /* left */ - (xdc_Bits16)0x1930, /* right */ - }, /* [41] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x1935, /* right */ - }, /* [42] */ - { - (xdc_Bits16)0x802a, /* left */ - (xdc_Bits16)0x18d1, /* right */ - }, /* [43] */ - { - (xdc_Bits16)0x802a, /* left */ - (xdc_Bits16)0x193a, /* right */ - }, /* [44] */ - { - (xdc_Bits16)0x801b, /* left */ - (xdc_Bits16)0x1942, /* right */ - }, /* [45] */ - { - (xdc_Bits16)0x802d, /* left */ - (xdc_Bits16)0x193a, /* right */ - }, /* [46] */ - { - (xdc_Bits16)0x802d, /* left */ - (xdc_Bits16)0x1947, /* right */ - }, /* [47] */ - { - (xdc_Bits16)0x802d, /* left */ - (xdc_Bits16)0x1959, /* right */ - }, /* [48] */ - { - (xdc_Bits16)0x8001, /* left */ - (xdc_Bits16)0x18f3, /* right */ - }, /* [49] */ - { - (xdc_Bits16)0x8031, /* left */ - (xdc_Bits16)0x195f, /* right */ - }, /* [50] */ - { - (xdc_Bits16)0x8031, /* left */ - (xdc_Bits16)0x1964, /* right */ - }, /* [51] */ - { - (xdc_Bits16)0x8031, /* left */ - (xdc_Bits16)0x196e, /* right */ - }, /* [52] */ - { - (xdc_Bits16)0x8031, /* left */ - (xdc_Bits16)0x197a, /* right */ - }, /* [53] */ - { - (xdc_Bits16)0x8031, /* left */ - (xdc_Bits16)0x1983, /* right */ - }, /* [54] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x1991, /* right */ - }, /* [55] */ - { - (xdc_Bits16)0x8037, /* left */ - (xdc_Bits16)0x1995, /* right */ - }, /* [56] */ - { - (xdc_Bits16)0x8037, /* left */ - (xdc_Bits16)0x1999, /* right */ - }, /* [57] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x199d, /* right */ - }, /* [58] */ - { - (xdc_Bits16)0x803a, /* left */ - (xdc_Bits16)0x19a4, /* right */ - }, /* [59] */ - { - (xdc_Bits16)0x803a, /* left */ - (xdc_Bits16)0x19ac, /* right */ - }, /* [60] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x19b6, /* right */ - }, /* [61] */ - { - (xdc_Bits16)0x803d, /* left */ - (xdc_Bits16)0x19c2, /* right */ - }, /* [62] */ - { - (xdc_Bits16)0x8018, /* left */ - (xdc_Bits16)0x19d3, /* right */ - }, /* [63] */ - { - (xdc_Bits16)0x803f, /* left */ - (xdc_Bits16)0x19da, /* right */ - }, /* [64] */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__diagsEnabled__C, ".const:xdc_runtime_Text_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Text_Module__diagsEnabled xdc_runtime_Text_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__diagsIncluded__C, ".const:xdc_runtime_Text_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Text_Module__diagsIncluded xdc_runtime_Text_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__diagsMask__C, ".const:xdc_runtime_Text_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Text_Module__diagsMask xdc_runtime_Text_Module__diagsMask__C = ((CT__xdc_runtime_Text_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__gateObj__C, ".const:xdc_runtime_Text_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Text_Module__gateObj xdc_runtime_Text_Module__gateObj__C = ((CT__xdc_runtime_Text_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__gatePrms__C, ".const:xdc_runtime_Text_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Text_Module__gatePrms xdc_runtime_Text_Module__gatePrms__C = ((CT__xdc_runtime_Text_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__id__C, ".const:xdc_runtime_Text_Module__id__C"); -__FAR__ const CT__xdc_runtime_Text_Module__id xdc_runtime_Text_Module__id__C = (xdc_Bits16)0x8010; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerDefined__C, ".const:xdc_runtime_Text_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerDefined xdc_runtime_Text_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerObj__C, ".const:xdc_runtime_Text_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerObj xdc_runtime_Text_Module__loggerObj__C = ((CT__xdc_runtime_Text_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerFxn0__C, ".const:xdc_runtime_Text_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerFxn0 xdc_runtime_Text_Module__loggerFxn0__C = ((CT__xdc_runtime_Text_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerFxn1__C, ".const:xdc_runtime_Text_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerFxn1 xdc_runtime_Text_Module__loggerFxn1__C = ((CT__xdc_runtime_Text_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerFxn2__C, ".const:xdc_runtime_Text_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerFxn2 xdc_runtime_Text_Module__loggerFxn2__C = ((CT__xdc_runtime_Text_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerFxn4__C, ".const:xdc_runtime_Text_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerFxn4 xdc_runtime_Text_Module__loggerFxn4__C = ((CT__xdc_runtime_Text_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__loggerFxn8__C, ".const:xdc_runtime_Text_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Text_Module__loggerFxn8 xdc_runtime_Text_Module__loggerFxn8__C = ((CT__xdc_runtime_Text_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Module__startupDoneFxn__C, ".const:xdc_runtime_Text_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Text_Module__startupDoneFxn xdc_runtime_Text_Module__startupDoneFxn__C = ((CT__xdc_runtime_Text_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Object__count__C, ".const:xdc_runtime_Text_Object__count__C"); -__FAR__ const CT__xdc_runtime_Text_Object__count xdc_runtime_Text_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Object__heap__C, ".const:xdc_runtime_Text_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Text_Object__heap xdc_runtime_Text_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Object__sizeof__C, ".const:xdc_runtime_Text_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Text_Object__sizeof xdc_runtime_Text_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Text_Object__table__C, ".const:xdc_runtime_Text_Object__table__C"); -__FAR__ const CT__xdc_runtime_Text_Object__table xdc_runtime_Text_Object__table__C = 0; - -/* nameUnknown__C */ -#pragma DATA_SECTION(xdc_runtime_Text_nameUnknown__C, ".const:xdc_runtime_Text_nameUnknown__C"); -__FAR__ const CT__xdc_runtime_Text_nameUnknown xdc_runtime_Text_nameUnknown__C = "{unknown-instance-name}"; - -/* nameEmpty__C */ -#pragma DATA_SECTION(xdc_runtime_Text_nameEmpty__C, ".const:xdc_runtime_Text_nameEmpty__C"); -__FAR__ const CT__xdc_runtime_Text_nameEmpty xdc_runtime_Text_nameEmpty__C = "{empty-instance-name}"; - -/* nameStatic__C */ -#pragma DATA_SECTION(xdc_runtime_Text_nameStatic__C, ".const:xdc_runtime_Text_nameStatic__C"); -__FAR__ const CT__xdc_runtime_Text_nameStatic xdc_runtime_Text_nameStatic__C = "{static-instance-name}"; - -/* isLoaded__C */ -#pragma DATA_SECTION(xdc_runtime_Text_isLoaded__C, ".const:xdc_runtime_Text_isLoaded__C"); -__FAR__ const CT__xdc_runtime_Text_isLoaded xdc_runtime_Text_isLoaded__C = 1; - -/* charTab__C */ -#pragma DATA_SECTION(xdc_runtime_Text_charTab__C, ".const:xdc_runtime_Text_charTab__C"); -__FAR__ const CT__xdc_runtime_Text_charTab xdc_runtime_Text_charTab__C = ((CT__xdc_runtime_Text_charTab)xdc_runtime_Text_charTab__A); - -/* nodeTab__C */ -#pragma DATA_SECTION(xdc_runtime_Text_nodeTab__C, ".const:xdc_runtime_Text_nodeTab__C"); -__FAR__ const CT__xdc_runtime_Text_nodeTab xdc_runtime_Text_nodeTab__C = ((CT__xdc_runtime_Text_nodeTab)xdc_runtime_Text_nodeTab__A); - -/* charCnt__C */ -#pragma DATA_SECTION(xdc_runtime_Text_charCnt__C, ".const:xdc_runtime_Text_charCnt__C"); -__FAR__ const CT__xdc_runtime_Text_charCnt xdc_runtime_Text_charCnt__C = (xdc_Int16)0x1aed; - -/* nodeCnt__C */ -#pragma DATA_SECTION(xdc_runtime_Text_nodeCnt__C, ".const:xdc_runtime_Text_nodeCnt__C"); -__FAR__ const CT__xdc_runtime_Text_nodeCnt xdc_runtime_Text_nodeCnt__C = (xdc_Int16)0x41; - -/* unnamedModsLastId__C */ -#pragma DATA_SECTION(xdc_runtime_Text_unnamedModsLastId__C, ".const:xdc_runtime_Text_unnamedModsLastId__C"); -__FAR__ const CT__xdc_runtime_Text_unnamedModsLastId xdc_runtime_Text_unnamedModsLastId__C = (xdc_UInt16)0x4000; - -/* registryModsLastId__C */ -#pragma DATA_SECTION(xdc_runtime_Text_registryModsLastId__C, ".const:xdc_runtime_Text_registryModsLastId__C"); -__FAR__ const CT__xdc_runtime_Text_registryModsLastId xdc_runtime_Text_registryModsLastId__C = (xdc_UInt16)0x7fff; - -/* visitRopeFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Text_visitRopeFxn__C, ".const:xdc_runtime_Text_visitRopeFxn__C"); -__FAR__ const CT__xdc_runtime_Text_visitRopeFxn xdc_runtime_Text_visitRopeFxn__C = ((CT__xdc_runtime_Text_visitRopeFxn)((xdc_Fxn)xdc_runtime_Text_visitRope__I)); - -/* visitRopeFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Text_visitRopeFxn2__C, ".const:xdc_runtime_Text_visitRopeFxn2__C"); -__FAR__ const CT__xdc_runtime_Text_visitRopeFxn2 xdc_runtime_Text_visitRopeFxn2__C = ((CT__xdc_runtime_Text_visitRopeFxn2)((xdc_Fxn)xdc_runtime_Text_visitRope2__I)); - - -/* - * ======== xdc.runtime.Timestamp INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__diagsEnabled__C, ".const:xdc_runtime_Timestamp_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__diagsEnabled xdc_runtime_Timestamp_Module__diagsEnabled__C = (xdc_Bits32)0x10; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__diagsIncluded__C, ".const:xdc_runtime_Timestamp_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__diagsIncluded xdc_runtime_Timestamp_Module__diagsIncluded__C = (xdc_Bits32)0x10; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__diagsMask__C, ".const:xdc_runtime_Timestamp_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__diagsMask xdc_runtime_Timestamp_Module__diagsMask__C = ((CT__xdc_runtime_Timestamp_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__gateObj__C, ".const:xdc_runtime_Timestamp_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__gateObj xdc_runtime_Timestamp_Module__gateObj__C = ((CT__xdc_runtime_Timestamp_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__gatePrms__C, ".const:xdc_runtime_Timestamp_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__gatePrms xdc_runtime_Timestamp_Module__gatePrms__C = ((CT__xdc_runtime_Timestamp_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__id__C, ".const:xdc_runtime_Timestamp_Module__id__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__id xdc_runtime_Timestamp_Module__id__C = (xdc_Bits16)0x8011; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerDefined__C, ".const:xdc_runtime_Timestamp_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerDefined xdc_runtime_Timestamp_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerObj__C, ".const:xdc_runtime_Timestamp_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerObj xdc_runtime_Timestamp_Module__loggerObj__C = ((CT__xdc_runtime_Timestamp_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerFxn0__C, ".const:xdc_runtime_Timestamp_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerFxn0 xdc_runtime_Timestamp_Module__loggerFxn0__C = ((CT__xdc_runtime_Timestamp_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerFxn1__C, ".const:xdc_runtime_Timestamp_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerFxn1 xdc_runtime_Timestamp_Module__loggerFxn1__C = ((CT__xdc_runtime_Timestamp_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerFxn2__C, ".const:xdc_runtime_Timestamp_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerFxn2 xdc_runtime_Timestamp_Module__loggerFxn2__C = ((CT__xdc_runtime_Timestamp_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerFxn4__C, ".const:xdc_runtime_Timestamp_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerFxn4 xdc_runtime_Timestamp_Module__loggerFxn4__C = ((CT__xdc_runtime_Timestamp_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__loggerFxn8__C, ".const:xdc_runtime_Timestamp_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__loggerFxn8 xdc_runtime_Timestamp_Module__loggerFxn8__C = ((CT__xdc_runtime_Timestamp_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Module__startupDoneFxn__C, ".const:xdc_runtime_Timestamp_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Module__startupDoneFxn xdc_runtime_Timestamp_Module__startupDoneFxn__C = ((CT__xdc_runtime_Timestamp_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Object__count__C, ".const:xdc_runtime_Timestamp_Object__count__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Object__count xdc_runtime_Timestamp_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Object__heap__C, ".const:xdc_runtime_Timestamp_Object__heap__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Object__heap xdc_runtime_Timestamp_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Object__sizeof__C, ".const:xdc_runtime_Timestamp_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Object__sizeof xdc_runtime_Timestamp_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_Timestamp_Object__table__C, ".const:xdc_runtime_Timestamp_Object__table__C"); -__FAR__ const CT__xdc_runtime_Timestamp_Object__table xdc_runtime_Timestamp_Object__table__C = 0; - - -/* - * ======== xdc.runtime.Timestamp_SupportProxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.knl.SemThread INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SemThread_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__PARAMS__C, ".const:xdc_runtime_knl_SemThread_Object__PARAMS__C"); -__FAR__ const xdc_runtime_knl_SemThread_Params xdc_runtime_knl_SemThread_Object__PARAMS__C = { - sizeof (xdc_runtime_knl_SemThread_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&xdc_runtime_knl_SemThread_Object__PARAMS__C.__iprms, /* instance */ - xdc_runtime_knl_ISemaphore_Mode_COUNTING, /* mode */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -xdc_runtime_knl_SemThread_Module__ xdc_runtime_knl_SemThread_Module__root__V = { - {&xdc_runtime_knl_SemThread_Module__root__V.link, /* link.next */ - &xdc_runtime_knl_SemThread_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__diagsEnabled__C, ".const:xdc_runtime_knl_SemThread_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__diagsEnabled xdc_runtime_knl_SemThread_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__diagsIncluded__C, ".const:xdc_runtime_knl_SemThread_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__diagsIncluded xdc_runtime_knl_SemThread_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__diagsMask__C, ".const:xdc_runtime_knl_SemThread_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__diagsMask xdc_runtime_knl_SemThread_Module__diagsMask__C = ((CT__xdc_runtime_knl_SemThread_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__gateObj__C, ".const:xdc_runtime_knl_SemThread_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__gateObj xdc_runtime_knl_SemThread_Module__gateObj__C = ((CT__xdc_runtime_knl_SemThread_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__gatePrms__C, ".const:xdc_runtime_knl_SemThread_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__gatePrms xdc_runtime_knl_SemThread_Module__gatePrms__C = ((CT__xdc_runtime_knl_SemThread_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__id__C, ".const:xdc_runtime_knl_SemThread_Module__id__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__id xdc_runtime_knl_SemThread_Module__id__C = (xdc_Bits16)0x8033; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerDefined__C, ".const:xdc_runtime_knl_SemThread_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerDefined xdc_runtime_knl_SemThread_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerObj__C, ".const:xdc_runtime_knl_SemThread_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerObj xdc_runtime_knl_SemThread_Module__loggerObj__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerFxn0__C, ".const:xdc_runtime_knl_SemThread_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerFxn0 xdc_runtime_knl_SemThread_Module__loggerFxn0__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerFxn1__C, ".const:xdc_runtime_knl_SemThread_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerFxn1 xdc_runtime_knl_SemThread_Module__loggerFxn1__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerFxn2__C, ".const:xdc_runtime_knl_SemThread_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerFxn2 xdc_runtime_knl_SemThread_Module__loggerFxn2__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerFxn4__C, ".const:xdc_runtime_knl_SemThread_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerFxn4 xdc_runtime_knl_SemThread_Module__loggerFxn4__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__loggerFxn8__C, ".const:xdc_runtime_knl_SemThread_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__loggerFxn8 xdc_runtime_knl_SemThread_Module__loggerFxn8__C = ((CT__xdc_runtime_knl_SemThread_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Module__startupDoneFxn__C, ".const:xdc_runtime_knl_SemThread_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Module__startupDoneFxn xdc_runtime_knl_SemThread_Module__startupDoneFxn__C = ((CT__xdc_runtime_knl_SemThread_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__count__C, ".const:xdc_runtime_knl_SemThread_Object__count__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Object__count xdc_runtime_knl_SemThread_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__heap__C, ".const:xdc_runtime_knl_SemThread_Object__heap__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Object__heap xdc_runtime_knl_SemThread_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__sizeof__C, ".const:xdc_runtime_knl_SemThread_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Object__sizeof xdc_runtime_knl_SemThread_Object__sizeof__C = sizeof(xdc_runtime_knl_SemThread_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__table__C, ".const:xdc_runtime_knl_SemThread_Object__table__C"); -__FAR__ const CT__xdc_runtime_knl_SemThread_Object__table xdc_runtime_knl_SemThread_Object__table__C = 0; - - -/* - * ======== xdc.runtime.knl.SemThread_Proxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.knl.Sync INITIALIZERS ======== - */ - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__diagsEnabled__C, ".const:xdc_runtime_knl_Sync_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__diagsEnabled xdc_runtime_knl_Sync_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__diagsIncluded__C, ".const:xdc_runtime_knl_Sync_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__diagsIncluded xdc_runtime_knl_Sync_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__diagsMask__C, ".const:xdc_runtime_knl_Sync_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__diagsMask xdc_runtime_knl_Sync_Module__diagsMask__C = ((CT__xdc_runtime_knl_Sync_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__gateObj__C, ".const:xdc_runtime_knl_Sync_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__gateObj xdc_runtime_knl_Sync_Module__gateObj__C = ((CT__xdc_runtime_knl_Sync_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__gatePrms__C, ".const:xdc_runtime_knl_Sync_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__gatePrms xdc_runtime_knl_Sync_Module__gatePrms__C = ((CT__xdc_runtime_knl_Sync_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__id__C, ".const:xdc_runtime_knl_Sync_Module__id__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__id xdc_runtime_knl_Sync_Module__id__C = (xdc_Bits16)0x8032; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerDefined__C, ".const:xdc_runtime_knl_Sync_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerDefined xdc_runtime_knl_Sync_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerObj__C, ".const:xdc_runtime_knl_Sync_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerObj xdc_runtime_knl_Sync_Module__loggerObj__C = ((CT__xdc_runtime_knl_Sync_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerFxn0__C, ".const:xdc_runtime_knl_Sync_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerFxn0 xdc_runtime_knl_Sync_Module__loggerFxn0__C = ((CT__xdc_runtime_knl_Sync_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerFxn1__C, ".const:xdc_runtime_knl_Sync_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerFxn1 xdc_runtime_knl_Sync_Module__loggerFxn1__C = ((CT__xdc_runtime_knl_Sync_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerFxn2__C, ".const:xdc_runtime_knl_Sync_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerFxn2 xdc_runtime_knl_Sync_Module__loggerFxn2__C = ((CT__xdc_runtime_knl_Sync_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerFxn4__C, ".const:xdc_runtime_knl_Sync_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerFxn4 xdc_runtime_knl_Sync_Module__loggerFxn4__C = ((CT__xdc_runtime_knl_Sync_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__loggerFxn8__C, ".const:xdc_runtime_knl_Sync_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__loggerFxn8 xdc_runtime_knl_Sync_Module__loggerFxn8__C = ((CT__xdc_runtime_knl_Sync_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Module__startupDoneFxn__C, ".const:xdc_runtime_knl_Sync_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Module__startupDoneFxn xdc_runtime_knl_Sync_Module__startupDoneFxn__C = ((CT__xdc_runtime_knl_Sync_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Object__count__C, ".const:xdc_runtime_knl_Sync_Object__count__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Object__count xdc_runtime_knl_Sync_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Object__heap__C, ".const:xdc_runtime_knl_Sync_Object__heap__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Object__heap xdc_runtime_knl_Sync_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Object__sizeof__C, ".const:xdc_runtime_knl_Sync_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Object__sizeof xdc_runtime_knl_Sync_Object__sizeof__C = 0; - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_knl_Sync_Object__table__C, ".const:xdc_runtime_knl_Sync_Object__table__C"); -__FAR__ const CT__xdc_runtime_knl_Sync_Object__table xdc_runtime_knl_Sync_Object__table__C = 0; - - -/* - * ======== xdc.runtime.knl.SyncGeneric INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncGeneric_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__PARAMS__C, ".const:xdc_runtime_knl_SyncGeneric_Object__PARAMS__C"); -__FAR__ const xdc_runtime_knl_SyncGeneric_Params xdc_runtime_knl_SyncGeneric_Object__PARAMS__C = { - sizeof (xdc_runtime_knl_SyncGeneric_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&xdc_runtime_knl_SyncGeneric_Object__PARAMS__C.__iprms, /* instance */ - ((xdc_Void(*)(xdc_UArg))0), /* userSignal */ - ((xdc_UArg)0), /* signalArg */ - ((xdc_Bool(*)(xdc_UArg,xdc_UInt))0), /* userWait */ - ((xdc_UArg)0), /* waitArg */ - ((xdc_Bool(*)(xdc_Int))0), /* userQuery */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -xdc_runtime_knl_SyncGeneric_Module__ xdc_runtime_knl_SyncGeneric_Module__root__V = { - {&xdc_runtime_knl_SyncGeneric_Module__root__V.link, /* link.next */ - &xdc_runtime_knl_SyncGeneric_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__diagsEnabled__C, ".const:xdc_runtime_knl_SyncGeneric_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__diagsEnabled xdc_runtime_knl_SyncGeneric_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__diagsIncluded__C, ".const:xdc_runtime_knl_SyncGeneric_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__diagsIncluded xdc_runtime_knl_SyncGeneric_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__diagsMask__C, ".const:xdc_runtime_knl_SyncGeneric_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__diagsMask xdc_runtime_knl_SyncGeneric_Module__diagsMask__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__gateObj__C, ".const:xdc_runtime_knl_SyncGeneric_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__gateObj xdc_runtime_knl_SyncGeneric_Module__gateObj__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__gatePrms__C, ".const:xdc_runtime_knl_SyncGeneric_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__gatePrms xdc_runtime_knl_SyncGeneric_Module__gatePrms__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__id__C, ".const:xdc_runtime_knl_SyncGeneric_Module__id__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__id xdc_runtime_knl_SyncGeneric_Module__id__C = (xdc_Bits16)0x8034; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerDefined__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerDefined xdc_runtime_knl_SyncGeneric_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerObj__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerObj xdc_runtime_knl_SyncGeneric_Module__loggerObj__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerFxn0__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn0 xdc_runtime_knl_SyncGeneric_Module__loggerFxn0__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerFxn1__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn1 xdc_runtime_knl_SyncGeneric_Module__loggerFxn1__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerFxn2__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn2 xdc_runtime_knl_SyncGeneric_Module__loggerFxn2__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerFxn4__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn4 xdc_runtime_knl_SyncGeneric_Module__loggerFxn4__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__loggerFxn8__C, ".const:xdc_runtime_knl_SyncGeneric_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn8 xdc_runtime_knl_SyncGeneric_Module__loggerFxn8__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Module__startupDoneFxn__C, ".const:xdc_runtime_knl_SyncGeneric_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Module__startupDoneFxn xdc_runtime_knl_SyncGeneric_Module__startupDoneFxn__C = ((CT__xdc_runtime_knl_SyncGeneric_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__count__C, ".const:xdc_runtime_knl_SyncGeneric_Object__count__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Object__count xdc_runtime_knl_SyncGeneric_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__heap__C, ".const:xdc_runtime_knl_SyncGeneric_Object__heap__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Object__heap xdc_runtime_knl_SyncGeneric_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__sizeof__C, ".const:xdc_runtime_knl_SyncGeneric_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Object__sizeof xdc_runtime_knl_SyncGeneric_Object__sizeof__C = sizeof(xdc_runtime_knl_SyncGeneric_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__table__C, ".const:xdc_runtime_knl_SyncGeneric_Object__table__C"); -__FAR__ const CT__xdc_runtime_knl_SyncGeneric_Object__table xdc_runtime_knl_SyncGeneric_Object__table__C = 0; - - -/* - * ======== xdc.runtime.knl.SyncNull INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncNull_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__PARAMS__C, ".const:xdc_runtime_knl_SyncNull_Object__PARAMS__C"); -__FAR__ const xdc_runtime_knl_SyncNull_Params xdc_runtime_knl_SyncNull_Object__PARAMS__C = { - sizeof (xdc_runtime_knl_SyncNull_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&xdc_runtime_knl_SyncNull_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -xdc_runtime_knl_SyncNull_Module__ xdc_runtime_knl_SyncNull_Module__root__V = { - {&xdc_runtime_knl_SyncNull_Module__root__V.link, /* link.next */ - &xdc_runtime_knl_SyncNull_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__diagsEnabled__C, ".const:xdc_runtime_knl_SyncNull_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__diagsEnabled xdc_runtime_knl_SyncNull_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__diagsIncluded__C, ".const:xdc_runtime_knl_SyncNull_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__diagsIncluded xdc_runtime_knl_SyncNull_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__diagsMask__C, ".const:xdc_runtime_knl_SyncNull_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__diagsMask xdc_runtime_knl_SyncNull_Module__diagsMask__C = ((CT__xdc_runtime_knl_SyncNull_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__gateObj__C, ".const:xdc_runtime_knl_SyncNull_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__gateObj xdc_runtime_knl_SyncNull_Module__gateObj__C = ((CT__xdc_runtime_knl_SyncNull_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__gatePrms__C, ".const:xdc_runtime_knl_SyncNull_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__gatePrms xdc_runtime_knl_SyncNull_Module__gatePrms__C = ((CT__xdc_runtime_knl_SyncNull_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__id__C, ".const:xdc_runtime_knl_SyncNull_Module__id__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__id xdc_runtime_knl_SyncNull_Module__id__C = (xdc_Bits16)0x8035; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerDefined__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerDefined xdc_runtime_knl_SyncNull_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerObj__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerObj xdc_runtime_knl_SyncNull_Module__loggerObj__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerFxn0__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerFxn0 xdc_runtime_knl_SyncNull_Module__loggerFxn0__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerFxn1__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerFxn1 xdc_runtime_knl_SyncNull_Module__loggerFxn1__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerFxn2__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerFxn2 xdc_runtime_knl_SyncNull_Module__loggerFxn2__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerFxn4__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerFxn4 xdc_runtime_knl_SyncNull_Module__loggerFxn4__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__loggerFxn8__C, ".const:xdc_runtime_knl_SyncNull_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__loggerFxn8 xdc_runtime_knl_SyncNull_Module__loggerFxn8__C = ((CT__xdc_runtime_knl_SyncNull_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Module__startupDoneFxn__C, ".const:xdc_runtime_knl_SyncNull_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Module__startupDoneFxn xdc_runtime_knl_SyncNull_Module__startupDoneFxn__C = ((CT__xdc_runtime_knl_SyncNull_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__count__C, ".const:xdc_runtime_knl_SyncNull_Object__count__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Object__count xdc_runtime_knl_SyncNull_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__heap__C, ".const:xdc_runtime_knl_SyncNull_Object__heap__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Object__heap xdc_runtime_knl_SyncNull_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__sizeof__C, ".const:xdc_runtime_knl_SyncNull_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Object__sizeof xdc_runtime_knl_SyncNull_Object__sizeof__C = sizeof(xdc_runtime_knl_SyncNull_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__table__C, ".const:xdc_runtime_knl_SyncNull_Object__table__C"); -__FAR__ const CT__xdc_runtime_knl_SyncNull_Object__table xdc_runtime_knl_SyncNull_Object__table__C = 0; - - -/* - * ======== xdc.runtime.knl.SyncSemThread INITIALIZERS ======== - */ - -/* Object__DESC__C */ -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncSemThread_Object__DESC__C; - -/* Object__PARAMS__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__PARAMS__C, ".const:xdc_runtime_knl_SyncSemThread_Object__PARAMS__C"); -__FAR__ const xdc_runtime_knl_SyncSemThread_Params xdc_runtime_knl_SyncSemThread_Object__PARAMS__C = { - sizeof (xdc_runtime_knl_SyncSemThread_Params), /* __size */ - 0, /* __self */ - 0, /* __fxns */ - (xdc_runtime_IInstance_Params*)&xdc_runtime_knl_SyncSemThread_Object__PARAMS__C.__iprms, /* instance */ - { - sizeof (xdc_runtime_IInstance_Params), /* __size */ - 0, /* name */ - }, /* instance */ -}; - -/* Module__root__V */ -xdc_runtime_knl_SyncSemThread_Module__ xdc_runtime_knl_SyncSemThread_Module__root__V = { - {&xdc_runtime_knl_SyncSemThread_Module__root__V.link, /* link.next */ - &xdc_runtime_knl_SyncSemThread_Module__root__V.link}, /* link.prev */ -}; - -/* Module__diagsEnabled__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__diagsEnabled__C, ".const:xdc_runtime_knl_SyncSemThread_Module__diagsEnabled__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__diagsEnabled xdc_runtime_knl_SyncSemThread_Module__diagsEnabled__C = (xdc_Bits32)0x90; - -/* Module__diagsIncluded__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__diagsIncluded__C, ".const:xdc_runtime_knl_SyncSemThread_Module__diagsIncluded__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__diagsIncluded xdc_runtime_knl_SyncSemThread_Module__diagsIncluded__C = (xdc_Bits32)0x90; - -/* Module__diagsMask__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__diagsMask__C, ".const:xdc_runtime_knl_SyncSemThread_Module__diagsMask__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__diagsMask xdc_runtime_knl_SyncSemThread_Module__diagsMask__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__diagsMask)0); - -/* Module__gateObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__gateObj__C, ".const:xdc_runtime_knl_SyncSemThread_Module__gateObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__gateObj xdc_runtime_knl_SyncSemThread_Module__gateObj__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__gateObj)0); - -/* Module__gatePrms__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__gatePrms__C, ".const:xdc_runtime_knl_SyncSemThread_Module__gatePrms__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__gatePrms xdc_runtime_knl_SyncSemThread_Module__gatePrms__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__gatePrms)0); - -/* Module__id__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__id__C, ".const:xdc_runtime_knl_SyncSemThread_Module__id__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__id xdc_runtime_knl_SyncSemThread_Module__id__C = (xdc_Bits16)0x8036; - -/* Module__loggerDefined__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerDefined__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerDefined__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerDefined xdc_runtime_knl_SyncSemThread_Module__loggerDefined__C = 0; - -/* Module__loggerObj__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerObj__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerObj__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerObj xdc_runtime_knl_SyncSemThread_Module__loggerObj__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerObj)0); - -/* Module__loggerFxn0__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerFxn0__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerFxn0__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn0 xdc_runtime_knl_SyncSemThread_Module__loggerFxn0__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn0)0); - -/* Module__loggerFxn1__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerFxn1__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerFxn1__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn1 xdc_runtime_knl_SyncSemThread_Module__loggerFxn1__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn1)0); - -/* Module__loggerFxn2__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerFxn2__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerFxn2__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn2 xdc_runtime_knl_SyncSemThread_Module__loggerFxn2__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn2)0); - -/* Module__loggerFxn4__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerFxn4__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerFxn4__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn4 xdc_runtime_knl_SyncSemThread_Module__loggerFxn4__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn4)0); - -/* Module__loggerFxn8__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__loggerFxn8__C, ".const:xdc_runtime_knl_SyncSemThread_Module__loggerFxn8__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn8 xdc_runtime_knl_SyncSemThread_Module__loggerFxn8__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__loggerFxn8)0); - -/* Module__startupDoneFxn__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Module__startupDoneFxn__C, ".const:xdc_runtime_knl_SyncSemThread_Module__startupDoneFxn__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Module__startupDoneFxn xdc_runtime_knl_SyncSemThread_Module__startupDoneFxn__C = ((CT__xdc_runtime_knl_SyncSemThread_Module__startupDoneFxn)0); - -/* Object__count__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__count__C, ".const:xdc_runtime_knl_SyncSemThread_Object__count__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Object__count xdc_runtime_knl_SyncSemThread_Object__count__C = 0; - -/* Object__heap__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__heap__C, ".const:xdc_runtime_knl_SyncSemThread_Object__heap__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Object__heap xdc_runtime_knl_SyncSemThread_Object__heap__C = 0; - -/* Object__sizeof__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__sizeof__C, ".const:xdc_runtime_knl_SyncSemThread_Object__sizeof__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Object__sizeof xdc_runtime_knl_SyncSemThread_Object__sizeof__C = sizeof(xdc_runtime_knl_SyncSemThread_Object__); - -/* Object__table__C */ -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__table__C, ".const:xdc_runtime_knl_SyncSemThread_Object__table__C"); -__FAR__ const CT__xdc_runtime_knl_SyncSemThread_Object__table xdc_runtime_knl_SyncSemThread_Object__table__C = 0; - - -/* - * ======== xdc.runtime.knl.Sync_Proxy INITIALIZERS ======== - */ - - -/* - * ======== xdc.runtime.System FUNCTION STUBS ======== - */ - -/* printf_va__E */ -xdc_Int xdc_runtime_System_printf_va__E( xdc_CString fmt, va_list __va ) -{ - return xdc_runtime_System_printf_va__F(fmt, __va); -} - -/* printf__E */ -xdc_Int xdc_runtime_System_printf__E( xdc_CString fmt, ... ) -{ - xdc_Int __ret; - - va_list __va; va_start(__va, fmt); - __ret = xdc_runtime_System_printf_va__F(fmt, __va); - - va_end(__va); - return __ret; -} - -/* aprintf_va__E */ -xdc_Int xdc_runtime_System_aprintf_va__E( xdc_CString fmt, va_list __va ) -{ - return xdc_runtime_System_aprintf_va__F(fmt, __va); -} - -/* aprintf__E */ -xdc_Int xdc_runtime_System_aprintf__E( xdc_CString fmt, ... ) -{ - xdc_Int __ret; - - va_list __va; va_start(__va, fmt); - __ret = xdc_runtime_System_aprintf_va__F(fmt, __va); - - va_end(__va); - return __ret; -} - -/* sprintf_va__E */ -xdc_Int xdc_runtime_System_sprintf_va__E( xdc_Char buf[], xdc_CString fmt, va_list __va ) -{ - return xdc_runtime_System_sprintf_va__F(buf, fmt, __va); -} - -/* sprintf__E */ -xdc_Int xdc_runtime_System_sprintf__E( xdc_Char buf[], xdc_CString fmt, ... ) -{ - xdc_Int __ret; - - va_list __va; va_start(__va, fmt); - __ret = xdc_runtime_System_sprintf_va__F(buf, fmt, __va); - - va_end(__va); - return __ret; -} - -/* asprintf_va__E */ -xdc_Int xdc_runtime_System_asprintf_va__E( xdc_Char buf[], xdc_CString fmt, va_list __va ) -{ - return xdc_runtime_System_asprintf_va__F(buf, fmt, __va); -} - -/* asprintf__E */ -xdc_Int xdc_runtime_System_asprintf__E( xdc_Char buf[], xdc_CString fmt, ... ) -{ - xdc_Int __ret; - - va_list __va; va_start(__va, fmt); - __ret = xdc_runtime_System_asprintf_va__F(buf, fmt, __va); - - va_end(__va); - return __ret; -} - -/* snprintf_va__E */ -xdc_Int xdc_runtime_System_snprintf_va__E( xdc_Char buf[], xdc_SizeT n, xdc_CString fmt, va_list __va ) -{ - return xdc_runtime_System_snprintf_va__F(buf, n, fmt, __va); -} - -/* snprintf__E */ -xdc_Int xdc_runtime_System_snprintf__E( xdc_Char buf[], xdc_SizeT n, xdc_CString fmt, ... ) -{ - xdc_Int __ret; - - va_list __va; va_start(__va, fmt); - __ret = xdc_runtime_System_snprintf_va__F(buf, n, fmt, __va); - - va_end(__va); - return __ret; -} - - -/* - * ======== ti.sysbios.BIOS_RtsGateProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.gates.GateMutex */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_BIOS_RtsGateProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_gates_GateMutex_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_BIOS_RtsGateProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_BIOS_RtsGateProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_gates_GateMutex_Object__create__S(__obj, __osz, __aa, (ti_sysbios_gates_GateMutex___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_IGateProvider_Params), __eb); -} - -/* create */ -ti_sysbios_BIOS_RtsGateProxy_Handle ti_sysbios_BIOS_RtsGateProxy_create( const ti_sysbios_BIOS_RtsGateProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (ti_sysbios_BIOS_RtsGateProxy_Handle)ti_sysbios_BIOS_RtsGateProxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(ti_sysbios_BIOS_RtsGateProxy_Params), __eb); -} - -/* Object__delete__S */ -void ti_sysbios_BIOS_RtsGateProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_gates_GateMutex_Object__delete__S(instp); -} - -/* delete */ -void ti_sysbios_BIOS_RtsGateProxy_delete(ti_sysbios_BIOS_RtsGateProxy_Handle *instp) -{ - ti_sysbios_BIOS_RtsGateProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void ti_sysbios_BIOS_RtsGateProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_gates_GateMutex_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_BIOS_RtsGateProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_gates_GateMutex_Handle__label__S(obj, lab); -} - -/* query__E */ -xdc_Bool ti_sysbios_BIOS_RtsGateProxy_query__E( xdc_Int qual ) -{ - return ti_sysbios_gates_GateMutex_query(qual); -} - -/* enter__E */ -xdc_IArg ti_sysbios_BIOS_RtsGateProxy_enter__E( ti_sysbios_BIOS_RtsGateProxy_Handle __inst ) -{ - return ti_sysbios_gates_GateMutex_enter((ti_sysbios_gates_GateMutex_Handle)__inst); -} - -/* leave__E */ -xdc_Void ti_sysbios_BIOS_RtsGateProxy_leave__E( ti_sysbios_BIOS_RtsGateProxy_Handle __inst, xdc_IArg key ) -{ - ti_sysbios_gates_GateMutex_leave((ti_sysbios_gates_GateMutex_Handle)__inst, key); -} - - -/* - * ======== ti.sysbios.hal.Hwi_HwiProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.m3.Hwi */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_hal_Hwi_HwiProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_m3_Hwi_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_hal_Hwi_HwiProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_hal_Hwi_HwiProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_family_arm_m3_Hwi_Object__create__S(__obj, __osz, __aa, (ti_sysbios_family_arm_m3_Hwi___ParamsPtr)__paramsPtr, sizeof(ti_sysbios_interfaces_IHwi_Params), __eb); -} - -/* create */ -ti_sysbios_hal_Hwi_HwiProxy_Handle ti_sysbios_hal_Hwi_HwiProxy_create( xdc_Int intNum, ti_sysbios_interfaces_IHwi_FuncPtr hwiFxn, const ti_sysbios_hal_Hwi_HwiProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_hal_Hwi_HwiProxy_Args__create __args; - __args.intNum = intNum; - __args.hwiFxn = hwiFxn; - return (ti_sysbios_hal_Hwi_HwiProxy_Handle)ti_sysbios_hal_Hwi_HwiProxy_Object__create__S(0, 0, &__args, (const xdc_UChar*)__prms, sizeof(ti_sysbios_hal_Hwi_HwiProxy_Params), __eb); -} - -/* Object__delete__S */ -void ti_sysbios_hal_Hwi_HwiProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_family_arm_m3_Hwi_Object__delete__S(instp); -} - -/* delete */ -void ti_sysbios_hal_Hwi_HwiProxy_delete(ti_sysbios_hal_Hwi_HwiProxy_Handle *instp) -{ - ti_sysbios_hal_Hwi_HwiProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void ti_sysbios_hal_Hwi_HwiProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_family_arm_m3_Hwi_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_hal_Hwi_HwiProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_family_arm_m3_Hwi_Handle__label__S(obj, lab); -} - -/* getStackInfo__E */ -xdc_Bool ti_sysbios_hal_Hwi_HwiProxy_getStackInfo__E( ti_sysbios_interfaces_IHwi_StackInfo *stkInfo, xdc_Bool computeStackDepth ) -{ - return ti_sysbios_family_arm_m3_Hwi_getStackInfo(stkInfo, computeStackDepth); -} - -/* getCoreStackInfo__E */ -xdc_Bool ti_sysbios_hal_Hwi_HwiProxy_getCoreStackInfo__E( ti_sysbios_interfaces_IHwi_StackInfo *stkInfo, xdc_Bool computeStackDepth, xdc_UInt coreId ) -{ - return ti_sysbios_family_arm_m3_Hwi_getCoreStackInfo(stkInfo, computeStackDepth, coreId); -} - -/* startup__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_startup__E( void ) -{ - ti_sysbios_family_arm_m3_Hwi_startup(); -} - -/* disable__E */ -xdc_UInt ti_sysbios_hal_Hwi_HwiProxy_disable__E( void ) -{ - return ti_sysbios_family_arm_m3_Hwi_disable(); -} - -/* enable__E */ -xdc_UInt ti_sysbios_hal_Hwi_HwiProxy_enable__E( void ) -{ - return ti_sysbios_family_arm_m3_Hwi_enable(); -} - -/* restore__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_restore__E( xdc_UInt key ) -{ - ti_sysbios_family_arm_m3_Hwi_restore(key); -} - -/* switchFromBootStack__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_switchFromBootStack__E( void ) -{ - ti_sysbios_family_arm_m3_Hwi_switchFromBootStack(); -} - -/* post__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_post__E( xdc_UInt intNum ) -{ - ti_sysbios_family_arm_m3_Hwi_post(intNum); -} - -/* getTaskSP__E */ -xdc_Char *ti_sysbios_hal_Hwi_HwiProxy_getTaskSP__E( void ) -{ - return ti_sysbios_family_arm_m3_Hwi_getTaskSP(); -} - -/* disableInterrupt__E */ -xdc_UInt ti_sysbios_hal_Hwi_HwiProxy_disableInterrupt__E( xdc_UInt intNum ) -{ - return ti_sysbios_family_arm_m3_Hwi_disableInterrupt(intNum); -} - -/* enableInterrupt__E */ -xdc_UInt ti_sysbios_hal_Hwi_HwiProxy_enableInterrupt__E( xdc_UInt intNum ) -{ - return ti_sysbios_family_arm_m3_Hwi_enableInterrupt(intNum); -} - -/* restoreInterrupt__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_restoreInterrupt__E( xdc_UInt intNum, xdc_UInt key ) -{ - ti_sysbios_family_arm_m3_Hwi_restoreInterrupt(intNum, key); -} - -/* clearInterrupt__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_clearInterrupt__E( xdc_UInt intNum ) -{ - ti_sysbios_family_arm_m3_Hwi_clearInterrupt(intNum); -} - -/* getFunc__E */ -ti_sysbios_interfaces_IHwi_FuncPtr ti_sysbios_hal_Hwi_HwiProxy_getFunc__E( ti_sysbios_hal_Hwi_HwiProxy_Handle __inst, xdc_UArg *arg ) -{ - return ti_sysbios_family_arm_m3_Hwi_getFunc((ti_sysbios_family_arm_m3_Hwi_Handle)__inst, arg); -} - -/* setFunc__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_setFunc__E( ti_sysbios_hal_Hwi_HwiProxy_Handle __inst, ti_sysbios_interfaces_IHwi_FuncPtr fxn, xdc_UArg arg ) -{ - ti_sysbios_family_arm_m3_Hwi_setFunc((ti_sysbios_family_arm_m3_Hwi_Handle)__inst, fxn, arg); -} - -/* getHookContext__E */ -xdc_Ptr ti_sysbios_hal_Hwi_HwiProxy_getHookContext__E( ti_sysbios_hal_Hwi_HwiProxy_Handle __inst, xdc_Int id ) -{ - return ti_sysbios_family_arm_m3_Hwi_getHookContext((ti_sysbios_family_arm_m3_Hwi_Handle)__inst, id); -} - -/* setHookContext__E */ -xdc_Void ti_sysbios_hal_Hwi_HwiProxy_setHookContext__E( ti_sysbios_hal_Hwi_HwiProxy_Handle __inst, xdc_Int id, xdc_Ptr hookContext ) -{ - ti_sysbios_family_arm_m3_Hwi_setHookContext((ti_sysbios_family_arm_m3_Hwi_Handle)__inst, id, hookContext); -} - -/* getIrp__E */ -ti_sysbios_interfaces_IHwi_Irp ti_sysbios_hal_Hwi_HwiProxy_getIrp__E( ti_sysbios_hal_Hwi_HwiProxy_Handle __inst ) -{ - return ti_sysbios_family_arm_m3_Hwi_getIrp((ti_sysbios_family_arm_m3_Hwi_Handle)__inst); -} - - -/* - * ======== ti.sysbios.hal.Seconds_SecondsProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.lm4.Seconds */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_hal_Seconds_SecondsProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_lm4_Seconds_Module__startupDone__S(); -} - -/* get__E */ -xdc_UInt32 ti_sysbios_hal_Seconds_SecondsProxy_get__E( void ) -{ - return ti_sysbios_family_arm_lm4_Seconds_get(); -} - -/* getTime__E */ -xdc_UInt32 ti_sysbios_hal_Seconds_SecondsProxy_getTime__E( ti_sysbios_interfaces_ISeconds_Time *ts ) -{ - return ti_sysbios_family_arm_lm4_Seconds_getTime(ts); -} - -/* set__E */ -xdc_Void ti_sysbios_hal_Seconds_SecondsProxy_set__E( xdc_UInt32 seconds ) -{ - ti_sysbios_family_arm_lm4_Seconds_set(seconds); -} - - -/* - * ======== ti.sysbios.heaps.HeapMem_Module_GateProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.gates.GateMutex */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_gates_GateMutex_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_heaps_HeapMem_Module_GateProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_gates_GateMutex_Object__create__S(__obj, __osz, __aa, (ti_sysbios_gates_GateMutex___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_IGateProvider_Params), __eb); -} - -/* create */ -ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle ti_sysbios_heaps_HeapMem_Module_GateProxy_create( const ti_sysbios_heaps_HeapMem_Module_GateProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle)ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(ti_sysbios_heaps_HeapMem_Module_GateProxy_Params), __eb); -} - -/* Object__delete__S */ -void ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_gates_GateMutex_Object__delete__S(instp); -} - -/* delete */ -void ti_sysbios_heaps_HeapMem_Module_GateProxy_delete(ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle *instp) -{ - ti_sysbios_heaps_HeapMem_Module_GateProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void ti_sysbios_heaps_HeapMem_Module_GateProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_gates_GateMutex_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_gates_GateMutex_Handle__label__S(obj, lab); -} - -/* query__E */ -xdc_Bool ti_sysbios_heaps_HeapMem_Module_GateProxy_query__E( xdc_Int qual ) -{ - return ti_sysbios_gates_GateMutex_query(qual); -} - -/* enter__E */ -xdc_IArg ti_sysbios_heaps_HeapMem_Module_GateProxy_enter__E( ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle __inst ) -{ - return ti_sysbios_gates_GateMutex_enter((ti_sysbios_gates_GateMutex_Handle)__inst); -} - -/* leave__E */ -xdc_Void ti_sysbios_heaps_HeapMem_Module_GateProxy_leave__E( ti_sysbios_heaps_HeapMem_Module_GateProxy_Handle __inst, xdc_IArg key ) -{ - ti_sysbios_gates_GateMutex_leave((ti_sysbios_gates_GateMutex_Handle)__inst, key); -} - - -/* - * ======== ti.sysbios.knl.Clock_TimerProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.lm4.Timer */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Clock_TimerProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_lm4_Timer_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Clock_TimerProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Clock_TimerProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_family_arm_lm4_Timer_Object__create__S(__obj, __osz, __aa, (ti_sysbios_family_arm_lm4_Timer___ParamsPtr)__paramsPtr, sizeof(ti_sysbios_interfaces_ITimer_Params), __eb); -} - -/* create */ -ti_sysbios_knl_Clock_TimerProxy_Handle ti_sysbios_knl_Clock_TimerProxy_create( xdc_Int id, ti_sysbios_interfaces_ITimer_FuncPtr tickFxn, const ti_sysbios_knl_Clock_TimerProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Clock_TimerProxy_Args__create __args; - __args.id = id; - __args.tickFxn = tickFxn; - return (ti_sysbios_knl_Clock_TimerProxy_Handle)ti_sysbios_knl_Clock_TimerProxy_Object__create__S(0, 0, &__args, (const xdc_UChar*)__prms, sizeof(ti_sysbios_knl_Clock_TimerProxy_Params), __eb); -} - -/* Object__delete__S */ -void ti_sysbios_knl_Clock_TimerProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_family_arm_lm4_Timer_Object__delete__S(instp); -} - -/* delete */ -void ti_sysbios_knl_Clock_TimerProxy_delete(ti_sysbios_knl_Clock_TimerProxy_Handle *instp) -{ - ti_sysbios_knl_Clock_TimerProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void ti_sysbios_knl_Clock_TimerProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_family_arm_lm4_Timer_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Clock_TimerProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_family_arm_lm4_Timer_Handle__label__S(obj, lab); -} - -/* getNumTimers__E */ -xdc_UInt ti_sysbios_knl_Clock_TimerProxy_getNumTimers__E( void ) -{ - return ti_sysbios_family_arm_lm4_Timer_getNumTimers(); -} - -/* getStatus__E */ -ti_sysbios_interfaces_ITimer_Status ti_sysbios_knl_Clock_TimerProxy_getStatus__E( xdc_UInt id ) -{ - return ti_sysbios_family_arm_lm4_Timer_getStatus(id); -} - -/* startup__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_startup__E( void ) -{ - ti_sysbios_family_arm_lm4_Timer_startup(); -} - -/* getMaxTicks__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getMaxTicks__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - return ti_sysbios_family_arm_lm4_Timer_getMaxTicks((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* setNextTick__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_setNextTick__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UInt32 ticks ) -{ - ti_sysbios_family_arm_lm4_Timer_setNextTick((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, ticks); -} - -/* start__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_start__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - ti_sysbios_family_arm_lm4_Timer_start((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* stop__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_stop__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - ti_sysbios_family_arm_lm4_Timer_stop((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* setPeriod__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_setPeriod__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UInt32 period ) -{ - ti_sysbios_family_arm_lm4_Timer_setPeriod((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, period); -} - -/* setPeriodMicroSecs__E */ -xdc_Bool ti_sysbios_knl_Clock_TimerProxy_setPeriodMicroSecs__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UInt32 microsecs ) -{ - return ti_sysbios_family_arm_lm4_Timer_setPeriodMicroSecs((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, microsecs); -} - -/* getPeriod__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getPeriod__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - return ti_sysbios_family_arm_lm4_Timer_getPeriod((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* getCount__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getCount__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - return ti_sysbios_family_arm_lm4_Timer_getCount((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* getFreq__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_getFreq__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_runtime_Types_FreqHz *freq ) -{ - ti_sysbios_family_arm_lm4_Timer_getFreq((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, freq); -} - -/* getFunc__E */ -ti_sysbios_interfaces_ITimer_FuncPtr ti_sysbios_knl_Clock_TimerProxy_getFunc__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UArg *arg ) -{ - return ti_sysbios_family_arm_lm4_Timer_getFunc((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, arg); -} - -/* setFunc__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_setFunc__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, ti_sysbios_interfaces_ITimer_FuncPtr fxn, xdc_UArg arg ) -{ - ti_sysbios_family_arm_lm4_Timer_setFunc((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, fxn, arg); -} - -/* trigger__E */ -xdc_Void ti_sysbios_knl_Clock_TimerProxy_trigger__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UInt32 cycles ) -{ - ti_sysbios_family_arm_lm4_Timer_trigger((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, cycles); -} - -/* getExpiredCounts__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getExpiredCounts__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst ) -{ - return ti_sysbios_family_arm_lm4_Timer_getExpiredCounts((ti_sysbios_family_arm_lm4_Timer_Handle)__inst); -} - -/* getExpiredTicks__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getExpiredTicks__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_UInt32 tickPeriod ) -{ - return ti_sysbios_family_arm_lm4_Timer_getExpiredTicks((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, tickPeriod); -} - -/* getCurrentTick__E */ -xdc_UInt32 ti_sysbios_knl_Clock_TimerProxy_getCurrentTick__E( ti_sysbios_knl_Clock_TimerProxy_Handle __inst, xdc_Bool save ) -{ - return ti_sysbios_family_arm_lm4_Timer_getCurrentTick((ti_sysbios_family_arm_lm4_Timer_Handle)__inst, save); -} - - -/* - * ======== ti.sysbios.knl.Intrinsics_SupportProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.m3.IntrinsicsSupport */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Intrinsics_SupportProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDone__S(); -} - -/* maxbit__E */ -xdc_UInt ti_sysbios_knl_Intrinsics_SupportProxy_maxbit__E( xdc_UInt bits ) -{ - return ti_sysbios_family_arm_m3_IntrinsicsSupport_maxbit(bits); -} - - -/* - * ======== ti.sysbios.knl.Task_SupportProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.m3.TaskSupport */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Task_SupportProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_Module__startupDone__S(); -} - -/* start__E */ -xdc_Ptr ti_sysbios_knl_Task_SupportProxy_start__E( xdc_Ptr curTask, ti_sysbios_interfaces_ITaskSupport_FuncPtr enter, ti_sysbios_interfaces_ITaskSupport_FuncPtr exit, xdc_runtime_Error_Block *eb ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_start(curTask, enter, exit, eb); -} - -/* swap__E */ -xdc_Void ti_sysbios_knl_Task_SupportProxy_swap__E( xdc_Ptr *oldtskContext, xdc_Ptr *newtskContext ) -{ - ti_sysbios_family_arm_m3_TaskSupport_swap(oldtskContext, newtskContext); -} - -/* checkStack__E */ -xdc_Bool ti_sysbios_knl_Task_SupportProxy_checkStack__E( xdc_Char *stack, xdc_SizeT size ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_checkStack(stack, size); -} - -/* stackUsed__E */ -xdc_SizeT ti_sysbios_knl_Task_SupportProxy_stackUsed__E( xdc_Char *stack, xdc_SizeT size ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_stackUsed(stack, size); -} - -/* getStackAlignment__E */ -xdc_UInt ti_sysbios_knl_Task_SupportProxy_getStackAlignment__E( void ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_getStackAlignment(); -} - -/* getDefaultStackSize__E */ -xdc_SizeT ti_sysbios_knl_Task_SupportProxy_getDefaultStackSize__E( void ) -{ - return ti_sysbios_family_arm_m3_TaskSupport_getDefaultStackSize(); -} - - -/* - * ======== xdc.runtime.Main_Module_GateProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.gates.GateHwi */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Main_Module_GateProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_gates_GateHwi_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_Main_Module_GateProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_Main_Module_GateProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_gates_GateHwi_Object__create__S(__obj, __osz, __aa, (ti_sysbios_gates_GateHwi___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_IGateProvider_Params), __eb); -} - -/* create */ -xdc_runtime_Main_Module_GateProxy_Handle xdc_runtime_Main_Module_GateProxy_create( const xdc_runtime_Main_Module_GateProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_Main_Module_GateProxy_Handle)xdc_runtime_Main_Module_GateProxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(xdc_runtime_Main_Module_GateProxy_Params), __eb); -} - -/* Object__delete__S */ -void xdc_runtime_Main_Module_GateProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_gates_GateHwi_Object__delete__S(instp); -} - -/* delete */ -void xdc_runtime_Main_Module_GateProxy_delete(xdc_runtime_Main_Module_GateProxy_Handle *instp) -{ - xdc_runtime_Main_Module_GateProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void xdc_runtime_Main_Module_GateProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_gates_GateHwi_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_Main_Module_GateProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_gates_GateHwi_Handle__label__S(obj, lab); -} - -/* query__E */ -xdc_Bool xdc_runtime_Main_Module_GateProxy_query__E( xdc_Int qual ) -{ - return ti_sysbios_gates_GateHwi_query(qual); -} - -/* enter__E */ -xdc_IArg xdc_runtime_Main_Module_GateProxy_enter__E( xdc_runtime_Main_Module_GateProxy_Handle __inst ) -{ - return ti_sysbios_gates_GateHwi_enter((ti_sysbios_gates_GateHwi_Handle)__inst); -} - -/* leave__E */ -xdc_Void xdc_runtime_Main_Module_GateProxy_leave__E( xdc_runtime_Main_Module_GateProxy_Handle __inst, xdc_IArg key ) -{ - ti_sysbios_gates_GateHwi_leave((ti_sysbios_gates_GateHwi_Handle)__inst, key); -} - - -/* - * ======== xdc.runtime.Memory_HeapProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.heaps.HeapMem */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Memory_HeapProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_heaps_HeapMem_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_Memory_HeapProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_Memory_HeapProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_heaps_HeapMem_Object__create__S(__obj, __osz, __aa, (ti_sysbios_heaps_HeapMem___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_IHeap_Params), __eb); -} - -/* create */ -xdc_runtime_Memory_HeapProxy_Handle xdc_runtime_Memory_HeapProxy_create( const xdc_runtime_Memory_HeapProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_Memory_HeapProxy_Handle)xdc_runtime_Memory_HeapProxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(xdc_runtime_Memory_HeapProxy_Params), __eb); -} - -/* Object__delete__S */ -void xdc_runtime_Memory_HeapProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_heaps_HeapMem_Object__delete__S(instp); -} - -/* delete */ -void xdc_runtime_Memory_HeapProxy_delete(xdc_runtime_Memory_HeapProxy_Handle *instp) -{ - xdc_runtime_Memory_HeapProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void xdc_runtime_Memory_HeapProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_heaps_HeapMem_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_Memory_HeapProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_heaps_HeapMem_Handle__label__S(obj, lab); -} - -/* alloc__E */ -xdc_Ptr xdc_runtime_Memory_HeapProxy_alloc__E( xdc_runtime_Memory_HeapProxy_Handle __inst, xdc_SizeT size, xdc_SizeT align, xdc_runtime_Error_Block *eb ) -{ - return xdc_runtime_IHeap_alloc((xdc_runtime_IHeap_Handle)__inst, size, align, eb); -} - -/* free__E */ -xdc_Void xdc_runtime_Memory_HeapProxy_free__E( xdc_runtime_Memory_HeapProxy_Handle __inst, xdc_Ptr block, xdc_SizeT size ) -{ - xdc_runtime_IHeap_free((xdc_runtime_IHeap_Handle)__inst, block, size); -} - -/* isBlocking__E */ -xdc_Bool xdc_runtime_Memory_HeapProxy_isBlocking__E( xdc_runtime_Memory_HeapProxy_Handle __inst ) -{ - return xdc_runtime_IHeap_isBlocking((xdc_runtime_IHeap_Handle)__inst); -} - -/* getStats__E */ -xdc_Void xdc_runtime_Memory_HeapProxy_getStats__E( xdc_runtime_Memory_HeapProxy_Handle __inst, xdc_runtime_Memory_Stats *stats ) -{ - xdc_runtime_IHeap_getStats((xdc_runtime_IHeap_Handle)__inst, stats); -} - - -/* - * ======== xdc.runtime.System_Module_GateProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.gates.GateHwi */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_System_Module_GateProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_gates_GateHwi_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_System_Module_GateProxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_System_Module_GateProxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_gates_GateHwi_Object__create__S(__obj, __osz, __aa, (ti_sysbios_gates_GateHwi___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_IGateProvider_Params), __eb); -} - -/* create */ -xdc_runtime_System_Module_GateProxy_Handle xdc_runtime_System_Module_GateProxy_create( const xdc_runtime_System_Module_GateProxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_System_Module_GateProxy_Handle)xdc_runtime_System_Module_GateProxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(xdc_runtime_System_Module_GateProxy_Params), __eb); -} - -/* Object__delete__S */ -void xdc_runtime_System_Module_GateProxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_gates_GateHwi_Object__delete__S(instp); -} - -/* delete */ -void xdc_runtime_System_Module_GateProxy_delete(xdc_runtime_System_Module_GateProxy_Handle *instp) -{ - xdc_runtime_System_Module_GateProxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void xdc_runtime_System_Module_GateProxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_gates_GateHwi_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_System_Module_GateProxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_gates_GateHwi_Handle__label__S(obj, lab); -} - -/* query__E */ -xdc_Bool xdc_runtime_System_Module_GateProxy_query__E( xdc_Int qual ) -{ - return ti_sysbios_gates_GateHwi_query(qual); -} - -/* enter__E */ -xdc_IArg xdc_runtime_System_Module_GateProxy_enter__E( xdc_runtime_System_Module_GateProxy_Handle __inst ) -{ - return ti_sysbios_gates_GateHwi_enter((ti_sysbios_gates_GateHwi_Handle)__inst); -} - -/* leave__E */ -xdc_Void xdc_runtime_System_Module_GateProxy_leave__E( xdc_runtime_System_Module_GateProxy_Handle __inst, xdc_IArg key ) -{ - ti_sysbios_gates_GateHwi_leave((ti_sysbios_gates_GateHwi_Handle)__inst, key); -} - - -/* - * ======== xdc.runtime.System_SupportProxy PROXY BODY ======== - */ - -/* DELEGATES TO xdc.runtime.SysMin */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_System_SupportProxy_Module__startupDone__S( void ) -{ - return xdc_runtime_SysMin_Module__startupDone__S(); -} - -/* abort__E */ -xdc_Void xdc_runtime_System_SupportProxy_abort__E( xdc_CString str ) -{ - xdc_runtime_SysMin_abort(str); -} - -/* exit__E */ -xdc_Void xdc_runtime_System_SupportProxy_exit__E( xdc_Int stat ) -{ - xdc_runtime_SysMin_exit(stat); -} - -/* flush__E */ -xdc_Void xdc_runtime_System_SupportProxy_flush__E( void ) -{ - xdc_runtime_SysMin_flush(); -} - -/* putch__E */ -xdc_Void xdc_runtime_System_SupportProxy_putch__E( xdc_Char ch ) -{ - xdc_runtime_SysMin_putch(ch); -} - -/* ready__E */ -xdc_Bool xdc_runtime_System_SupportProxy_ready__E( void ) -{ - return xdc_runtime_SysMin_ready(); -} - - -/* - * ======== xdc.runtime.Timestamp_SupportProxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.family.arm.lm4.TimestampProvider */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Timestamp_SupportProxy_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDone__S(); -} - -/* get32__E */ -xdc_Bits32 xdc_runtime_Timestamp_SupportProxy_get32__E( void ) -{ - return ti_sysbios_family_arm_lm4_TimestampProvider_get32(); -} - -/* get64__E */ -xdc_Void xdc_runtime_Timestamp_SupportProxy_get64__E( xdc_runtime_Types_Timestamp64 *result ) -{ - ti_sysbios_family_arm_lm4_TimestampProvider_get64(result); -} - -/* getFreq__E */ -xdc_Void xdc_runtime_Timestamp_SupportProxy_getFreq__E( xdc_runtime_Types_FreqHz *freq ) -{ - ti_sysbios_family_arm_lm4_TimestampProvider_getFreq(freq); -} - - -/* - * ======== xdc.runtime.knl.SemThread_Proxy PROXY BODY ======== - */ - -/* DELEGATES TO ti.sysbios.xdcruntime.SemThreadSupport */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_SemThread_Proxy_Module__startupDone__S( void ) -{ - return ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_SemThread_Proxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_SemThread_Proxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return ti_sysbios_xdcruntime_SemThreadSupport_Object__create__S(__obj, __osz, __aa, (ti_sysbios_xdcruntime_SemThreadSupport___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_knl_ISemThreadSupport_Params), __eb); -} - -/* create */ -xdc_runtime_knl_SemThread_Proxy_Handle xdc_runtime_knl_SemThread_Proxy_create( xdc_Int count, const xdc_runtime_knl_SemThread_Proxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SemThread_Proxy_Args__create __args; - __args.count = count; - return (xdc_runtime_knl_SemThread_Proxy_Handle)xdc_runtime_knl_SemThread_Proxy_Object__create__S(0, 0, &__args, (const xdc_UChar*)__prms, sizeof(xdc_runtime_knl_SemThread_Proxy_Params), __eb); -} - -/* Object__delete__S */ -void xdc_runtime_knl_SemThread_Proxy_Object__delete__S( xdc_Ptr instp ) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Object__delete__S(instp); -} - -/* delete */ -void xdc_runtime_knl_SemThread_Proxy_delete(xdc_runtime_knl_SemThread_Proxy_Handle *instp) -{ - xdc_runtime_knl_SemThread_Proxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void xdc_runtime_knl_SemThread_Proxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_SemThread_Proxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return ti_sysbios_xdcruntime_SemThreadSupport_Handle__label__S(obj, lab); -} - -/* pend__E */ -xdc_Int xdc_runtime_knl_SemThread_Proxy_pend__E( xdc_runtime_knl_SemThread_Proxy_Handle __inst, xdc_UInt timeout, xdc_runtime_Error_Block *eb ) -{ - return ti_sysbios_xdcruntime_SemThreadSupport_pend((ti_sysbios_xdcruntime_SemThreadSupport_Handle)__inst, timeout, eb); -} - -/* post__E */ -xdc_Bool xdc_runtime_knl_SemThread_Proxy_post__E( xdc_runtime_knl_SemThread_Proxy_Handle __inst, xdc_runtime_Error_Block *eb ) -{ - return ti_sysbios_xdcruntime_SemThreadSupport_post((ti_sysbios_xdcruntime_SemThreadSupport_Handle)__inst, eb); -} - - -/* - * ======== xdc.runtime.knl.Sync_Proxy PROXY BODY ======== - */ - -/* DELEGATES TO xdc.runtime.knl.SyncNull */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_Sync_Proxy_Module__startupDone__S( void ) -{ - return xdc_runtime_knl_SyncNull_Module__startupDone__S(); -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_Sync_Proxy_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_Sync_Proxy___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - return xdc_runtime_knl_SyncNull_Object__create__S(__obj, __osz, __aa, (xdc_runtime_knl_SyncNull___ParamsPtr)__paramsPtr, sizeof(xdc_runtime_knl_ISync_Params), __eb); -} - -/* create */ -xdc_runtime_knl_Sync_Proxy_Handle xdc_runtime_knl_Sync_Proxy_create( const xdc_runtime_knl_Sync_Proxy_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_knl_Sync_Proxy_Handle)xdc_runtime_knl_Sync_Proxy_Object__create__S(0, 0, 0, (const xdc_UChar*)__prms, sizeof(xdc_runtime_knl_Sync_Proxy_Params), __eb); -} - -/* Object__delete__S */ -void xdc_runtime_knl_Sync_Proxy_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_knl_SyncNull_Object__delete__S(instp); -} - -/* delete */ -void xdc_runtime_knl_Sync_Proxy_delete(xdc_runtime_knl_Sync_Proxy_Handle *instp) -{ - xdc_runtime_knl_Sync_Proxy_Object__delete__S(instp); -} - -/* Params__init__S */ -void xdc_runtime_knl_Sync_Proxy_Params__init__S( xdc_Ptr dst, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_knl_SyncNull_Params__init__S(dst, src, psz, isz); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_Sync_Proxy_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - return xdc_runtime_knl_SyncNull_Handle__label__S(obj, lab); -} - -/* query__E */ -xdc_Bool xdc_runtime_knl_Sync_Proxy_query__E( xdc_runtime_knl_Sync_Proxy_Handle __inst, xdc_Int qual ) -{ - return xdc_runtime_knl_ISync_query((xdc_runtime_knl_ISync_Handle)__inst, qual); -} - -/* signal__E */ -xdc_Void xdc_runtime_knl_Sync_Proxy_signal__E( xdc_runtime_knl_Sync_Proxy_Handle __inst ) -{ - xdc_runtime_knl_ISync_signal((xdc_runtime_knl_ISync_Handle)__inst); -} - -/* wait__E */ -xdc_Int xdc_runtime_knl_Sync_Proxy_wait__E( xdc_runtime_knl_Sync_Proxy_Handle __inst, xdc_UInt timeout, xdc_runtime_Error_Block *eb ) -{ - return xdc_runtime_knl_ISync_wait((xdc_runtime_knl_ISync_Handle)__inst, timeout, eb); -} - - -/* - * ======== ti.sysbios.family.arm.lm4.Timer OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_family_arm_lm4_Timer_Object2__ s0; char c; } ti_sysbios_family_arm_lm4_Timer___S1; -#pragma DATA_SECTION(ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, ".const:ti_sysbios_family_arm_lm4_Timer_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_family_arm_lm4_Timer_Object__DESC__C = { - (xdc_Ptr)0, /* fxnTab */ - &ti_sysbios_family_arm_lm4_Timer_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_family_arm_lm4_Timer___S1) - sizeof(ti_sysbios_family_arm_lm4_Timer_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_family_arm_lm4_Timer_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_family_arm_lm4_Timer_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_family_arm_m3_Hwi_Object2__ s0; char c; } ti_sysbios_family_arm_m3_Hwi___S1; -#pragma DATA_SECTION(ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, ".const:ti_sysbios_family_arm_m3_Hwi_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_family_arm_m3_Hwi_Object__DESC__C = { - (xdc_Ptr)0, /* fxnTab */ - &ti_sysbios_family_arm_m3_Hwi_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_family_arm_m3_Hwi___S1) - sizeof(ti_sysbios_family_arm_m3_Hwi_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_family_arm_m3_Hwi_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_family_arm_m3_Hwi_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.gates.GateHwi OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_gates_GateHwi_Object2__ s0; char c; } ti_sysbios_gates_GateHwi___S1; -#pragma DATA_SECTION(ti_sysbios_gates_GateHwi_Object__DESC__C, ".const:ti_sysbios_gates_GateHwi_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_gates_GateHwi_Object__DESC__C = { - (xdc_Ptr)&ti_sysbios_gates_GateHwi_Module__FXNS__C, /* fxnTab */ - &ti_sysbios_gates_GateHwi_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_gates_GateHwi___S1) - sizeof(ti_sysbios_gates_GateHwi_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_gates_GateHwi_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_gates_GateHwi_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_gates_GateHwi_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.gates.GateMutex OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_gates_GateMutex_Object2__ s0; char c; } ti_sysbios_gates_GateMutex___S1; -#pragma DATA_SECTION(ti_sysbios_gates_GateMutex_Object__DESC__C, ".const:ti_sysbios_gates_GateMutex_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_gates_GateMutex_Object__DESC__C = { - (xdc_Ptr)&ti_sysbios_gates_GateMutex_Module__FXNS__C, /* fxnTab */ - &ti_sysbios_gates_GateMutex_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_gates_GateMutex___S1) - sizeof(ti_sysbios_gates_GateMutex_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_gates_GateMutex_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_gates_GateMutex_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_gates_GateMutex_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.hal.Hwi OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_hal_Hwi_Object2__ s0; char c; } ti_sysbios_hal_Hwi___S1; -#pragma DATA_SECTION(ti_sysbios_hal_Hwi_Object__DESC__C, ".const:ti_sysbios_hal_Hwi_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_hal_Hwi_Object__DESC__C = { - (xdc_Ptr)0, /* fxnTab */ - &ti_sysbios_hal_Hwi_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_hal_Hwi___S1) - sizeof(ti_sysbios_hal_Hwi_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_hal_Hwi_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_hal_Hwi_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_hal_Hwi_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.heaps.HeapMem OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_heaps_HeapMem_Object2__ s0; char c; } ti_sysbios_heaps_HeapMem___S1; -#pragma DATA_SECTION(ti_sysbios_heaps_HeapMem_Object__DESC__C, ".const:ti_sysbios_heaps_HeapMem_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_heaps_HeapMem_Object__DESC__C = { - (xdc_Ptr)&ti_sysbios_heaps_HeapMem_Module__FXNS__C, /* fxnTab */ - &ti_sysbios_heaps_HeapMem_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_heaps_HeapMem___S1) - sizeof(ti_sysbios_heaps_HeapMem_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_heaps_HeapMem_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_heaps_HeapMem_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_heaps_HeapMem_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.io.DEV OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_io_DEV_Object2__ s0; char c; } ti_sysbios_io_DEV___S1; -#pragma DATA_SECTION(ti_sysbios_io_DEV_Object__DESC__C, ".const:ti_sysbios_io_DEV_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_io_DEV_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_io_DEV_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_io_DEV___S1) - sizeof(ti_sysbios_io_DEV_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_io_DEV_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_io_DEV_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_io_DEV_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.io.GIO OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_io_GIO_Object2__ s0; char c; } ti_sysbios_io_GIO___S1; -#pragma DATA_SECTION(ti_sysbios_io_GIO_Object__DESC__C, ".const:ti_sysbios_io_GIO_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_io_GIO_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_io_GIO_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_io_GIO___S1) - sizeof(ti_sysbios_io_GIO_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_io_GIO_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_io_GIO_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_io_GIO_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Clock OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Clock_Object2__ s0; char c; } ti_sysbios_knl_Clock___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Clock_Object__DESC__C, ".const:ti_sysbios_knl_Clock_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Clock_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Clock_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Clock___S1) - sizeof(ti_sysbios_knl_Clock_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Clock_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Clock_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Clock_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Event OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Event_Object2__ s0; char c; } ti_sysbios_knl_Event___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Event_Object__DESC__C, ".const:ti_sysbios_knl_Event_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Event_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Event_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Event___S1) - sizeof(ti_sysbios_knl_Event_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Event_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Event_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Event_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Mailbox OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Mailbox_Object2__ s0; char c; } ti_sysbios_knl_Mailbox___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Mailbox_Object__DESC__C, ".const:ti_sysbios_knl_Mailbox_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Mailbox_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Mailbox_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Mailbox___S1) - sizeof(ti_sysbios_knl_Mailbox_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Mailbox_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Mailbox_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Mailbox_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Queue OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Queue_Object2__ s0; char c; } ti_sysbios_knl_Queue___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Queue_Object__DESC__C, ".const:ti_sysbios_knl_Queue_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Queue_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Queue_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Queue___S1) - sizeof(ti_sysbios_knl_Queue_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Queue_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Queue_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Queue_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Semaphore OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Semaphore_Object2__ s0; char c; } ti_sysbios_knl_Semaphore___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Semaphore_Object__DESC__C, ".const:ti_sysbios_knl_Semaphore_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Semaphore_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Semaphore_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Semaphore___S1) - sizeof(ti_sysbios_knl_Semaphore_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Semaphore_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Semaphore_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Semaphore_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Swi OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Swi_Object2__ s0; char c; } ti_sysbios_knl_Swi___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Swi_Object__DESC__C, ".const:ti_sysbios_knl_Swi_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Swi_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Swi_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Swi___S1) - sizeof(ti_sysbios_knl_Swi_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Swi_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Swi_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Swi_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.knl.Task OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_knl_Task_Object2__ s0; char c; } ti_sysbios_knl_Task___S1; -#pragma DATA_SECTION(ti_sysbios_knl_Task_Object__DESC__C, ".const:ti_sysbios_knl_Task_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_knl_Task_Object__DESC__C = { - (xdc_Ptr)-1, /* fxnTab */ - &ti_sysbios_knl_Task_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_knl_Task___S1) - sizeof(ti_sysbios_knl_Task_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_knl_Task_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_knl_Task_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_knl_Task_Params), /* prmsSize */ -}; - - -/* - * ======== ti.sysbios.xdcruntime.SemThreadSupport OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { ti_sysbios_xdcruntime_SemThreadSupport_Object2__ s0; char c; } ti_sysbios_xdcruntime_SemThreadSupport___S1; -#pragma DATA_SECTION(ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, ".const:ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C = { - (xdc_Ptr)0, /* fxnTab */ - &ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link, /* modLink */ - sizeof(ti_sysbios_xdcruntime_SemThreadSupport___S1) - sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Object2__), /* objSize */ - (xdc_Ptr)&ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C, /* prmsInit */ - sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.HeapStd OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { xdc_runtime_HeapStd_Object2__ s0; char c; } xdc_runtime_HeapStd___S1; -#pragma DATA_SECTION(xdc_runtime_HeapStd_Object__DESC__C, ".const:xdc_runtime_HeapStd_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_HeapStd_Object__DESC__C = { - (xdc_Ptr)&xdc_runtime_HeapStd_Module__FXNS__C, /* fxnTab */ - &xdc_runtime_HeapStd_Module__root__V.link, /* modLink */ - sizeof(xdc_runtime_HeapStd___S1) - sizeof(xdc_runtime_HeapStd_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(xdc_runtime_HeapStd_Object2__), /* objSize */ - (xdc_Ptr)&xdc_runtime_HeapStd_Object__PARAMS__C, /* prmsInit */ - sizeof(xdc_runtime_HeapStd_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.knl.SemThread OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { xdc_runtime_knl_SemThread_Object2__ s0; char c; } xdc_runtime_knl_SemThread___S1; -#pragma DATA_SECTION(xdc_runtime_knl_SemThread_Object__DESC__C, ".const:xdc_runtime_knl_SemThread_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SemThread_Object__DESC__C = { - (xdc_Ptr)&xdc_runtime_knl_SemThread_Module__FXNS__C, /* fxnTab */ - &xdc_runtime_knl_SemThread_Module__root__V.link, /* modLink */ - sizeof(xdc_runtime_knl_SemThread___S1) - sizeof(xdc_runtime_knl_SemThread_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(xdc_runtime_knl_SemThread_Object2__), /* objSize */ - (xdc_Ptr)&xdc_runtime_knl_SemThread_Object__PARAMS__C, /* prmsInit */ - sizeof(xdc_runtime_knl_SemThread_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.knl.SyncGeneric OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { xdc_runtime_knl_SyncGeneric_Object2__ s0; char c; } xdc_runtime_knl_SyncGeneric___S1; -#pragma DATA_SECTION(xdc_runtime_knl_SyncGeneric_Object__DESC__C, ".const:xdc_runtime_knl_SyncGeneric_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncGeneric_Object__DESC__C = { - (xdc_Ptr)&xdc_runtime_knl_SyncGeneric_Module__FXNS__C, /* fxnTab */ - &xdc_runtime_knl_SyncGeneric_Module__root__V.link, /* modLink */ - sizeof(xdc_runtime_knl_SyncGeneric___S1) - sizeof(xdc_runtime_knl_SyncGeneric_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(xdc_runtime_knl_SyncGeneric_Object2__), /* objSize */ - (xdc_Ptr)&xdc_runtime_knl_SyncGeneric_Object__PARAMS__C, /* prmsInit */ - sizeof(xdc_runtime_knl_SyncGeneric_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.knl.SyncNull OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { xdc_runtime_knl_SyncNull_Object2__ s0; char c; } xdc_runtime_knl_SyncNull___S1; -#pragma DATA_SECTION(xdc_runtime_knl_SyncNull_Object__DESC__C, ".const:xdc_runtime_knl_SyncNull_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncNull_Object__DESC__C = { - (xdc_Ptr)&xdc_runtime_knl_SyncNull_Module__FXNS__C, /* fxnTab */ - &xdc_runtime_knl_SyncNull_Module__root__V.link, /* modLink */ - sizeof(xdc_runtime_knl_SyncNull___S1) - sizeof(xdc_runtime_knl_SyncNull_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(xdc_runtime_knl_SyncNull_Object2__), /* objSize */ - (xdc_Ptr)&xdc_runtime_knl_SyncNull_Object__PARAMS__C, /* prmsInit */ - sizeof(xdc_runtime_knl_SyncNull_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.knl.SyncSemThread OBJECT DESCRIPTOR ======== - */ - -/* Object__DESC__C */ -typedef struct { xdc_runtime_knl_SyncSemThread_Object2__ s0; char c; } xdc_runtime_knl_SyncSemThread___S1; -#pragma DATA_SECTION(xdc_runtime_knl_SyncSemThread_Object__DESC__C, ".const:xdc_runtime_knl_SyncSemThread_Object__DESC__C"); -__FAR__ const xdc_runtime_Core_ObjDesc xdc_runtime_knl_SyncSemThread_Object__DESC__C = { - (xdc_Ptr)&xdc_runtime_knl_SyncSemThread_Module__FXNS__C, /* fxnTab */ - &xdc_runtime_knl_SyncSemThread_Module__root__V.link, /* modLink */ - sizeof(xdc_runtime_knl_SyncSemThread___S1) - sizeof(xdc_runtime_knl_SyncSemThread_Object2__), /* objAlign */ - 0, /* objHeap */ - 0, /* objName */ - sizeof(xdc_runtime_knl_SyncSemThread_Object2__), /* objSize */ - (xdc_Ptr)&xdc_runtime_knl_SyncSemThread_Object__PARAMS__C, /* prmsInit */ - sizeof(xdc_runtime_knl_SyncSemThread_Params), /* prmsSize */ -}; - - -/* - * ======== xdc.runtime.IHeap VIRTUAL FUNCTIONS ======== - */ - -/* create */ -xdc_runtime_IHeap_Handle xdc_runtime_IHeap_create( xdc_runtime_IHeap_Module __mod, const xdc_runtime_IHeap_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_IHeap_Handle) __mod->__sysp->__create(0, 0, 0, (const xdc_UChar*)__prms, sizeof (xdc_runtime_IHeap_Params), __eb); -} - -/* delete */ -void xdc_runtime_IHeap_delete( xdc_runtime_IHeap_Handle *instp ) -{ - (*instp)->__fxns->__sysp->__delete(instp); -} - - -/* - * ======== xdc.runtime.knl.ISemaphore VIRTUAL FUNCTIONS ======== - */ - -/* create */ -xdc_runtime_knl_ISemaphore_Handle xdc_runtime_knl_ISemaphore_create( xdc_runtime_knl_ISemaphore_Module __mod, const xdc_runtime_knl_ISemaphore_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_knl_ISemaphore_Handle) __mod->__sysp->__create(0, 0, 0, (const xdc_UChar*)__prms, sizeof (xdc_runtime_knl_ISemaphore_Params), __eb); -} - -/* delete */ -void xdc_runtime_knl_ISemaphore_delete( xdc_runtime_knl_ISemaphore_Handle *instp ) -{ - (*instp)->__fxns->__sysp->__delete(instp); -} - - -/* - * ======== xdc.runtime.IGateProvider VIRTUAL FUNCTIONS ======== - */ - -/* create */ -xdc_runtime_IGateProvider_Handle xdc_runtime_IGateProvider_create( xdc_runtime_IGateProvider_Module __mod, const xdc_runtime_IGateProvider_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_IGateProvider_Handle) __mod->__sysp->__create(0, 0, 0, (const xdc_UChar*)__prms, sizeof (xdc_runtime_IGateProvider_Params), __eb); -} - -/* delete */ -void xdc_runtime_IGateProvider_delete( xdc_runtime_IGateProvider_Handle *instp ) -{ - (*instp)->__fxns->__sysp->__delete(instp); -} - - -/* - * ======== xdc.runtime.knl.ISync VIRTUAL FUNCTIONS ======== - */ - -/* create */ -xdc_runtime_knl_ISync_Handle xdc_runtime_knl_ISync_create( xdc_runtime_knl_ISync_Module __mod, const xdc_runtime_knl_ISync_Params *__prms, xdc_runtime_Error_Block *__eb ) -{ - return (xdc_runtime_knl_ISync_Handle) __mod->__sysp->__create(0, 0, 0, (const xdc_UChar*)__prms, sizeof (xdc_runtime_knl_ISync_Params), __eb); -} - -/* delete */ -void xdc_runtime_knl_ISync_delete( xdc_runtime_knl_ISync_Handle *instp ) -{ - (*instp)->__fxns->__sysp->__delete(instp); -} - - -/* - * ======== ti.catalog.arm.cortexm4.tiva.ce.Boot SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_catalog_arm_cortexm4_tiva_ce_Boot_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.BIOS SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_BIOS_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.BIOS_RtsGateProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_BIOS_RtsGateProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_BIOS_RtsGateProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_BIOS_RtsGateProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_BIOS_RtsGateProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_BIOS_RtsGateProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_BIOS_RtsGateProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_BIOS_RtsGateProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_BIOS_RtsGateProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_BIOS_RtsGateProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_BIOS_RtsGateProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_BIOS_RtsGateProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_BIOS_RtsGateProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_BIOS_RtsGateProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_BIOS_RtsGateProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_BIOS_RtsGateProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_BIOS_RtsGateProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_BIOS_RtsGateProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_BIOS_RtsGateProxy_Module_GateProxy_query - -xdc_Bool ti_sysbios_BIOS_RtsGateProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_BIOS_RtsGateProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_gates_GateMutex_Module__FXNS__C; -} - - - -/* - * ======== ti.sysbios.family.arm.lm4.Seconds SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_lm4_Seconds_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.family.arm.lm4.Timer SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_family_arm_lm4_Timer_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_family_arm_lm4_Timer_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_family_arm_lm4_Timer_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_family_arm_lm4_Timer_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_family_arm_lm4_Timer_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_family_arm_lm4_Timer_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_family_arm_lm4_Timer_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_family_arm_lm4_Timer_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_family_arm_lm4_Timer_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_family_arm_lm4_Timer_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_family_arm_lm4_Timer_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_family_arm_lm4_Timer_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_family_arm_lm4_Timer_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_family_arm_lm4_Timer_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_lm4_Timer_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_lm4_Timer_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_family_arm_lm4_Timer_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32816; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_family_arm_lm4_Timer_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_family_arm_lm4_Timer_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_family_arm_lm4_Timer_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_family_arm_lm4_Timer_Object__ *)oa) + i; - } - - if (ti_sysbios_family_arm_lm4_Timer_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_family_arm_lm4_Timer_Object__ *)ti_sysbios_family_arm_lm4_Timer_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_family_arm_lm4_Timer_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_family_arm_lm4_Timer_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_family_arm_lm4_Timer_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_family_arm_lm4_Timer_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_family_arm_lm4_Timer_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_family_arm_lm4_Timer_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_family_arm_lm4_Timer___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_family_arm_lm4_Timer_Args__create *__args = __aa; - ti_sysbios_family_arm_lm4_Timer_Params __prms; - ti_sysbios_family_arm_lm4_Timer_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_lm4_Timer_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_lm4_Timer_Instance_init__E(__newobj, __args->id, __args->tickFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_family_arm_lm4_Timer_Handle ti_sysbios_family_arm_lm4_Timer_create( xdc_Int id, ti_sysbios_interfaces_ITimer_FuncPtr tickFxn, const ti_sysbios_family_arm_lm4_Timer_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_family_arm_lm4_Timer_Params __prms; - ti_sysbios_family_arm_lm4_Timer_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_lm4_Timer_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_lm4_Timer_Instance_init__E(__newobj, id, tickFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_family_arm_lm4_Timer_construct(ti_sysbios_family_arm_lm4_Timer_Struct *__obj, xdc_Int id, ti_sysbios_interfaces_ITimer_FuncPtr tickFxn, const ti_sysbios_family_arm_lm4_Timer_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_family_arm_lm4_Timer_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_lm4_Timer_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_lm4_Timer_Instance_init__E((xdc_Ptr)__obj, id, tickFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_family_arm_lm4_Timer_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_family_arm_lm4_Timer_destruct(ti_sysbios_family_arm_lm4_Timer_Struct *obj) -{ - ti_sysbios_family_arm_lm4_Timer_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_family_arm_lm4_Timer_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_lm4_Timer_Object__DESC__C, *((ti_sysbios_family_arm_lm4_Timer_Object**)instp), (xdc_Fxn)ti_sysbios_family_arm_lm4_Timer_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_family_arm_lm4_Timer_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_family_arm_lm4_Timer_delete(ti_sysbios_family_arm_lm4_Timer_Handle *instp) -{ - ti_sysbios_family_arm_lm4_Timer_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.family.arm.lm4.TimestampProvider SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_lm4_TimestampProvider_Module__startupDone__F(); -} - - - -/* - * ======== ti.sysbios.family.arm.m3.Hwi SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_family_arm_m3_Hwi_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_family_arm_m3_Hwi_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_family_arm_m3_Hwi_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_family_arm_m3_Hwi_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_family_arm_m3_Hwi_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_family_arm_m3_Hwi_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_family_arm_m3_Hwi_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_family_arm_m3_Hwi_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_family_arm_m3_Hwi_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_family_arm_m3_Hwi_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_family_arm_m3_Hwi_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_family_arm_m3_Hwi_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_family_arm_m3_Hwi_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_family_arm_m3_Hwi_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_m3_Hwi_Module__startupDone__S( void ) -{ - return ti_sysbios_family_arm_m3_Hwi_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_family_arm_m3_Hwi_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32797; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_family_arm_m3_Hwi_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_family_arm_m3_Hwi_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_family_arm_m3_Hwi_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_family_arm_m3_Hwi_Object__ *)oa) + i; - } - - if (ti_sysbios_family_arm_m3_Hwi_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_family_arm_m3_Hwi_Object__ *)ti_sysbios_family_arm_m3_Hwi_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_family_arm_m3_Hwi_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_family_arm_m3_Hwi_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_family_arm_m3_Hwi_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_family_arm_m3_Hwi_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_family_arm_m3_Hwi_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_family_arm_m3_Hwi_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_family_arm_m3_Hwi___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_family_arm_m3_Hwi_Args__create *__args = __aa; - ti_sysbios_family_arm_m3_Hwi_Params __prms; - ti_sysbios_family_arm_m3_Hwi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_m3_Hwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_m3_Hwi_Instance_init__E(__newobj, __args->intNum, __args->hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_family_arm_m3_Hwi_Handle ti_sysbios_family_arm_m3_Hwi_create( xdc_Int intNum, ti_sysbios_interfaces_IHwi_FuncPtr hwiFxn, const ti_sysbios_family_arm_m3_Hwi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_family_arm_m3_Hwi_Params __prms; - ti_sysbios_family_arm_m3_Hwi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_m3_Hwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_m3_Hwi_Instance_init__E(__newobj, intNum, hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_family_arm_m3_Hwi_construct(ti_sysbios_family_arm_m3_Hwi_Struct *__obj, xdc_Int intNum, ti_sysbios_interfaces_IHwi_FuncPtr hwiFxn, const ti_sysbios_family_arm_m3_Hwi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_family_arm_m3_Hwi_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_family_arm_m3_Hwi_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_family_arm_m3_Hwi_Instance_init__E((xdc_Ptr)__obj, intNum, hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_family_arm_m3_Hwi_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_family_arm_m3_Hwi_destruct(ti_sysbios_family_arm_m3_Hwi_Struct *obj) -{ - ti_sysbios_family_arm_m3_Hwi_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_family_arm_m3_Hwi_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_family_arm_m3_Hwi_Object__DESC__C, *((ti_sysbios_family_arm_m3_Hwi_Object**)instp), (xdc_Fxn)ti_sysbios_family_arm_m3_Hwi_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_family_arm_m3_Hwi_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_family_arm_m3_Hwi_delete(ti_sysbios_family_arm_m3_Hwi_Handle *instp) -{ - ti_sysbios_family_arm_m3_Hwi_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.family.arm.m3.IntrinsicsSupport SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.family.arm.m3.TaskSupport SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_family_arm_m3_TaskSupport_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.gates.GateHwi SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_gates_GateHwi_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_gates_GateHwi_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_gates_GateHwi_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_gates_GateHwi_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_gates_GateHwi_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_gates_GateHwi_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_gates_GateHwi_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_gates_GateHwi_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_gates_GateHwi_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_gates_GateHwi_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_gates_GateHwi_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_gates_GateHwi_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_gates_GateHwi_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_gates_GateHwi_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_gates_GateHwi_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_gates_GateHwi_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_gates_GateHwi_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_gates_GateHwi_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_gates_GateHwi_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_gates_GateHwi_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32827; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_gates_GateHwi_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_gates_GateHwi_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_gates_GateHwi_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_gates_GateHwi_Object__ *)oa) + i; - } - - if (ti_sysbios_gates_GateHwi_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_gates_GateHwi_Object__ *)ti_sysbios_gates_GateHwi_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_gates_GateHwi_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_gates_GateHwi_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_gates_GateHwi_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_gates_GateHwi_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_gates_GateHwi_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_gates_GateHwi_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_gates_GateHwi___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_gates_GateHwi_Params __prms; - ti_sysbios_gates_GateHwi_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_gates_GateHwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateHwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_gates_GateHwi_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_gates_GateHwi_Handle ti_sysbios_gates_GateHwi_create( const ti_sysbios_gates_GateHwi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_gates_GateHwi_Params __prms; - ti_sysbios_gates_GateHwi_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_gates_GateHwi_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateHwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_gates_GateHwi_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_gates_GateHwi_construct(ti_sysbios_gates_GateHwi_Struct *__obj, const ti_sysbios_gates_GateHwi_Params *__paramsPtr ) -{ - ti_sysbios_gates_GateHwi_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_gates_GateHwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateHwi_Params), NULL); - /* module-specific initialization */ - ti_sysbios_gates_GateHwi_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_gates_GateHwi_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_gates_GateHwi_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_gates_GateHwi_destruct(ti_sysbios_gates_GateHwi_Struct *obj) -{ - ti_sysbios_gates_GateHwi_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_gates_GateHwi_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_gates_GateHwi_Object__DESC__C, *((ti_sysbios_gates_GateHwi_Object**)instp), NULL, -1, FALSE); - *((ti_sysbios_gates_GateHwi_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_gates_GateHwi_delete(ti_sysbios_gates_GateHwi_Handle *instp) -{ - ti_sysbios_gates_GateHwi_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.gates.GateMutex SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_gates_GateMutex_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_gates_GateMutex_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_gates_GateMutex_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_gates_GateMutex_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_gates_GateMutex_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_gates_GateMutex_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_gates_GateMutex_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_gates_GateMutex_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_gates_GateMutex_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_gates_GateMutex_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_gates_GateMutex_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_gates_GateMutex_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_gates_GateMutex_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_gates_GateMutex_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_gates_GateMutex_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_gates_GateMutex_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_gates_GateMutex_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_gates_GateMutex_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_gates_GateMutex_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_gates_GateMutex_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32828; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_gates_GateMutex_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_gates_GateMutex_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_gates_GateMutex_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_gates_GateMutex_Object__ *)oa) + i; - } - - if (ti_sysbios_gates_GateMutex_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_gates_GateMutex_Object__ *)ti_sysbios_gates_GateMutex_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_gates_GateMutex_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_gates_GateMutex_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_gates_GateMutex_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_gates_GateMutex_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_gates_GateMutex_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_gates_GateMutex_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_gates_GateMutex___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_gates_GateMutex_Params __prms; - ti_sysbios_gates_GateMutex_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_gates_GateMutex_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateMutex_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_gates_GateMutex_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_gates_GateMutex_Handle ti_sysbios_gates_GateMutex_create( const ti_sysbios_gates_GateMutex_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_gates_GateMutex_Params __prms; - ti_sysbios_gates_GateMutex_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_gates_GateMutex_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateMutex_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_gates_GateMutex_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_gates_GateMutex_construct(ti_sysbios_gates_GateMutex_Struct *__obj, const ti_sysbios_gates_GateMutex_Params *__paramsPtr ) -{ - ti_sysbios_gates_GateMutex_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_gates_GateMutex_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_gates_GateMutex_Params), NULL); - /* module-specific initialization */ - ti_sysbios_gates_GateMutex_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_gates_GateMutex_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_gates_GateMutex_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_gates_GateMutex_Instance_finalize__E, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_gates_GateMutex_destruct(ti_sysbios_gates_GateMutex_Struct *obj) -{ - ti_sysbios_gates_GateMutex_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_gates_GateMutex_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_gates_GateMutex_Object__DESC__C, *((ti_sysbios_gates_GateMutex_Object**)instp), (xdc_Fxn)ti_sysbios_gates_GateMutex_Instance_finalize__E, -1, FALSE); - *((ti_sysbios_gates_GateMutex_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_gates_GateMutex_delete(ti_sysbios_gates_GateMutex_Handle *instp) -{ - ti_sysbios_gates_GateMutex_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.hal.Hwi SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_hal_Hwi_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_hal_Hwi_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_hal_Hwi_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_hal_Hwi_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_hal_Hwi_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_hal_Hwi_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_hal_Hwi_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_hal_Hwi_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_hal_Hwi_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_hal_Hwi_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_hal_Hwi_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_hal_Hwi_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_hal_Hwi_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_hal_Hwi_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_hal_Hwi_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_hal_Hwi_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_hal_Hwi_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_hal_Hwi_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_hal_Hwi_Module__startupDone__S( void ) -{ - return ti_sysbios_hal_Hwi_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_hal_Hwi_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32811; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_hal_Hwi_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_hal_Hwi_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_hal_Hwi_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_hal_Hwi_Object__ *)oa) + i; - } - - if (ti_sysbios_hal_Hwi_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_hal_Hwi_Object__ *)ti_sysbios_hal_Hwi_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_hal_Hwi_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_hal_Hwi_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_hal_Hwi_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_hal_Hwi_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_hal_Hwi_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_hal_Hwi_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_hal_Hwi___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_hal_Hwi_Args__create *__args = __aa; - ti_sysbios_hal_Hwi_Params __prms; - ti_sysbios_hal_Hwi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_hal_Hwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_hal_Hwi_Instance_init__E(__newobj, __args->intNum, __args->hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_hal_Hwi_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_hal_Hwi_Handle ti_sysbios_hal_Hwi_create( xdc_Int intNum, ti_sysbios_hal_Hwi_FuncPtr hwiFxn, const ti_sysbios_hal_Hwi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_hal_Hwi_Params __prms; - ti_sysbios_hal_Hwi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_hal_Hwi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_hal_Hwi_Instance_init__E(__newobj, intNum, hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_hal_Hwi_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_hal_Hwi_construct(ti_sysbios_hal_Hwi_Struct *__obj, xdc_Int intNum, ti_sysbios_hal_Hwi_FuncPtr hwiFxn, const ti_sysbios_hal_Hwi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_hal_Hwi_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_hal_Hwi_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_hal_Hwi_Instance_init__E((xdc_Ptr)__obj, intNum, hwiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_hal_Hwi_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_hal_Hwi_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_hal_Hwi_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_hal_Hwi_destruct(ti_sysbios_hal_Hwi_Struct *obj) -{ - ti_sysbios_hal_Hwi_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_hal_Hwi_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_hal_Hwi_Object__DESC__C, *((ti_sysbios_hal_Hwi_Object**)instp), (xdc_Fxn)ti_sysbios_hal_Hwi_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_hal_Hwi_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_hal_Hwi_delete(ti_sysbios_hal_Hwi_Handle *instp) -{ - ti_sysbios_hal_Hwi_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.hal.Hwi_HwiProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_hal_Hwi_HwiProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_hal_Hwi_HwiProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_hal_Hwi_HwiProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_hal_Hwi_HwiProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_hal_Hwi_HwiProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_hal_Hwi_HwiProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_hal_Hwi_HwiProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_hal_Hwi_HwiProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_hal_Hwi_HwiProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_hal_Hwi_HwiProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_hal_Hwi_HwiProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_hal_Hwi_HwiProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_hal_Hwi_HwiProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_hal_Hwi_HwiProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_hal_Hwi_HwiProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_hal_Hwi_HwiProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_hal_Hwi_HwiProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_hal_Hwi_HwiProxy_Module_GateProxy_query - -xdc_Bool ti_sysbios_hal_Hwi_HwiProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_hal_Hwi_HwiProxy_Proxy__delegate__S( void ) -{ - return 0; -} - - - -/* - * ======== ti.sysbios.hal.Seconds SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_hal_Seconds_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.hal.Seconds_SecondsProxy SYSTEM FUNCTIONS ======== - */ - - -xdc_Bool ti_sysbios_hal_Seconds_SecondsProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_hal_Seconds_SecondsProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_family_arm_lm4_Seconds_Module__FXNS__C; -} - - -/* - * ======== ti.sysbios.heaps.HeapMem SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_heaps_HeapMem_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_heaps_HeapMem_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_heaps_HeapMem_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_heaps_HeapMem_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_heaps_HeapMem_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_heaps_HeapMem_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_heaps_HeapMem_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_heaps_HeapMem_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_heaps_HeapMem_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_heaps_HeapMem_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_heaps_HeapMem_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_heaps_HeapMem_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_heaps_HeapMem_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_heaps_HeapMem_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_heaps_HeapMem_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_heaps_HeapMem_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_heaps_HeapMem_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_heaps_HeapMem_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_heaps_HeapMem_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_heaps_HeapMem_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32832; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_heaps_HeapMem_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_heaps_HeapMem_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_heaps_HeapMem_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_heaps_HeapMem_Object__ *)oa) + i; - } - - if (ti_sysbios_heaps_HeapMem_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_heaps_HeapMem_Object__ *)ti_sysbios_heaps_HeapMem_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_heaps_HeapMem_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_heaps_HeapMem_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_heaps_HeapMem_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_heaps_HeapMem_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_heaps_HeapMem_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_heaps_HeapMem_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_heaps_HeapMem___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_heaps_HeapMem_Params __prms; - ti_sysbios_heaps_HeapMem_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_heaps_HeapMem_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_heaps_HeapMem_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_heaps_HeapMem_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_heaps_HeapMem_Handle ti_sysbios_heaps_HeapMem_create( const ti_sysbios_heaps_HeapMem_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_heaps_HeapMem_Params __prms; - ti_sysbios_heaps_HeapMem_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_heaps_HeapMem_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_heaps_HeapMem_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_heaps_HeapMem_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_heaps_HeapMem_construct(ti_sysbios_heaps_HeapMem_Struct *__obj, const ti_sysbios_heaps_HeapMem_Params *__paramsPtr ) -{ - ti_sysbios_heaps_HeapMem_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_heaps_HeapMem_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_heaps_HeapMem_Params), NULL); - /* module-specific initialization */ - ti_sysbios_heaps_HeapMem_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_heaps_HeapMem_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_heaps_HeapMem_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_heaps_HeapMem_destruct(ti_sysbios_heaps_HeapMem_Struct *obj) -{ - ti_sysbios_heaps_HeapMem_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_heaps_HeapMem_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_heaps_HeapMem_Object__DESC__C, *((ti_sysbios_heaps_HeapMem_Object**)instp), NULL, -1, FALSE); - *((ti_sysbios_heaps_HeapMem_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_heaps_HeapMem_delete(ti_sysbios_heaps_HeapMem_Handle *instp) -{ - ti_sysbios_heaps_HeapMem_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.heaps.HeapMem_Module_GateProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_heaps_HeapMem_Module_GateProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_heaps_HeapMem_Module_GateProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_heaps_HeapMem_Module_GateProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_heaps_HeapMem_Module_GateProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_heaps_HeapMem_Module_GateProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_heaps_HeapMem_Module_GateProxy_Module_GateProxy_query - -xdc_Bool ti_sysbios_heaps_HeapMem_Module_GateProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_heaps_HeapMem_Module_GateProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_gates_GateMutex_Module__FXNS__C; -} - - - -/* - * ======== ti.sysbios.io.DEV SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_io_DEV_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_io_DEV_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_io_DEV_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_io_DEV_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_io_DEV_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_io_DEV_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_io_DEV_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_io_DEV_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_io_DEV_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_io_DEV_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_io_DEV_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_io_DEV_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_io_DEV_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_io_DEV_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_io_DEV_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_io_DEV_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_io_DEV_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_io_DEV_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_io_DEV_Module__startupDone__S( void ) -{ - return ti_sysbios_io_DEV_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_io_DEV_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32824; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_io_DEV_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_io_DEV_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_io_DEV_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_io_DEV_Object__ *)oa) + i; - } - - if (ti_sysbios_io_DEV_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_io_DEV_Object__ *)ti_sysbios_io_DEV_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_io_DEV_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_io_DEV_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_io_DEV_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_io_DEV_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_io_DEV_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_io_DEV_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_io_DEV___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_io_DEV_Args__create *__args = __aa; - ti_sysbios_io_DEV_Params __prms; - ti_sysbios_io_DEV_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_io_DEV_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_DEV_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_io_DEV_Instance_init__E(__newobj, __args->name, __args->fxns, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_DEV_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_io_DEV_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_io_DEV_Handle ti_sysbios_io_DEV_create( xdc_String name, xdc_Ptr fxns, const ti_sysbios_io_DEV_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_io_DEV_Params __prms; - ti_sysbios_io_DEV_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_io_DEV_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_DEV_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_io_DEV_Instance_init__E(__newobj, name, fxns, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_DEV_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_io_DEV_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_io_DEV_construct(ti_sysbios_io_DEV_Struct *__obj, xdc_String name, xdc_Ptr fxns, const ti_sysbios_io_DEV_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_io_DEV_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_io_DEV_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_DEV_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_io_DEV_Instance_init__E((xdc_Ptr)__obj, name, fxns, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_DEV_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_io_DEV_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_io_DEV_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_DEV_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_io_DEV_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_io_DEV_destruct(ti_sysbios_io_DEV_Struct *obj) -{ - ti_sysbios_io_DEV_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_io_DEV_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_DEV_Object__DESC__C, *((ti_sysbios_io_DEV_Object**)instp), (xdc_Fxn)ti_sysbios_io_DEV_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_io_DEV_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_io_DEV_delete(ti_sysbios_io_DEV_Handle *instp) -{ - ti_sysbios_io_DEV_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.io.GIO SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_io_GIO_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_io_GIO_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_io_GIO_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_io_GIO_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_io_GIO_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_io_GIO_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_io_GIO_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_io_GIO_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_io_GIO_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_io_GIO_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_io_GIO_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_io_GIO_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_io_GIO_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_io_GIO_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_io_GIO_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_io_GIO_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_io_GIO_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_io_GIO_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_io_GIO_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_io_GIO_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32825; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_io_GIO_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_io_GIO_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_io_GIO_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_io_GIO_Object__ *)oa) + i; - } - - if (ti_sysbios_io_GIO_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_io_GIO_Object__ *)ti_sysbios_io_GIO_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_io_GIO_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_io_GIO_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_io_GIO_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_io_GIO_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_io_GIO_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_io_GIO_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_io_GIO___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_io_GIO_Args__create *__args = __aa; - ti_sysbios_io_GIO_Params __prms; - ti_sysbios_io_GIO_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_io_GIO_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_GIO_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_io_GIO_Instance_init__E(__newobj, __args->name, __args->mode, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_GIO_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_io_GIO_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_io_GIO_Handle ti_sysbios_io_GIO_create( xdc_String name, xdc_UInt mode, const ti_sysbios_io_GIO_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_io_GIO_Params __prms; - ti_sysbios_io_GIO_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_io_GIO_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_GIO_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_io_GIO_Instance_init__E(__newobj, name, mode, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_GIO_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_io_GIO_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_io_GIO_construct(ti_sysbios_io_GIO_Struct *__obj, xdc_String name, xdc_UInt mode, const ti_sysbios_io_GIO_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_io_GIO_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_io_GIO_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_io_GIO_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_io_GIO_Instance_init__E((xdc_Ptr)__obj, name, mode, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_GIO_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_io_GIO_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_io_GIO_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_GIO_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_io_GIO_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_io_GIO_destruct(ti_sysbios_io_GIO_Struct *obj) -{ - ti_sysbios_io_GIO_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_io_GIO_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_io_GIO_Object__DESC__C, *((ti_sysbios_io_GIO_Object**)instp), (xdc_Fxn)ti_sysbios_io_GIO_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_io_GIO_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_io_GIO_delete(ti_sysbios_io_GIO_Handle *instp) -{ - ti_sysbios_io_GIO_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Clock SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Clock_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Clock_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Clock_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Clock_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Clock_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Clock_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Clock_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Clock_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Clock_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Clock_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Clock_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Clock_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Clock_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Clock_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Clock_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Clock_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Clock_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Clock_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Clock_Module__startupDone__S( void ) -{ - return ti_sysbios_knl_Clock_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Clock_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32801; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Clock_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Clock_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Clock_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Clock_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Clock_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Clock_Object__ *)ti_sysbios_knl_Clock_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Clock_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Clock_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Clock_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Clock_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Clock_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Clock_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Clock___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Clock_Args__create *__args = __aa; - ti_sysbios_knl_Clock_Params __prms; - ti_sysbios_knl_Clock_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Clock_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Clock_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Clock_Instance_init__E(__newobj, __args->clockFxn, __args->timeout, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_knl_Clock_Handle ti_sysbios_knl_Clock_create( ti_sysbios_knl_Clock_FuncPtr clockFxn, xdc_UInt timeout, const ti_sysbios_knl_Clock_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Clock_Params __prms; - ti_sysbios_knl_Clock_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Clock_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Clock_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Clock_Instance_init__E(__newobj, clockFxn, timeout, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Clock_construct(ti_sysbios_knl_Clock_Struct *__obj, ti_sysbios_knl_Clock_FuncPtr clockFxn, xdc_UInt timeout, const ti_sysbios_knl_Clock_Params *__paramsPtr ) -{ - ti_sysbios_knl_Clock_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Clock_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Clock_Params), NULL); - /* module-specific initialization */ - ti_sysbios_knl_Clock_Instance_init__E((xdc_Ptr)__obj, clockFxn, timeout, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Clock_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Clock_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_knl_Clock_Instance_finalize__E, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Clock_destruct(ti_sysbios_knl_Clock_Struct *obj) -{ - ti_sysbios_knl_Clock_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Clock_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Clock_Object__DESC__C, *((ti_sysbios_knl_Clock_Object**)instp), (xdc_Fxn)ti_sysbios_knl_Clock_Instance_finalize__E, -1, FALSE); - *((ti_sysbios_knl_Clock_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Clock_delete(ti_sysbios_knl_Clock_Handle *instp) -{ - ti_sysbios_knl_Clock_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Clock_TimerProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Clock_TimerProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Clock_TimerProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Clock_TimerProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Clock_TimerProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Clock_TimerProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Clock_TimerProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Clock_TimerProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Clock_TimerProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Clock_TimerProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Clock_TimerProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Clock_TimerProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Clock_TimerProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Clock_TimerProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Clock_TimerProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Clock_TimerProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Clock_TimerProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Clock_TimerProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Clock_TimerProxy_Module_GateProxy_query - -xdc_Bool ti_sysbios_knl_Clock_TimerProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_knl_Clock_TimerProxy_Proxy__delegate__S( void ) -{ - return 0; -} - - - -/* - * ======== ti.sysbios.knl.Event SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Event_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Event_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Event_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Event_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Event_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Event_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Event_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Event_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Event_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Event_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Event_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Event_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Event_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Event_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Event_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Event_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Event_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Event_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Event_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Event_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32804; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Event_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Event_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Event_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Event_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Event_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Event_Object__ *)ti_sysbios_knl_Event_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Event_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Event_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Event_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Event_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Event_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Event_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Event___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Event_Params __prms; - ti_sysbios_knl_Event_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Event_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Event_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Event_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_knl_Event_Handle ti_sysbios_knl_Event_create( const ti_sysbios_knl_Event_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Event_Params __prms; - ti_sysbios_knl_Event_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Event_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Event_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Event_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Event_construct(ti_sysbios_knl_Event_Struct *__obj, const ti_sysbios_knl_Event_Params *__paramsPtr ) -{ - ti_sysbios_knl_Event_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Event_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Event_Params), NULL); - /* module-specific initialization */ - ti_sysbios_knl_Event_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Event_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Event_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Event_destruct(ti_sysbios_knl_Event_Struct *obj) -{ - ti_sysbios_knl_Event_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Event_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Event_Object__DESC__C, *((ti_sysbios_knl_Event_Object**)instp), NULL, -1, FALSE); - *((ti_sysbios_knl_Event_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Event_delete(ti_sysbios_knl_Event_Handle *instp) -{ - ti_sysbios_knl_Event_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Idle SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Idle_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.knl.Intrinsics SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Intrinsics_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== ti.sysbios.knl.Intrinsics_SupportProxy SYSTEM FUNCTIONS ======== - */ - - -xdc_Bool ti_sysbios_knl_Intrinsics_SupportProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_knl_Intrinsics_SupportProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_family_arm_m3_IntrinsicsSupport_Module__FXNS__C; -} - - -/* - * ======== ti.sysbios.knl.Mailbox SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Mailbox_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Mailbox_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Mailbox_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Mailbox_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Mailbox_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Mailbox_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Mailbox_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Mailbox_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Mailbox_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Mailbox_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Mailbox_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Mailbox_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Mailbox_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Mailbox_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Mailbox_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Mailbox_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Mailbox_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Mailbox_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Mailbox_Module__startupDone__S( void ) -{ - return ti_sysbios_knl_Mailbox_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Mailbox_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32805; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Mailbox_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Mailbox_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Mailbox_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Mailbox_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Mailbox_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Mailbox_Object__ *)ti_sysbios_knl_Mailbox_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Mailbox_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Mailbox_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Mailbox_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Mailbox_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Mailbox_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Mailbox_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Mailbox___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Mailbox_Args__create *__args = __aa; - ti_sysbios_knl_Mailbox_Params __prms; - ti_sysbios_knl_Mailbox_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Mailbox_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Mailbox_Instance_init__E(__newobj, __args->msgSize, __args->numMsgs, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Mailbox_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_knl_Mailbox_Handle ti_sysbios_knl_Mailbox_create( xdc_SizeT msgSize, xdc_UInt numMsgs, const ti_sysbios_knl_Mailbox_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Mailbox_Params __prms; - ti_sysbios_knl_Mailbox_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Mailbox_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Mailbox_Instance_init__E(__newobj, msgSize, numMsgs, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Mailbox_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Mailbox_construct(ti_sysbios_knl_Mailbox_Struct *__obj, xdc_SizeT msgSize, xdc_UInt numMsgs, const ti_sysbios_knl_Mailbox_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Mailbox_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Mailbox_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_knl_Mailbox_Instance_init__E((xdc_Ptr)__obj, msgSize, numMsgs, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_knl_Mailbox_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Mailbox_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_knl_Mailbox_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Mailbox_destruct(ti_sysbios_knl_Mailbox_Struct *obj) -{ - ti_sysbios_knl_Mailbox_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Mailbox_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Mailbox_Object__DESC__C, *((ti_sysbios_knl_Mailbox_Object**)instp), (xdc_Fxn)ti_sysbios_knl_Mailbox_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_knl_Mailbox_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Mailbox_delete(ti_sysbios_knl_Mailbox_Handle *instp) -{ - ti_sysbios_knl_Mailbox_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Queue SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Queue_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Queue_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Queue_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Queue_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Queue_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Queue_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Queue_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Queue_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Queue_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Queue_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Queue_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Queue_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Queue_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Queue_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Queue_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Queue_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Queue_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Queue_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Queue_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Queue_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32806; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Queue_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Queue_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Queue_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Queue_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Queue_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Queue_Object__ *)ti_sysbios_knl_Queue_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Queue_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Queue_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Queue_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Queue_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Queue_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Queue_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Queue___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Queue_Params __prms; - ti_sysbios_knl_Queue_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Queue_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Queue_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Queue_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_knl_Queue_Handle ti_sysbios_knl_Queue_create( const ti_sysbios_knl_Queue_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Queue_Params __prms; - ti_sysbios_knl_Queue_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Queue_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Queue_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Queue_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Queue_construct(ti_sysbios_knl_Queue_Struct *__obj, const ti_sysbios_knl_Queue_Params *__paramsPtr ) -{ - ti_sysbios_knl_Queue_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Queue_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Queue_Params), NULL); - /* module-specific initialization */ - ti_sysbios_knl_Queue_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Queue_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Queue_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Queue_destruct(ti_sysbios_knl_Queue_Struct *obj) -{ - ti_sysbios_knl_Queue_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Queue_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Queue_Object__DESC__C, *((ti_sysbios_knl_Queue_Object**)instp), NULL, -1, FALSE); - *((ti_sysbios_knl_Queue_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Queue_delete(ti_sysbios_knl_Queue_Handle *instp) -{ - ti_sysbios_knl_Queue_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Semaphore SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Semaphore_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Semaphore_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Semaphore_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Semaphore_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Semaphore_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Semaphore_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Semaphore_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Semaphore_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Semaphore_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Semaphore_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Semaphore_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Semaphore_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Semaphore_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Semaphore_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Semaphore_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Semaphore_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Semaphore_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Semaphore_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Semaphore_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Semaphore_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32807; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Semaphore_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Semaphore_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Semaphore_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Semaphore_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Semaphore_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Semaphore_Object__ *)ti_sysbios_knl_Semaphore_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Semaphore_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Semaphore_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Semaphore_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Semaphore_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Semaphore_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Semaphore_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Semaphore___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Semaphore_Args__create *__args = __aa; - ti_sysbios_knl_Semaphore_Params __prms; - ti_sysbios_knl_Semaphore_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Semaphore_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Semaphore_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Semaphore_Instance_init__E(__newobj, __args->count, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_knl_Semaphore_Handle ti_sysbios_knl_Semaphore_create( xdc_Int count, const ti_sysbios_knl_Semaphore_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Semaphore_Params __prms; - ti_sysbios_knl_Semaphore_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Semaphore_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Semaphore_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_knl_Semaphore_Instance_init__E(__newobj, count, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Semaphore_construct(ti_sysbios_knl_Semaphore_Struct *__obj, xdc_Int count, const ti_sysbios_knl_Semaphore_Params *__paramsPtr ) -{ - ti_sysbios_knl_Semaphore_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Semaphore_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Semaphore_Params), NULL); - /* module-specific initialization */ - ti_sysbios_knl_Semaphore_Instance_init__E((xdc_Ptr)__obj, count, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Semaphore_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Semaphore_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_knl_Semaphore_Instance_finalize__E, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Semaphore_destruct(ti_sysbios_knl_Semaphore_Struct *obj) -{ - ti_sysbios_knl_Semaphore_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Semaphore_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Semaphore_Object__DESC__C, *((ti_sysbios_knl_Semaphore_Object**)instp), (xdc_Fxn)ti_sysbios_knl_Semaphore_Instance_finalize__E, -1, FALSE); - *((ti_sysbios_knl_Semaphore_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Semaphore_delete(ti_sysbios_knl_Semaphore_Handle *instp) -{ - ti_sysbios_knl_Semaphore_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Swi SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Swi_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Swi_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Swi_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Swi_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Swi_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Swi_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Swi_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Swi_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Swi_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Swi_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Swi_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Swi_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Swi_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Swi_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Swi_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Swi_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Swi_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Swi_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Swi_Module__startupDone__S( void ) -{ - return ti_sysbios_knl_Swi_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Swi_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32808; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Swi_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Swi_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Swi_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Swi_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Swi_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Swi_Object__ *)ti_sysbios_knl_Swi_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Swi_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Swi_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Swi_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Swi_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Swi_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Swi_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Swi___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Swi_Args__create *__args = __aa; - ti_sysbios_knl_Swi_Params __prms; - ti_sysbios_knl_Swi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Swi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Swi_Instance_init__E(__newobj, __args->swiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Swi_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_knl_Swi_Handle ti_sysbios_knl_Swi_create( ti_sysbios_knl_Swi_FuncPtr swiFxn, const ti_sysbios_knl_Swi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Swi_Params __prms; - ti_sysbios_knl_Swi_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Swi_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Swi_Instance_init__E(__newobj, swiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Swi_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Swi_construct(ti_sysbios_knl_Swi_Struct *__obj, ti_sysbios_knl_Swi_FuncPtr swiFxn, const ti_sysbios_knl_Swi_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Swi_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Swi_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_knl_Swi_Instance_init__E((xdc_Ptr)__obj, swiFxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_knl_Swi_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Swi_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_knl_Swi_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Swi_destruct(ti_sysbios_knl_Swi_Struct *obj) -{ - ti_sysbios_knl_Swi_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Swi_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Swi_Object__DESC__C, *((ti_sysbios_knl_Swi_Object**)instp), (xdc_Fxn)ti_sysbios_knl_Swi_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_knl_Swi_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Swi_delete(ti_sysbios_knl_Swi_Handle *instp) -{ - ti_sysbios_knl_Swi_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Task SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_knl_Task_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_knl_Task_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_knl_Task_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_knl_Task_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_knl_Task_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_knl_Task_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_knl_Task_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_knl_Task_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_knl_Task_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_knl_Task_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_knl_Task_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_knl_Task_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_knl_Task_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_knl_Task_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_knl_Task_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_knl_Task_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_knl_Task_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_knl_Task_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_knl_Task_Module__startupDone__S( void ) -{ - return ti_sysbios_knl_Task_Module__startupDone__F(); -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_knl_Task_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32809; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_knl_Task_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_knl_Task_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_knl_Task_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_knl_Task_Object__ *)oa) + i; - } - - if (ti_sysbios_knl_Task_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_knl_Task_Object__ *)ti_sysbios_knl_Task_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_knl_Task_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_knl_Task_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_knl_Task_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_knl_Task_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_knl_Task_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_knl_Task_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_knl_Task___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_knl_Task_Args__create *__args = __aa; - ti_sysbios_knl_Task_Params __prms; - ti_sysbios_knl_Task_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Task_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Task_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Task_Instance_init__E(__newobj, __args->fxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Task_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Task_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -ti_sysbios_knl_Task_Handle ti_sysbios_knl_Task_create( ti_sysbios_knl_Task_FuncPtr fxn, const ti_sysbios_knl_Task_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Task_Params __prms; - ti_sysbios_knl_Task_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_knl_Task_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Task_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = ti_sysbios_knl_Task_Instance_init__E(__newobj, fxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Task_Object__DESC__C, __newobj, (xdc_Fxn)ti_sysbios_knl_Task_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void ti_sysbios_knl_Task_construct(ti_sysbios_knl_Task_Struct *__obj, ti_sysbios_knl_Task_FuncPtr fxn, const ti_sysbios_knl_Task_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_knl_Task_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_knl_Task_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_knl_Task_Params), __eb); - /* module-specific initialization */ - iStat = ti_sysbios_knl_Task_Instance_init__E((xdc_Ptr)__obj, fxn, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Task_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)ti_sysbios_knl_Task_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_knl_Task_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Task_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_knl_Task_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void ti_sysbios_knl_Task_destruct(ti_sysbios_knl_Task_Struct *obj) -{ - ti_sysbios_knl_Task_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_knl_Task_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_knl_Task_Object__DESC__C, *((ti_sysbios_knl_Task_Object**)instp), (xdc_Fxn)ti_sysbios_knl_Task_Instance_finalize__E, 0, FALSE); - *((ti_sysbios_knl_Task_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_knl_Task_delete(ti_sysbios_knl_Task_Handle *instp) -{ - ti_sysbios_knl_Task_Object__delete__S(instp); -} - - -/* - * ======== ti.sysbios.knl.Task_SupportProxy SYSTEM FUNCTIONS ======== - */ - - -xdc_Bool ti_sysbios_knl_Task_SupportProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr ti_sysbios_knl_Task_SupportProxy_Proxy__delegate__S( void ) -{ - return 0; -} - - -/* - * ======== ti.sysbios.xdcruntime.SemThreadSupport SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID ti_sysbios_xdcruntime_SemThreadSupport_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK ti_sysbios_xdcruntime_SemThreadSupport_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 ti_sysbios_xdcruntime_SemThreadSupport_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ ti_sysbios_xdcruntime_SemThreadSupport_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS ti_sysbios_xdcruntime_SemThreadSupport_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create ti_sysbios_xdcruntime_SemThreadSupport_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete ti_sysbios_xdcruntime_SemThreadSupport_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter ti_sysbios_xdcruntime_SemThreadSupport_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave ti_sysbios_xdcruntime_SemThreadSupport_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query ti_sysbios_xdcruntime_SemThreadSupport_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool ti_sysbios_xdcruntime_SemThreadSupport_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *ti_sysbios_xdcruntime_SemThreadSupport_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32830; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void ti_sysbios_xdcruntime_SemThreadSupport_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &ti_sysbios_xdcruntime_SemThreadSupport_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr ti_sysbios_xdcruntime_SemThreadSupport_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((ti_sysbios_xdcruntime_SemThreadSupport_Object__ *)oa) + i; - } - - if (ti_sysbios_xdcruntime_SemThreadSupport_Object__count__C == 0) { - return NULL; - } - - return ((ti_sysbios_xdcruntime_SemThreadSupport_Object__ *)ti_sysbios_xdcruntime_SemThreadSupport_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr ti_sysbios_xdcruntime_SemThreadSupport_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr ti_sysbios_xdcruntime_SemThreadSupport_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&ti_sysbios_xdcruntime_SemThreadSupport_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr ti_sysbios_xdcruntime_SemThreadSupport_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const ti_sysbios_xdcruntime_SemThreadSupport___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Args__create *__args = __aa; - ti_sysbios_xdcruntime_SemThreadSupport_Params __prms; - ti_sysbios_xdcruntime_SemThreadSupport_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_xdcruntime_SemThreadSupport_Instance_init__E(__newobj, __args->count, &__prms); - return __newobj; -} - -/* create */ -ti_sysbios_xdcruntime_SemThreadSupport_Handle ti_sysbios_xdcruntime_SemThreadSupport_create( xdc_Int count, const ti_sysbios_xdcruntime_SemThreadSupport_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Params __prms; - ti_sysbios_xdcruntime_SemThreadSupport_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - ti_sysbios_xdcruntime_SemThreadSupport_Instance_init__E(__newobj, count, &__prms); - return __newobj; -} - -/* construct */ -void ti_sysbios_xdcruntime_SemThreadSupport_construct(ti_sysbios_xdcruntime_SemThreadSupport_Struct *__obj, xdc_Int count, const ti_sysbios_xdcruntime_SemThreadSupport_Params *__paramsPtr ) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(ti_sysbios_xdcruntime_SemThreadSupport_Params), NULL); - /* module-specific initialization */ - ti_sysbios_xdcruntime_SemThreadSupport_Instance_init__E((xdc_Ptr)__obj, count, &__prms); -} - -/* Object__destruct__S */ -xdc_Void ti_sysbios_xdcruntime_SemThreadSupport_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, obj, (xdc_Fxn)ti_sysbios_xdcruntime_SemThreadSupport_Instance_finalize__E, -1, TRUE); -} - -/* destruct */ -void ti_sysbios_xdcruntime_SemThreadSupport_destruct(ti_sysbios_xdcruntime_SemThreadSupport_Struct *obj) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void ti_sysbios_xdcruntime_SemThreadSupport_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&ti_sysbios_xdcruntime_SemThreadSupport_Object__DESC__C, *((ti_sysbios_xdcruntime_SemThreadSupport_Object**)instp), (xdc_Fxn)ti_sysbios_xdcruntime_SemThreadSupport_Instance_finalize__E, -1, FALSE); - *((ti_sysbios_xdcruntime_SemThreadSupport_Handle*)instp) = NULL; -} - -/* delete */ -void ti_sysbios_xdcruntime_SemThreadSupport_delete(ti_sysbios_xdcruntime_SemThreadSupport_Handle *instp) -{ - ti_sysbios_xdcruntime_SemThreadSupport_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.Assert SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Assert_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Core SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Core_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Defaults SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Defaults_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Diags SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Diags_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Error SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Error_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Gate SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Gate_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.HeapStd SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_HeapStd_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_HeapStd_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_HeapStd_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_HeapStd_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_HeapStd_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_HeapStd_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_HeapStd_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_HeapStd_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_HeapStd_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_HeapStd_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_HeapStd_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_HeapStd_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_HeapStd_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_HeapStd_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_HeapStd_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_HeapStd_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_HeapStd_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_HeapStd_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_HeapStd_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_HeapStd_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32779; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void xdc_runtime_HeapStd_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &xdc_runtime_HeapStd_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr xdc_runtime_HeapStd_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((xdc_runtime_HeapStd_Object__ *)oa) + i; - } - - if (xdc_runtime_HeapStd_Object__count__C == 0) { - return NULL; - } - - return ((xdc_runtime_HeapStd_Object__ *)xdc_runtime_HeapStd_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr xdc_runtime_HeapStd_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)xdc_runtime_HeapStd_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&xdc_runtime_HeapStd_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr xdc_runtime_HeapStd_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&xdc_runtime_HeapStd_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_HeapStd_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_HeapStd___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - xdc_runtime_HeapStd_Params __prms; - xdc_runtime_HeapStd_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_HeapStd_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_HeapStd_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_HeapStd_Instance_init__E(__newobj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_HeapStd_Object__DESC__C, __newobj, NULL, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -xdc_runtime_HeapStd_Handle xdc_runtime_HeapStd_create( const xdc_runtime_HeapStd_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_HeapStd_Params __prms; - xdc_runtime_HeapStd_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_HeapStd_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_HeapStd_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_HeapStd_Instance_init__E(__newobj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_HeapStd_Object__DESC__C, __newobj, NULL, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void xdc_runtime_HeapStd_construct(xdc_runtime_HeapStd_Struct *__obj, const xdc_runtime_HeapStd_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_HeapStd_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&xdc_runtime_HeapStd_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_HeapStd_Params), __eb); - /* module-specific initialization */ - iStat = xdc_runtime_HeapStd_Instance_init__E((xdc_Ptr)__obj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_HeapStd_Object__DESC__C, (xdc_Ptr)__obj, NULL, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void xdc_runtime_HeapStd_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_HeapStd_Object__DESC__C, obj, NULL, 0, TRUE); -} - -/* destruct */ -void xdc_runtime_HeapStd_destruct(xdc_runtime_HeapStd_Struct *obj) -{ - xdc_runtime_HeapStd_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void xdc_runtime_HeapStd_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_HeapStd_Object__DESC__C, *((xdc_runtime_HeapStd_Object**)instp), NULL, 0, FALSE); - *((xdc_runtime_HeapStd_Handle*)instp) = NULL; -} - -/* delete */ -void xdc_runtime_HeapStd_delete(xdc_runtime_HeapStd_Handle *instp) -{ - xdc_runtime_HeapStd_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.Log SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Log_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Main SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Main_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Main_Module_GateProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_Main_Module_GateProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_Main_Module_GateProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_Main_Module_GateProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_Main_Module_GateProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_Main_Module_GateProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_Main_Module_GateProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_Main_Module_GateProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_Main_Module_GateProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_Main_Module_GateProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_Main_Module_GateProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_Main_Module_GateProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_Main_Module_GateProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_Main_Module_GateProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_Main_Module_GateProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_Main_Module_GateProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_Main_Module_GateProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_Main_Module_GateProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_Main_Module_GateProxy_Module_GateProxy_query - -xdc_Bool xdc_runtime_Main_Module_GateProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr xdc_runtime_Main_Module_GateProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_gates_GateHwi_Module__FXNS__C; -} - - - -/* - * ======== xdc.runtime.Memory SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Memory_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Memory_HeapProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_Memory_HeapProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_Memory_HeapProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_Memory_HeapProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_Memory_HeapProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_Memory_HeapProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_Memory_HeapProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_Memory_HeapProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_Memory_HeapProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_Memory_HeapProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_Memory_HeapProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_Memory_HeapProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_Memory_HeapProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_Memory_HeapProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_Memory_HeapProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_Memory_HeapProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_Memory_HeapProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_Memory_HeapProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_Memory_HeapProxy_Module_GateProxy_query - -xdc_Bool xdc_runtime_Memory_HeapProxy_Proxy__abstract__S( void ) -{ - return 1; -} -xdc_Ptr xdc_runtime_Memory_HeapProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_heaps_HeapMem_Module__FXNS__C; -} - - - -/* - * ======== xdc.runtime.Registry SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Registry_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Startup SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Startup_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.SysMin SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_SysMin_Module__startupDone__S( void ) -{ - return xdc_runtime_SysMin_Module__startupDone__F(); -} - - - -/* - * ======== xdc.runtime.System SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_System_Module__startupDone__S( void ) -{ - return xdc_runtime_System_Module__startupDone__F(); -} - - - -/* - * ======== xdc.runtime.System_Module_GateProxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_System_Module_GateProxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_System_Module_GateProxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_System_Module_GateProxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_System_Module_GateProxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_System_Module_GateProxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_System_Module_GateProxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_System_Module_GateProxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_System_Module_GateProxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_System_Module_GateProxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_System_Module_GateProxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_System_Module_GateProxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_System_Module_GateProxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_System_Module_GateProxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_System_Module_GateProxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_System_Module_GateProxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_System_Module_GateProxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_System_Module_GateProxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_System_Module_GateProxy_Module_GateProxy_query - -xdc_Bool xdc_runtime_System_Module_GateProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr xdc_runtime_System_Module_GateProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&ti_sysbios_gates_GateHwi_Module__FXNS__C; -} - - - -/* - * ======== xdc.runtime.System_SupportProxy SYSTEM FUNCTIONS ======== - */ - - -xdc_Bool xdc_runtime_System_SupportProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr xdc_runtime_System_SupportProxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&xdc_runtime_SysMin_Module__FXNS__C; -} - - -/* - * ======== xdc.runtime.Text SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Text_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Timestamp SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_Timestamp_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.Timestamp_SupportProxy SYSTEM FUNCTIONS ======== - */ - - -xdc_Bool xdc_runtime_Timestamp_SupportProxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr xdc_runtime_Timestamp_SupportProxy_Proxy__delegate__S( void ) -{ - return 0; -} - - -/* - * ======== xdc.runtime.knl.SemThread SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_SemThread_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_SemThread_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_SemThread_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_SemThread_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_SemThread_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_SemThread_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_SemThread_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_SemThread_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_SemThread_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_SemThread_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_SemThread_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_SemThread_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_SemThread_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_SemThread_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_SemThread_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_SemThread_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_SemThread_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_SemThread_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_SemThread_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_SemThread_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32819; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void xdc_runtime_knl_SemThread_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &xdc_runtime_knl_SemThread_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr xdc_runtime_knl_SemThread_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((xdc_runtime_knl_SemThread_Object__ *)oa) + i; - } - - if (xdc_runtime_knl_SemThread_Object__count__C == 0) { - return NULL; - } - - return ((xdc_runtime_knl_SemThread_Object__ *)xdc_runtime_knl_SemThread_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr xdc_runtime_knl_SemThread_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)xdc_runtime_knl_SemThread_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&xdc_runtime_knl_SemThread_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr xdc_runtime_knl_SemThread_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&xdc_runtime_knl_SemThread_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_SemThread_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_SemThread___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - xdc_runtime_knl_SemThread_Args__create *__args = __aa; - xdc_runtime_knl_SemThread_Params __prms; - xdc_runtime_knl_SemThread_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SemThread_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_knl_SemThread_Instance_init__E(__newobj, __args->count, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, __newobj, (xdc_Fxn)xdc_runtime_knl_SemThread_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -xdc_runtime_knl_SemThread_Handle xdc_runtime_knl_SemThread_create( xdc_Int count, const xdc_runtime_knl_SemThread_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SemThread_Params __prms; - xdc_runtime_knl_SemThread_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SemThread_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_knl_SemThread_Instance_init__E(__newobj, count, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, __newobj, (xdc_Fxn)xdc_runtime_knl_SemThread_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void xdc_runtime_knl_SemThread_construct(xdc_runtime_knl_SemThread_Struct *__obj, xdc_Int count, const xdc_runtime_knl_SemThread_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SemThread_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SemThread_Params), __eb); - /* module-specific initialization */ - iStat = xdc_runtime_knl_SemThread_Instance_init__E((xdc_Ptr)__obj, count, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)xdc_runtime_knl_SemThread_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void xdc_runtime_knl_SemThread_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, obj, (xdc_Fxn)xdc_runtime_knl_SemThread_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void xdc_runtime_knl_SemThread_destruct(xdc_runtime_knl_SemThread_Struct *obj) -{ - xdc_runtime_knl_SemThread_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void xdc_runtime_knl_SemThread_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SemThread_Object__DESC__C, *((xdc_runtime_knl_SemThread_Object**)instp), (xdc_Fxn)xdc_runtime_knl_SemThread_Instance_finalize__E, 0, FALSE); - *((xdc_runtime_knl_SemThread_Handle*)instp) = NULL; -} - -/* delete */ -void xdc_runtime_knl_SemThread_delete(xdc_runtime_knl_SemThread_Handle *instp) -{ - xdc_runtime_knl_SemThread_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.knl.SemThread_Proxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_SemThread_Proxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_SemThread_Proxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_SemThread_Proxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_SemThread_Proxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_SemThread_Proxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_SemThread_Proxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_SemThread_Proxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_SemThread_Proxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_SemThread_Proxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_SemThread_Proxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_SemThread_Proxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_SemThread_Proxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_SemThread_Proxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_SemThread_Proxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_SemThread_Proxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_SemThread_Proxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_SemThread_Proxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_SemThread_Proxy_Module_GateProxy_query - -xdc_Bool xdc_runtime_knl_SemThread_Proxy_Proxy__abstract__S( void ) -{ - return 0; -} -xdc_Ptr xdc_runtime_knl_SemThread_Proxy_Proxy__delegate__S( void ) -{ - return 0; -} - - - -/* - * ======== xdc.runtime.knl.Sync SYSTEM FUNCTIONS ======== - */ - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_Sync_Module__startupDone__S( void ) -{ - return 1; -} - - - -/* - * ======== xdc.runtime.knl.SyncGeneric SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_SyncGeneric_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_SyncGeneric_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_SyncGeneric_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_SyncGeneric_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_SyncGeneric_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_SyncGeneric_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_SyncGeneric_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_SyncGeneric_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_SyncGeneric_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_SyncGeneric_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_SyncGeneric_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_SyncGeneric_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_SyncGeneric_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_SyncGeneric_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_SyncGeneric_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_SyncGeneric_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_SyncGeneric_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_SyncGeneric_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_SyncGeneric_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_SyncGeneric_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32820; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void xdc_runtime_knl_SyncGeneric_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &xdc_runtime_knl_SyncGeneric_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr xdc_runtime_knl_SyncGeneric_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((xdc_runtime_knl_SyncGeneric_Object__ *)oa) + i; - } - - if (xdc_runtime_knl_SyncGeneric_Object__count__C == 0) { - return NULL; - } - - return ((xdc_runtime_knl_SyncGeneric_Object__ *)xdc_runtime_knl_SyncGeneric_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr xdc_runtime_knl_SyncGeneric_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)xdc_runtime_knl_SyncGeneric_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&xdc_runtime_knl_SyncGeneric_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr xdc_runtime_knl_SyncGeneric_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&xdc_runtime_knl_SyncGeneric_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_SyncGeneric_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_SyncGeneric___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - xdc_runtime_knl_SyncGeneric_Params __prms; - xdc_runtime_knl_SyncGeneric_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncGeneric_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncGeneric_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - xdc_runtime_knl_SyncGeneric_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* create */ -xdc_runtime_knl_SyncGeneric_Handle xdc_runtime_knl_SyncGeneric_create( const xdc_runtime_knl_SyncGeneric_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SyncGeneric_Params __prms; - xdc_runtime_knl_SyncGeneric_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncGeneric_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncGeneric_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - xdc_runtime_knl_SyncGeneric_Instance_init__E(__newobj, &__prms); - return __newobj; -} - -/* construct */ -void xdc_runtime_knl_SyncGeneric_construct(xdc_runtime_knl_SyncGeneric_Struct *__obj, const xdc_runtime_knl_SyncGeneric_Params *__paramsPtr ) -{ - xdc_runtime_knl_SyncGeneric_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&xdc_runtime_knl_SyncGeneric_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncGeneric_Params), NULL); - /* module-specific initialization */ - xdc_runtime_knl_SyncGeneric_Instance_init__E((xdc_Ptr)__obj, &__prms); -} - -/* Object__destruct__S */ -xdc_Void xdc_runtime_knl_SyncGeneric_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncGeneric_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void xdc_runtime_knl_SyncGeneric_destruct(xdc_runtime_knl_SyncGeneric_Struct *obj) -{ - xdc_runtime_knl_SyncGeneric_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void xdc_runtime_knl_SyncGeneric_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncGeneric_Object__DESC__C, *((xdc_runtime_knl_SyncGeneric_Object**)instp), NULL, -1, FALSE); - *((xdc_runtime_knl_SyncGeneric_Handle*)instp) = NULL; -} - -/* delete */ -void xdc_runtime_knl_SyncGeneric_delete(xdc_runtime_knl_SyncGeneric_Handle *instp) -{ - xdc_runtime_knl_SyncGeneric_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.knl.SyncNull SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_SyncNull_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_SyncNull_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_SyncNull_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_SyncNull_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_SyncNull_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_SyncNull_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_SyncNull_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_SyncNull_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_SyncNull_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_SyncNull_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_SyncNull_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_SyncNull_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_SyncNull_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_SyncNull_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_SyncNull_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_SyncNull_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_SyncNull_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_SyncNull_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_SyncNull_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_SyncNull_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32821; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void xdc_runtime_knl_SyncNull_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &xdc_runtime_knl_SyncNull_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr xdc_runtime_knl_SyncNull_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((xdc_runtime_knl_SyncNull_Object__ *)oa) + i; - } - - if (xdc_runtime_knl_SyncNull_Object__count__C == 0) { - return NULL; - } - - return ((xdc_runtime_knl_SyncNull_Object__ *)xdc_runtime_knl_SyncNull_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr xdc_runtime_knl_SyncNull_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)xdc_runtime_knl_SyncNull_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&xdc_runtime_knl_SyncNull_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr xdc_runtime_knl_SyncNull_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&xdc_runtime_knl_SyncNull_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_SyncNull_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_SyncNull___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - xdc_runtime_knl_SyncNull_Params __prms; - xdc_runtime_knl_SyncNull_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncNull_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncNull_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - return __newobj; -} - -/* create */ -xdc_runtime_knl_SyncNull_Handle xdc_runtime_knl_SyncNull_create( const xdc_runtime_knl_SyncNull_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SyncNull_Params __prms; - xdc_runtime_knl_SyncNull_Object *__newobj; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncNull_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncNull_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - return __newobj; -} - -/* construct */ -void xdc_runtime_knl_SyncNull_construct(xdc_runtime_knl_SyncNull_Struct *__obj, const xdc_runtime_knl_SyncNull_Params *__paramsPtr ) -{ - xdc_runtime_knl_SyncNull_Params __prms; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&xdc_runtime_knl_SyncNull_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncNull_Params), NULL); -} - -/* Object__destruct__S */ -xdc_Void xdc_runtime_knl_SyncNull_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncNull_Object__DESC__C, obj, NULL, -1, TRUE); -} - -/* destruct */ -void xdc_runtime_knl_SyncNull_destruct(xdc_runtime_knl_SyncNull_Struct *obj) -{ - xdc_runtime_knl_SyncNull_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void xdc_runtime_knl_SyncNull_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncNull_Object__DESC__C, *((xdc_runtime_knl_SyncNull_Object**)instp), NULL, -1, FALSE); - *((xdc_runtime_knl_SyncNull_Handle*)instp) = NULL; -} - -/* delete */ -void xdc_runtime_knl_SyncNull_delete(xdc_runtime_knl_SyncNull_Handle *instp) -{ - xdc_runtime_knl_SyncNull_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.knl.SyncSemThread SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_SyncSemThread_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_SyncSemThread_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_SyncSemThread_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_SyncSemThread_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_SyncSemThread_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_SyncSemThread_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_SyncSemThread_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_SyncSemThread_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_SyncSemThread_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_SyncSemThread_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_SyncSemThread_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_SyncSemThread_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_SyncSemThread_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_SyncSemThread_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_SyncSemThread_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_SyncSemThread_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_SyncSemThread_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_SyncSemThread_Module_GateProxy_query - -/* Module__startupDone__S */ -xdc_Bool xdc_runtime_knl_SyncSemThread_Module__startupDone__S( void ) -{ - return 1; -} - -/* Handle__label__S */ -xdc_runtime_Types_Label *xdc_runtime_knl_SyncSemThread_Handle__label__S(xdc_Ptr obj, xdc_runtime_Types_Label *lab) -{ - lab->handle = obj; - lab->modId = 32822; - xdc_runtime_Core_assignLabel(lab, 0, 0); - - return lab; -} - -/* Params__init__S */ -xdc_Void xdc_runtime_knl_SyncSemThread_Params__init__S( xdc_Ptr prms, const void *src, xdc_SizeT psz, xdc_SizeT isz ) -{ - xdc_runtime_Core_assignParams__I(prms, (xdc_Ptr)(src ? src : &xdc_runtime_knl_SyncSemThread_Object__PARAMS__C), psz, isz); -} - -/* Object__get__S */ -xdc_Ptr xdc_runtime_knl_SyncSemThread_Object__get__S(xdc_Ptr oa, xdc_Int i) -{ - if (oa) { - return ((xdc_runtime_knl_SyncSemThread_Object__ *)oa) + i; - } - - if (xdc_runtime_knl_SyncSemThread_Object__count__C == 0) { - return NULL; - } - - return ((xdc_runtime_knl_SyncSemThread_Object__ *)xdc_runtime_knl_SyncSemThread_Object__table__C) + i; -} - -/* Object__first__S */ -xdc_Ptr xdc_runtime_knl_SyncSemThread_Object__first__S( void ) -{ - xdc_runtime_Types_InstHdr *iHdr = (xdc_runtime_Types_InstHdr *)xdc_runtime_knl_SyncSemThread_Module__root__V.link.next; - - if (iHdr != (xdc_runtime_Types_InstHdr *)&xdc_runtime_knl_SyncSemThread_Module__root__V.link) { - return iHdr + 1; - } - else { - return NULL; - } -} - -/* Object__next__S */ -xdc_Ptr xdc_runtime_knl_SyncSemThread_Object__next__S( xdc_Ptr obj ) -{ - xdc_runtime_Types_InstHdr *iHdr = ((xdc_runtime_Types_InstHdr *)obj) - 1; - - if (iHdr->link.next != (xdc_runtime_Types_Link *)&xdc_runtime_knl_SyncSemThread_Module__root__V.link) { - return (xdc_runtime_Types_InstHdr *)(iHdr->link.next) + 1; - } - else { - return NULL; - } -} - -/* Object__create__S */ -xdc_Ptr xdc_runtime_knl_SyncSemThread_Object__create__S ( - xdc_Ptr __obj, - xdc_SizeT __osz, - const xdc_Ptr __aa, - const xdc_runtime_knl_SyncSemThread___ParamsPtr __paramsPtr, - xdc_SizeT __psz, - xdc_runtime_Error_Block *__eb) -{ - xdc_runtime_knl_SyncSemThread_Params __prms; - xdc_runtime_knl_SyncSemThread_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncSemThread_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_knl_SyncSemThread_Instance_init__E(__newobj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, __newobj, (xdc_Fxn)xdc_runtime_knl_SyncSemThread_Instance_finalize__E, iStat, (xdc_Bool)(__obj != NULL)); - return NULL; - } - - return __newobj; -} - -/* create */ -xdc_runtime_knl_SyncSemThread_Handle xdc_runtime_knl_SyncSemThread_create( const xdc_runtime_knl_SyncSemThread_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SyncSemThread_Params __prms; - xdc_runtime_knl_SyncSemThread_Object *__newobj; - int iStat; - - /* common instance initialization */ - __newobj = xdc_runtime_Core_createObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, 0, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncSemThread_Params), __eb); - if (__newobj == NULL) { - return NULL; - } - - /* module-specific initialization */ - iStat = xdc_runtime_knl_SyncSemThread_Instance_init__E(__newobj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, __newobj, (xdc_Fxn)xdc_runtime_knl_SyncSemThread_Instance_finalize__E, iStat, 0); - return NULL; - } - - return __newobj; -} - -/* construct */ -void xdc_runtime_knl_SyncSemThread_construct(xdc_runtime_knl_SyncSemThread_Struct *__obj, const xdc_runtime_knl_SyncSemThread_Params *__paramsPtr, xdc_runtime_Error_Block *__eb ) -{ - xdc_runtime_knl_SyncSemThread_Params __prms; - int iStat; - - /* common instance initialization */ - xdc_runtime_Core_constructObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, __obj, &__prms, (xdc_Ptr)__paramsPtr, sizeof(xdc_runtime_knl_SyncSemThread_Params), __eb); - /* module-specific initialization */ - iStat = xdc_runtime_knl_SyncSemThread_Instance_init__E((xdc_Ptr)__obj, &__prms, __eb); - if (xdc_runtime_Error_check(__eb)) { - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, (xdc_Ptr)__obj, (xdc_Fxn)xdc_runtime_knl_SyncSemThread_Instance_finalize__E, iStat, 1); - } - -} - -/* Object__destruct__S */ -xdc_Void xdc_runtime_knl_SyncSemThread_Object__destruct__S( xdc_Ptr obj ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, obj, (xdc_Fxn)xdc_runtime_knl_SyncSemThread_Instance_finalize__E, 0, TRUE); -} - -/* destruct */ -void xdc_runtime_knl_SyncSemThread_destruct(xdc_runtime_knl_SyncSemThread_Struct *obj) -{ - xdc_runtime_knl_SyncSemThread_Object__destruct__S(obj); -} - -/* Object__delete__S */ -xdc_Void xdc_runtime_knl_SyncSemThread_Object__delete__S( xdc_Ptr instp ) -{ - xdc_runtime_Core_deleteObject__I(&xdc_runtime_knl_SyncSemThread_Object__DESC__C, *((xdc_runtime_knl_SyncSemThread_Object**)instp), (xdc_Fxn)xdc_runtime_knl_SyncSemThread_Instance_finalize__E, 0, FALSE); - *((xdc_runtime_knl_SyncSemThread_Handle*)instp) = NULL; -} - -/* delete */ -void xdc_runtime_knl_SyncSemThread_delete(xdc_runtime_knl_SyncSemThread_Handle *instp) -{ - xdc_runtime_knl_SyncSemThread_Object__delete__S(instp); -} - - -/* - * ======== xdc.runtime.knl.Sync_Proxy SYSTEM FUNCTIONS ======== - */ - -/* per-module runtime symbols */ -#undef Module__MID -#define Module__MID xdc_runtime_knl_Sync_Proxy_Module__id__C -#undef Module__DGSINCL -#define Module__DGSINCL xdc_runtime_knl_Sync_Proxy_Module__diagsIncluded__C -#undef Module__DGSENAB -#define Module__DGSENAB xdc_runtime_knl_Sync_Proxy_Module__diagsEnabled__C -#undef Module__DGSMASK -#define Module__DGSMASK xdc_runtime_knl_Sync_Proxy_Module__diagsMask__C -#undef Module__LOGDEF -#define Module__LOGDEF xdc_runtime_knl_Sync_Proxy_Module__loggerDefined__C -#undef Module__LOGOBJ -#define Module__LOGOBJ xdc_runtime_knl_Sync_Proxy_Module__loggerObj__C -#undef Module__LOGFXN0 -#define Module__LOGFXN0 xdc_runtime_knl_Sync_Proxy_Module__loggerFxn0__C -#undef Module__LOGFXN1 -#define Module__LOGFXN1 xdc_runtime_knl_Sync_Proxy_Module__loggerFxn1__C -#undef Module__LOGFXN2 -#define Module__LOGFXN2 xdc_runtime_knl_Sync_Proxy_Module__loggerFxn2__C -#undef Module__LOGFXN4 -#define Module__LOGFXN4 xdc_runtime_knl_Sync_Proxy_Module__loggerFxn4__C -#undef Module__LOGFXN8 -#define Module__LOGFXN8 xdc_runtime_knl_Sync_Proxy_Module__loggerFxn8__C -#undef Module__G_OBJ -#define Module__G_OBJ xdc_runtime_knl_Sync_Proxy_Module__gateObj__C -#undef Module__G_PRMS -#define Module__G_PRMS xdc_runtime_knl_Sync_Proxy_Module__gatePrms__C -#undef Module__GP_create -#define Module__GP_create xdc_runtime_knl_Sync_Proxy_Module_GateProxy_create -#undef Module__GP_delete -#define Module__GP_delete xdc_runtime_knl_Sync_Proxy_Module_GateProxy_delete -#undef Module__GP_enter -#define Module__GP_enter xdc_runtime_knl_Sync_Proxy_Module_GateProxy_enter -#undef Module__GP_leave -#define Module__GP_leave xdc_runtime_knl_Sync_Proxy_Module_GateProxy_leave -#undef Module__GP_query -#define Module__GP_query xdc_runtime_knl_Sync_Proxy_Module_GateProxy_query - -xdc_Bool xdc_runtime_knl_Sync_Proxy_Proxy__abstract__S( void ) -{ - return 1; -} -xdc_Ptr xdc_runtime_knl_Sync_Proxy_Proxy__delegate__S( void ) -{ - return (xdc_Ptr)&xdc_runtime_knl_SyncNull_Module__FXNS__C; -} - - - -/* - * ======== INITIALIZATION ENTRY POINT ======== - */ - -extern int __xdc__init(void); -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -__FAR__ int (* volatile __xdc__init__addr)(void) = &__xdc__init; - - -/* - * ======== PROGRAM GLOBALS ======== - */ - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle adcHwi = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[0]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle sysTick = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[1]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle portpint = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[2]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle timer0 = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[3]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle watchdog = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[4]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle timer2 = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[5]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle timer1 = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[6]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_family_arm_m3_Hwi_Handle timer3 = (ti_sysbios_family_arm_m3_Hwi_Handle)((ti_sysbios_family_arm_m3_Hwi_Handle)&ti_sysbios_family_arm_m3_Hwi_Object__table__V[7]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Semaphore_Handle initConnectionSem = (ti_sysbios_knl_Semaphore_Handle)((ti_sysbios_knl_Semaphore_Handle)&ti_sysbios_knl_Semaphore_Object__table__V[0]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Semaphore_Handle adcResultSem = (ti_sysbios_knl_Semaphore_Handle)((ti_sysbios_knl_Semaphore_Handle)&ti_sysbios_knl_Semaphore_Object__table__V[1]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Semaphore_Handle updateSem = (ti_sysbios_knl_Semaphore_Handle)((ti_sysbios_knl_Semaphore_Handle)&ti_sysbios_knl_Semaphore_Object__table__V[2]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Semaphore_Handle ReconnectSem = (ti_sysbios_knl_Semaphore_Handle)((ti_sysbios_knl_Semaphore_Handle)&ti_sysbios_knl_Semaphore_Object__table__V[3]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle millisec = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[0]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle control = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[1]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle AlarmHandling = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[2]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle communicationTx = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[3]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle process = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[4]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle HeatersControl = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[5]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle communication = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[6]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle millisecLow = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[7]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle controlLow = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[8]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle Diagnostics = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[9]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle adcProcess = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[10]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle report = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[11]); - -#ifdef __GNUC__ -#ifndef __TI_COMPILER_VERSION__ - __attribute__ ((externally_visible)) -#endif -#endif -const ti_sysbios_knl_Task_Handle update = (ti_sysbios_knl_Task_Handle)((ti_sysbios_knl_Task_Handle)&ti_sysbios_knl_Task_Object__table__V[12]); - diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.cfg b/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.cfg deleted file mode 100644 index 30879d993..000000000 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.cfg +++ /dev/null @@ -1,268 +0,0 @@ -/* - * ======== package/cfg/Embedded_pem4f.cfg ======== - * This generated configuration script runs the user's configuration script - * the context of a specific target and platform in order to generate - * all the files necessary to create an executable; e.g., linker command - * files, static C/C++ data structures, etc. - */ - -/* - * ======== _applyChanges ======== - * Changes that bring the build target to the state at the end of the build - * model - */ -function _applyChanges(obj, chgObj) { - var wasSealed = false; - if (obj.$sealed) { - wasSealed = true; - obj.$unseal(); - } - for (var prop in chgObj) { - if (typeof obj[prop] == 'object' && obj[prop] != undefined) { - if ("$category" in obj[prop] && obj[prop].$category == "Vector") { - obj[prop].length = chgObj[prop].length; - for (var i = 0; i < chgObj[prop].length; i++) { - if (obj[prop].length < i + 1) { - obj[prop].length++; - } - obj[prop][i] = chgObj[prop][i]; - } - } - else { - _applyChanges(obj[prop], chgObj[prop]); - } - } - else { - obj[prop] = chgObj[prop]; - } - } - if (wasSealed) { - obj.$seal(); - } -} - -/* - * ======== _runescape ======== - * Recursive unescape to decode serialized strings - */ -function _runescape(obj) { - for (var i in obj) { - if (obj[i] != null) { - if (typeof obj[i] == 'string') { - obj[i] = unescape(obj[i]); - } - else if (typeof obj[i] == 'object') { - _runescape(obj[i]); - } - } - } -} - -/* - * ======== _getPlatCfg ======== - */ -function _getPlatCfg() { - var tmp = {}; - _runescape(tmp); - return (tmp); -} -/* - * ======== _cfginit ======== - */ -function _cfginit() { - xdc.loadPackage('xdc.services.intern.cmd'); - var prog = xdc.om['xdc.cfg.Program']; - - /* initialize prog attrs from build model */ - var build = { - profile: "release", - cfgScript: "C%3A/Tango/Software/Embedded_SW/Embedded/Embedded.cfg", - cfgHome: "configPkg", - cfgArgs: "null", - cfgArgsEncoded: true, - releases: { - 0: { - name: "configPkg", - attrs: { - prefix: "", - label: "default" - }, - otherFiles: {}, - excludeDirs: {} - } - }, - prelink: false - }; - _runescape(build); - build.cfgArgs = null; - build.target = xdc.module("ti.targets.arm.elf.M4F"); - var targChange = { - platforms: [ - "ti.platforms.tiva%3ATM4C1294NCPDT%3A1" - ], - version: "ti.targets.arm.elf.M4F%7B1%2C0%2C16.9%2C4", - extensions: { - ".sem4fe": { - suf: ".sem4fe", - typ: "asm" - }, - ".sem4f": { - suf: ".sem4f", - typ: "asm" - }, - ".sv7M4": { - suf: ".sv7M4", - typ: "asm" - }, - ".sv7M": { - suf: ".sv7M", - typ: "asm" - } - }, - rootDir: "C%3A/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS", - ccOpts: { - prefix: "-mv7M4%20--code_state%3D16%20--float_support%3DFPv4SPD16%20-me%20-qq%20-pdsw225" - }, - rawVersion: "16.9.4" - }; - _runescape(targChange); - _applyChanges(build.target, targChange); - - prog.build = build; - - prog.name = "Embedded.xem4f"; - prog.cfgBase = "package/cfg/Embedded_pem4f"; - - prog.endian = prog.build.target.model.endian; - prog.codeModel = prog.build.target.model.codeModel; - - /* use the platform package's Platform module */ - var Platform = xdc.useModule("ti.platforms.tiva.Platform"); - var platParams = _getPlatCfg(); - var invalidParams = []; - for (var prop in platParams) { - if (!(prop in Platform.PARAMS)) { - delete platParams[prop]; - invalidParams.push(prop); - } - } - prog.platformName = "ti.platforms.tiva:TM4C129XNCZAD"; - prog.platform = Platform.create("TM4C129XNCZAD", platParams); - for (var i = 0; i < invalidParams.length; i++) { - Platform.$logWarning("The parameter '" + invalidParams[i] + "' is " + - "passed to this platform instance through Build.platformTable, " + - "but the instance does not have a configuration parameter with " + - "that name.", prog.platform, "TM4C129XNCZAD"); - } - - /* record the executable's package name */ - prog.buildPackage = "configPkg"; - - /* record build-model information required during config generation */ - prog.$$bind("$$isasm", 0); - prog.$$bind("$$isrom", 0); - prog.$$bind("$$gentab", [ - ]); - - /* bind prog to an appropriate execution context */ - prog.cpu = prog.platform.getExeContext(prog); - - /* import the target's run-time support pkg */ - xdc.loadPackage("ti.targets.arm.rtsarm"); -} - -/* function to import the cfg script's package */ -function _userscript(script) { - var home; - var spath; - home = xdc.loadPackage("configPkg"); - - xdc.om.$$bind('$homepkg', home); - - var cfgScript = "C:/Tango/Software/Embedded_SW/Embedded/Embedded.cfg"; - if (!script) { - utils.loadCapsule(cfgScript, false, spath); - } - else { - /* set up the same environment that loadCapsule would */ - var $saveCsd = utils.csd; - var $cfgFile = utils.findFile(cfgScript, spath); - var cname = cfgScript; - if ($cfgFile) { - $cfgFile = java.io.File($cfgFile); - utils.csd = $cfgFile.getParentFile().getCanonicalPath(); - cname = "" + $cfgFile.getCanonicalPath(); - } - - /* create the capsule object */ - var cap = { - prototype: utils.global, - $path: cname, - $private: {path: cname}, - $capsule: undefined, /* set to cap below */ - }; - - /* 'this.$capsule' is always cap object */ - cap.$capsule = cap; - - /* save the capsule object */ - utils.$$capmap[cname] = cap; - - try { - var cx = - Packages.org.mozilla.javascript.Context.getCurrentContext(); - var rdr = new - java.io.BufferedReader(new java.io.StringReader(script)); - Packages.config.Shell.evaluateLoad(cx, cap, rdr, cname, 1); - } - finally { - rdr.close(); - utils.csd = $saveCsd; - } - } -} - -function _postinit() { - var cout = null; - - var Program = xdc.om['xdc.cfg.Program']; - /* get the exec command for this executable */ - if (Program.execCmd == null) { - Program.execCmd = Program.platform.getExecCmd(Program, - xdc.om["ti.platforms.tiva"].packageBase); - } - cout = "define EXEC." + Program.name + '\n\n'; - cout += Program.execCmd; - cout += "\nendef\n\n"; - - /* if SourceDir generates a makefile, we need to run it */ - _genSourceDirMak("package/cfg/Embedded_pem4f", "Embedded.pem4f"); - - utils.genDep("package/cfg/Embedded_pem4f", "configPkg", utils.loadedFiles, cout, null); -} - -function _genSourceDirMak(cfgBase, cfgName) -{ - var SourceDir = xdc.om['xdc.cfg.SourceDir']; - - if (SourceDir && SourceDir.$instances.length > 0) { - /* construct rule to run SourceDir generated makefile */ - var make = "\t$(MAKE) -f " - + SourceDir.outputDir + "/" + SourceDir.makefileName; - - /* this file is included by package.mak (if it exists) */ - var file = new java.io.File(cfgBase + ".cfg.mak"); - file["delete"](); - var out = new java.io.BufferedWriter(new java.io.FileWriter(file)); - - /* add rules to run SourceDir generated makefile */ - out.write("# invoke SourceDir generated makefile for " + cfgName - + "\n" + cfgName + ": .libraries," + cfgName - + "\n.libraries," + cfgName + ": " + cfgBase + ".xdl\n" - + make + "\n\n" - + "clean::\n" + make + " clean\n\n" - ); - out.close(); - out = null; - } -} diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.h b/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.h deleted file mode 100644 index 0c9d47734..000000000 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/configPkg/package/cfg/Embedded_pem4f.h +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Do not modify this file; it is automatically - * generated and any modifications will be overwritten. - * - * @(#) xdc-B06 - */ - -#include - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle adcHwi; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle sysTick; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle portpint; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle timer0; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle watchdog; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle timer2; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle timer1; - -#include -extern const ti_sysbios_family_arm_m3_Hwi_Handle timer3; - -#include -extern const ti_sysbios_knl_Semaphore_Handle initConnectionSem; - -#include -extern const ti_sysbios_knl_Semaphore_Handle adcResultSem; - -#include -extern const ti_sysbios_knl_Semaphore_Handle updateSem; - -#include -extern const ti_sysbios_knl_Semaphore_Handle ReconnectSem; - -#include -extern const ti_sysbios_knl_Task_Handle millisec; - -#include -extern const ti_sysbios_knl_Task_Handle control; - -#include -extern const ti_sysbios_knl_Task_Handle AlarmHandling; - -#include -extern const ti_sysbios_knl_Task_Handle communicationTx; - -#include -extern const ti_sysbios_knl_Task_Handle process; - -#include -extern const ti_sysbios_knl_Task_Handle HeatersControl; - -#include -extern const ti_sysbios_knl_Task_Handle communication; - -#include -extern const ti_sysbios_knl_Task_Handle millisecLow; - -#include -extern const ti_sysbios_knl_Task_Handle controlLow; - -#include -extern const ti_sysbios_knl_Task_Handle Diagnostics; - -#include -extern const ti_sysbios_knl_Task_Handle adcProcess; - -#include -extern const ti_sysbios_knl_Task_Handle report; - -#include -extern const ti_sysbios_knl_Task_Handle update; - -extern int xdc_runtime_Startup__EXECFXN__C; - -extern int xdc_runtime_Startup__RESETFXN__C; - -- cgit v1.3.1 From 8fee48ffc4ac129074cd6c240cd9098cc4c7e0c6 Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Tue, 23 Apr 2019 09:57:24 +0300 Subject: stub to Create File System (delete the old data and create new FS) --- Software/Embedded_SW/.jxbrowser-data/Login Data | Bin 18432 -> 18432 bytes .../Embedded/Modules/Stubs_Handler/Progress.c | 47 +++++--- Software/Embedded_SW/Embedded/debug_w_pmr/makefile | 120 ++++++++++++--------- .../Embedded_SW/Embedded/debug_w_pmr/sources.mk | 6 +- .../Embedded/debug_w_pmr/subdir_rules.mk | 20 ++-- .../Embedded_SW/Embedded/src/sysbios/sysbios.aem4f | Bin 1751774 -> 1751774 bytes 6 files changed, 113 insertions(+), 80 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/.jxbrowser-data/Login Data b/Software/Embedded_SW/.jxbrowser-data/Login Data index 344eacb15..0a6e4afb8 100644 Binary files a/Software/Embedded_SW/.jxbrowser-data/Login Data and b/Software/Embedded_SW/.jxbrowser-data/Login Data differ diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index d041b648e..958c91926 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -9,6 +9,9 @@ #include "Drivers/USB_Communication/USBCDCD.h" #include "StateMachines/Initialization/PowerOffSequence.h" +#include "drivers/Flash_Memory/FATFS/ff.h" +#include "drivers/Flash_Memory/FATFS/Control_File_System.h" + //#include "graphics_adapter.h" void Stub_ProgressRequest(MessageContainer* requestContainer) @@ -20,27 +23,39 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) //writeLine("Progress Request..."); ProgressResponse response = PROGRESS_RESPONSE__INIT; - response.has_progress = true; - PowerOffInit(); - int i = 0; - for (i = 0; i < request->amount; i++) - { - response.progress = i; - responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); - uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); - size_t container_size = message_container__pack(&responseContainer, container_buffer); - free(responseContainer.data.data); - SendChars((char*)container_buffer, container_size); - //free(container_buffer); - - int co = 0; - for (co = 0; co < request->delay; co++) + if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive + { + FRESULT iFResult = Init_Flash_File_System(true); + if(iFResult != FR_OK) { - __delay_cycles(1000000); + LOG_ERROR (iFResult, "Error during init Flash File System"); + assert(iFResult); } } + else + { + response.has_progress = true; + PowerOffInit(); + int i = 0; + for (i = 0; i < request->amount; i++) + { + response.progress = i; + responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); + uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + //free(container_buffer); + + int co = 0; + for (co = 0; co < request->delay; co++) + { + __delay_cycles(1000000); + } + } + } responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size); uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); size_t container_size = message_container__pack(&responseContainer, container_buffer); diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/makefile b/Software/Embedded_SW/Embedded/debug_w_pmr/makefile index a20bf907b..ffcf18162 100644 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/makefile +++ b/Software/Embedded_SW/Embedded/debug_w_pmr/makefile @@ -4,7 +4,7 @@ SHELL = cmd.exe -CG_TOOL_ROOT := C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS +CG_TOOL_ROOT := C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS GEN_OPTS__FLAG := --cmd_file="configPkg/compiler.opt" GEN_CMDS__FLAG := -l"configPkg/linker.cmd" @@ -41,7 +41,10 @@ ORDERED_OBJS += \ "./Communication/PMR/Connection/DisconnectResponse.pb-c.obj" \ "./Communication/PMR/Connection/KeepAliveRequest.pb-c.obj" \ "./Communication/PMR/Connection/KeepAliveResponse.pb-c.obj" \ +"./Communication/PMR/Debugging/DebugDistributor.pb-c.obj" \ "./Communication/PMR/Debugging/DebugLogCategory.pb-c.obj" \ +"./Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.obj" \ +"./Communication/PMR/Debugging/SetupDebugDisributorsResponse.pb-c.obj" \ "./Communication/PMR/Debugging/StartDebugLogRequest.pb-c.obj" \ "./Communication/PMR/Debugging/StartDebugLogResponse.pb-c.obj" \ "./Communication/PMR/Debugging/StopDebugLogRequest.pb-c.obj" \ @@ -106,6 +109,8 @@ ORDERED_OBJS += \ "./Communication/PMR/EmbeddedParameters/AlarmSourceType.pb-c.obj" \ "./Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.obj" \ "./Communication/PMR/EmbeddedParameters/DispenserData.pb-c.obj" \ +"./Communication/PMR/EmbeddedParameters/DispenserDataRequest.pb-c.obj" \ +"./Communication/PMR/EmbeddedParameters/DispenserDataResponse.pb-c.obj" \ "./Communication/PMR/EmbeddedParameters/DispenserRunningData.pb-c.obj" \ "./Communication/PMR/FirmwareUpgrade/ActivateVersionRequest.pb-c.obj" \ "./Communication/PMR/FirmwareUpgrade/ActivateVersionResponse.pb-c.obj" \ @@ -293,7 +298,7 @@ ORDERED_OBJS += \ "./Drivers/FPGA/Full_Vme/ispvme/hardware.obj" \ "./Drivers/FPGA/Full_Vme/ispvme/ispvm_ui.obj" \ "./Drivers/FPGA/Full_Vme/ispvme/ivm_core.obj" \ -"./Drivers/FPGA/Moters_Driver/L6470.obj" \ +"./Drivers/FPGA/Motors_Driver/L6470.obj" \ "./Drivers/Flash_Memory/FATFS/Control_File_System.obj" \ "./Drivers/Flash_Memory/FATFS/cc932.obj" \ "./Drivers/Flash_Memory/FATFS/fatfs_port_mx66l51235f.obj" \ @@ -306,10 +311,13 @@ ORDERED_OBJS += \ "./Drivers/Heater/TemperatureSensor.obj" \ "./Drivers/I2C_Communication/ADC_MUX/ADC_MUX.obj" \ "./Drivers/I2C_Communication/DAC/Blower.obj" \ -"./Drivers/I2C_Communication/Dispensers_EEPROM_MUX/Disp_EEPROM_MUX.obj" \ +"./Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.obj" \ +"./Drivers/I2C_Communication/Dispenser_Card/I2C_Dispenser_Card_Mux.obj" \ +"./Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.obj" \ "./Drivers/I2C_Communication/I2C.obj" \ "./Drivers/I2C_Communication/I2C_Comm.obj" \ "./Drivers/I2C_Communication/RFID_NFC/NFC_I2C/NFC_I2C.obj" \ +"./Drivers/I2C_Communication/RFID_NFC/NFC_I2C/Test_NFC.obj" \ "./Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.obj" \ "./Drivers/I2C_Communication/Thermo_K/MCP9600.obj" \ "./Drivers/Motors/Motor.obj" \ @@ -333,6 +341,7 @@ ORDERED_OBJS += \ "./Modules/Diagnostics/DiagnosticsHoming.obj" \ "./Modules/Diagnostics/DiagnosticsJogging.obj" \ "./Modules/General/GeneralHardware.obj" \ +"./Modules/General/Safety.obj" \ "./Modules/General/buttons.obj" \ "./Modules/General/process.obj" \ "./Modules/Heaters/Heaters_bit.obj" \ @@ -340,6 +349,7 @@ ORDERED_OBJS += \ "./Modules/Heaters/Heaters_maint.obj" \ "./Modules/Heaters/Heaters_print.obj" \ "./Modules/IDS/IDS_BIT.obj" \ +"./Modules/IDS/IDS_Cleaning.obj" \ "./Modules/IDS/IDS_dispenser.obj" \ "./Modules/IDS/IDS_init.obj" \ "./Modules/IDS/IDS_maint.obj" \ @@ -383,6 +393,8 @@ ORDERED_OBJS += \ "./Modules/Waste/Waste_maint.obj" \ "./Modules/Waste/Waste_print.obj" \ "./StateMachines/Initialization/InitSequence.obj" \ +"./StateMachines/Initialization/PowerIdle.obj" \ +"./StateMachines/Initialization/PowerOffSequence.obj" \ "./StateMachines/Printing/JobSTM.obj" \ "./StateMachines/Printing/PrintingSTM.obj" \ "../tm4c129xnczad.cmd" \ @@ -424,13 +436,15 @@ RMDIR := RMDIR /S/Q -include Drivers/FPGA/FPGA_INTERRUPTS/subdir_vars.mk -include Drivers/FPGA/Full_Vme/subdir_vars.mk -include Drivers/FPGA/Full_Vme/ispvme/subdir_vars.mk --include Drivers/FPGA/Moters_Driver/subdir_vars.mk +-include Drivers/FPGA/Motors_Driver/subdir_vars.mk -include Drivers/Flash_Memory/FATFS/subdir_vars.mk -include Drivers/Flash_Memory/subdir_vars.mk -include Drivers/Heater/subdir_vars.mk -include Drivers/I2C_Communication/ADC_MUX/subdir_vars.mk -include Drivers/I2C_Communication/DAC/subdir_vars.mk --include Drivers/I2C_Communication/Dispensers_EEPROM_MUX/subdir_vars.mk +-include Drivers/I2C_Communication/Dispenser_Card/EEPROM/subdir_vars.mk +-include Drivers/I2C_Communication/Dispenser_Card/subdir_vars.mk +-include Drivers/I2C_Communication/Dispenser_Card/IO_Ports/subdir_vars.mk -include Drivers/I2C_Communication/subdir_vars.mk -include Drivers/I2C_Communication/RFID_NFC/NFC_I2C/subdir_vars.mk -include Drivers/I2C_Communication/RFID_NFC/PN7150/subdir_vars.mk @@ -481,13 +495,15 @@ RMDIR := RMDIR /S/Q -include Drivers/FPGA/FPGA_INTERRUPTS/subdir_rules.mk -include Drivers/FPGA/Full_Vme/subdir_rules.mk -include Drivers/FPGA/Full_Vme/ispvme/subdir_rules.mk --include Drivers/FPGA/Moters_Driver/subdir_rules.mk +-include Drivers/FPGA/Motors_Driver/subdir_rules.mk -include Drivers/Flash_Memory/FATFS/subdir_rules.mk -include Drivers/Flash_Memory/subdir_rules.mk -include Drivers/Heater/subdir_rules.mk -include Drivers/I2C_Communication/ADC_MUX/subdir_rules.mk -include Drivers/I2C_Communication/DAC/subdir_rules.mk --include Drivers/I2C_Communication/Dispensers_EEPROM_MUX/subdir_rules.mk +-include Drivers/I2C_Communication/Dispenser_Card/EEPROM/subdir_rules.mk +-include Drivers/I2C_Communication/Dispenser_Card/subdir_rules.mk +-include Drivers/I2C_Communication/Dispenser_Card/IO_Ports/subdir_rules.mk -include Drivers/I2C_Communication/subdir_rules.mk -include Drivers/I2C_Communication/RFID_NFC/NFC_I2C/subdir_rules.mk -include Drivers/I2C_Communication/RFID_NFC/PN7150/subdir_rules.mk @@ -631,21 +647,20 @@ main-build: Embedded.out # Tool invocations Embedded.out: $(OBJS) $(CMD_SRCS) $(GEN_CMDS) - @echo 'Building target: "$@"' + @echo 'Building target: $@' @echo 'Invoking: ARM Linker' - @echo 'Flags: -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi -z -m"Embedded.map" --heap_size=20480 --stack_size=4095 -i"C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/lib" -i"C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/include" --reread_libs --diag_wrap=off --display_error_number --warn_sections --xml_link_info="Embedded_linkInfo.xml" --rom_model' - $(shell echo -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi -z -m"Embedded.map" --heap_size=20480 --stack_size=4095 -i"C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/lib" -i"C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/include" --reread_libs --diag_wrap=off --display_error_number --warn_sections --xml_link_info="Embedded_linkInfo.xml" --rom_model > "ccsLinker.opt") + @echo 'Flags: -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi -z -m"Embedded.map" --heap_size=20480 --stack_size=4095 -i"C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/lib" -i"C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/include" --reread_libs --diag_wrap=off --display_error_number --warn_sections --xml_link_info="Embedded_linkInfo.xml" --rom_model' + $(shell echo -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi -z -m"Embedded.map" --heap_size=20480 --stack_size=4095 -i"C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/lib" -i"C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/include" --reread_libs --diag_wrap=off --display_error_number --warn_sections --xml_link_info="Embedded_linkInfo.xml" --rom_model > "ccsLinker.opt") $(shell type "ccsObjs.opt" >> "ccsLinker.opt") - "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armcl" -@"ccsLinker.opt" -o "Embedded.out" - @echo 'Finished building target: "$@"' + "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armcl" -@"ccsLinker.opt" -o "Embedded.out" + @echo 'Finished building target: $@' @echo ' ' @$(MAKE) --no-print-directory post-build Embedded.bin: $(EXE_OUTPUTS) - @echo 'Building files: $(strip $(EXE_OUTPUTS__QUOTED))' @echo 'Invoking: ARM Hex Utility' - "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armhex" -o "Embedded.bin" $(EXE_OUTPUTS__QUOTED) - @echo 'Finished building: $(strip $(EXE_OUTPUTS__QUOTED))' + "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armhex" -o "Embedded.bin" $(EXE_OUTPUTS__QUOTED) + @echo 'Finished building: $@' @echo ' ' @$(MAKE) --no-print-directory post-build @@ -654,43 +669,44 @@ clean: -$(RM) $(GEN_CMDS__QUOTED)$(GEN_MISC_FILES__QUOTED)$(BIN_OUTPUTS__QUOTED)$(GEN_FILES__QUOTED)$(EXE_OUTPUTS__QUOTED)$(GEN_OPTS__QUOTED) -$(RMDIR) $(GEN_MISC_DIRS__QUOTED) -$(RM) "Main.obj" "delay.obj" "Common\SWUpdate\FileSystem.obj" "Common\SWUpdate\FirmwareUpgrade.obj" "Common\SW_Info\SW_Info.obj" "Common\Software_CRC\sw_crc.obj" "Common\Sys_PinOut_Config\MCU_MAIN_pinout.obj" "Common\Sys_PinOut_Config\Pin.obj" "Common\Sys_PinOut_Config\Pin_config.obj" "Common\Utilities\Update.obj" "Common\Utilities\Utils.obj" "Common\Utilities\idle_task.obj" "Common\Utilities\ustdlib.obj" "Common\protobuf-c\protobuf-c.obj" "Common\report\distributor.obj" "Common\report\filter.obj" "Common\report\reportInit.obj" "Communication\CommunicationTask.obj" "Communication\Connection.obj" "Communication\Container.obj" "Communication\PMR\Common\ErrorCode.pb-c.obj" "Communication\PMR\Common\ErrorResponse.pb-c.obj" "Communication\PMR\Common\MessageContainer.pb-c.obj" "Communication\PMR\Common\MessageType.pb-c.obj" "Communication\PMR\Connection\ConnectRequest.pb-c.obj" "Communication\PMR\Connection\ConnectResponse.pb-c.obj" "Communication\PMR\Connection\DeviceInformation.pb-c.obj" "Communication\PMR\Connection\DisconnectRequest.pb-c.obj" - -$(RM) "Communication\PMR\Connection\DisconnectResponse.pb-c.obj" "Communication\PMR\Connection\KeepAliveRequest.pb-c.obj" "Communication\PMR\Connection\KeepAliveResponse.pb-c.obj" "Communication\PMR\Debugging\DebugLogCategory.pb-c.obj" "Communication\PMR\Debugging\StartDebugLogRequest.pb-c.obj" "Communication\PMR\Debugging\StartDebugLogResponse.pb-c.obj" "Communication\PMR\Debugging\StopDebugLogRequest.pb-c.obj" "Communication\PMR\Debugging\StopDebugLogResponse.pb-c.obj" "Communication\PMR\Diagnostics\DataFileFrame.pb-c.obj" "Communication\PMR\Diagnostics\DiagnosticsMonitors.pb-c.obj" "Communication\PMR\Diagnostics\DigitalInterfaceState.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DispenserHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserHomingResponse.pb-c.obj" - -$(RM) "Communication\PMR\Diagnostics\DispenserJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DoubleArray.pb-c.obj" "Communication\PMR\Diagnostics\Event.pb-c.obj" "Communication\PMR\Diagnostics\EventType.pb-c.obj" "Communication\PMR\Diagnostics\HeaterState.pb-c.obj" "Communication\PMR\Diagnostics\HeaterType.pb-c.obj" "Communication\PMR\Diagnostics\InterfaceIOs.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorDirection.pb-c.obj" "Communication\PMR\Diagnostics\MotorHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorJoggingResponse.pb-c.obj" - -$(RM) "Communication\PMR\Diagnostics\ResolveEventRequest.pb-c.obj" "Communication\PMR\Diagnostics\ResolveEventResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetBlowerStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetBlowerStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetComponentValueRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetComponentValueResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetDigitalOutRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetDigitalOutResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetHeaterStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetHeaterStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetValveStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetValveStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\StartDiagnosticsRequest.pb-c.obj" "Communication\PMR\Diagnostics\StartDiagnosticsResponse.pb-c.obj" "Communication\PMR\Diagnostics\StartEventsNotificationRequest.pb-c.obj" "Communication\PMR\Diagnostics\StartEventsNotificationResponse.pb-c.obj" - -$(RM) "Communication\PMR\Diagnostics\StopDiagnosticsRequest.pb-c.obj" "Communication\PMR\Diagnostics\StopDiagnosticsResponse.pb-c.obj" "Communication\PMR\Diagnostics\StopEventsNotificationRequest.pb-c.obj" "Communication\PMR\Diagnostics\StopEventsNotificationResponse.pb-c.obj" "Communication\PMR\Diagnostics\ThreadAbortJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\ThreadAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\ThreadJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\ThreadJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\ValueComponent.pb-c.obj" "Communication\PMR\Diagnostics\ValueComponentState.pb-c.obj" "Communication\PMR\Diagnostics\ValveState.pb-c.obj" "Communication\PMR\Diagnostics\ValveStateCode.pb-c.obj" "Communication\PMR\Diagnostics\ValveType.pb-c.obj" "Communication\PMR\EmbeddedParameters\AlarmHandlingItem.pb-c.obj" "Communication\PMR\EmbeddedParameters\AlarmParameters.pb-c.obj" "Communication\PMR\EmbeddedParameters\AlarmSourceType.pb-c.obj" - -$(RM) "Communication\PMR\EmbeddedParameters\ConfigurationParameters.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserData.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserRunningData.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ActivateVersionRequest.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ActivateVersionResponse.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ValidateVersionRequest.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ValidateVersionResponse.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionFileDescriptor.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionFileDestination.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionPackageDescriptor.pb-c.obj" "Communication\PMR\Hardware\HardwareBlower.pb-c.obj" "Communication\PMR\Hardware\HardwareBlowerType.pb-c.obj" "Communication\PMR\Hardware\HardwareBreakSensor.pb-c.obj" "Communication\PMR\Hardware\HardwareBreakSensorType.pb-c.obj" "Communication\PMR\Hardware\HardwareConfiguration.pb-c.obj" "Communication\PMR\Hardware\HardwareDancer.pb-c.obj" - -$(RM) "Communication\PMR\Hardware\HardwareDancerType.pb-c.obj" "Communication\PMR\Hardware\HardwareDispenser.pb-c.obj" "Communication\PMR\Hardware\HardwareDispenserType.pb-c.obj" "Communication\PMR\Hardware\HardwareMotor.pb-c.obj" "Communication\PMR\Hardware\HardwareMotorType.pb-c.obj" "Communication\PMR\Hardware\HardwarePidControl.pb-c.obj" "Communication\PMR\Hardware\HardwarePidControlType.pb-c.obj" "Communication\PMR\Hardware\HardwareSpeedSensor.pb-c.obj" "Communication\PMR\Hardware\HardwareSpeedSensorType.pb-c.obj" "Communication\PMR\Hardware\HardwareWinder.pb-c.obj" "Communication\PMR\Hardware\HardwareWinderType.pb-c.obj" "Communication\PMR\Hardware\SystemResetRequest.pb-c.obj" "Communication\PMR\Hardware\SystemResetResponse.pb-c.obj" "Communication\PMR\Hardware\UploadHardwareConfigurationRequest.pb-c.obj" "Communication\PMR\Hardware\UploadHardwareConfigurationResponse.pb-c.obj" "Communication\PMR\IO\CreateRequest.pb-c.obj" "Communication\PMR\IO\CreateResponse.pb-c.obj" "Communication\PMR\IO\DeleteRequest.pb-c.obj" - -$(RM) "Communication\PMR\IO\DeleteResponse.pb-c.obj" "Communication\PMR\IO\ExecuteProcessRequest.pb-c.obj" "Communication\PMR\IO\ExecuteProcessResponse.pb-c.obj" "Communication\PMR\IO\FileAttribute.pb-c.obj" "Communication\PMR\IO\FileChunkDownloadRequest.pb-c.obj" "Communication\PMR\IO\FileChunkDownloadResponse.pb-c.obj" "Communication\PMR\IO\FileChunkUploadRequest.pb-c.obj" "Communication\PMR\IO\FileChunkUploadResponse.pb-c.obj" "Communication\PMR\IO\FileDownloadRequest.pb-c.obj" "Communication\PMR\IO\FileDownloadResponse.pb-c.obj" "Communication\PMR\IO\FileInfo.pb-c.obj" "Communication\PMR\IO\FileUploadRequest.pb-c.obj" "Communication\PMR\IO\FileUploadResponse.pb-c.obj" "Communication\PMR\IO\GetFilesRequest.pb-c.obj" "Communication\PMR\IO\GetFilesResponse.pb-c.obj" "Communication\PMR\IO\GetStorageInfoRequest.pb-c.obj" "Communication\PMR\IO\GetStorageInfoResponse.pb-c.obj" "Communication\PMR\IO\KillProcessRequest.pb-c.obj" "Communication\PMR\IO\KillProcessResponse.pb-c.obj" "Communication\PMR\Printing\AbortJobRequest.pb-c.obj" - -$(RM) "Communication\PMR\Printing\AbortJobResponse.pb-c.obj" "Communication\PMR\Printing\CurrentJobRequest.pb-c.obj" "Communication\PMR\Printing\CurrentJobResponse.pb-c.obj" "Communication\PMR\Printing\DispenserLiquidType.pb-c.obj" "Communication\PMR\Printing\DispenserStepDivision.pb-c.obj" "Communication\PMR\Printing\JobBrushStop.pb-c.obj" "Communication\PMR\Printing\JobDescriptionFileBrushStop.pb-c.obj" "Communication\PMR\Printing\JobDescriptionFileSegment.pb-c.obj" "Communication\PMR\Printing\JobDispenser.pb-c.obj" "Communication\PMR\Printing\JobRequest.pb-c.obj" "Communication\PMR\Printing\JobResponse.pb-c.obj" "Communication\PMR\Printing\JobSegment.pb-c.obj" "Communication\PMR\Printing\JobSpool.pb-c.obj" "Communication\PMR\Printing\JobSpoolType.pb-c.obj" "Communication\PMR\Printing\JobStatus.pb-c.obj" "Communication\PMR\Printing\JobTicket.pb-c.obj" "Communication\PMR\Printing\JobUploadStrategy.pb-c.obj" "Communication\PMR\Printing\JobWindingMethod.pb-c.obj" "Communication\PMR\Printing\ProcessParameters.pb-c.obj" - -$(RM) "Communication\PMR\Printing\ResumeCurrentJobRequest.pb-c.obj" "Communication\PMR\Printing\ResumeCurrentJobResponse.pb-c.obj" "Communication\PMR\Printing\UploadProcessParametersRequest.pb-c.obj" "Communication\PMR\Printing\UploadProcessParametersResponse.pb-c.obj" "Communication\PMR\Stubs\CalculateRequest.pb-c.obj" "Communication\PMR\Stubs\CalculateResponse.pb-c.obj" "Communication\PMR\Stubs\ProgressRequest.pb-c.obj" "Communication\PMR\Stubs\ProgressResponse.pb-c.obj" "Communication\PMR\Stubs\StubAbortJobRequest.pb-c.obj" "Communication\PMR\Stubs\StubAbortJobResponse.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeReadRequest.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeWriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeWriteResponse.pb-c.obj" "Communication\PMR\Stubs\StubDancerPositionRequest.pb-c.obj" "Communication\PMR\Stubs\StubDancerPositionResponse.pb-c.obj" "Communication\PMR\Stubs\StubDispenserRequest.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubDispenserResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadWordsRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadWordsResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteWordsRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteWordsResponse.pb-c.obj" "Communication\PMR\Stubs\StubF3Gpo01WriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubF3Gpo01WriteResponse.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadBackRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadBackRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubFpgaReadRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFpgaReadRegResponse.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubFpgaWriteRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFpgaWriteRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOInputSetupRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOInputSetupResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadBitRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadBitResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadByteRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadByteResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteBitRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteBitResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteByteRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteByteResponse.pb-c.obj" "Communication\PMR\Stubs\StubHWVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubHWVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubHeaterRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeaterResponse.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestPollRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestPollResponse.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubHeatingTestRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CReadBytesRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CReadBytesResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CWriteBytesRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CWriteBytesResponse.pb-c.obj" "Communication\PMR\Stubs\StubIntADCReadRequest.pb-c.obj" "Communication\PMR\Stubs\StubIntADCReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubJobRequest.pb-c.obj" "Communication\PMR\Stubs\StubJobResponse.pb-c.obj" "Communication\PMR\Stubs\StubL6470DriverRequest.pb-c.obj" "Communication\PMR\Stubs\StubL6470DriverResponse.pb-c.obj" "Communication\PMR\Stubs\StubMidTankPressureSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubMidTankPressureSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorHomeMarkRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorHomeMarkResponse.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubMotorInitRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorInitResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorMovRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorMovResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorPositionRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorPositionResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunStepTickRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunStepTickResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorSpeedRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorSpeedResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorStatusRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorStatusResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorStopRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorStopResponse.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubOptLimitSwitchRequest.pb-c.obj" "Communication\PMR\Stubs\StubOptLimitSwitchResponse.pb-c.obj" "Communication\PMR\Stubs\StubReadEmbeddedVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubReadEmbeddedVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubRealTimeUsageRequest.pb-c.obj" "Communication\PMR\Stubs\StubRealTimeUsageResponse.pb-c.obj" "Communication\PMR\Stubs\StubSpeedSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubSpeedSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubSteperMotorRequest.pb-c.obj" "Communication\PMR\Stubs\StubSteperMotorResponse.pb-c.obj" "Communication\PMR\Stubs\StubTempSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubTempSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubTivaReadRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubTivaReadRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubTivaWriteRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubTivaWriteRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubValveRequest.pb-c.obj" - -$(RM) "Communication\PMR\Stubs\StubValveResponse.pb-c.obj" "Drivers\ADC_Sampling\ADC.obj" "Drivers\FPGA\FPGA.obj" "Drivers\FPGA\FPGA_SPI_Comm.obj" "Drivers\FPGA\FPGA_SSI_Comm.obj" "Drivers\FPGA\FPGA_GPIO\FPGA_GPIO.obj" "Drivers\FPGA\FPGA_INTERRUPTS\FPGA_Interrupts.obj" "Drivers\FPGA\Full_Vme\FPGA_Programming_Up.obj" "Drivers\FPGA\Full_Vme\ispvme\hardware.obj" "Drivers\FPGA\Full_Vme\ispvme\ispvm_ui.obj" "Drivers\FPGA\Full_Vme\ispvme\ivm_core.obj" "Drivers\FPGA\Moters_Driver\L6470.obj" "Drivers\Flash_Memory\FATFS\Control_File_System.obj" "Drivers\Flash_Memory\FATFS\cc932.obj" "Drivers\Flash_Memory\FATFS\fatfs_port_mx66l51235f.obj" "Drivers\Flash_Memory\FATFS\ff.obj" "Drivers\Flash_Memory\FATFS\mx66l51235f.obj" "Drivers\Flash_Memory\FATFS\spi_flash.obj" "Drivers\Flash_Memory\Flash_Memory.obj" "Drivers\Heater\ADS1220.obj" "Drivers\Heater\Heater.obj" "Drivers\Heater\TemperatureSensor.obj" "Drivers\I2C_Communication\ADC_MUX\ADC_MUX.obj" "Drivers\I2C_Communication\DAC\Blower.obj" "Drivers\I2C_Communication\Dispensers_EEPROM_MUX\Disp_EEPROM_MUX.obj" - -$(RM) "Drivers\I2C_Communication\I2C.obj" "Drivers\I2C_Communication\I2C_Comm.obj" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\NFC_I2C.obj" "Drivers\I2C_Communication\RFID_NFC\PN7150\PN7150.obj" "Drivers\I2C_Communication\Thermo_K\MCP9600.obj" "Drivers\Motors\Motor.obj" "Drivers\Motors\MotorActions.obj" "Drivers\On_Chip_Flash\Flashstore.obj" "Drivers\SPI\SPI_Comm.obj" "Drivers\SSI_Comm\Dancer\Dancer.obj" "Drivers\SSI_Comm\SSI_Comm.obj" "Drivers\SSI_Comm\Speed_Sensor\Speed_Sensor.obj" "Drivers\USB_Communication\USBCDCD.obj" "Drivers\Uart_Comm\Uart.obj" "Drivers\Valves\Valve.obj" "Drivers\flash_ram\FlashProgram.obj" "Modules\AlarmHandling\AlarmHandling.obj" "Modules\Control\DriverWithCallbackExample.obj" "Modules\Control\MillisecTask.obj" "Modules\Control\PIDAlgo.obj" "Modules\Control\control.obj" "Modules\Diagnostics\DiagnosticActions.obj" "Modules\Diagnostics\Diagnostics.obj" "Modules\Diagnostics\DiagnosticsHoming.obj" "Modules\Diagnostics\DiagnosticsJogging.obj" "Modules\General\GeneralHardware.obj" - -$(RM) "Modules\General\buttons.obj" "Modules\General\process.obj" "Modules\Heaters\Heaters_bit.obj" "Modules\Heaters\Heaters_init.obj" "Modules\Heaters\Heaters_maint.obj" "Modules\Heaters\Heaters_print.obj" "Modules\IDS\IDS_BIT.obj" "Modules\IDS\IDS_dispenser.obj" "Modules\IDS\IDS_init.obj" "Modules\IDS\IDS_maint.obj" "Modules\IDS\IDS_print.obj" "Modules\Stubs_Handler\Calculate.obj" "Modules\Stubs_Handler\Progress.obj" "Modules\Stubs_Handler\StubRealTimeUsage.obj" "Modules\Stubs_Handler\Stub_Cartridge.obj" "Modules\Stubs_Handler\Stub_Dancer.obj" "Modules\Stubs_Handler\Stub_Dispenser.obj" "Modules\Stubs_Handler\Stub_ExtFlash.obj" "Modules\Stubs_Handler\Stub_FPGARWReg.obj" "Modules\Stubs_Handler\Stub_FPGAReadBackReg.obj" "Modules\Stubs_Handler\Stub_FPGAReadVersion.obj" "Modules\Stubs_Handler\Stub_GPIO.obj" "Modules\Stubs_Handler\Stub_HW_Version.obj" "Modules\Stubs_Handler\Stub_Heater.obj" "Modules\Stubs_Handler\Stub_I2C.obj" "Modules\Stubs_Handler\Stub_IntADC.obj" "Modules\Stubs_Handler\Stub_L6470.obj" - -$(RM) "Modules\Stubs_Handler\Stub_MidTankPressureSensor.obj" "Modules\Stubs_Handler\Stub_Motor.obj" "Modules\Stubs_Handler\Stub_OptLimitSwitch.obj" "Modules\Stubs_Handler\Stub_ReadEmbeddedVersion.obj" "Modules\Stubs_Handler\Stub_SpeedSensor.obj" "Modules\Stubs_Handler\Stub_Status.obj" "Modules\Stubs_Handler\Stub_SteperMotor.obj" "Modules\Stubs_Handler\Stub_TempSensor.obj" "Modules\Stubs_Handler\Stub_TivaReg.obj" "Modules\Stubs_Handler\Stub_Valve.obj" "Modules\Stubs_Handler\User_Leds.obj" "Modules\Stubs_Handler\temperature_sensor.obj" "Modules\Thread\ThreadLoad.obj" "Modules\Thread\Thread_BIT.obj" "Modules\Thread\Thread_Winder.obj" "Modules\Thread\Thread_init.obj" "Modules\Thread\Thread_maint.obj" "Modules\Thread\Thread_print.obj" "Modules\Waste\Waste_BIT.obj" "Modules\Waste\Waste_init.obj" "Modules\Waste\Waste_maint.obj" "Modules\Waste\Waste_print.obj" "StateMachines\Initialization\InitSequence.obj" "StateMachines\Printing\JobSTM.obj" "StateMachines\Printing\PrintingSTM.obj" + -$(RM) "Communication\PMR\Connection\DisconnectResponse.pb-c.obj" "Communication\PMR\Connection\KeepAliveRequest.pb-c.obj" "Communication\PMR\Connection\KeepAliveResponse.pb-c.obj" "Communication\PMR\Debugging\DebugDistributor.pb-c.obj" "Communication\PMR\Debugging\DebugLogCategory.pb-c.obj" "Communication\PMR\Debugging\SetupDebugDisributorsRequest.pb-c.obj" "Communication\PMR\Debugging\SetupDebugDisributorsResponse.pb-c.obj" "Communication\PMR\Debugging\StartDebugLogRequest.pb-c.obj" "Communication\PMR\Debugging\StartDebugLogResponse.pb-c.obj" "Communication\PMR\Debugging\StopDebugLogRequest.pb-c.obj" "Communication\PMR\Debugging\StopDebugLogResponse.pb-c.obj" "Communication\PMR\Diagnostics\DataFileFrame.pb-c.obj" "Communication\PMR\Diagnostics\DiagnosticsMonitors.pb-c.obj" "Communication\PMR\Diagnostics\DigitalInterfaceState.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DispenserAbortJoggingRequest.pb-c.obj" + -$(RM) "Communication\PMR\Diagnostics\DispenserAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DispenserHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DispenserJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\DispenserJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\DoubleArray.pb-c.obj" "Communication\PMR\Diagnostics\Event.pb-c.obj" "Communication\PMR\Diagnostics\EventType.pb-c.obj" "Communication\PMR\Diagnostics\HeaterState.pb-c.obj" "Communication\PMR\Diagnostics\HeaterType.pb-c.obj" "Communication\PMR\Diagnostics\InterfaceIOs.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortHomingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorDirection.pb-c.obj" "Communication\PMR\Diagnostics\MotorHomingRequest.pb-c.obj" + -$(RM) "Communication\PMR\Diagnostics\MotorHomingResponse.pb-c.obj" "Communication\PMR\Diagnostics\MotorJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\MotorJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\ResolveEventRequest.pb-c.obj" "Communication\PMR\Diagnostics\ResolveEventResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetBlowerStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetBlowerStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetComponentValueRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetComponentValueResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetDigitalOutRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetDigitalOutResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetHeaterStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetHeaterStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\SetValveStateRequest.pb-c.obj" "Communication\PMR\Diagnostics\SetValveStateResponse.pb-c.obj" "Communication\PMR\Diagnostics\StartDiagnosticsRequest.pb-c.obj" + -$(RM) "Communication\PMR\Diagnostics\StartDiagnosticsResponse.pb-c.obj" "Communication\PMR\Diagnostics\StartEventsNotificationRequest.pb-c.obj" "Communication\PMR\Diagnostics\StartEventsNotificationResponse.pb-c.obj" "Communication\PMR\Diagnostics\StopDiagnosticsRequest.pb-c.obj" "Communication\PMR\Diagnostics\StopDiagnosticsResponse.pb-c.obj" "Communication\PMR\Diagnostics\StopEventsNotificationRequest.pb-c.obj" "Communication\PMR\Diagnostics\StopEventsNotificationResponse.pb-c.obj" "Communication\PMR\Diagnostics\ThreadAbortJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\ThreadAbortJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\ThreadJoggingRequest.pb-c.obj" "Communication\PMR\Diagnostics\ThreadJoggingResponse.pb-c.obj" "Communication\PMR\Diagnostics\ValueComponent.pb-c.obj" "Communication\PMR\Diagnostics\ValueComponentState.pb-c.obj" "Communication\PMR\Diagnostics\ValveState.pb-c.obj" "Communication\PMR\Diagnostics\ValveStateCode.pb-c.obj" "Communication\PMR\Diagnostics\ValveType.pb-c.obj" + -$(RM) "Communication\PMR\EmbeddedParameters\AlarmHandlingItem.pb-c.obj" "Communication\PMR\EmbeddedParameters\AlarmParameters.pb-c.obj" "Communication\PMR\EmbeddedParameters\AlarmSourceType.pb-c.obj" "Communication\PMR\EmbeddedParameters\ConfigurationParameters.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserData.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserDataRequest.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserDataResponse.pb-c.obj" "Communication\PMR\EmbeddedParameters\DispenserRunningData.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ActivateVersionRequest.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ActivateVersionResponse.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ValidateVersionRequest.pb-c.obj" "Communication\PMR\FirmwareUpgrade\ValidateVersionResponse.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionFileDescriptor.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionFileDestination.pb-c.obj" "Communication\PMR\FirmwareUpgrade\VersionPackageDescriptor.pb-c.obj" + -$(RM) "Communication\PMR\Hardware\HardwareBlower.pb-c.obj" "Communication\PMR\Hardware\HardwareBlowerType.pb-c.obj" "Communication\PMR\Hardware\HardwareBreakSensor.pb-c.obj" "Communication\PMR\Hardware\HardwareBreakSensorType.pb-c.obj" "Communication\PMR\Hardware\HardwareConfiguration.pb-c.obj" "Communication\PMR\Hardware\HardwareDancer.pb-c.obj" "Communication\PMR\Hardware\HardwareDancerType.pb-c.obj" "Communication\PMR\Hardware\HardwareDispenser.pb-c.obj" "Communication\PMR\Hardware\HardwareDispenserType.pb-c.obj" "Communication\PMR\Hardware\HardwareMotor.pb-c.obj" "Communication\PMR\Hardware\HardwareMotorType.pb-c.obj" "Communication\PMR\Hardware\HardwarePidControl.pb-c.obj" "Communication\PMR\Hardware\HardwarePidControlType.pb-c.obj" "Communication\PMR\Hardware\HardwareSpeedSensor.pb-c.obj" "Communication\PMR\Hardware\HardwareSpeedSensorType.pb-c.obj" "Communication\PMR\Hardware\HardwareWinder.pb-c.obj" "Communication\PMR\Hardware\HardwareWinderType.pb-c.obj" "Communication\PMR\Hardware\SystemResetRequest.pb-c.obj" + -$(RM) "Communication\PMR\Hardware\SystemResetResponse.pb-c.obj" "Communication\PMR\Hardware\UploadHardwareConfigurationRequest.pb-c.obj" "Communication\PMR\Hardware\UploadHardwareConfigurationResponse.pb-c.obj" "Communication\PMR\IO\CreateRequest.pb-c.obj" "Communication\PMR\IO\CreateResponse.pb-c.obj" "Communication\PMR\IO\DeleteRequest.pb-c.obj" "Communication\PMR\IO\DeleteResponse.pb-c.obj" "Communication\PMR\IO\ExecuteProcessRequest.pb-c.obj" "Communication\PMR\IO\ExecuteProcessResponse.pb-c.obj" "Communication\PMR\IO\FileAttribute.pb-c.obj" "Communication\PMR\IO\FileChunkDownloadRequest.pb-c.obj" "Communication\PMR\IO\FileChunkDownloadResponse.pb-c.obj" "Communication\PMR\IO\FileChunkUploadRequest.pb-c.obj" "Communication\PMR\IO\FileChunkUploadResponse.pb-c.obj" "Communication\PMR\IO\FileDownloadRequest.pb-c.obj" "Communication\PMR\IO\FileDownloadResponse.pb-c.obj" "Communication\PMR\IO\FileInfo.pb-c.obj" "Communication\PMR\IO\FileUploadRequest.pb-c.obj" "Communication\PMR\IO\FileUploadResponse.pb-c.obj" + -$(RM) "Communication\PMR\IO\GetFilesRequest.pb-c.obj" "Communication\PMR\IO\GetFilesResponse.pb-c.obj" "Communication\PMR\IO\GetStorageInfoRequest.pb-c.obj" "Communication\PMR\IO\GetStorageInfoResponse.pb-c.obj" "Communication\PMR\IO\KillProcessRequest.pb-c.obj" "Communication\PMR\IO\KillProcessResponse.pb-c.obj" "Communication\PMR\Printing\AbortJobRequest.pb-c.obj" "Communication\PMR\Printing\AbortJobResponse.pb-c.obj" "Communication\PMR\Printing\CurrentJobRequest.pb-c.obj" "Communication\PMR\Printing\CurrentJobResponse.pb-c.obj" "Communication\PMR\Printing\DispenserLiquidType.pb-c.obj" "Communication\PMR\Printing\DispenserStepDivision.pb-c.obj" "Communication\PMR\Printing\JobBrushStop.pb-c.obj" "Communication\PMR\Printing\JobDescriptionFileBrushStop.pb-c.obj" "Communication\PMR\Printing\JobDescriptionFileSegment.pb-c.obj" "Communication\PMR\Printing\JobDispenser.pb-c.obj" "Communication\PMR\Printing\JobRequest.pb-c.obj" "Communication\PMR\Printing\JobResponse.pb-c.obj" "Communication\PMR\Printing\JobSegment.pb-c.obj" + -$(RM) "Communication\PMR\Printing\JobSpool.pb-c.obj" "Communication\PMR\Printing\JobSpoolType.pb-c.obj" "Communication\PMR\Printing\JobStatus.pb-c.obj" "Communication\PMR\Printing\JobTicket.pb-c.obj" "Communication\PMR\Printing\JobUploadStrategy.pb-c.obj" "Communication\PMR\Printing\JobWindingMethod.pb-c.obj" "Communication\PMR\Printing\ProcessParameters.pb-c.obj" "Communication\PMR\Printing\ResumeCurrentJobRequest.pb-c.obj" "Communication\PMR\Printing\ResumeCurrentJobResponse.pb-c.obj" "Communication\PMR\Printing\UploadProcessParametersRequest.pb-c.obj" "Communication\PMR\Printing\UploadProcessParametersResponse.pb-c.obj" "Communication\PMR\Stubs\CalculateRequest.pb-c.obj" "Communication\PMR\Stubs\CalculateResponse.pb-c.obj" "Communication\PMR\Stubs\ProgressRequest.pb-c.obj" "Communication\PMR\Stubs\ProgressResponse.pb-c.obj" "Communication\PMR\Stubs\StubAbortJobRequest.pb-c.obj" "Communication\PMR\Stubs\StubAbortJobResponse.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeReadRequest.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubCartridgeReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeWriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubCartridgeWriteResponse.pb-c.obj" "Communication\PMR\Stubs\StubDancerPositionRequest.pb-c.obj" "Communication\PMR\Stubs\StubDancerPositionResponse.pb-c.obj" "Communication\PMR\Stubs\StubDispenserRequest.pb-c.obj" "Communication\PMR\Stubs\StubDispenserResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadWordsRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashReadWordsResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteResponse.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteWordsRequest.pb-c.obj" "Communication\PMR\Stubs\StubExtFlashWriteWordsResponse.pb-c.obj" "Communication\PMR\Stubs\StubF3Gpo01WriteRequest.pb-c.obj" "Communication\PMR\Stubs\StubF3Gpo01WriteResponse.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubFPGAReadBackRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadBackRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubFPGAReadVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubFpgaReadRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFpgaReadRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubFpgaWriteRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubFpgaWriteRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOInputSetupRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOInputSetupResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadBitRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadBitResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadByteRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOReadByteResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteBitRequest.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteBitResponse.pb-c.obj" "Communication\PMR\Stubs\StubGPIOWriteByteRequest.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubGPIOWriteByteResponse.pb-c.obj" "Communication\PMR\Stubs\StubHWVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubHWVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubHeaterRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeaterResponse.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestPollRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestPollResponse.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestRequest.pb-c.obj" "Communication\PMR\Stubs\StubHeatingTestResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CReadBytesRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CReadBytesResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CResponse.pb-c.obj" "Communication\PMR\Stubs\StubI2CWriteBytesRequest.pb-c.obj" "Communication\PMR\Stubs\StubI2CWriteBytesResponse.pb-c.obj" "Communication\PMR\Stubs\StubIntADCReadRequest.pb-c.obj" "Communication\PMR\Stubs\StubIntADCReadResponse.pb-c.obj" "Communication\PMR\Stubs\StubJobRequest.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubJobResponse.pb-c.obj" "Communication\PMR\Stubs\StubL6470DriverRequest.pb-c.obj" "Communication\PMR\Stubs\StubL6470DriverResponse.pb-c.obj" "Communication\PMR\Stubs\StubMidTankPressureSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubMidTankPressureSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorHomeMarkRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorHomeMarkResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorInitRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorInitResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorMovRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorMovResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorPositionRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorPositionResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorRunStepTickRequest.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubMotorRunStepTickResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorSpeedRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorSpeedResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorStatusRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorStatusResponse.pb-c.obj" "Communication\PMR\Stubs\StubMotorStopRequest.pb-c.obj" "Communication\PMR\Stubs\StubMotorStopResponse.pb-c.obj" "Communication\PMR\Stubs\StubOptLimitSwitchRequest.pb-c.obj" "Communication\PMR\Stubs\StubOptLimitSwitchResponse.pb-c.obj" "Communication\PMR\Stubs\StubReadEmbeddedVersionRequest.pb-c.obj" "Communication\PMR\Stubs\StubReadEmbeddedVersionResponse.pb-c.obj" "Communication\PMR\Stubs\StubRealTimeUsageRequest.pb-c.obj" "Communication\PMR\Stubs\StubRealTimeUsageResponse.pb-c.obj" "Communication\PMR\Stubs\StubSpeedSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubSpeedSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubSteperMotorRequest.pb-c.obj" "Communication\PMR\Stubs\StubSteperMotorResponse.pb-c.obj" + -$(RM) "Communication\PMR\Stubs\StubTempSensorRequest.pb-c.obj" "Communication\PMR\Stubs\StubTempSensorResponse.pb-c.obj" "Communication\PMR\Stubs\StubTivaReadRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubTivaReadRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubTivaWriteRegRequest.pb-c.obj" "Communication\PMR\Stubs\StubTivaWriteRegResponse.pb-c.obj" "Communication\PMR\Stubs\StubValveRequest.pb-c.obj" "Communication\PMR\Stubs\StubValveResponse.pb-c.obj" "Drivers\ADC_Sampling\ADC.obj" "Drivers\FPGA\FPGA.obj" "Drivers\FPGA\FPGA_SPI_Comm.obj" "Drivers\FPGA\FPGA_SSI_Comm.obj" "Drivers\FPGA\FPGA_GPIO\FPGA_GPIO.obj" "Drivers\FPGA\FPGA_INTERRUPTS\FPGA_Interrupts.obj" "Drivers\FPGA\Full_Vme\FPGA_Programming_Up.obj" "Drivers\FPGA\Full_Vme\ispvme\hardware.obj" "Drivers\FPGA\Full_Vme\ispvme\ispvm_ui.obj" "Drivers\FPGA\Full_Vme\ispvme\ivm_core.obj" "Drivers\FPGA\Motors_Driver\L6470.obj" "Drivers\Flash_Memory\FATFS\Control_File_System.obj" "Drivers\Flash_Memory\FATFS\cc932.obj" "Drivers\Flash_Memory\FATFS\fatfs_port_mx66l51235f.obj" + -$(RM) "Drivers\Flash_Memory\FATFS\ff.obj" "Drivers\Flash_Memory\FATFS\mx66l51235f.obj" "Drivers\Flash_Memory\FATFS\spi_flash.obj" "Drivers\Flash_Memory\Flash_Memory.obj" "Drivers\Heater\ADS1220.obj" "Drivers\Heater\Heater.obj" "Drivers\Heater\TemperatureSensor.obj" "Drivers\I2C_Communication\ADC_MUX\ADC_MUX.obj" "Drivers\I2C_Communication\DAC\Blower.obj" "Drivers\I2C_Communication\Dispenser_Card\EEPROM\Dispenser_EEPROM.obj" "Drivers\I2C_Communication\Dispenser_Card\I2C_Dispenser_Card_Mux.obj" "Drivers\I2C_Communication\Dispenser_Card\IO_Ports\Dispenser_IO.obj" "Drivers\I2C_Communication\I2C.obj" "Drivers\I2C_Communication\I2C_Comm.obj" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\NFC_I2C.obj" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\Test_NFC.obj" "Drivers\I2C_Communication\RFID_NFC\PN7150\PN7150.obj" "Drivers\I2C_Communication\Thermo_K\MCP9600.obj" "Drivers\Motors\Motor.obj" "Drivers\Motors\MotorActions.obj" "Drivers\On_Chip_Flash\Flashstore.obj" "Drivers\SPI\SPI_Comm.obj" "Drivers\SSI_Comm\Dancer\Dancer.obj" + -$(RM) "Drivers\SSI_Comm\SSI_Comm.obj" "Drivers\SSI_Comm\Speed_Sensor\Speed_Sensor.obj" "Drivers\USB_Communication\USBCDCD.obj" "Drivers\Uart_Comm\Uart.obj" "Drivers\Valves\Valve.obj" "Drivers\flash_ram\FlashProgram.obj" "Modules\AlarmHandling\AlarmHandling.obj" "Modules\Control\DriverWithCallbackExample.obj" "Modules\Control\MillisecTask.obj" "Modules\Control\PIDAlgo.obj" "Modules\Control\control.obj" "Modules\Diagnostics\DiagnosticActions.obj" "Modules\Diagnostics\Diagnostics.obj" "Modules\Diagnostics\DiagnosticsHoming.obj" "Modules\Diagnostics\DiagnosticsJogging.obj" "Modules\General\GeneralHardware.obj" "Modules\General\Safety.obj" "Modules\General\buttons.obj" "Modules\General\process.obj" "Modules\Heaters\Heaters_bit.obj" "Modules\Heaters\Heaters_init.obj" "Modules\Heaters\Heaters_maint.obj" "Modules\Heaters\Heaters_print.obj" "Modules\IDS\IDS_BIT.obj" "Modules\IDS\IDS_Cleaning.obj" "Modules\IDS\IDS_dispenser.obj" "Modules\IDS\IDS_init.obj" "Modules\IDS\IDS_maint.obj" "Modules\IDS\IDS_print.obj" + -$(RM) "Modules\Stubs_Handler\Calculate.obj" "Modules\Stubs_Handler\Progress.obj" "Modules\Stubs_Handler\StubRealTimeUsage.obj" "Modules\Stubs_Handler\Stub_Cartridge.obj" "Modules\Stubs_Handler\Stub_Dancer.obj" "Modules\Stubs_Handler\Stub_Dispenser.obj" "Modules\Stubs_Handler\Stub_ExtFlash.obj" "Modules\Stubs_Handler\Stub_FPGARWReg.obj" "Modules\Stubs_Handler\Stub_FPGAReadBackReg.obj" "Modules\Stubs_Handler\Stub_FPGAReadVersion.obj" "Modules\Stubs_Handler\Stub_GPIO.obj" "Modules\Stubs_Handler\Stub_HW_Version.obj" "Modules\Stubs_Handler\Stub_Heater.obj" "Modules\Stubs_Handler\Stub_I2C.obj" "Modules\Stubs_Handler\Stub_IntADC.obj" "Modules\Stubs_Handler\Stub_L6470.obj" "Modules\Stubs_Handler\Stub_MidTankPressureSensor.obj" "Modules\Stubs_Handler\Stub_Motor.obj" "Modules\Stubs_Handler\Stub_OptLimitSwitch.obj" "Modules\Stubs_Handler\Stub_ReadEmbeddedVersion.obj" "Modules\Stubs_Handler\Stub_SpeedSensor.obj" "Modules\Stubs_Handler\Stub_Status.obj" "Modules\Stubs_Handler\Stub_SteperMotor.obj" "Modules\Stubs_Handler\Stub_TempSensor.obj" + -$(RM) "Modules\Stubs_Handler\Stub_TivaReg.obj" "Modules\Stubs_Handler\Stub_Valve.obj" "Modules\Stubs_Handler\User_Leds.obj" "Modules\Stubs_Handler\temperature_sensor.obj" "Modules\Thread\ThreadLoad.obj" "Modules\Thread\Thread_BIT.obj" "Modules\Thread\Thread_Winder.obj" "Modules\Thread\Thread_init.obj" "Modules\Thread\Thread_maint.obj" "Modules\Thread\Thread_print.obj" "Modules\Waste\Waste_BIT.obj" "Modules\Waste\Waste_init.obj" "Modules\Waste\Waste_maint.obj" "Modules\Waste\Waste_print.obj" "StateMachines\Initialization\InitSequence.obj" "StateMachines\Initialization\PowerIdle.obj" "StateMachines\Initialization\PowerOffSequence.obj" "StateMachines\Printing\JobSTM.obj" "StateMachines\Printing\PrintingSTM.obj" -$(RM) "Main.d" "delay.d" "Common\SWUpdate\FileSystem.d" "Common\SWUpdate\FirmwareUpgrade.d" "Common\SW_Info\SW_Info.d" "Common\Software_CRC\sw_crc.d" "Common\Sys_PinOut_Config\MCU_MAIN_pinout.d" "Common\Sys_PinOut_Config\Pin.d" "Common\Sys_PinOut_Config\Pin_config.d" "Common\Utilities\Update.d" "Common\Utilities\Utils.d" "Common\Utilities\idle_task.d" "Common\Utilities\ustdlib.d" "Common\protobuf-c\protobuf-c.d" "Common\report\distributor.d" "Common\report\filter.d" "Common\report\reportInit.d" "Communication\CommunicationTask.d" "Communication\Connection.d" "Communication\Container.d" "Communication\PMR\Common\ErrorCode.pb-c.d" "Communication\PMR\Common\ErrorResponse.pb-c.d" "Communication\PMR\Common\MessageContainer.pb-c.d" "Communication\PMR\Common\MessageType.pb-c.d" "Communication\PMR\Connection\ConnectRequest.pb-c.d" "Communication\PMR\Connection\ConnectResponse.pb-c.d" "Communication\PMR\Connection\DeviceInformation.pb-c.d" "Communication\PMR\Connection\DisconnectRequest.pb-c.d" "Communication\PMR\Connection\DisconnectResponse.pb-c.d" - -$(RM) "Communication\PMR\Connection\KeepAliveRequest.pb-c.d" "Communication\PMR\Connection\KeepAliveResponse.pb-c.d" "Communication\PMR\Debugging\DebugLogCategory.pb-c.d" "Communication\PMR\Debugging\StartDebugLogRequest.pb-c.d" "Communication\PMR\Debugging\StartDebugLogResponse.pb-c.d" "Communication\PMR\Debugging\StopDebugLogRequest.pb-c.d" "Communication\PMR\Debugging\StopDebugLogResponse.pb-c.d" "Communication\PMR\Diagnostics\DataFileFrame.pb-c.d" "Communication\PMR\Diagnostics\DiagnosticsMonitors.pb-c.d" "Communication\PMR\Diagnostics\DigitalInterfaceState.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\DispenserHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\DispenserJoggingRequest.pb-c.d" - -$(RM) "Communication\PMR\Diagnostics\DispenserJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\DoubleArray.pb-c.d" "Communication\PMR\Diagnostics\Event.pb-c.d" "Communication\PMR\Diagnostics\EventType.pb-c.d" "Communication\PMR\Diagnostics\HeaterState.pb-c.d" "Communication\PMR\Diagnostics\HeaterType.pb-c.d" "Communication\PMR\Diagnostics\InterfaceIOs.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorDirection.pb-c.d" "Communication\PMR\Diagnostics\MotorHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ResolveEventRequest.pb-c.d" "Communication\PMR\Diagnostics\ResolveEventResponse.pb-c.d" - -$(RM) "Communication\PMR\Diagnostics\SetBlowerStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetBlowerStateResponse.pb-c.d" "Communication\PMR\Diagnostics\SetComponentValueRequest.pb-c.d" "Communication\PMR\Diagnostics\SetComponentValueResponse.pb-c.d" "Communication\PMR\Diagnostics\SetDigitalOutRequest.pb-c.d" "Communication\PMR\Diagnostics\SetDigitalOutResponse.pb-c.d" "Communication\PMR\Diagnostics\SetHeaterStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetHeaterStateResponse.pb-c.d" "Communication\PMR\Diagnostics\SetValveStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetValveStateResponse.pb-c.d" "Communication\PMR\Diagnostics\StartDiagnosticsRequest.pb-c.d" "Communication\PMR\Diagnostics\StartDiagnosticsResponse.pb-c.d" "Communication\PMR\Diagnostics\StartEventsNotificationRequest.pb-c.d" "Communication\PMR\Diagnostics\StartEventsNotificationResponse.pb-c.d" "Communication\PMR\Diagnostics\StopDiagnosticsRequest.pb-c.d" "Communication\PMR\Diagnostics\StopDiagnosticsResponse.pb-c.d" - -$(RM) "Communication\PMR\Diagnostics\StopEventsNotificationRequest.pb-c.d" "Communication\PMR\Diagnostics\StopEventsNotificationResponse.pb-c.d" "Communication\PMR\Diagnostics\ThreadAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\ThreadAbortJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ThreadJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\ThreadJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ValueComponent.pb-c.d" "Communication\PMR\Diagnostics\ValueComponentState.pb-c.d" "Communication\PMR\Diagnostics\ValveState.pb-c.d" "Communication\PMR\Diagnostics\ValveStateCode.pb-c.d" "Communication\PMR\Diagnostics\ValveType.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmHandlingItem.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmParameters.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmSourceType.pb-c.d" "Communication\PMR\EmbeddedParameters\ConfigurationParameters.pb-c.d" "Communication\PMR\EmbeddedParameters\DispenserData.pb-c.d" "Communication\PMR\EmbeddedParameters\DispenserRunningData.pb-c.d" - -$(RM) "Communication\PMR\FirmwareUpgrade\ActivateVersionRequest.pb-c.d" "Communication\PMR\FirmwareUpgrade\ActivateVersionResponse.pb-c.d" "Communication\PMR\FirmwareUpgrade\ValidateVersionRequest.pb-c.d" "Communication\PMR\FirmwareUpgrade\ValidateVersionResponse.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionFileDescriptor.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionFileDestination.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionPackageDescriptor.pb-c.d" "Communication\PMR\Hardware\HardwareBlower.pb-c.d" "Communication\PMR\Hardware\HardwareBlowerType.pb-c.d" "Communication\PMR\Hardware\HardwareBreakSensor.pb-c.d" "Communication\PMR\Hardware\HardwareBreakSensorType.pb-c.d" "Communication\PMR\Hardware\HardwareConfiguration.pb-c.d" "Communication\PMR\Hardware\HardwareDancer.pb-c.d" "Communication\PMR\Hardware\HardwareDancerType.pb-c.d" "Communication\PMR\Hardware\HardwareDispenser.pb-c.d" "Communication\PMR\Hardware\HardwareDispenserType.pb-c.d" "Communication\PMR\Hardware\HardwareMotor.pb-c.d" - -$(RM) "Communication\PMR\Hardware\HardwareMotorType.pb-c.d" "Communication\PMR\Hardware\HardwarePidControl.pb-c.d" "Communication\PMR\Hardware\HardwarePidControlType.pb-c.d" "Communication\PMR\Hardware\HardwareSpeedSensor.pb-c.d" "Communication\PMR\Hardware\HardwareSpeedSensorType.pb-c.d" "Communication\PMR\Hardware\HardwareWinder.pb-c.d" "Communication\PMR\Hardware\HardwareWinderType.pb-c.d" "Communication\PMR\Hardware\SystemResetRequest.pb-c.d" "Communication\PMR\Hardware\SystemResetResponse.pb-c.d" "Communication\PMR\Hardware\UploadHardwareConfigurationRequest.pb-c.d" "Communication\PMR\Hardware\UploadHardwareConfigurationResponse.pb-c.d" "Communication\PMR\IO\CreateRequest.pb-c.d" "Communication\PMR\IO\CreateResponse.pb-c.d" "Communication\PMR\IO\DeleteRequest.pb-c.d" "Communication\PMR\IO\DeleteResponse.pb-c.d" "Communication\PMR\IO\ExecuteProcessRequest.pb-c.d" "Communication\PMR\IO\ExecuteProcessResponse.pb-c.d" "Communication\PMR\IO\FileAttribute.pb-c.d" "Communication\PMR\IO\FileChunkDownloadRequest.pb-c.d" - -$(RM) "Communication\PMR\IO\FileChunkDownloadResponse.pb-c.d" "Communication\PMR\IO\FileChunkUploadRequest.pb-c.d" "Communication\PMR\IO\FileChunkUploadResponse.pb-c.d" "Communication\PMR\IO\FileDownloadRequest.pb-c.d" "Communication\PMR\IO\FileDownloadResponse.pb-c.d" "Communication\PMR\IO\FileInfo.pb-c.d" "Communication\PMR\IO\FileUploadRequest.pb-c.d" "Communication\PMR\IO\FileUploadResponse.pb-c.d" "Communication\PMR\IO\GetFilesRequest.pb-c.d" "Communication\PMR\IO\GetFilesResponse.pb-c.d" "Communication\PMR\IO\GetStorageInfoRequest.pb-c.d" "Communication\PMR\IO\GetStorageInfoResponse.pb-c.d" "Communication\PMR\IO\KillProcessRequest.pb-c.d" "Communication\PMR\IO\KillProcessResponse.pb-c.d" "Communication\PMR\Printing\AbortJobRequest.pb-c.d" "Communication\PMR\Printing\AbortJobResponse.pb-c.d" "Communication\PMR\Printing\CurrentJobRequest.pb-c.d" "Communication\PMR\Printing\CurrentJobResponse.pb-c.d" "Communication\PMR\Printing\DispenserLiquidType.pb-c.d" "Communication\PMR\Printing\DispenserStepDivision.pb-c.d" - -$(RM) "Communication\PMR\Printing\JobBrushStop.pb-c.d" "Communication\PMR\Printing\JobDescriptionFileBrushStop.pb-c.d" "Communication\PMR\Printing\JobDescriptionFileSegment.pb-c.d" "Communication\PMR\Printing\JobDispenser.pb-c.d" "Communication\PMR\Printing\JobRequest.pb-c.d" "Communication\PMR\Printing\JobResponse.pb-c.d" "Communication\PMR\Printing\JobSegment.pb-c.d" "Communication\PMR\Printing\JobSpool.pb-c.d" "Communication\PMR\Printing\JobSpoolType.pb-c.d" "Communication\PMR\Printing\JobStatus.pb-c.d" "Communication\PMR\Printing\JobTicket.pb-c.d" "Communication\PMR\Printing\JobUploadStrategy.pb-c.d" "Communication\PMR\Printing\JobWindingMethod.pb-c.d" "Communication\PMR\Printing\ProcessParameters.pb-c.d" "Communication\PMR\Printing\ResumeCurrentJobRequest.pb-c.d" "Communication\PMR\Printing\ResumeCurrentJobResponse.pb-c.d" "Communication\PMR\Printing\UploadProcessParametersRequest.pb-c.d" "Communication\PMR\Printing\UploadProcessParametersResponse.pb-c.d" "Communication\PMR\Stubs\CalculateRequest.pb-c.d" - -$(RM) "Communication\PMR\Stubs\CalculateResponse.pb-c.d" "Communication\PMR\Stubs\ProgressRequest.pb-c.d" "Communication\PMR\Stubs\ProgressResponse.pb-c.d" "Communication\PMR\Stubs\StubAbortJobRequest.pb-c.d" "Communication\PMR\Stubs\StubAbortJobResponse.pb-c.d" "Communication\PMR\Stubs\StubCartridgeReadRequest.pb-c.d" "Communication\PMR\Stubs\StubCartridgeReadResponse.pb-c.d" "Communication\PMR\Stubs\StubCartridgeWriteRequest.pb-c.d" "Communication\PMR\Stubs\StubCartridgeWriteResponse.pb-c.d" "Communication\PMR\Stubs\StubDancerPositionRequest.pb-c.d" "Communication\PMR\Stubs\StubDancerPositionResponse.pb-c.d" "Communication\PMR\Stubs\StubDispenserRequest.pb-c.d" "Communication\PMR\Stubs\StubDispenserResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadWordsRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadWordsResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteRequest.pb-c.d" - -$(RM) "Communication\PMR\Stubs\StubExtFlashWriteResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteWordsRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteWordsResponse.pb-c.d" "Communication\PMR\Stubs\StubF3Gpo01WriteRequest.pb-c.d" "Communication\PMR\Stubs\StubF3Gpo01WriteResponse.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadBackRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadBackRegResponse.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubFpgaReadRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFpgaReadRegResponse.pb-c.d" "Communication\PMR\Stubs\StubFpgaWriteRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFpgaWriteRegResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOInputSetupRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOInputSetupResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadBitRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadBitResponse.pb-c.d" - -$(RM) "Communication\PMR\Stubs\StubGPIOReadByteRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadByteResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteBitRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteBitResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteByteRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteByteResponse.pb-c.d" "Communication\PMR\Stubs\StubHWVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubHWVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubHeaterRequest.pb-c.d" "Communication\PMR\Stubs\StubHeaterResponse.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestPollRequest.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestPollResponse.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestRequest.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestResponse.pb-c.d" "Communication\PMR\Stubs\StubI2CReadBytesRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CReadBytesResponse.pb-c.d" "Communication\PMR\Stubs\StubI2CRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CResponse.pb-c.d" - -$(RM) "Communication\PMR\Stubs\StubI2CWriteBytesRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CWriteBytesResponse.pb-c.d" "Communication\PMR\Stubs\StubIntADCReadRequest.pb-c.d" "Communication\PMR\Stubs\StubIntADCReadResponse.pb-c.d" "Communication\PMR\Stubs\StubJobRequest.pb-c.d" "Communication\PMR\Stubs\StubJobResponse.pb-c.d" "Communication\PMR\Stubs\StubL6470DriverRequest.pb-c.d" "Communication\PMR\Stubs\StubL6470DriverResponse.pb-c.d" "Communication\PMR\Stubs\StubMidTankPressureSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubMidTankPressureSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorHomeMarkRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorHomeMarkResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorInitRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorInitResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorMovRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorMovResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorPositionRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorPositionResponse.pb-c.d" - -$(RM) "Communication\PMR\Stubs\StubMotorRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorRunRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorRunResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorRunStepTickRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorRunStepTickResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorSpeedRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorSpeedResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorStatusRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorStatusResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorStopRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorStopResponse.pb-c.d" "Communication\PMR\Stubs\StubOptLimitSwitchRequest.pb-c.d" "Communication\PMR\Stubs\StubOptLimitSwitchResponse.pb-c.d" "Communication\PMR\Stubs\StubReadEmbeddedVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubReadEmbeddedVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubRealTimeUsageRequest.pb-c.d" "Communication\PMR\Stubs\StubRealTimeUsageResponse.pb-c.d" - -$(RM) "Communication\PMR\Stubs\StubSpeedSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubSpeedSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubSteperMotorRequest.pb-c.d" "Communication\PMR\Stubs\StubSteperMotorResponse.pb-c.d" "Communication\PMR\Stubs\StubTempSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubTempSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubTivaReadRegRequest.pb-c.d" "Communication\PMR\Stubs\StubTivaReadRegResponse.pb-c.d" "Communication\PMR\Stubs\StubTivaWriteRegRequest.pb-c.d" "Communication\PMR\Stubs\StubTivaWriteRegResponse.pb-c.d" "Communication\PMR\Stubs\StubValveRequest.pb-c.d" "Communication\PMR\Stubs\StubValveResponse.pb-c.d" "Drivers\ADC_Sampling\ADC.d" "Drivers\FPGA\FPGA.d" "Drivers\FPGA\FPGA_SPI_Comm.d" "Drivers\FPGA\FPGA_SSI_Comm.d" "Drivers\FPGA\FPGA_GPIO\FPGA_GPIO.d" "Drivers\FPGA\FPGA_INTERRUPTS\FPGA_Interrupts.d" "Drivers\FPGA\Full_Vme\FPGA_Programming_Up.d" "Drivers\FPGA\Full_Vme\ispvme\hardware.d" "Drivers\FPGA\Full_Vme\ispvme\ispvm_ui.d" "Drivers\FPGA\Full_Vme\ispvme\ivm_core.d" - -$(RM) "Drivers\FPGA\Moters_Driver\L6470.d" "Drivers\Flash_Memory\FATFS\Control_File_System.d" "Drivers\Flash_Memory\FATFS\cc932.d" "Drivers\Flash_Memory\FATFS\fatfs_port_mx66l51235f.d" "Drivers\Flash_Memory\FATFS\ff.d" "Drivers\Flash_Memory\FATFS\mx66l51235f.d" "Drivers\Flash_Memory\FATFS\spi_flash.d" "Drivers\Flash_Memory\Flash_Memory.d" "Drivers\Heater\ADS1220.d" "Drivers\Heater\Heater.d" "Drivers\Heater\TemperatureSensor.d" "Drivers\I2C_Communication\ADC_MUX\ADC_MUX.d" "Drivers\I2C_Communication\DAC\Blower.d" "Drivers\I2C_Communication\Dispensers_EEPROM_MUX\Disp_EEPROM_MUX.d" "Drivers\I2C_Communication\I2C.d" "Drivers\I2C_Communication\I2C_Comm.d" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\NFC_I2C.d" "Drivers\I2C_Communication\RFID_NFC\PN7150\PN7150.d" "Drivers\I2C_Communication\Thermo_K\MCP9600.d" "Drivers\Motors\Motor.d" "Drivers\Motors\MotorActions.d" "Drivers\On_Chip_Flash\Flashstore.d" "Drivers\SPI\SPI_Comm.d" "Drivers\SSI_Comm\Dancer\Dancer.d" "Drivers\SSI_Comm\SSI_Comm.d" "Drivers\SSI_Comm\Speed_Sensor\Speed_Sensor.d" - -$(RM) "Drivers\USB_Communication\USBCDCD.d" "Drivers\Uart_Comm\Uart.d" "Drivers\Valves\Valve.d" "Drivers\flash_ram\FlashProgram.d" "Modules\AlarmHandling\AlarmHandling.d" "Modules\Control\DriverWithCallbackExample.d" "Modules\Control\MillisecTask.d" "Modules\Control\PIDAlgo.d" "Modules\Control\control.d" "Modules\Diagnostics\DiagnosticActions.d" "Modules\Diagnostics\Diagnostics.d" "Modules\Diagnostics\DiagnosticsHoming.d" "Modules\Diagnostics\DiagnosticsJogging.d" "Modules\General\GeneralHardware.d" "Modules\General\buttons.d" "Modules\General\process.d" "Modules\Heaters\Heaters_bit.d" "Modules\Heaters\Heaters_init.d" "Modules\Heaters\Heaters_maint.d" "Modules\Heaters\Heaters_print.d" "Modules\IDS\IDS_BIT.d" "Modules\IDS\IDS_dispenser.d" "Modules\IDS\IDS_init.d" "Modules\IDS\IDS_maint.d" "Modules\IDS\IDS_print.d" "Modules\Stubs_Handler\Calculate.d" "Modules\Stubs_Handler\Progress.d" "Modules\Stubs_Handler\StubRealTimeUsage.d" "Modules\Stubs_Handler\Stub_Cartridge.d" "Modules\Stubs_Handler\Stub_Dancer.d" - -$(RM) "Modules\Stubs_Handler\Stub_Dispenser.d" "Modules\Stubs_Handler\Stub_ExtFlash.d" "Modules\Stubs_Handler\Stub_FPGARWReg.d" "Modules\Stubs_Handler\Stub_FPGAReadBackReg.d" "Modules\Stubs_Handler\Stub_FPGAReadVersion.d" "Modules\Stubs_Handler\Stub_GPIO.d" "Modules\Stubs_Handler\Stub_HW_Version.d" "Modules\Stubs_Handler\Stub_Heater.d" "Modules\Stubs_Handler\Stub_I2C.d" "Modules\Stubs_Handler\Stub_IntADC.d" "Modules\Stubs_Handler\Stub_L6470.d" "Modules\Stubs_Handler\Stub_MidTankPressureSensor.d" "Modules\Stubs_Handler\Stub_Motor.d" "Modules\Stubs_Handler\Stub_OptLimitSwitch.d" "Modules\Stubs_Handler\Stub_ReadEmbeddedVersion.d" "Modules\Stubs_Handler\Stub_SpeedSensor.d" "Modules\Stubs_Handler\Stub_Status.d" "Modules\Stubs_Handler\Stub_SteperMotor.d" "Modules\Stubs_Handler\Stub_TempSensor.d" "Modules\Stubs_Handler\Stub_TivaReg.d" "Modules\Stubs_Handler\Stub_Valve.d" "Modules\Stubs_Handler\User_Leds.d" "Modules\Stubs_Handler\temperature_sensor.d" "Modules\Thread\ThreadLoad.d" "Modules\Thread\Thread_BIT.d" - -$(RM) "Modules\Thread\Thread_Winder.d" "Modules\Thread\Thread_init.d" "Modules\Thread\Thread_maint.d" "Modules\Thread\Thread_print.d" "Modules\Waste\Waste_BIT.d" "Modules\Waste\Waste_init.d" "Modules\Waste\Waste_maint.d" "Modules\Waste\Waste_print.d" "StateMachines\Initialization\InitSequence.d" "StateMachines\Printing\JobSTM.d" "StateMachines\Printing\PrintingSTM.d" + -$(RM) "Communication\PMR\Connection\KeepAliveRequest.pb-c.d" "Communication\PMR\Connection\KeepAliveResponse.pb-c.d" "Communication\PMR\Debugging\DebugDistributor.pb-c.d" "Communication\PMR\Debugging\DebugLogCategory.pb-c.d" "Communication\PMR\Debugging\SetupDebugDisributorsRequest.pb-c.d" "Communication\PMR\Debugging\SetupDebugDisributorsResponse.pb-c.d" "Communication\PMR\Debugging\StartDebugLogRequest.pb-c.d" "Communication\PMR\Debugging\StartDebugLogResponse.pb-c.d" "Communication\PMR\Debugging\StopDebugLogRequest.pb-c.d" "Communication\PMR\Debugging\StopDebugLogResponse.pb-c.d" "Communication\PMR\Diagnostics\DataFileFrame.pb-c.d" "Communication\PMR\Diagnostics\DiagnosticsMonitors.pb-c.d" "Communication\PMR\Diagnostics\DigitalInterfaceState.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserAbortJoggingResponse.pb-c.d" + -$(RM) "Communication\PMR\Diagnostics\DispenserHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\DispenserJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\DispenserJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\DoubleArray.pb-c.d" "Communication\PMR\Diagnostics\Event.pb-c.d" "Communication\PMR\Diagnostics\EventType.pb-c.d" "Communication\PMR\Diagnostics\HeaterState.pb-c.d" "Communication\PMR\Diagnostics\HeaterType.pb-c.d" "Communication\PMR\Diagnostics\InterfaceIOs.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorAbortJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorDirection.pb-c.d" "Communication\PMR\Diagnostics\MotorHomingRequest.pb-c.d" "Communication\PMR\Diagnostics\MotorHomingResponse.pb-c.d" "Communication\PMR\Diagnostics\MotorJoggingRequest.pb-c.d" + -$(RM) "Communication\PMR\Diagnostics\MotorJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ResolveEventRequest.pb-c.d" "Communication\PMR\Diagnostics\ResolveEventResponse.pb-c.d" "Communication\PMR\Diagnostics\SetBlowerStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetBlowerStateResponse.pb-c.d" "Communication\PMR\Diagnostics\SetComponentValueRequest.pb-c.d" "Communication\PMR\Diagnostics\SetComponentValueResponse.pb-c.d" "Communication\PMR\Diagnostics\SetDigitalOutRequest.pb-c.d" "Communication\PMR\Diagnostics\SetDigitalOutResponse.pb-c.d" "Communication\PMR\Diagnostics\SetHeaterStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetHeaterStateResponse.pb-c.d" "Communication\PMR\Diagnostics\SetValveStateRequest.pb-c.d" "Communication\PMR\Diagnostics\SetValveStateResponse.pb-c.d" "Communication\PMR\Diagnostics\StartDiagnosticsRequest.pb-c.d" "Communication\PMR\Diagnostics\StartDiagnosticsResponse.pb-c.d" "Communication\PMR\Diagnostics\StartEventsNotificationRequest.pb-c.d" "Communication\PMR\Diagnostics\StartEventsNotificationResponse.pb-c.d" + -$(RM) "Communication\PMR\Diagnostics\StopDiagnosticsRequest.pb-c.d" "Communication\PMR\Diagnostics\StopDiagnosticsResponse.pb-c.d" "Communication\PMR\Diagnostics\StopEventsNotificationRequest.pb-c.d" "Communication\PMR\Diagnostics\StopEventsNotificationResponse.pb-c.d" "Communication\PMR\Diagnostics\ThreadAbortJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\ThreadAbortJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ThreadJoggingRequest.pb-c.d" "Communication\PMR\Diagnostics\ThreadJoggingResponse.pb-c.d" "Communication\PMR\Diagnostics\ValueComponent.pb-c.d" "Communication\PMR\Diagnostics\ValueComponentState.pb-c.d" "Communication\PMR\Diagnostics\ValveState.pb-c.d" "Communication\PMR\Diagnostics\ValveStateCode.pb-c.d" "Communication\PMR\Diagnostics\ValveType.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmHandlingItem.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmParameters.pb-c.d" "Communication\PMR\EmbeddedParameters\AlarmSourceType.pb-c.d" "Communication\PMR\EmbeddedParameters\ConfigurationParameters.pb-c.d" + -$(RM) "Communication\PMR\EmbeddedParameters\DispenserData.pb-c.d" "Communication\PMR\EmbeddedParameters\DispenserDataRequest.pb-c.d" "Communication\PMR\EmbeddedParameters\DispenserDataResponse.pb-c.d" "Communication\PMR\EmbeddedParameters\DispenserRunningData.pb-c.d" "Communication\PMR\FirmwareUpgrade\ActivateVersionRequest.pb-c.d" "Communication\PMR\FirmwareUpgrade\ActivateVersionResponse.pb-c.d" "Communication\PMR\FirmwareUpgrade\ValidateVersionRequest.pb-c.d" "Communication\PMR\FirmwareUpgrade\ValidateVersionResponse.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionFileDescriptor.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionFileDestination.pb-c.d" "Communication\PMR\FirmwareUpgrade\VersionPackageDescriptor.pb-c.d" "Communication\PMR\Hardware\HardwareBlower.pb-c.d" "Communication\PMR\Hardware\HardwareBlowerType.pb-c.d" "Communication\PMR\Hardware\HardwareBreakSensor.pb-c.d" "Communication\PMR\Hardware\HardwareBreakSensorType.pb-c.d" "Communication\PMR\Hardware\HardwareConfiguration.pb-c.d" + -$(RM) "Communication\PMR\Hardware\HardwareDancer.pb-c.d" "Communication\PMR\Hardware\HardwareDancerType.pb-c.d" "Communication\PMR\Hardware\HardwareDispenser.pb-c.d" "Communication\PMR\Hardware\HardwareDispenserType.pb-c.d" "Communication\PMR\Hardware\HardwareMotor.pb-c.d" "Communication\PMR\Hardware\HardwareMotorType.pb-c.d" "Communication\PMR\Hardware\HardwarePidControl.pb-c.d" "Communication\PMR\Hardware\HardwarePidControlType.pb-c.d" "Communication\PMR\Hardware\HardwareSpeedSensor.pb-c.d" "Communication\PMR\Hardware\HardwareSpeedSensorType.pb-c.d" "Communication\PMR\Hardware\HardwareWinder.pb-c.d" "Communication\PMR\Hardware\HardwareWinderType.pb-c.d" "Communication\PMR\Hardware\SystemResetRequest.pb-c.d" "Communication\PMR\Hardware\SystemResetResponse.pb-c.d" "Communication\PMR\Hardware\UploadHardwareConfigurationRequest.pb-c.d" "Communication\PMR\Hardware\UploadHardwareConfigurationResponse.pb-c.d" "Communication\PMR\IO\CreateRequest.pb-c.d" "Communication\PMR\IO\CreateResponse.pb-c.d" + -$(RM) "Communication\PMR\IO\DeleteRequest.pb-c.d" "Communication\PMR\IO\DeleteResponse.pb-c.d" "Communication\PMR\IO\ExecuteProcessRequest.pb-c.d" "Communication\PMR\IO\ExecuteProcessResponse.pb-c.d" "Communication\PMR\IO\FileAttribute.pb-c.d" "Communication\PMR\IO\FileChunkDownloadRequest.pb-c.d" "Communication\PMR\IO\FileChunkDownloadResponse.pb-c.d" "Communication\PMR\IO\FileChunkUploadRequest.pb-c.d" "Communication\PMR\IO\FileChunkUploadResponse.pb-c.d" "Communication\PMR\IO\FileDownloadRequest.pb-c.d" "Communication\PMR\IO\FileDownloadResponse.pb-c.d" "Communication\PMR\IO\FileInfo.pb-c.d" "Communication\PMR\IO\FileUploadRequest.pb-c.d" "Communication\PMR\IO\FileUploadResponse.pb-c.d" "Communication\PMR\IO\GetFilesRequest.pb-c.d" "Communication\PMR\IO\GetFilesResponse.pb-c.d" "Communication\PMR\IO\GetStorageInfoRequest.pb-c.d" "Communication\PMR\IO\GetStorageInfoResponse.pb-c.d" "Communication\PMR\IO\KillProcessRequest.pb-c.d" "Communication\PMR\IO\KillProcessResponse.pb-c.d" "Communication\PMR\Printing\AbortJobRequest.pb-c.d" + -$(RM) "Communication\PMR\Printing\AbortJobResponse.pb-c.d" "Communication\PMR\Printing\CurrentJobRequest.pb-c.d" "Communication\PMR\Printing\CurrentJobResponse.pb-c.d" "Communication\PMR\Printing\DispenserLiquidType.pb-c.d" "Communication\PMR\Printing\DispenserStepDivision.pb-c.d" "Communication\PMR\Printing\JobBrushStop.pb-c.d" "Communication\PMR\Printing\JobDescriptionFileBrushStop.pb-c.d" "Communication\PMR\Printing\JobDescriptionFileSegment.pb-c.d" "Communication\PMR\Printing\JobDispenser.pb-c.d" "Communication\PMR\Printing\JobRequest.pb-c.d" "Communication\PMR\Printing\JobResponse.pb-c.d" "Communication\PMR\Printing\JobSegment.pb-c.d" "Communication\PMR\Printing\JobSpool.pb-c.d" "Communication\PMR\Printing\JobSpoolType.pb-c.d" "Communication\PMR\Printing\JobStatus.pb-c.d" "Communication\PMR\Printing\JobTicket.pb-c.d" "Communication\PMR\Printing\JobUploadStrategy.pb-c.d" "Communication\PMR\Printing\JobWindingMethod.pb-c.d" "Communication\PMR\Printing\ProcessParameters.pb-c.d" "Communication\PMR\Printing\ResumeCurrentJobRequest.pb-c.d" + -$(RM) "Communication\PMR\Printing\ResumeCurrentJobResponse.pb-c.d" "Communication\PMR\Printing\UploadProcessParametersRequest.pb-c.d" "Communication\PMR\Printing\UploadProcessParametersResponse.pb-c.d" "Communication\PMR\Stubs\CalculateRequest.pb-c.d" "Communication\PMR\Stubs\CalculateResponse.pb-c.d" "Communication\PMR\Stubs\ProgressRequest.pb-c.d" "Communication\PMR\Stubs\ProgressResponse.pb-c.d" "Communication\PMR\Stubs\StubAbortJobRequest.pb-c.d" "Communication\PMR\Stubs\StubAbortJobResponse.pb-c.d" "Communication\PMR\Stubs\StubCartridgeReadRequest.pb-c.d" "Communication\PMR\Stubs\StubCartridgeReadResponse.pb-c.d" "Communication\PMR\Stubs\StubCartridgeWriteRequest.pb-c.d" "Communication\PMR\Stubs\StubCartridgeWriteResponse.pb-c.d" "Communication\PMR\Stubs\StubDancerPositionRequest.pb-c.d" "Communication\PMR\Stubs\StubDancerPositionResponse.pb-c.d" "Communication\PMR\Stubs\StubDispenserRequest.pb-c.d" "Communication\PMR\Stubs\StubDispenserResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadRequest.pb-c.d" + -$(RM) "Communication\PMR\Stubs\StubExtFlashReadResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadWordsRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashReadWordsResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteResponse.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteWordsRequest.pb-c.d" "Communication\PMR\Stubs\StubExtFlashWriteWordsResponse.pb-c.d" "Communication\PMR\Stubs\StubF3Gpo01WriteRequest.pb-c.d" "Communication\PMR\Stubs\StubF3Gpo01WriteResponse.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadBackRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadBackRegResponse.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubFPGAReadVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubFpgaReadRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFpgaReadRegResponse.pb-c.d" "Communication\PMR\Stubs\StubFpgaWriteRegRequest.pb-c.d" "Communication\PMR\Stubs\StubFpgaWriteRegResponse.pb-c.d" + -$(RM) "Communication\PMR\Stubs\StubGPIOInputSetupRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOInputSetupResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadBitRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadBitResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadByteRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOReadByteResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteBitRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteBitResponse.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteByteRequest.pb-c.d" "Communication\PMR\Stubs\StubGPIOWriteByteResponse.pb-c.d" "Communication\PMR\Stubs\StubHWVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubHWVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubHeaterRequest.pb-c.d" "Communication\PMR\Stubs\StubHeaterResponse.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestPollRequest.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestPollResponse.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestRequest.pb-c.d" "Communication\PMR\Stubs\StubHeatingTestResponse.pb-c.d" + -$(RM) "Communication\PMR\Stubs\StubI2CReadBytesRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CReadBytesResponse.pb-c.d" "Communication\PMR\Stubs\StubI2CRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CResponse.pb-c.d" "Communication\PMR\Stubs\StubI2CWriteBytesRequest.pb-c.d" "Communication\PMR\Stubs\StubI2CWriteBytesResponse.pb-c.d" "Communication\PMR\Stubs\StubIntADCReadRequest.pb-c.d" "Communication\PMR\Stubs\StubIntADCReadResponse.pb-c.d" "Communication\PMR\Stubs\StubJobRequest.pb-c.d" "Communication\PMR\Stubs\StubJobResponse.pb-c.d" "Communication\PMR\Stubs\StubL6470DriverRequest.pb-c.d" "Communication\PMR\Stubs\StubL6470DriverResponse.pb-c.d" "Communication\PMR\Stubs\StubMidTankPressureSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubMidTankPressureSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorHomeMarkRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorHomeMarkResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorInitRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorInitResponse.pb-c.d" + -$(RM) "Communication\PMR\Stubs\StubMotorMovRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorMovResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorPositionRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorPositionResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorRunRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorRunResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorRunStepTickRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorRunStepTickResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorSpeedRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorSpeedResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorStatusRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorStatusResponse.pb-c.d" "Communication\PMR\Stubs\StubMotorStopRequest.pb-c.d" "Communication\PMR\Stubs\StubMotorStopResponse.pb-c.d" "Communication\PMR\Stubs\StubOptLimitSwitchRequest.pb-c.d" "Communication\PMR\Stubs\StubOptLimitSwitchResponse.pb-c.d" + -$(RM) "Communication\PMR\Stubs\StubReadEmbeddedVersionRequest.pb-c.d" "Communication\PMR\Stubs\StubReadEmbeddedVersionResponse.pb-c.d" "Communication\PMR\Stubs\StubRealTimeUsageRequest.pb-c.d" "Communication\PMR\Stubs\StubRealTimeUsageResponse.pb-c.d" "Communication\PMR\Stubs\StubSpeedSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubSpeedSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubSteperMotorRequest.pb-c.d" "Communication\PMR\Stubs\StubSteperMotorResponse.pb-c.d" "Communication\PMR\Stubs\StubTempSensorRequest.pb-c.d" "Communication\PMR\Stubs\StubTempSensorResponse.pb-c.d" "Communication\PMR\Stubs\StubTivaReadRegRequest.pb-c.d" "Communication\PMR\Stubs\StubTivaReadRegResponse.pb-c.d" "Communication\PMR\Stubs\StubTivaWriteRegRequest.pb-c.d" "Communication\PMR\Stubs\StubTivaWriteRegResponse.pb-c.d" "Communication\PMR\Stubs\StubValveRequest.pb-c.d" "Communication\PMR\Stubs\StubValveResponse.pb-c.d" "Drivers\ADC_Sampling\ADC.d" "Drivers\FPGA\FPGA.d" "Drivers\FPGA\FPGA_SPI_Comm.d" "Drivers\FPGA\FPGA_SSI_Comm.d" + -$(RM) "Drivers\FPGA\FPGA_GPIO\FPGA_GPIO.d" "Drivers\FPGA\FPGA_INTERRUPTS\FPGA_Interrupts.d" "Drivers\FPGA\Full_Vme\FPGA_Programming_Up.d" "Drivers\FPGA\Full_Vme\ispvme\hardware.d" "Drivers\FPGA\Full_Vme\ispvme\ispvm_ui.d" "Drivers\FPGA\Full_Vme\ispvme\ivm_core.d" "Drivers\FPGA\Motors_Driver\L6470.d" "Drivers\Flash_Memory\FATFS\Control_File_System.d" "Drivers\Flash_Memory\FATFS\cc932.d" "Drivers\Flash_Memory\FATFS\fatfs_port_mx66l51235f.d" "Drivers\Flash_Memory\FATFS\ff.d" "Drivers\Flash_Memory\FATFS\mx66l51235f.d" "Drivers\Flash_Memory\FATFS\spi_flash.d" "Drivers\Flash_Memory\Flash_Memory.d" "Drivers\Heater\ADS1220.d" "Drivers\Heater\Heater.d" "Drivers\Heater\TemperatureSensor.d" "Drivers\I2C_Communication\ADC_MUX\ADC_MUX.d" "Drivers\I2C_Communication\DAC\Blower.d" "Drivers\I2C_Communication\Dispenser_Card\EEPROM\Dispenser_EEPROM.d" "Drivers\I2C_Communication\Dispenser_Card\I2C_Dispenser_Card_Mux.d" "Drivers\I2C_Communication\Dispenser_Card\IO_Ports\Dispenser_IO.d" "Drivers\I2C_Communication\I2C.d" + -$(RM) "Drivers\I2C_Communication\I2C_Comm.d" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\NFC_I2C.d" "Drivers\I2C_Communication\RFID_NFC\NFC_I2C\Test_NFC.d" "Drivers\I2C_Communication\RFID_NFC\PN7150\PN7150.d" "Drivers\I2C_Communication\Thermo_K\MCP9600.d" "Drivers\Motors\Motor.d" "Drivers\Motors\MotorActions.d" "Drivers\On_Chip_Flash\Flashstore.d" "Drivers\SPI\SPI_Comm.d" "Drivers\SSI_Comm\Dancer\Dancer.d" "Drivers\SSI_Comm\SSI_Comm.d" "Drivers\SSI_Comm\Speed_Sensor\Speed_Sensor.d" "Drivers\USB_Communication\USBCDCD.d" "Drivers\Uart_Comm\Uart.d" "Drivers\Valves\Valve.d" "Drivers\flash_ram\FlashProgram.d" "Modules\AlarmHandling\AlarmHandling.d" "Modules\Control\DriverWithCallbackExample.d" "Modules\Control\MillisecTask.d" "Modules\Control\PIDAlgo.d" "Modules\Control\control.d" "Modules\Diagnostics\DiagnosticActions.d" "Modules\Diagnostics\Diagnostics.d" "Modules\Diagnostics\DiagnosticsHoming.d" "Modules\Diagnostics\DiagnosticsJogging.d" "Modules\General\GeneralHardware.d" "Modules\General\Safety.d" + -$(RM) "Modules\General\buttons.d" "Modules\General\process.d" "Modules\Heaters\Heaters_bit.d" "Modules\Heaters\Heaters_init.d" "Modules\Heaters\Heaters_maint.d" "Modules\Heaters\Heaters_print.d" "Modules\IDS\IDS_BIT.d" "Modules\IDS\IDS_Cleaning.d" "Modules\IDS\IDS_dispenser.d" "Modules\IDS\IDS_init.d" "Modules\IDS\IDS_maint.d" "Modules\IDS\IDS_print.d" "Modules\Stubs_Handler\Calculate.d" "Modules\Stubs_Handler\Progress.d" "Modules\Stubs_Handler\StubRealTimeUsage.d" "Modules\Stubs_Handler\Stub_Cartridge.d" "Modules\Stubs_Handler\Stub_Dancer.d" "Modules\Stubs_Handler\Stub_Dispenser.d" "Modules\Stubs_Handler\Stub_ExtFlash.d" "Modules\Stubs_Handler\Stub_FPGARWReg.d" "Modules\Stubs_Handler\Stub_FPGAReadBackReg.d" "Modules\Stubs_Handler\Stub_FPGAReadVersion.d" "Modules\Stubs_Handler\Stub_GPIO.d" "Modules\Stubs_Handler\Stub_HW_Version.d" "Modules\Stubs_Handler\Stub_Heater.d" "Modules\Stubs_Handler\Stub_I2C.d" "Modules\Stubs_Handler\Stub_IntADC.d" "Modules\Stubs_Handler\Stub_L6470.d" "Modules\Stubs_Handler\Stub_MidTankPressureSensor.d" + -$(RM) "Modules\Stubs_Handler\Stub_Motor.d" "Modules\Stubs_Handler\Stub_OptLimitSwitch.d" "Modules\Stubs_Handler\Stub_ReadEmbeddedVersion.d" "Modules\Stubs_Handler\Stub_SpeedSensor.d" "Modules\Stubs_Handler\Stub_Status.d" "Modules\Stubs_Handler\Stub_SteperMotor.d" "Modules\Stubs_Handler\Stub_TempSensor.d" "Modules\Stubs_Handler\Stub_TivaReg.d" "Modules\Stubs_Handler\Stub_Valve.d" "Modules\Stubs_Handler\User_Leds.d" "Modules\Stubs_Handler\temperature_sensor.d" "Modules\Thread\ThreadLoad.d" "Modules\Thread\Thread_BIT.d" "Modules\Thread\Thread_Winder.d" "Modules\Thread\Thread_init.d" "Modules\Thread\Thread_maint.d" "Modules\Thread\Thread_print.d" "Modules\Waste\Waste_BIT.d" "Modules\Waste\Waste_init.d" "Modules\Waste\Waste_maint.d" "Modules\Waste\Waste_print.d" "StateMachines\Initialization\InitSequence.d" "StateMachines\Initialization\PowerIdle.d" "StateMachines\Initialization\PowerOffSequence.d" "StateMachines\Printing\JobSTM.d" "StateMachines\Printing\PrintingSTM.d" -@echo 'Finished clean' -@echo ' ' @@ -699,7 +715,7 @@ pre-build: -@echo ' ' post-build: - -"C:/ti/ccsv7/utils/tiobj2bin/tiobj2bin" "Embedded.out" "Embedded.bin" "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armofd" "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armhex" "C:/ti/ccsv7/utils/tiobj2bin/mkhex4bin" + -"C:/TI/ccsv7/utils/tiobj2bin/tiobj2bin" "Embedded.out" "Embedded.bin" "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armofd" "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armhex" "C:/TI/ccsv7/utils/tiobj2bin/mkhex4bin" -@echo ' ' .PHONY: all clean dependents diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/sources.mk b/Software/Embedded_SW/Embedded/debug_w_pmr/sources.mk index 20fa167ed..0a0f2f4dc 100644 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/sources.mk +++ b/Software/Embedded_SW/Embedded/debug_w_pmr/sources.mk @@ -148,13 +148,15 @@ Drivers/FPGA/FPGA_GPIO \ Drivers/FPGA/FPGA_INTERRUPTS \ Drivers/FPGA/Full_Vme \ Drivers/FPGA/Full_Vme/ispvme \ -Drivers/FPGA/Moters_Driver \ +Drivers/FPGA/Motors_Driver \ Drivers/Flash_Memory/FATFS \ Drivers/Flash_Memory \ Drivers/Heater \ Drivers/I2C_Communication/ADC_MUX \ Drivers/I2C_Communication/DAC \ -Drivers/I2C_Communication/Dispensers_EEPROM_MUX \ +Drivers/I2C_Communication/Dispenser_Card/EEPROM \ +Drivers/I2C_Communication/Dispenser_Card \ +Drivers/I2C_Communication/Dispenser_Card/IO_Ports \ Drivers/I2C_Communication \ Drivers/I2C_Communication/RFID_NFC/NFC_I2C \ Drivers/I2C_Communication/RFID_NFC/PN7150 \ diff --git a/Software/Embedded_SW/Embedded/debug_w_pmr/subdir_rules.mk b/Software/Embedded_SW/Embedded/debug_w_pmr/subdir_rules.mk index 31c7e347f..c9da089bb 100644 --- a/Software/Embedded_SW/Embedded/debug_w_pmr/subdir_rules.mk +++ b/Software/Embedded_SW/Embedded/debug_w_pmr/subdir_rules.mk @@ -6,13 +6,13 @@ SHELL = cmd.exe # Each subdirectory must supply rules for building sources it contributes build-306001487: - @$(MAKE) --no-print-directory -Onone -f subdir_rules.mk build-306001487-inproc + @$(MAKE) -Onone -f subdir_rules.mk build-306001487-inproc build-306001487-inproc: ../Embedded.cfg - @echo 'Building file: "$<"' + @echo 'Building file: $<' @echo 'Invoking: XDCtools' - "C:/ti/xdctools_3_32_02_25_core/xs" --xdcpath="C:/ti/TivaWare_C_Series-2.1.2.111;C:/ti/ccsv7/ccs_base;" xdc.tools.configuro -o configPkg -t ti.targets.arm.elf.M4F -p ti.platforms.tiva:TM4C129XNCZAD -r release -c "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS" --compileOptions "-mv7M4 --code_state=16 --float_support=FPv4SPD16 -me" "$<" - @echo 'Finished building: "$<"' + "C:/TI/xdctools_3_32_00_06_core/xs" --xdcpath="C:/ti/tirtos_tivac_2_16_00_08/packages;C:/ti/tirtos_tivac_2_16_00_08/products/tidrivers_tivac_2_16_00_08/packages;C:/ti/tirtos_tivac_2_16_00_08/products/bios_6_45_01_29/packages;C:/ti/tirtos_tivac_2_16_00_08/products/ndk_2_25_00_09/packages;C:/ti/tirtos_tivac_2_16_00_08/products/uia_2_00_05_50/packages;C:/ti/tirtos_tivac_2_16_00_08/products/ns_1_11_00_10/packages;C:/ti/TivaWare_C_Series-2.1.2.111;C:/TI/ccsv7/ccs_base;" xdc.tools.configuro -o configPkg -t ti.targets.arm.elf.M4F -p ti.platforms.tiva:TM4C129XNCZAD -r release -c "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS" --compileOptions "-mv7M4 --code_state=16 --float_support=FPv4SPD16 -me" "$<" + @echo 'Finished building: $<' @echo ' ' configPkg/linker.cmd: build-306001487 ../Embedded.cfg @@ -20,17 +20,17 @@ configPkg/compiler.opt: build-306001487 configPkg/: build-306001487 Main.obj: ../Main.c $(GEN_OPTS) | $(GEN_HDRS) - @echo 'Building file: "$<"' + @echo 'Building file: $<' @echo 'Invoking: ARM Compiler' - "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --include_path="/products/ndk_2_25_00_09/packages/ti/ndk/inc/bsd" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common/protobuf-c" --include_path="C:/Tango/Software/Embedded_SW/Embedded" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Hardware" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Printing" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Debugging" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Modules" --include_path="C:/ti/TivaWare_C_Series-2.1.2.111" --include_path="C:/ti/xdctools_3_32_00_06_core/include" --include_path="/products/TivaWare_C_Series-2.1.1.71b" --include_path="/products/bios_6_45_01_29/packages/ti/sysbios/posix" --include_path="/products/tidrivers_tivac_2_16_00_08" --include_path="C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/include" --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi --preproc_with_compile --preproc_dependency="Main.d_raw" $(GEN_OPTS__FLAG) "$<" - @echo 'Finished building: "$<"' + "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/ndk_2_25_00_09/packages/ti/ndk/inc/bsd" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common/protobuf-c" --include_path="C:/Tango/Software/Embedded_SW/Embedded" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Hardware" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Printing" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Debugging" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Modules" --include_path="C:/ti/TivaWare_C_Series-2.1.2.111" --include_path="C:/ti/xdctools_3_32_00_06_core/include" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/TivaWare_C_Series-2.1.1.71b" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/bios_6_45_01_29/packages/ti/sysbios/posix" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/tidrivers_tivac_2_16_00_08" --include_path="C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/include" --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi --preproc_with_compile --preproc_dependency="Main.d_raw" $(GEN_OPTS__FLAG) "$<" + @echo 'Finished building: $<' @echo ' ' delay.obj: ../delay.c $(GEN_OPTS) | $(GEN_HDRS) - @echo 'Building file: "$<"' + @echo 'Building file: $<' @echo 'Invoking: ARM Compiler' - "C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --include_path="/products/ndk_2_25_00_09/packages/ti/ndk/inc/bsd" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common/protobuf-c" --include_path="C:/Tango/Software/Embedded_SW/Embedded" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Hardware" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Printing" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Debugging" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Modules" --include_path="C:/ti/TivaWare_C_Series-2.1.2.111" --include_path="C:/ti/xdctools_3_32_00_06_core/include" --include_path="/products/TivaWare_C_Series-2.1.1.71b" --include_path="/products/bios_6_45_01_29/packages/ti/sysbios/posix" --include_path="/products/tidrivers_tivac_2_16_00_08" --include_path="C:/ti/ccsv7/tools/compiler/ti-cgt-arm_16.9.6.LTS/include" --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi --preproc_with_compile --preproc_dependency="delay.d_raw" $(GEN_OPTS__FLAG) "$<" - @echo 'Finished building: "$<"' + "C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 -me -Ooff --opt_for_speed=0 --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/ndk_2_25_00_09/packages/ti/ndk/inc/bsd" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common/protobuf-c" --include_path="C:/Tango/Software/Embedded_SW/Embedded" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Hardware" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Printing" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Debugging" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication/PMR" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Communication" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Common" --include_path="C:/Tango/Software/Embedded_SW/Embedded/Modules" --include_path="C:/ti/TivaWare_C_Series-2.1.2.111" --include_path="C:/ti/xdctools_3_32_00_06_core/include" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/TivaWare_C_Series-2.1.1.71b" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/bios_6_45_01_29/packages/ti/sysbios/posix" --include_path="C:/ti/tirtos_tivac_2_16_00_08/products/tidrivers_tivac_2_16_00_08" --include_path="C:/TI/ccsv7/tools/compiler/ti-cgt-arm_16.9.4.LTS/include" --define=ENABLE_LFN --define=DEBUG_TEST_FUNCTIONS --define=TARGET_IS_TM4C129_RA0 --define=ccs="ccs" --define=ccs --define=TIVAWARE --define=PART_TM4C129XNCZAD -g --gcc --diag_warning=225 --diag_warning=255 --diag_wrap=off --display_error_number --abi=eabi --preproc_with_compile --preproc_dependency="delay.d_raw" $(GEN_OPTS__FLAG) "$<" + @echo 'Finished building: $<' @echo ' ' diff --git a/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f b/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f index 6aabbbe3b..117dea776 100644 Binary files a/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f and b/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f differ -- cgit v1.3.1 From 1f69098e7cda9524010068ac72149593051db41c Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 23 Apr 2019 16:47:35 +0300 Subject: Version 1.3.9.2 no automatic homing. lubricant on file jobs (#707). midtank offest 0; watchdog prepared --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- Software/Embedded_SW/Embedded/Embedded.cfg | 11 ++- Software/Embedded_SW/Embedded/Main.c | 86 ++++++++++++++++++---- .../Embedded/Modules/General/GeneralHardware.c | 2 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 34 ++++++--- .../Embedded/Modules/Stubs_Handler/Progress.c | 5 +- .../Embedded/Software Release Notes.txt | 19 +++++ 7 files changed, 133 insertions(+), 26 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 54c24efa7..8a2a071dd 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,9,1}; +TangoVersion_t _gTangoVersion = {1,3,9,2}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 7efea86f4..1127c5a30 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -212,7 +212,16 @@ var Text = xdc.useModule('xdc.runtime.Text'); Text.isLoaded = true; //Text.isLoaded = false; - +/* ================ Error configuration ================ */ +/* set errHook (defined in main.c) as the error + * hook function. Strings begining with '&' + * can be assigned to function pointers to + * reference unspecified external functions + */ +Error.raiseHook = "&errHook"; + +/* set user-defined code for E_generic errors */ +Error.E_generic.code = 28; /* ================ Types configuration ================ */ var Types = xdc.useModule('xdc.runtime.Types'); diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index a125ef10c..b0c151b87 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -25,6 +25,12 @@ #include "Communication/CommunicationTask.h" +#include +#include +#include + +#include +#include #include #include "drivers/Flash_ram/FlashProgram.h" @@ -68,6 +74,8 @@ #include "Modules/General/buttons.h" #include "Modules/Waste/Waste.h" //#define WATCHDOG + + //***************************************************************************** // // The system tick rate expressed both as ticks per second and a millisecond @@ -76,6 +84,7 @@ //***************************************************************************** #define TICKS_PER_SECOND 1000 + //***************************************************************************** // // Global system tick counter @@ -94,19 +103,72 @@ F1_GPO_REG F1_GPO_Reg; F3_GPO_01_REG F3_GPO_01_Reg; -//MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)); -uint32_t MainDummyFunction(uint32_t IfIndex, uint32_t ReadValue) -{ - return OK; -} -uint32_t HWControlId; +Types_Site *site; +Error_Id eid; +int eCode; -uint32_t MainHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) +/* ======== errHook ======== */ +Void errHook(Error_Block *eb) { - RemoveControlCallback(HWControlId, MainHWInitCallBackFunction ); - HWConfigurationInit(); - return OK; + FRESULT Fresult = FR_OK; + FIL *FileHandle = 0; //the system supports a single active file + uint32_t Bytes = 0; + char ErrorPath[50] = "0://ErrorFile.txt"; + char message[300]; + int len; + + STATUS_GREEN_LED_OFF; + ACTIVITY_GREEN_LED_OFF; + COMM_GREEN_LED_OFF; + + STATUS_RED_LED_ON; + ACTIVITY_RED_LED_ON; + COMM_RED_LED_ON; + + site = Error_getSite(eb); + eid = Error_getId(eb); + eCode = Error_getCode(eb); + FileHandle = my_malloc(sizeof(FIL)); + if (FileHandle == 0) + Fresult = FR_DENIED; + else + { + Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ); + if (Fresult == FR_OK) + { + len = usnprintf(message, 80, "%s %s",__DATE__, __TIME__); + Fresult = f_write(FileHandle,message,len,&Bytes ); + /* print user supplied error code */ + len = usnprintf(message, 300, "error %d, eid %d file %s line %d mod %d", + eCode, eid, site->file, + site->line, + site->mod); + Fresult = f_write(FileHandle,message,len,&Bytes ); + + LOG_ERROR (eCode, "error # "); + /* check originator's mod id against known mods */ + if (site->mod == Main_Module_id()) { + Fresult = f_write(FileHandle,"app error: ",12,&Bytes ); + } + + /* check error id against known errors */ + if (eid == Error_E_generic) { + Fresult = f_write(FileHandle,"generic: ",10,&Bytes ); + } + else if (eid == Assert_E_assertFailed) { + System_printf("assertion violation: "); + Fresult = f_write(FileHandle,"assertion violation: ",22,&Bytes ); + } + + /* perform default error output */ + f_close(FileHandle); + } + Task_sleep (200); + my_free(FileHandle); + } + Power_Reset(); } + //***************************************************************************** // // Interrupt handler for the system tick counter. @@ -177,7 +239,7 @@ int main(void) #endif #ifdef WATCHDOG - InitWatchdog(ui32SysClock); + InitWatchdog(ui32SysClock*2); #endif CommunicationTaskInit(); @@ -242,8 +304,6 @@ int main(void) IDLE_TASK_package_init(); -// HWControlId = AddControlCallback( MainHWInitCallBackFunction, 2* eOneSecond/*eHundredMillisecond*/, MainDummyFunction,0,0, 0 ); - Start_InitSequence(); PowerIdleInit(); BIOS_start(); diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 6f1dc2052..0e35e09a7 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -150,7 +150,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dcheatersupperoperationlimit = true; EmbeddedParameters.dcheatersupperoperationlimit = 1002; EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.2; + EmbeddedParameters.midtankpressurecorrection = 0.0; EmbeddedParameters.has_dispenserpresegmentwfcf = true; EmbeddedParameters.dispenserpresegmentwfcf = 80; EmbeddedParameters.has_startheatingoninitsequence = true; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 5ebe10705..eeab745f8 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -197,7 +197,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile(); void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); */ - /************************************************************************************************************************************/ + /************************************************************************************************************************************ uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails) { JobTicket* JobTicket = JobDetails; @@ -206,6 +206,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); int Dispenser_i, Brush_i,DispenserId; FRESULT Fresult = FR_OK; uint32_t status = OK; + bool lookForLubrication = false; for (Dispenser_i = 0;Dispenser_ienablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } Fresult = OpenJobFile(); if (Fresult == FR_OK) @@ -238,12 +242,12 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0) { DispenserUsedInJob[DispenserId] = true; - /*if(DispenserId == LUBRICANT_DISPENSER) + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) { - lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ - JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; - REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); - }*/ + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } } }//for dispenser }//if dispensers @@ -270,6 +274,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); return status; } + *************************************************************************************************************************************/ /************************************************************************************************************************************/ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails) { @@ -282,7 +287,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); uint32_t status = OK; FRESULT Fresult = FR_OK; FIL *FileHandle = 0; //the system supports a single active file - + bool lookForLubrication = false; /* Parsing the job description file. The job description file simply contains an array of segments and their brush stops. @@ -312,7 +317,10 @@ c. Go to step 2.a x Segment.BrushStopsCount. if (EnableCleaning == true) DispenserUsedInJob[CLEANER_DISPENSER] = true; if (JobTicket->enablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile) { FileHandle = my_malloc(sizeof(FIL)); @@ -365,6 +373,12 @@ c. Go to step 2.a x Segment.BrushStopsCount. { DispenserUsedInJob[DispenserId] = true; } + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) + { + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } }//for dispenser }//if dispensers else @@ -529,7 +543,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. //IDS_MapDispenserUsedinJob(JobDetails); for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++) { - IDS_StopHomeDispenser(i); + //IDS_StopHomeDispenser(i); if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers { DispenserReady[i] = false; @@ -1060,7 +1074,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); //MotorStop(HW_Motor_Id,Hard_Hiz); - IDS_HomeDispenser (deviceID, 800 , NULL); + //IDS_HomeDispenser (deviceID, 800 , NULL); return OK; } @@ -1100,6 +1114,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) uint32_t IDS_StartLubrication(void) { IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); Lubricant_2Way_Valve (START); return OK; } @@ -1108,6 +1123,7 @@ uint32_t IDS_StopLubrication(void) if(DispenserUsedInJob[LUBRICANT_DISPENSER]) { IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); Lubricant_2Way_Valve (STOP); } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index 958c91926..34cb61e27 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -33,10 +33,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) assert(iFResult); } } + else if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off + { + PowerOffInit(); + } else { response.has_progress = true; - PowerOffInit(); int i = 0; for (i = 0; i < request->amount; i++) { diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt index d62cee15e..5caeae761 100644 --- a/Software/Embedded_SW/Embedded/Software Release Notes.txt +++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt @@ -1,3 +1,22 @@ +Embedded SW Release note - Version 1.3.9.1 - Itma Candidate 1 +============================================================= +Jobs: + Multiple segments, gradients, job is downloaded as a file, lubrication, automatic refill at the end of a job +Machine: + Power Idle + Power down sequence + Initialization sequence - reads midtank pressure. + Drivers support for hardware upgrades and variations + Buttons support + Waste handling +Modules: + Temperature - mitigate spikes, handle algorithm better. SW thermal cut off + Preparation for logs ditributor - not operativer yet. + File download on lower priority, blocked when a job is active. improved FPGA upgrade process + preparation for watchdog + communication: dispenser data request. some stubs removed. InterfaceIOs - only supported. additional event types, not supported yet (machine state, VOC). additional embedded parameters +---------------------------------------------------------------- + Embedded SW Release note - Version 1.3.8.2 File upload: prevent on job, reduce priority (watchdog) Report: packages filters introduced, please feel free to use them. -- cgit v1.3.1 From 52967e858bd52621208f6360e84f4c47ec435816 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 23 Apr 2019 22:23:54 +0300 Subject: sync --- .../Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c | 8 ++++---- .../Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c | 6 ++++++ 2 files changed, 10 insertions(+), 4 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 94c7614d1..13403cad3 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -229,10 +229,10 @@ const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT ," MotorRightLoaderOverCurrent " }, /* 3004 */ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT ," MotorLeftLoaderOverCurrent " }, /* 3006 */ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT ," MotorLoadindARMOverCurrent " }, /* 3009 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/ ," MotorWinderDancerOverCurrent " }, /* 3036 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/ ," MotorPullerDancerOverCurrent " }, /* 3037 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/ ," MotorFeederDancerOverCurrent " }, /* 3038 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/ ," MotorDryerLidOverCurrent " }, /* 4017 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT ," MotorWinderDancerOverCurrent " }, /* 3036 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT ," MotorPullerDancerOverCurrent " }, /* 3037 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT ," MotorFeederDancerOverCurrent " }, /* 3038 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT ," MotorDryerLidOverCurrent " }, /* 4017 */ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT ," MotorDyeingHeadCoverOverCurrent " }, /* 5031 */ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningMechanismOverCurrent "}, /* 5035 */ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningHeadOverCurrent " }, /* 5039 */ diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index e3f593924..7bd537e9c 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -248,6 +248,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ + case INTERFACE_IOS__GPO_BLOWER_PWM: + if (request->value == true) + Control_Dryer_Fan(START,75); + else + Control_Dryer_Fan(STOP, 0); + break; case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) Valve_Set(VALVE_MIXCHIP_WASTECH,1); -- cgit v1.3.1 From 363603ac89278995f8c7730c6fc92a8e19ed1f92 Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Sun, 28 Apr 2019 15:55:09 +0300 Subject: change the blinking frequency of the machine panel leds to 300msec --- Software/Embedded_SW/Embedded/Modules/Control/control.c | 2 +- .../Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index b316fd73f..f1e19d851 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -158,7 +158,7 @@ uint32_t ControlActivityLed( uint32_t Parameter1) { static bool flag = false; static uint8_t counter; - const uint8_t Blink_Freq = 15;//odd number + const uint8_t Blink_Freq = 3;//odd number if (flag==true) { diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index b0a1945db..6a1821f4b 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -26,6 +26,7 @@ #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h" #include "drivers/Valves/Valve.h" #include "drivers/Heater/Heater.h" +#include "modules/waste/waste.h" #include "modules/ids/ids_ex.h" @@ -243,12 +244,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ - case INTERFACE_IOS__GPO_BLOWER_PWM: +/* case INTERFACE_IOS__GPO_BLOWER_PWM: if (request->value == true) Control_Dryer_Fan(START,75); else Control_Dryer_Fan(STOP, 0); - break; + break;*/ case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) Valve_Set(VALVE_MIXCHIP_WASTECH,1); -- cgit v1.3.1 From 3bed1b881037c06d160573583be4d85dc186d3a7 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Sun, 28 Apr 2019 19:35:39 +0300 Subject: version 1.3.9.3: segments and gradients handling, diagnostics is faster. code faiure handling --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Communication/PMR/Diagnostics/EventType.pb-c.c | 538 +++++++++++---------- .../Communication/PMR/Diagnostics/EventType.pb-c.h | 12 +- .../Dispenser_Card/IO_Ports/Dispenser_IO.c | 39 ++ .../Dispenser_Card/IO_Ports/Dispenser_IO.h | 4 + Software/Embedded_SW/Embedded/Main.c | 94 +++- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 38 +- .../Modules/Diagnostics/DiagnosticActions.c | 12 +- .../Embedded/Modules/Diagnostics/Diagnostics.c | 2 +- .../Embedded/Modules/General/GeneralHardware.c | 8 +- .../Embedded_SW/Embedded/Modules/General/Safety.c | 43 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 44 +- .../Embedded/Modules/Stubs_Handler/Progress.c | 50 +- 13 files changed, 551 insertions(+), 335 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 07fbf3ddd..c8ec2a487 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,8,51}; +TangoVersion_t _gTangoVersion = {1,3,9,3}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c index 785da53e2..d5b888912 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c @@ -7,7 +7,7 @@ #endif #include "EventType.pb-c.h" -static const ProtobufCEnumValue event_type__enum_values_by_number[279] = +static const ProtobufCEnumValue event_type__enum_values_by_number[285] = { { "None", "EVENT_TYPE__None", 0 }, { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 }, @@ -33,6 +33,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "MACHINE_FANS_STOPPED", "EVENT_TYPE__MACHINE_FANS_STOPPED", 2010 }, { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 2011 }, { "ELECTRICAL_CABINET_FANS_STOPPED", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED", 2012 }, + { "MACHINE_STATE_NO_CFG_FILE", "EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE", 2013 }, + { "MACHINE_STATE_HW_CONFIG_FAILED", "EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED", 2014 }, + { "MACHINE_STATE_INITIAL_BLOWER_FAILED", "EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED", 2015 }, + { "UNSPECIFIED", "EVENT_TYPE__UNSPECIFIED", 2016 }, { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 3000 }, { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 3001 }, { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 3002 }, @@ -83,6 +87,7 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 3047 }, { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 3048 }, { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 3049 }, + { "MACHINE_STATE_NO_THREAD_DETECTED", "EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED", 3050 }, { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 4000 }, { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 4001 }, { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 4002 }, @@ -240,8 +245,8 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "DISPENSER_4_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE", 7083 }, { "DISPENSER_5_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE", 7084 }, { "DISPENSER_6_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE", 7085 }, - { "DISPENSER_8_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE", 7086 }, - { "DISPENSER_7_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE", 7087 }, + { "DISPENSER_7_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE", 7086 }, + { "DISPENSER_8_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE", 7087 }, { "MID_TANK_1_LOW_LEVEL", "EVENT_TYPE__MID_TANK_1_LOW_LEVEL", 8000 }, { "MID_TANK_2_LOW_LEVEL", "EVENT_TYPE__MID_TANK_2_LOW_LEVEL", 8001 }, { "MID_TANK_3_LOW_LEVEL", "EVENT_TYPE__MID_TANK_3_LOW_LEVEL", 8002 }, @@ -279,9 +284,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "WASTE_CONTAINER_EMPTYING_TIMEOUT", "EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT", 9002 }, { "NO_AIR_PRESSURE", "EVENT_TYPE__NO_AIR_PRESSURE", 9003 }, { "WASTE_CONTAINER_OVERFLOW", "EVENT_TYPE__WASTE_CONTAINER_OVERFLOW", 9004 }, - { "VOC_SENSOR_ALARM", "EVENT_TYPE__VOC_SENSOR_ALARM", 9005 }, + { "VOC_SENSOR_ALARM_TIME", "EVENT_TYPE__VOC_SENSOR_ALARM_TIME", 9005 }, { "CHILLER_DRY_CONTACT", "EVENT_TYPE__CHILLER_DRY_CONTACT", 9006 }, { "INSUFFICIENT_AIR_FLOW", "EVENT_TYPE__INSUFFICIENT_AIR_FLOW", 9007 }, + { "VOC_SENSOR_ALARM_SLOPE", "EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE", 9008 }, { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 10000 }, { "INK_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT", 10001 }, { "NO_WASTE_CARTRIDGE_AVAILABLE", "EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE", 10002 }, @@ -290,289 +296,295 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{1000, 1},{2000, 11},{3000, 24},{4000, 74},{5000, 96},{6000, 139},{7000, 145},{8000, 233},{9000, 265},{10000, 273},{0, 279} +{0, 0},{1000, 1},{2000, 11},{3000, 28},{4000, 79},{5000, 101},{6000, 144},{7000, 150},{8000, 238},{9000, 270},{10000, 279},{0, 285} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[279] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[285] = { - { "AIR_FILTER_CLOGGED", 266 }, - { "AIR_FILTER_NOT_INSTALLED", 265 }, - { "ALL_WASTE_CARTRIDGES_FULL", 276 }, + { "AIR_FILTER_CLOGGED", 271 }, + { "AIR_FILTER_NOT_INSTALLED", 270 }, + { "ALL_WASTE_CARTRIDGES_FULL", 282 }, { "APPLICATION_EXCEPTION", 4 }, { "APPLICATION_INFORMATION", 5 }, { "APPLICATION_STARTED", 6 }, { "APPLICATION_TERMINATED", 7 }, { "CARTRIDGES_COVER_OPEN", 17 }, - { "CHILLER_DRY_CONTACT", 271 }, - { "DISPENSER_1_EMPTY", 161 }, - { "DISPENSER_1_HIGH_PRESSURE", 225 }, - { "DISPENSER_1_LOWER_HARD_LIMIT", 217 }, - { "DISPENSER_1_MOTOR_OVERCURRENT", 177 }, - { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 185 }, - { "DISPENSER_1_MOTOR_STALL", 193 }, - { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 201 }, - { "DISPENSER_1_OVERPRESSURE", 145 }, - { "DISPENSER_1_REFILL_FAILURE", 169 }, - { "DISPENSER_1_UNDERPRESSURE", 153 }, - { "DISPENSER_1_UPPER_HARD_LIMIT", 209 }, - { "DISPENSER_2_EMPTY", 162 }, - { "DISPENSER_2_HIGH_PRESSURE", 226 }, - { "DISPENSER_2_LOWER_HARD_LIMIT", 218 }, - { "DISPENSER_2_MOTOR_OVERCURRENT", 178 }, - { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 186 }, - { "DISPENSER_2_MOTOR_STALL", 194 }, - { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 202 }, - { "DISPENSER_2_OVERPRESSURE", 146 }, - { "DISPENSER_2_REFILL_FAILURE", 170 }, - { "DISPENSER_2_UNDERPRESSURE", 154 }, - { "DISPENSER_2_UPPER_HARD_LIMIT", 210 }, - { "DISPENSER_3_EMPTY", 163 }, - { "DISPENSER_3_HIGH_PRESSURE", 227 }, - { "DISPENSER_3_LOWER_HARD_LIMIT", 219 }, - { "DISPENSER_3_MOTOR_OVERCURRENT", 179 }, - { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 187 }, - { "DISPENSER_3_MOTOR_STALL", 195 }, - { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 203 }, - { "DISPENSER_3_OVERPRESSURE", 147 }, - { "DISPENSER_3_REFILL_FAILURE", 171 }, - { "DISPENSER_3_UNDERPRESSURE", 155 }, - { "DISPENSER_3_UPPER_HARD_LIMIT", 211 }, - { "DISPENSER_4_EMPTY", 164 }, - { "DISPENSER_4_HIGH_PRESSURE", 228 }, - { "DISPENSER_4_LOWER_HARD_LIMIT", 220 }, - { "DISPENSER_4_MOTOR_OVERCURRENT", 180 }, - { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 188 }, - { "DISPENSER_4_MOTOR_STALL", 196 }, - { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 204 }, - { "DISPENSER_4_OVERPRESSURE", 148 }, - { "DISPENSER_4_REFILL_FAILURE", 172 }, - { "DISPENSER_4_UNDERPRESSURE", 156 }, - { "DISPENSER_4_UPPER_HARD_LIMIT", 212 }, - { "DISPENSER_5_EMPTY", 165 }, - { "DISPENSER_5_HIGH_PRESSURE", 229 }, - { "DISPENSER_5_LOWER_HARD_LIMIT", 221 }, - { "DISPENSER_5_MOTOR_OVERCURRENT", 181 }, - { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 189 }, - { "DISPENSER_5_MOTOR_STALL", 197 }, - { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 205 }, - { "DISPENSER_5_OVERPRESSURE", 149 }, - { "DISPENSER_5_REFILL_FAILURE", 173 }, - { "DISPENSER_5_UNDERPRESSURE", 157 }, - { "DISPENSER_5_UPPER_HARD_LIMIT", 213 }, - { "DISPENSER_6_EMPTY", 166 }, - { "DISPENSER_6_HIGH_PRESSURE", 230 }, - { "DISPENSER_6_LOWER_HARD_LIMIT", 222 }, - { "DISPENSER_6_MOTOR_OVERCURRENT", 182 }, - { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 190 }, - { "DISPENSER_6_MOTOR_STALL", 198 }, - { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 206 }, - { "DISPENSER_6_OVERPRESSURE", 150 }, - { "DISPENSER_6_REFILL_FAILURE", 174 }, - { "DISPENSER_6_UNDERPRESSURE", 158 }, - { "DISPENSER_6_UPPER_HARD_LIMIT", 214 }, - { "DISPENSER_7_EMPTY", 167 }, - { "DISPENSER_7_HIGH_PRESSURE", 232 }, - { "DISPENSER_7_LOWER_HARD_LIMIT", 223 }, - { "DISPENSER_7_MOTOR_OVERCURRENT", 183 }, - { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 191 }, - { "DISPENSER_7_MOTOR_STALL", 199 }, - { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 207 }, - { "DISPENSER_7_OVERPRESSURE", 151 }, - { "DISPENSER_7_REFILL_FAILURE", 175 }, - { "DISPENSER_7_UNDERPRESSURE", 159 }, - { "DISPENSER_7_UPPER_HARD_LIMIT", 215 }, - { "DISPENSER_8_EMPTY", 168 }, - { "DISPENSER_8_HIGH_PRESSURE", 231 }, - { "DISPENSER_8_LOWER_HARD_LIMIT", 224 }, - { "DISPENSER_8_MOTOR_OVERCURRENT", 184 }, - { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 192 }, - { "DISPENSER_8_MOTOR_STALL", 200 }, - { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 208 }, - { "DISPENSER_8_OVERPRESSURE", 152 }, - { "DISPENSER_8_REFILL_FAILURE", 176 }, - { "DISPENSER_8_UNDERPRESSURE", 160 }, - { "DISPENSER_8_UPPER_HARD_LIMIT", 216 }, - { "DRYER_DOOR_OPEN", 78 }, - { "DRYER_FAN_RPM_TOO_LOW", 89 }, - { "DRYER_FAN_STOPPED", 90 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 87 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 85 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 88 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 86 }, - { "DRYER_LID_MOTOR_OVERCURRENT", 91 }, - { "DRYER_LID_MOTOR_OVERTEMPERATURE", 92 }, - { "DRYER_LID_MOTOR_STALL", 93 }, - { "DRYER_LID_MOTOR_UNDERVOLTAGE", 94 }, - { "DRYER_MOTOR_OVERCURRENT", 74 }, - { "DRYER_MOTOR_OVERTEMPERATURE", 75 }, - { "DRYER_MOTOR_STALL", 76 }, - { "DRYER_MOTOR_UNDERVOLTAGE", 77 }, - { "DRYER_THERMAL_CUTOFF", 84 }, - { "DRYER_ZONE_1_OVERTEMPERATURE", 79 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 81 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 82 }, - { "DRYER_ZONE_2_OVERTEMPERATURE", 80 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 95 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 83 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 135 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 136 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 137 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 138 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 131 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 132 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 133 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 134 }, - { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 126 }, - { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 127 }, - { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 128 }, - { "DYEING_HEAD_COVER_MOTOR_STALL", 129 }, - { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 130 }, - { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 125 }, - { "DYEING_HEAD_THERMAL_CUTOFF", 124 }, - { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 119 }, - { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 114 }, - { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 96 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 102 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 108 }, - { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 120 }, - { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 115 }, - { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 97 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 103 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 109 }, - { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 121 }, - { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 116 }, - { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 98 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 104 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 110 }, - { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 122 }, - { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 117 }, - { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 99 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 105 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 111 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 123 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 118 }, - { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 100 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 106 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 112 }, - { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 101 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 107 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 113 }, + { "CHILLER_DRY_CONTACT", 276 }, + { "DISPENSER_1_EMPTY", 166 }, + { "DISPENSER_1_HIGH_PRESSURE", 230 }, + { "DISPENSER_1_LOWER_HARD_LIMIT", 222 }, + { "DISPENSER_1_MOTOR_OVERCURRENT", 182 }, + { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 190 }, + { "DISPENSER_1_MOTOR_STALL", 198 }, + { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 206 }, + { "DISPENSER_1_OVERPRESSURE", 150 }, + { "DISPENSER_1_REFILL_FAILURE", 174 }, + { "DISPENSER_1_UNDERPRESSURE", 158 }, + { "DISPENSER_1_UPPER_HARD_LIMIT", 214 }, + { "DISPENSER_2_EMPTY", 167 }, + { "DISPENSER_2_HIGH_PRESSURE", 231 }, + { "DISPENSER_2_LOWER_HARD_LIMIT", 223 }, + { "DISPENSER_2_MOTOR_OVERCURRENT", 183 }, + { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 191 }, + { "DISPENSER_2_MOTOR_STALL", 199 }, + { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 207 }, + { "DISPENSER_2_OVERPRESSURE", 151 }, + { "DISPENSER_2_REFILL_FAILURE", 175 }, + { "DISPENSER_2_UNDERPRESSURE", 159 }, + { "DISPENSER_2_UPPER_HARD_LIMIT", 215 }, + { "DISPENSER_3_EMPTY", 168 }, + { "DISPENSER_3_HIGH_PRESSURE", 232 }, + { "DISPENSER_3_LOWER_HARD_LIMIT", 224 }, + { "DISPENSER_3_MOTOR_OVERCURRENT", 184 }, + { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 192 }, + { "DISPENSER_3_MOTOR_STALL", 200 }, + { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 208 }, + { "DISPENSER_3_OVERPRESSURE", 152 }, + { "DISPENSER_3_REFILL_FAILURE", 176 }, + { "DISPENSER_3_UNDERPRESSURE", 160 }, + { "DISPENSER_3_UPPER_HARD_LIMIT", 216 }, + { "DISPENSER_4_EMPTY", 169 }, + { "DISPENSER_4_HIGH_PRESSURE", 233 }, + { "DISPENSER_4_LOWER_HARD_LIMIT", 225 }, + { "DISPENSER_4_MOTOR_OVERCURRENT", 185 }, + { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 193 }, + { "DISPENSER_4_MOTOR_STALL", 201 }, + { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 209 }, + { "DISPENSER_4_OVERPRESSURE", 153 }, + { "DISPENSER_4_REFILL_FAILURE", 177 }, + { "DISPENSER_4_UNDERPRESSURE", 161 }, + { "DISPENSER_4_UPPER_HARD_LIMIT", 217 }, + { "DISPENSER_5_EMPTY", 170 }, + { "DISPENSER_5_HIGH_PRESSURE", 234 }, + { "DISPENSER_5_LOWER_HARD_LIMIT", 226 }, + { "DISPENSER_5_MOTOR_OVERCURRENT", 186 }, + { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 194 }, + { "DISPENSER_5_MOTOR_STALL", 202 }, + { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 210 }, + { "DISPENSER_5_OVERPRESSURE", 154 }, + { "DISPENSER_5_REFILL_FAILURE", 178 }, + { "DISPENSER_5_UNDERPRESSURE", 162 }, + { "DISPENSER_5_UPPER_HARD_LIMIT", 218 }, + { "DISPENSER_6_EMPTY", 171 }, + { "DISPENSER_6_HIGH_PRESSURE", 235 }, + { "DISPENSER_6_LOWER_HARD_LIMIT", 227 }, + { "DISPENSER_6_MOTOR_OVERCURRENT", 187 }, + { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 195 }, + { "DISPENSER_6_MOTOR_STALL", 203 }, + { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 211 }, + { "DISPENSER_6_OVERPRESSURE", 155 }, + { "DISPENSER_6_REFILL_FAILURE", 179 }, + { "DISPENSER_6_UNDERPRESSURE", 163 }, + { "DISPENSER_6_UPPER_HARD_LIMIT", 219 }, + { "DISPENSER_7_EMPTY", 172 }, + { "DISPENSER_7_HIGH_PRESSURE", 236 }, + { "DISPENSER_7_LOWER_HARD_LIMIT", 228 }, + { "DISPENSER_7_MOTOR_OVERCURRENT", 188 }, + { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 196 }, + { "DISPENSER_7_MOTOR_STALL", 204 }, + { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 212 }, + { "DISPENSER_7_OVERPRESSURE", 156 }, + { "DISPENSER_7_REFILL_FAILURE", 180 }, + { "DISPENSER_7_UNDERPRESSURE", 164 }, + { "DISPENSER_7_UPPER_HARD_LIMIT", 220 }, + { "DISPENSER_8_EMPTY", 173 }, + { "DISPENSER_8_HIGH_PRESSURE", 237 }, + { "DISPENSER_8_LOWER_HARD_LIMIT", 229 }, + { "DISPENSER_8_MOTOR_OVERCURRENT", 189 }, + { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 197 }, + { "DISPENSER_8_MOTOR_STALL", 205 }, + { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 213 }, + { "DISPENSER_8_OVERPRESSURE", 157 }, + { "DISPENSER_8_REFILL_FAILURE", 181 }, + { "DISPENSER_8_UNDERPRESSURE", 165 }, + { "DISPENSER_8_UPPER_HARD_LIMIT", 221 }, + { "DRYER_DOOR_OPEN", 83 }, + { "DRYER_FAN_RPM_TOO_LOW", 94 }, + { "DRYER_FAN_STOPPED", 95 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 92 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 90 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 93 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 91 }, + { "DRYER_LID_MOTOR_OVERCURRENT", 96 }, + { "DRYER_LID_MOTOR_OVERTEMPERATURE", 97 }, + { "DRYER_LID_MOTOR_STALL", 98 }, + { "DRYER_LID_MOTOR_UNDERVOLTAGE", 99 }, + { "DRYER_MOTOR_OVERCURRENT", 79 }, + { "DRYER_MOTOR_OVERTEMPERATURE", 80 }, + { "DRYER_MOTOR_STALL", 81 }, + { "DRYER_MOTOR_UNDERVOLTAGE", 82 }, + { "DRYER_THERMAL_CUTOFF", 89 }, + { "DRYER_ZONE_1_OVERTEMPERATURE", 84 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 86 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 87 }, + { "DRYER_ZONE_2_OVERTEMPERATURE", 85 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 100 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 88 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 140 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 141 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 142 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 143 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 136 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 137 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 138 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 139 }, + { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 131 }, + { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 132 }, + { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 133 }, + { "DYEING_HEAD_COVER_MOTOR_STALL", 134 }, + { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 135 }, + { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 130 }, + { "DYEING_HEAD_THERMAL_CUTOFF", 129 }, + { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 124 }, + { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 119 }, + { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 101 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 107 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 113 }, + { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 125 }, + { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 120 }, + { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 102 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 108 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 114 }, + { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 126 }, + { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 121 }, + { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 103 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 109 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 115 }, + { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 127 }, + { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 122 }, + { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 104 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 110 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 116 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 128 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 123 }, + { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 105 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 111 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 117 }, + { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 106 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 112 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 118 }, { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 22 }, { "ELECTRICAL_CABINET_FANS_STOPPED", 23 }, { "EMERGENCY_PUSH_BUTTON_PRESSED", 12 }, - { "FEEDER_DANCER_MOTOR_OVERCURRENT", 62 }, - { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 65 }, - { "FEEDER_DANCER_MOTOR_STALL", 68 }, - { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 71 }, - { "FEEDER_MOTOR_OVERCURRENT", 27 }, - { "FEEDER_MOTOR_OVERTEMPERATURE", 34 }, - { "FEEDER_MOTOR_STALL", 41 }, - { "FEEDER_MOTOR_UNDERVOLTAGE", 48 }, + { "FEEDER_DANCER_MOTOR_OVERCURRENT", 66 }, + { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 69 }, + { "FEEDER_DANCER_MOTOR_STALL", 72 }, + { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 75 }, + { "FEEDER_MOTOR_OVERCURRENT", 31 }, + { "FEEDER_MOTOR_OVERTEMPERATURE", 38 }, + { "FEEDER_MOTOR_STALL", 45 }, + { "FEEDER_MOTOR_UNDERVOLTAGE", 52 }, { "FRONT_COVER_1_OPEN", 13 }, { "FRONT_COVER_2_OPEN", 14 }, { "FRONT_COVER_3_OPEN", 15 }, { "FRONT_COVER_4_OPEN", 16 }, - { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 273 }, - { "INK_CARTRIDGE_RFID_TIMEOUT", 274 }, - { "INSUFFICIENT_AIR_FLOW", 272 }, + { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 279 }, + { "INK_CARTRIDGE_RFID_TIMEOUT", 280 }, + { "INSUFFICIENT_AIR_FLOW", 277 }, { "JOB_STATUS", 10 }, - { "LEFT_LOADER_MOTOR_OVERCURRENT", 30 }, - { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 37 }, - { "LEFT_LOADER_MOTOR_STALL", 44 }, - { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 51 }, - { "LOADING_ARM_MOTOR_OVERCURRENT", 33 }, - { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 40 }, - { "LOADING_ARM_MOTOR_STALL", 47 }, - { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 54 }, - { "LTFU_DOWN_TIMEOUT", 56 }, - { "LTFU_UP_TIMEOUT", 55 }, + { "LEFT_LOADER_MOTOR_OVERCURRENT", 34 }, + { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 41 }, + { "LEFT_LOADER_MOTOR_STALL", 48 }, + { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 55 }, + { "LOADING_ARM_MOTOR_OVERCURRENT", 37 }, + { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 44 }, + { "LOADING_ARM_MOTOR_STALL", 51 }, + { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 58 }, + { "LTFU_DOWN_TIMEOUT", 60 }, + { "LTFU_UP_TIMEOUT", 59 }, { "MACHINE_FANS_RPM_TOO_LOW", 20 }, { "MACHINE_FANS_STOPPED", 21 }, { "MACHINE_INTERNAL_OVERTEMPERATURE", 19 }, - { "MID_TANK_1_EMPTY", 241 }, - { "MID_TANK_1_FILL_TIMEOUT", 257 }, - { "MID_TANK_1_LOW_LEVEL", 233 }, - { "MID_TANK_1_OVERFLOW", 249 }, - { "MID_TANK_2_EMPTY", 242 }, - { "MID_TANK_2_FILL_TIMEOUT", 258 }, - { "MID_TANK_2_LOW_LEVEL", 234 }, - { "MID_TANK_2_OVERFLOW", 250 }, - { "MID_TANK_3_EMPTY", 243 }, - { "MID_TANK_3_FILL_TIMEOUT", 259 }, - { "MID_TANK_3_LOW_LEVEL", 235 }, - { "MID_TANK_3_OVERFLOW", 251 }, - { "MID_TANK_4_EMPTY", 244 }, - { "MID_TANK_4_FILL_TIMEOUT", 260 }, - { "MID_TANK_4_LOW_LEVEL", 236 }, - { "MID_TANK_4_OVERFLOW", 252 }, - { "MID_TANK_5_EMPTY", 245 }, - { "MID_TANK_5_FILL_TIMEOUT", 261 }, - { "MID_TANK_5_LOW_LEVEL", 237 }, - { "MID_TANK_5_OVERFLOW", 253 }, - { "MID_TANK_6_EMPTY", 246 }, - { "MID_TANK_6_FILL_TIMEOUT", 262 }, - { "MID_TANK_6_LOW_LEVEL", 238 }, - { "MID_TANK_6_OVERFLOW", 254 }, - { "MID_TANK_7_EMPTY", 247 }, - { "MID_TANK_7_FILL_TIMEOUT", 263 }, - { "MID_TANK_7_LOW_LEVEL", 239 }, - { "MID_TANK_7_OVERFLOW", 255 }, - { "MID_TANK_8_EMPTY", 248 }, - { "MID_TANK_8_FILL_TIMEOUT", 264 }, - { "MID_TANK_8_LOW_LEVEL", 240 }, - { "MID_TANK_8_OVERFLOW", 256 }, - { "MIXER_CURRENT_LOOP_BREAK", 144 }, - { "MIXER_CURRENT_OUT_OF_RANGE", 143 }, - { "MIXER_OVERTEMPERATURE", 139 }, - { "MIXER_THERMAL_CUTOFF", 142 }, - { "MIXER_UNDERTEMPERATURE_A", 140 }, - { "MIXER_UNDERTEMPERATURE_B", 141 }, - { "NO_AIR_PRESSURE", 268 }, - { "NO_WASTE_CARTRIDGE_AVAILABLE", 275 }, + { "MACHINE_STATE_HW_CONFIG_FAILED", 25 }, + { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 26 }, + { "MACHINE_STATE_NO_CFG_FILE", 24 }, + { "MACHINE_STATE_NO_THREAD_DETECTED", 78 }, + { "MID_TANK_1_EMPTY", 246 }, + { "MID_TANK_1_FILL_TIMEOUT", 262 }, + { "MID_TANK_1_LOW_LEVEL", 238 }, + { "MID_TANK_1_OVERFLOW", 254 }, + { "MID_TANK_2_EMPTY", 247 }, + { "MID_TANK_2_FILL_TIMEOUT", 263 }, + { "MID_TANK_2_LOW_LEVEL", 239 }, + { "MID_TANK_2_OVERFLOW", 255 }, + { "MID_TANK_3_EMPTY", 248 }, + { "MID_TANK_3_FILL_TIMEOUT", 264 }, + { "MID_TANK_3_LOW_LEVEL", 240 }, + { "MID_TANK_3_OVERFLOW", 256 }, + { "MID_TANK_4_EMPTY", 249 }, + { "MID_TANK_4_FILL_TIMEOUT", 265 }, + { "MID_TANK_4_LOW_LEVEL", 241 }, + { "MID_TANK_4_OVERFLOW", 257 }, + { "MID_TANK_5_EMPTY", 250 }, + { "MID_TANK_5_FILL_TIMEOUT", 266 }, + { "MID_TANK_5_LOW_LEVEL", 242 }, + { "MID_TANK_5_OVERFLOW", 258 }, + { "MID_TANK_6_EMPTY", 251 }, + { "MID_TANK_6_FILL_TIMEOUT", 267 }, + { "MID_TANK_6_LOW_LEVEL", 243 }, + { "MID_TANK_6_OVERFLOW", 259 }, + { "MID_TANK_7_EMPTY", 252 }, + { "MID_TANK_7_FILL_TIMEOUT", 268 }, + { "MID_TANK_7_LOW_LEVEL", 244 }, + { "MID_TANK_7_OVERFLOW", 260 }, + { "MID_TANK_8_EMPTY", 253 }, + { "MID_TANK_8_FILL_TIMEOUT", 269 }, + { "MID_TANK_8_LOW_LEVEL", 245 }, + { "MID_TANK_8_OVERFLOW", 261 }, + { "MIXER_CURRENT_LOOP_BREAK", 149 }, + { "MIXER_CURRENT_OUT_OF_RANGE", 148 }, + { "MIXER_OVERTEMPERATURE", 144 }, + { "MIXER_THERMAL_CUTOFF", 147 }, + { "MIXER_UNDERTEMPERATURE_A", 145 }, + { "MIXER_UNDERTEMPERATURE_B", 146 }, + { "NO_AIR_PRESSURE", 273 }, + { "NO_WASTE_CARTRIDGE_AVAILABLE", 281 }, { "None", 0 }, { "POWER_UP_BIT_FAILURE", 11 }, - { "PULLER_DANCER_MOTOR_OVERCURRENT", 61 }, - { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 64 }, - { "PULLER_DANCER_MOTOR_STALL", 67 }, - { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 70 }, - { "PULLER_MOTOR_OVERCURRENT", 29 }, - { "PULLER_MOTOR_OVERTEMPERATURE", 36 }, - { "PULLER_MOTOR_STALL", 43 }, - { "PULLER_MOTOR_UNDERVOLTAGE", 50 }, + { "PULLER_DANCER_MOTOR_OVERCURRENT", 65 }, + { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 68 }, + { "PULLER_DANCER_MOTOR_STALL", 71 }, + { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 74 }, + { "PULLER_MOTOR_OVERCURRENT", 33 }, + { "PULLER_MOTOR_OVERTEMPERATURE", 40 }, + { "PULLER_MOTOR_STALL", 47 }, + { "PULLER_MOTOR_UNDERVOLTAGE", 54 }, { "REAR_COVER_OPEN", 18 }, { "RECORDING_STARTED", 8 }, { "RECORDING_STOPPED", 9 }, { "REQUEST_FAILED", 3 }, { "REQUEST_SENT", 1 }, { "RESPONSE_RECEIVED", 2 }, - { "RIGHT_LOADER_MOTOR_OVERCURRENT", 28 }, - { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 35 }, - { "RIGHT_LOADER_MOTOR_STALL", 42 }, - { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 49 }, - { "RTFU_DOWN_TIMEOUT", 58 }, - { "RTFU_UP_TIMEOUT", 57 }, - { "SCREW_MOTOR_LIMIT_TIMEOUT", 59 }, - { "SCREW_MOTOR_OVERCURRENT", 32 }, - { "SCREW_MOTOR_OVERTEMPERATURE", 39 }, - { "SCREW_MOTOR_STALL", 46 }, - { "SCREW_MOTOR_UNDERVOLTAGE", 53 }, - { "THREAD_BREAK", 24 }, - { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 25 }, - { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 72 }, - { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 73 }, - { "VOC_SENSOR_ALARM", 270 }, - { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 277 }, - { "WASTE_CARTRIDGE_RFID_TIMEOUT", 278 }, - { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 267 }, - { "WASTE_CONTAINER_OVERFLOW", 269 }, - { "WINDER_CONE_DOES_NOT_EXIST", 26 }, - { "WINDER_DANCER_MOTOR_OVERCURRENT", 60 }, - { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 63 }, - { "WINDER_DANCER_MOTOR_STALL", 66 }, - { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 69 }, - { "WINDER_MOTOR_OVERCURRENT", 31 }, - { "WINDER_MOTOR_OVERTEMPERATURE", 38 }, - { "WINDER_MOTOR_STALL", 45 }, - { "WINDER_MOTOR_UNDERVOLTAGE", 52 }, + { "RIGHT_LOADER_MOTOR_OVERCURRENT", 32 }, + { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 39 }, + { "RIGHT_LOADER_MOTOR_STALL", 46 }, + { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 53 }, + { "RTFU_DOWN_TIMEOUT", 62 }, + { "RTFU_UP_TIMEOUT", 61 }, + { "SCREW_MOTOR_LIMIT_TIMEOUT", 63 }, + { "SCREW_MOTOR_OVERCURRENT", 36 }, + { "SCREW_MOTOR_OVERTEMPERATURE", 43 }, + { "SCREW_MOTOR_STALL", 50 }, + { "SCREW_MOTOR_UNDERVOLTAGE", 57 }, + { "THREAD_BREAK", 28 }, + { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 29 }, + { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 76 }, + { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 77 }, + { "UNSPECIFIED", 27 }, + { "VOC_SENSOR_ALARM_SLOPE", 278 }, + { "VOC_SENSOR_ALARM_TIME", 275 }, + { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 283 }, + { "WASTE_CARTRIDGE_RFID_TIMEOUT", 284 }, + { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 272 }, + { "WASTE_CONTAINER_OVERFLOW", 274 }, + { "WINDER_CONE_DOES_NOT_EXIST", 30 }, + { "WINDER_DANCER_MOTOR_OVERCURRENT", 64 }, + { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 67 }, + { "WINDER_DANCER_MOTOR_STALL", 70 }, + { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 73 }, + { "WINDER_MOTOR_OVERCURRENT", 35 }, + { "WINDER_MOTOR_OVERTEMPERATURE", 42 }, + { "WINDER_MOTOR_STALL", 49 }, + { "WINDER_MOTOR_UNDERVOLTAGE", 56 }, }; const ProtobufCEnumDescriptor event_type__descriptor = { @@ -581,9 +593,9 @@ const ProtobufCEnumDescriptor event_type__descriptor = "EventType", "EventType", "", - 279, + 285, event_type__enum_values_by_number, - 279, + 285, event_type__enum_values_by_name, 11, event_type__value_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h index ae437f66c..f8aecc24f 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h @@ -44,6 +44,10 @@ typedef enum _EventType { EVENT_TYPE__MACHINE_FANS_STOPPED = 2010, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW = 2011, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED = 2012, + EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE = 2013, + EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED = 2014, + EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED = 2015, + EVENT_TYPE__UNSPECIFIED = 2016, EVENT_TYPE__THREAD_BREAK = 3000, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001, EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002, @@ -94,6 +98,7 @@ typedef enum _EventType { EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE = 3047, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER = 3048, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER = 3049, + EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED = 3050, EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 4000, EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 4001, EVENT_TYPE__DRYER_MOTOR_STALL = 4002, @@ -251,8 +256,8 @@ typedef enum _EventType { EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE = 7083, EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE = 7084, EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE = 7085, - EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE = 7086, - EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE = 7087, + EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE = 7086, + EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE = 7087, EVENT_TYPE__MID_TANK_1_LOW_LEVEL = 8000, EVENT_TYPE__MID_TANK_2_LOW_LEVEL = 8001, EVENT_TYPE__MID_TANK_3_LOW_LEVEL = 8002, @@ -290,9 +295,10 @@ typedef enum _EventType { EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT = 9002, EVENT_TYPE__NO_AIR_PRESSURE = 9003, EVENT_TYPE__WASTE_CONTAINER_OVERFLOW = 9004, - EVENT_TYPE__VOC_SENSOR_ALARM = 9005, + EVENT_TYPE__VOC_SENSOR_ALARM_TIME = 9005, EVENT_TYPE__CHILLER_DRY_CONTACT = 9006, EVENT_TYPE__INSUFFICIENT_AIR_FLOW = 9007, + EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE = 9008, EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 10000, EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT = 10001, EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE = 10002, diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c index 790f77f8a..3d1ad4f8c 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c @@ -15,6 +15,8 @@ #include #include +TCA9534Regs* Disp_IO_Reg; + uint8_t TCA9534Init(uint8_t Dispenser_ID, TCA9534Regs* Regs)//1 { uint8_t status = PASSED; @@ -267,6 +269,43 @@ uint8_t TCA9534ByPass(uint8_t Dispenser_ID, TCA9534Regs* Regs, bool EnableByPass } +uint8_t Init_Dispensers_IO_Registers(TCA9534Regs* Regs) +{ + uint8_t status = PASSED; + + uint8_t i; + + for(i=0;i<8;i++) + { + if(Dispenser_struct[i].Type == DISP_TYPE_EEPROM128KB) + { + status |= TCA9534Init(i, &Regs); + } + } + + return status; +} + +uint8_t Read_Dispensers_IO_Registers(TCA9534Regs* Regs) +{ + uint8_t status = PASSED; + + uint8_t i; + + for(i=0;i<8;i++) + { + if(Dispenser_struct[i].Type == DISP_TYPE_EEPROM128KB) + { + status |= TCA9534SetReadInputReg(i); + status |= TCA9534ReadInputReg(i, &Regs); + } + } + + return status; +} + + + bool Read_Notification_Disp_UP(uint8_t Dispenser_ID, TCA9534Regs* Regs) { return Regs->Input[Dispenser_ID].bit.DISP_UP; diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h index af1470da5..e8784a2ff 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h @@ -50,6 +50,8 @@ typedef struct { TCA9534_union Config[8]; } TCA9534Regs; +extern TCA9534Regs* Disp_IO_Reg; + uint8_t TCA9534Init(uint8_t Dispenser_ID, TCA9534Regs* Regs); uint8_t TCA9534SetReadInputReg(uint8_t Dispenser_ID); uint8_t TCA9534ReadInputReg(uint8_t Dispenser_ID, TCA9534Regs* Regs); @@ -61,5 +63,7 @@ bool Read_Notification_Disp_Down(uint8_t Dispenser_ID, TCA9534Regs* Regs); bool Read_Notification_Realy_On(uint8_t Dispenser_ID, TCA9534Regs* Regs); bool Read_Notification_Over_Press(uint8_t Dispenser_ID, TCA9534Regs* Regs); uint8_t test_IO(); +uint8_t Init_Dispensers_IO_Registers(TCA9534Regs* Regs); +uint8_t Read_Dispensers_IO_Registers(TCA9534Regs* Regs); #endif /* DRIVERS_I2C_COMMUNICATION_DISPENSERS_IO_PORT_IO_H_ */ diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index a125ef10c..64bac419e 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -25,6 +25,12 @@ #include "Communication/CommunicationTask.h" +#include +#include +#include + +#include +#include #include #include "drivers/Flash_ram/FlashProgram.h" @@ -67,7 +73,10 @@ #include "Modules/General/buttons.h" #include "Modules/Waste/Waste.h" +#include //#define WATCHDOG + + //***************************************************************************** // // The system tick rate expressed both as ticks per second and a millisecond @@ -76,6 +85,7 @@ //***************************************************************************** #define TICKS_PER_SECOND 1000 + //***************************************************************************** // // Global system tick counter @@ -94,19 +104,75 @@ F1_GPO_REG F1_GPO_Reg; F3_GPO_01_REG F3_GPO_01_Reg; -//MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)); -uint32_t MainDummyFunction(uint32_t IfIndex, uint32_t ReadValue) -{ - return OK; -} -uint32_t HWControlId; +Types_Site *site; +Error_Id eid; +int eCode; -uint32_t MainHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) +/* ======== errHook ======== */ +Void errHook(Error_Block *eb) { - RemoveControlCallback(HWControlId, MainHWInitCallBackFunction ); - HWConfigurationInit(); - return OK; + FRESULT Fresult = FR_OK; + FIL *FileHandle = 0; //the system supports a single active file + uint32_t Bytes = 0; + char ErrorPath[50] = "0://ErrorFile.txt"; + char File[50] = ""; + char message[300]; + int len; + + STATUS_GREEN_LED_OFF; + ACTIVITY_GREEN_LED_OFF; + COMM_GREEN_LED_OFF; + + STATUS_RED_LED_ON; + ACTIVITY_RED_LED_ON; + COMM_RED_LED_ON; + + site = Error_getSite(eb); + eid = Error_getId(eb); + eCode = Error_getCode(eb); + FileHandle = my_malloc(sizeof(FIL)); + if (FileHandle == 0) + Fresult = FR_DENIED; + else + { + Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ); + if (Fresult == FR_OK) + { + strcpy(File,site->file); + len = usnprintf(message, 80, "\r\n%s %s %s",__DATE__, __TIME__,File); + Fresult = f_write(FileHandle,message,len,&Bytes ); + /* print user supplied error code */ + len = usnprintf(message, 300, "\r\nerror %d, eid %d file %s line %d mod %d", + eCode, eid, site->file, + site->line, + site->mod); + Fresult = f_write(FileHandle,message,len,&Bytes ); + + LOG_ERROR (eCode, "error # "); + /* check originator's mod id against known mods */ + if (site->mod == Main_Module_id()) { + Fresult = f_write(FileHandle,"\r\napp error: ",12,&Bytes ); + } + + /* check error id against known errors */ + if (eid == Error_E_generic) { + Fresult = f_write(FileHandle,"generic: ",10,&Bytes ); + } + else if (eid == Assert_E_assertFailed) { + System_printf("assertion violation: "); + Fresult = f_write(FileHandle,"\r\nassertion violation: ",22,&Bytes ); + } + + /* perform default error output */ + f_close(FileHandle); + } + Task_sleep (200); + my_free(FileHandle); + } + //Power_Reset(); + SysCtlReset(); } + //***************************************************************************** // // Interrupt handler for the system tick counter. @@ -177,7 +243,7 @@ int main(void) #endif #ifdef WATCHDOG - InitWatchdog(ui32SysClock); + InitWatchdog(ui32SysClock*2); #endif CommunicationTaskInit(); @@ -196,8 +262,8 @@ int main(void) Heaters_Init(); MotorsInit(); //Shai WHS_HW_test(); // for WHS sensor test - WHS_init(); - Buttons_Init(); + //WHS_init(); + //Buttons_Init(); //IDS_ModuleInit(); Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); @@ -224,6 +290,8 @@ int main(void) //I2C_NFC_Test(); // //test_avi(); //example for shai + Init_Dispensers_IO_Registers(&Disp_IO_Reg); + Set_Speed_Sensor_TypeII_Registers(2,2);//set default values //Read_Speed_Sensor_TypeII();//must be delay between Set_Speed_Sensor_TypeII_Registers to Read_Speed_Sensor_TypeII diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 13f0515f9..2256ebd34 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -243,14 +243,14 @@ const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"}, {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"}, @@ -674,21 +674,25 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); event__init(AlarmState[Alarm_i].EventPtr); AlarmState[Alarm_i].EventPtr->has_type = true; AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; - AlarmState[Alarm_i].Status = value; - Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); + AlarmState[Alarm_i].Status = value; } + //ROM_IntMasterEnable(); + Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else { Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); } AlarmState[Alarm_i].Status = value; } @@ -923,8 +927,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) // alarm on { - AlarmState[Alarm_i].Status = true; - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) @@ -934,15 +936,21 @@ uint32_t AlarmHandlingLoop(uint32_t tick) AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } + AlarmState[Alarm_i].Status = true; + AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmState[Alarm_i].Status = false; - AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); - // report the alarm! if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); + } + AlarmState[Alarm_i].Status = false; + AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index 97489f431..da16df729 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -243,17 +243,17 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ - case INTERFACE_IOS__VALVE_WASTE_TANK: + case INTERFACE_IOS__GPO_BLOWER_PWM: if (request->value == true) - Valve_Set(VALVE_MIXCHIP_WASTECH,1); + Control_Dryer_Fan(START,75); else - Valve_Set(VALVE_MIXCHIP_WASTECH,0); + Control_Dryer_Fan(STOP, 0); break; - case INTERFACE_IOS__GPO_BLOWER_PWM: + case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) - Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100%(); + Valve_Set(VALVE_MIXCHIP_WASTECH,1); else - Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%(); + Valve_Set(VALVE_MIXCHIP_WASTECH,0); break; case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve Valve_Set(VALVE_WASTE_TANK, request->value); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 5ef216264..b09e47b45 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -152,7 +152,7 @@ void DiagnosticsInit(void) Error_init(&eb); - DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 20, NULL,&eb); + DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb); DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*8); DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8); diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 6f1dc2052..f0ce7397c 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_breaksensorlimit = true; EmbeddedParameters.breaksensorlimit = 10; EmbeddedParameters.has_diagnosticcollectionlimit = true; - EmbeddedParameters.diagnosticcollectionlimit = 2; + EmbeddedParameters.diagnosticcollectionlimit = 1; EmbeddedParameters.has_overheatcountlimit = true; EmbeddedParameters.overheatcountlimit = 3; EmbeddedParameters.has_underheatcountlimit = true; @@ -130,7 +130,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_initialdispenserpressure = true; EmbeddedParameters.initialdispenserpressure = 0.08; EmbeddedParameters.has_initialdispensertimeout = true; - EmbeddedParameters.initialdispensertimeout = 10000; + EmbeddedParameters.initialdispensertimeout = 60000; EmbeddedParameters.has_initialdispensertimelag = true; EmbeddedParameters.initialdispensertimelag = 100; EmbeddedParameters.has_dispenserbuildpressurespeed = true; @@ -138,7 +138,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dispenserbuildpressurelimit = true; EmbeddedParameters.dispenserbuildpressurelimit=1.5 ; EmbeddedParameters.has_dispenserbuildpressuretimeout = true; - EmbeddedParameters.dispenserbuildpressuretimeout=20000; + EmbeddedParameters.dispenserbuildpressuretimeout=50000; EmbeddedParameters.has_dispenserbuildpressurelag = true; EmbeddedParameters.dispenserbuildpressurelag=50; EmbeddedParameters.has_acheatersloweroperationlimit = true; @@ -150,7 +150,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dcheatersupperoperationlimit = true; EmbeddedParameters.dcheatersupperoperationlimit = 1002; EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.2; + EmbeddedParameters.midtankpressurecorrection = 0.0; EmbeddedParameters.has_dispenserpresegmentwfcf = true; EmbeddedParameters.dispenserpresegmentwfcf = 80; EmbeddedParameters.has_startheatingoninitsequence = true; diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c index 840898db7..f54a4be19 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c +++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c @@ -25,7 +25,10 @@ uint32_t SafetyControlId; bool DispenserOverPressure[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag); - +bool DrierDoorAlarmState = false; +bool AirFlowAlarmState = false; +bool AirFilterAlarmState = false; +bool WasteOverflowAlarmState = false; void Safety_Init(void) { SafetyControlId = AddControlCallback( Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); @@ -36,6 +39,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) int Disp_i; bool AllDispensersInSafety = true; bool AnyDispensersInSafety = false; + /*bool mDrierDoorAlarmState = false; + bool mAirFlowAlarmState = false; + bool mAirFilterAlarmState = false; + bool mWasteOverflowAlarmState = false;*/ for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) { if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true) @@ -51,6 +58,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle dryer door open AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true); + // mDrierDoorAlarmState = true; + // DrierDoorAlarmState = true; } else { @@ -59,6 +68,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) //report and handle air flow failure //if blower if off handling is different AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, true); + // mAirFlowAlarmState = true; + // AirFlowAlarmState = true; } else { @@ -66,6 +77,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle filter missing AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true); + // mAirFilterAlarmState = true; + // AirFilterAlarmState = true; } else { @@ -73,6 +86,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle waste overflow AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, true); + // mWasteOverflowAlarmState = true; + // WasteOverflowAlarmState = true; } } } @@ -108,7 +123,31 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) } } } - +/* if ((mDrierDoorAlarmState != DrierDoorAlarmState)|| (mDrierDoorAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, false); + DrierDoorAlarmState = mDrierDoorAlarmState; + } + if ((mAirFlowAlarmState != AirFlowAlarmState)|| (mAirFlowAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, false); + AirFlowAlarmState = mAirFlowAlarmState; + } + if ((mAirFilterAlarmState != AirFilterAlarmState)|| (mAirFilterAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, false); + AirFilterAlarmState = mAirFilterAlarmState; + } + if ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false); + WasteOverflowAlarmState = mWasteOverflowAlarmState; + } +*/ return OK; } diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 5ebe10705..3401dbaaa 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -197,7 +197,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile(); void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); */ - /************************************************************************************************************************************/ + /************************************************************************************************************************************ uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails) { JobTicket* JobTicket = JobDetails; @@ -206,6 +206,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); int Dispenser_i, Brush_i,DispenserId; FRESULT Fresult = FR_OK; uint32_t status = OK; + bool lookForLubrication = false; for (Dispenser_i = 0;Dispenser_ienablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } Fresult = OpenJobFile(); if (Fresult == FR_OK) @@ -238,12 +242,12 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0) { DispenserUsedInJob[DispenserId] = true; - /*if(DispenserId == LUBRICANT_DISPENSER) + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) { - lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ - JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; - REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); - }*/ + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } } }//for dispenser }//if dispensers @@ -270,6 +274,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); return status; } + *************************************************************************************************************************************/ /************************************************************************************************************************************/ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails) { @@ -282,7 +287,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); uint32_t status = OK; FRESULT Fresult = FR_OK; FIL *FileHandle = 0; //the system supports a single active file - + bool lookForLubrication = false; + int brushCounter = 0; /* Parsing the job description file. The job description file simply contains an array of segments and their brush stops. @@ -312,7 +318,10 @@ c. Go to step 2.a x Segment.BrushStopsCount. if (EnableCleaning == true) DispenserUsedInJob[CLEANER_DISPENSER] = true; if (JobTicket->enablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile) { FileHandle = my_malloc(sizeof(FIL)); @@ -337,7 +346,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. Segment = job_description_file_segment__unpack(NULL, SegmentSize, SegmentPtr); if ((Segment->has_brushstopscount)&&(Segment->brushstopscount)) { - REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount"); + //REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount"); for (Brush_i=0;Brush_ibrushstopscount;Brush_i++) { if (status == ERROR) @@ -354,7 +363,12 @@ c. Go to step 2.a x Segment.BrushStopsCount. { readBytes += ImmediateRead; BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr); - REPORT_MSG (BrushStopSize, "BrushStop"); + //REPORT_MSG (BrushStopSize, "BrushStop"); + if ((brushCounter++ % 100)==0) + { + SendJobProgress(0.0,0,false, "Processing file"); + Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds + } if (BrushStop->n_dispensers) { for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) @@ -365,6 +379,12 @@ c. Go to step 2.a x Segment.BrushStopsCount. { DispenserUsedInJob[DispenserId] = true; } + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) + { + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } }//for dispenser }//if dispensers else @@ -529,7 +549,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. //IDS_MapDispenserUsedinJob(JobDetails); for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++) { - IDS_StopHomeDispenser(i); + //IDS_StopHomeDispenser(i); if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers { DispenserReady[i] = false; @@ -1060,7 +1080,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); //MotorStop(HW_Motor_Id,Hard_Hiz); - IDS_HomeDispenser (deviceID, 800 , NULL); + //IDS_HomeDispenser (deviceID, 800 , NULL); return OK; } @@ -1100,6 +1120,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) uint32_t IDS_StartLubrication(void) { IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); Lubricant_2Way_Valve (START); return OK; } @@ -1108,6 +1129,7 @@ uint32_t IDS_StopLubrication(void) if(DispenserUsedInJob[LUBRICANT_DISPENSER]) { IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); Lubricant_2Way_Valve (STOP); } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index d041b648e..34cb61e27 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -9,6 +9,9 @@ #include "Drivers/USB_Communication/USBCDCD.h" #include "StateMachines/Initialization/PowerOffSequence.h" +#include "drivers/Flash_Memory/FATFS/ff.h" +#include "drivers/Flash_Memory/FATFS/Control_File_System.h" + //#include "graphics_adapter.h" void Stub_ProgressRequest(MessageContainer* requestContainer) @@ -20,27 +23,42 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) //writeLine("Progress Request..."); ProgressResponse response = PROGRESS_RESPONSE__INIT; - response.has_progress = true; - PowerOffInit(); - int i = 0; - for (i = 0; i < request->amount; i++) - { - response.progress = i; - responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); - uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); - size_t container_size = message_container__pack(&responseContainer, container_buffer); - free(responseContainer.data.data); - SendChars((char*)container_buffer, container_size); - //free(container_buffer); - - int co = 0; - for (co = 0; co < request->delay; co++) + if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive + { + FRESULT iFResult = Init_Flash_File_System(true); + if(iFResult != FR_OK) { - __delay_cycles(1000000); + LOG_ERROR (iFResult, "Error during init Flash File System"); + assert(iFResult); } } + else if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off + { + PowerOffInit(); + } + else + { + response.has_progress = true; + int i = 0; + for (i = 0; i < request->amount; i++) + { + response.progress = i; + responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); + uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + //free(container_buffer); + + int co = 0; + for (co = 0; co < request->delay; co++) + { + __delay_cycles(1000000); + } + } + } responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size); uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); size_t container_size = message_container__pack(&responseContainer, container_buffer); -- cgit v1.3.1 From fd7196c48de7ca02e9461b08022bb5538b0ec42e Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 29 Apr 2019 14:10:49 +0300 Subject: dispenser dtat writing disabled (potential disconnect cause). heaters bug. --- Software/Embedded_SW/Embedded/Main.c | 6 ++---- Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 2 +- 3 files changed, 4 insertions(+), 6 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 64bac419e..379c45f76 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -262,8 +262,8 @@ int main(void) Heaters_Init(); MotorsInit(); //Shai WHS_HW_test(); // for WHS sensor test - //WHS_init(); - //Buttons_Init(); + WHS_init(); + Buttons_Init(); //IDS_ModuleInit(); Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); @@ -310,8 +310,6 @@ int main(void) IDLE_TASK_package_init(); -// HWControlId = AddControlCallback( MainHWInitCallBackFunction, 2* eOneSecond/*eHundredMillisecond*/, MainDummyFunction,0,0, 0 ); - Start_InitSequence(); PowerIdleInit(); BIOS_start(); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index b09e47b45..f2b629c51 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -819,7 +819,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1) DiagnosticTenMsecCollection(); break; case DispensersCollectionTrigger: - DispensersCollectionCall(); + //DispensersCollectionCall(); //suspended for ITMA break; default: break; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 8fe0a9fd8..7a013f49f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -875,7 +875,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } - if ((HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + if ((readValue > HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; -- cgit v1.3.1 From 0ab9e00c3593340713276a7132eb58410d9b2d3d Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 29 Apr 2019 15:22:24 +0300 Subject: Add brackets to defines with calculation --- Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h | 2 +- Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h | 2 +- Software/Embedded_SW/Embedded/Modules/Thread/Thread.h | 4 ++-- Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h index 3b9eba3d8..894f60c09 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h @@ -20,7 +20,7 @@ #define TimerMotors_t HardwareMotorType -#define NUM_OF_MOTORS HARDWARE_MOTOR_TYPE__MOTO_RLOADING + 1 // TODO After the integration with mulbery change to: +#define NUM_OF_MOTORS (HARDWARE_MOTOR_TYPE__MOTO_RLOADING + 1) // TODO After the integration with mulbery change to: //#define NUM_OF_MOTORS HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1 diff --git a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h index 9028de45b..3a1c3ad5b 100644 --- a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h +++ b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h @@ -23,7 +23,7 @@ NUM_OF_ROTENC }RotEnc_t;*/ -#define NUM_OF_ROTENC HARDWARE_DANCER_TYPE__RightDancer+1 +#define NUM_OF_ROTENC (HARDWARE_DANCER_TYPE__RightDancer+1) void SSI1_Init(); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h index 3c9c59f3e..b25c3e5c7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h @@ -5,7 +5,7 @@ #include "PMR/Hardware/HardwarePidControlType.pb-c.h" #include "heaters_ex.h" /******************** DEFINITIONS ********************************************/ -#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1 +#define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1) #define MAX_TIMESLICES 200 extern uint32_t OutputProportionalSingleStep; //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h index 3e2a6aa40..97f3811c7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h @@ -41,8 +41,8 @@ typedef struct }MotorControlConfig_t; -#define MAX_THREAD_FEED_MOTORS WINDER_MOTOR+1 -#define MAX_SYSTEM_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1 +#define MAX_THREAD_FEED_MOTORS (WINDER_MOTOR+1) +#define MAX_SYSTEM_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1) extern TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM]; extern HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM]; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index d7ce917c0..91eedeb6b 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -9,7 +9,7 @@ #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer -#define NUM_OF_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1 +#define NUM_OF_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1) //} DANCER_ENUM; typedef enum threadMotorsEnum { -- cgit v1.3.1 From 594aa33b9a0689a8b75e5b0ea87a4b6fc01a3deb Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 29 Apr 2019 15:26:11 +0300 Subject: lubricant - divide the motor speed acording to microsteps --- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 33 ++++++++++++++++++++++ 1 file changed, 33 insertions(+) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 3401dbaaa..4bcdcc06a 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -246,6 +246,17 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); { lookForLubrication = false; lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } } @@ -383,6 +394,17 @@ c. Go to step 2.a x Segment.BrushStopsCount. { lookForLubrication = false; lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } }//for dispenser @@ -497,6 +519,17 @@ c. Go to step 2.a x Segment.BrushStopsCount. { lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; + if (JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } -- cgit v1.3.1 From 3e5e7e29a922b4e33b286292a743e69421dfb41f Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 11:52:07 +0300 Subject: new embedded parameters file --- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 4 +-- .../Modules/Diagnostics/DiagnosticActions.c | 6 ----- .../stubs/embeddedparametersbuild.cs | 30 ++++++++++++++++++++-- 3 files changed, 30 insertions(+), 10 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 2256ebd34..2a7aef30a 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -865,14 +865,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick) value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId); if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE) { - if (value*100 > AlarmItem[Alarm_i].AlarmValue) + if (value > AlarmItem[Alarm_i].AlarmValue) { Status = true; } } else { - if (value*100 < AlarmItem[Alarm_i].AlarmValue) + if (value < AlarmItem[Alarm_i].AlarmValue) { Status = true; } diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index 6a1821f4b..2b24f9832 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -244,12 +244,6 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ -/* case INTERFACE_IOS__GPO_BLOWER_PWM: - if (request->value == true) - Control_Dryer_Fan(START,75); - else - Control_Dryer_Fan(STOP, 0); - break;*/ case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) Valve_Set(VALVE_MIXCHIP_WASTECH,1); diff --git a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs index 3ad7c1da8..b896e9968 100644 --- a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs +++ b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs @@ -50,8 +50,34 @@ configurationParameters.ACHeatersUpperOperationLimit = 1005; configurationParameters.DCHeatersLowerOperationLimit = 978; configurationParameters.DCHeatersUpperOperationLimit = 1005; -configurationParameters.MidTankPressureCorrection = 0.2; - +configurationParameters.MidTankPressureCorrection = 0.0; + +configurationParameters.DispenserPresegmentWFCF = 80; +configurationParameters.StartHeatingOnInitSequence = false; + +Double checkHardLimitAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkHardLimitAlarms); +Double checkCurrentAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkCurrentAlarms); +Double checkTamperAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkTamperAlarms); + +configurationParameters.CurrentAlarmLowLimit = 0.80; +configurationParameters.CurrentAlarmHighLimit = 1.07; +configurationParameters.IDSSegmentRefillTimeout = 5000; +configurationParameters.IDSPreSegmentBuildupTime = 5000; +configurationParameters.IDSCleaningSpeed = 50; +configurationParameters.IDSCleaningStopBeforeSegmentTime = 3000; +configurationParameters.IDSCleaningStartSprayPreSegmentTime = 1000; +configurationParameters.IDSLeftCleaningMotorSpeed = 30; +configurationParameters.IDSRightCleaningMotorSpeed = 23; +configurationParameters.SwitchToIdleTimeinSeconds = 3600; +configurationParameters.IdleDrierTemperature = 80; +configurationParameters.IdleHeadTemperature = 80; +configurationParameters.IdleMixerTemperature = 0; +configurationParameters.PowerOffTemperatureLimit = 50; +configurationParameters.IDSPreSegmentWFCFTimeBeforeSegment = 1500; + File.WriteAllBytes("C:/temp/EmbParam.cfg",configurationParameters.ToBytes()); byte[] fileBytes = File.ReadAllBytes("C:/temp/EmbParam.cfg"); -- cgit v1.3.1 From 8b1f81f413f51facb57a320fef47f2a0e297dc40 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 14:49:51 +0300 Subject: Version 1.3.9.32 reduced diagnostics. new ITMA screens. heating improved. lubricant handled better --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded_SW/Embedded/Common/Utilities/Utils.c | 2 + Software/Embedded_SW/Embedded/Embedded.cfg | 10 +++-- Software/Embedded_SW/Embedded/Main.c | 14 +++---- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 18 ++++++++ .../Embedded/Modules/Diagnostics/Diagnostics.c | 28 +++++++++---- .../Embedded/Modules/Heaters/Heaters_print.c | 48 +++++++++++++++------- Software/Embedded_SW/Embedded/Modules/IDS/IDS.h | 3 ++ .../Embedded/Modules/IDS/IDS_dispenser.c | 11 ++++- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 20 ++++----- .../Embedded/StateMachines/Printing/JobSTM.c | 12 +++--- .../stubs/embeddedparametersbuild.cs | 9 ++-- 12 files changed, 122 insertions(+), 55 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index c8ec2a487..092772989 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,9,3}; +TangoVersion_t _gTangoVersion = {1,3,9,32}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c index 542ea659a..078aa5f53 100644 --- a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c +++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c @@ -11,6 +11,7 @@ #include "Common/Utilities/Utils.h" //#include #include "driverlib/hibernate.h" +#include //***************************************************************************** @@ -98,6 +99,7 @@ void InitWatchdog(uint32_t clock) // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); ROM_WatchdogIntClear(WATCHDOG0_BASE); + ROM_WatchdogIntTypeSet(WATCHDOG0_BASE,0); //interrupt, not NMI ROM_IntEnable(INT_WATCHDOG); // diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 1127c5a30..001fab666 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -136,12 +136,12 @@ Program.global.control = Task.create("&controlTask", ControlTaskParams); var AlarmHandlingTaskParams = new Task.Params(); AlarmHandlingTaskParams.instance.name = "AlarmHandling"; AlarmHandlingTaskParams.stackSize = 2048; -AlarmHandlingTaskParams.priority = 10; +AlarmHandlingTaskParams.priority = 9; Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams); var CommTxTaskParams = new Task.Params(); CommTxTaskParams.instance.name = "communicationTx"; -CommTxTaskParams.priority = 9; +CommTxTaskParams.priority = 10; CommTxTaskParams.stackSize = 4096; Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams); @@ -176,7 +176,7 @@ Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams) var DiagnosticsTaskParams = new Task.Params(); DiagnosticsTaskParams.instance.name = "Diagnostics"; -DiagnosticsTaskParams.priority = 4; +DiagnosticsTaskParams.priority = 6; DiagnosticsTaskParams.stackSize = 8192; Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams); @@ -219,7 +219,9 @@ Text.isLoaded = true; * reference unspecified external functions */ Error.raiseHook = "&errHook"; - + +BIOS.customCCOpts += " -Dxdc_FILE=__FILE__ "; + /* set user-defined code for E_generic errors */ Error.E_generic.code = 28; diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 379c45f76..ad88a9ed2 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -74,7 +74,7 @@ #include "Modules/General/buttons.h" #include "Modules/Waste/Waste.h" #include -//#define WATCHDOG +#define WATCHDOG //***************************************************************************** @@ -114,7 +114,7 @@ Void errHook(Error_Block *eb) FRESULT Fresult = FR_OK; FIL *FileHandle = 0; //the system supports a single active file uint32_t Bytes = 0; - char ErrorPath[50] = "0://ErrorFile.txt"; + char ErrorPath[50] = "0://ErrFile.txt"; char File[50] = ""; char message[300]; int len; @@ -138,14 +138,14 @@ Void errHook(Error_Block *eb) Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ); if (Fresult == FR_OK) { + f_lseek(FileHandle, FileHandle->fsize); strcpy(File,site->file); - len = usnprintf(message, 80, "\r\n%s %s %s",__DATE__, __TIME__,File); + len = usnprintf(message, 80, "\r\n%s %s",__DATE__, __TIME__); Fresult = f_write(FileHandle,message,len,&Bytes ); /* print user supplied error code */ - len = usnprintf(message, 300, "\r\nerror %d, eid %d file %s line %d mod %d", - eCode, eid, site->file, - site->line, - site->mod); + len = usnprintf(message, 300, "\r\nerror %d, eid %d mod %d file %s line %d", + eCode, eid,site->mod, + site->file,site->line); Fresult = f_write(FileHandle,message,len,&Bytes ); LOG_ERROR (eCode, "error # "); diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 2a7aef30a..3361bfdaa 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -175,6 +175,14 @@ const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"}, {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY,"MidTank 1 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY,"MidTank 2 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY,"MidTank 3 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY,"MidTank 4 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY,"MidTank 5 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY,"MidTank 8 Empty alarm"}, + + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"}, {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"}, {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"}, @@ -566,6 +574,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) } for (Alarm_i = 0;Alarm_i= HeaterControl[index].sensormaxvalue) + if ((MinreadValue) >= HeaterControl[index].sensormaxvalue) { if (HeaterMaxTempFlag[index] == false) { @@ -808,7 +808,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //Heaters OFF until coming into the proportional band HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); - //LOG_ERROR (0, "unconfigured"); + LOG_ERROR (0, "unconfigured"); return ERROR; } if (abs(readValue - HeaterPreviousRead[index])>2000) @@ -847,19 +847,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } // if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000)) + if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) { if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100); } return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target +/* if ((readValue > (HeaterCmd[index].targettemperatue-300)/`*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*`/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// + Report("AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); //InitialHeating = false; DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); @@ -875,11 +878,25 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } - if ((readValue > HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + */ + if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; - Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); + Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); +//////////////////////// + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); + HeatersControlStart(); + AlarmHandlingSetAlarm(HeaterUnderEventType[index], false); + if (BlowerCfg.enabled == true) + { + Turn_the_Blower_On();//Turn on with the Default_Voltage + if (BlowerCfg.voltage) + //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage); + Control_Voltage_To_Blower(BlowerCfg.voltage); + } + //////////////////////// HeaterReady[index] = true; Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); @@ -974,13 +991,14 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if (HeaterCmd[index].targettemperatue == 0) { DeActivateHeater(index); - //LOG_ERROR (index, "unconfigured"); + HeaterRecalculateHeaterParams(index, 0); + LOG_ERROR (index, "unconfigured"); return ERROR; } if (abs(readValue - HeaterPreviousRead[index])>2000) { Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); - if (readValue > HeaterCmd[index].targettemperatue) + //if (readValue > HeaterCmd[index].targettemperatue) { DeActivateHeater(index); HeaterRecalculateHeaterParams(index, 0); @@ -991,6 +1009,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); DeActivateHeater (index); + HeaterRecalculateHeaterParams(index, 0); return ERROR; } @@ -1017,6 +1036,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { + Report("DC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); //DCInitialHeating[index] = false; HeatersControlStart(); HeaterReady[index] = true; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h index 3d2bcf9ff..b47305d8c 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h @@ -5,6 +5,9 @@ #include "drivers/motors/motor.h" #include "ids_ex.h" +#define LUBRICANT_DISPENSER 7 +#define CLEANER_DISPENSER 6 + extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS]; extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; extern float DispenserPressure[MAX_SYSTEM_DISPENSERS]; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c index 13142ad5f..ed9a3adb7 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c @@ -66,8 +66,15 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re { uint32_t status; DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag; + double DispenserPressure = DispenserPreparePressure; - if ((GetDispenserPressure(DispenserId)>=DispenserPreparePressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)) + if (DispenserId == LUBRICANT_DISPENSER) + { + DispenserPressure = DispenserPreparePressure/5; + //lubricant lower pressure buildup + } + + if ((GetDispenserPressure(DispenserId)>=DispenserPressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)) { if (DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout) status = ERROR; @@ -249,6 +256,7 @@ void IDS_Dispenser_Content_Init (void) uint16_t seconds_counter = 0; uint32_t IDS_Dispenser_Store_Data (void) { + uint32_t timing = msec_millisecondCounter; FRESULT Status = FR_OK; IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; IDSDispenserData.dispenserinfo = dispenserdata; @@ -263,6 +271,7 @@ uint32_t IDS_Dispenser_Store_Data (void) else return ERROR; + REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time"); return Status; } void IDS_Dispenser_Content_Calculation (char DispenserId) diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 4bcdcc06a..30ad7d857 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -40,8 +40,6 @@ typedef struct PID_Config_Params m_params; }DispenserControlConfig_t; HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000; -#define LUBRICANT_DISPENSER 7 -#define CLEANER_DISPENSER 6 #define MAX_DYE_DISPENSERS 6 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0}; int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0}; @@ -321,6 +319,7 @@ b. Read brush stop message. c. Go to step 2.a x Segment.BrushStopsCount. 3. Go to step 1 until end of file. */ + GeneralHwReady = false; for (Dispenser_i = 0;Dispenser_in_dispensers) { for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) @@ -478,6 +478,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. if (BrushStop != NULL) job_description_file_brush_stop__free_unpacked (BrushStop,NULL); Fresult = f_close(FileHandle); + GeneralHwReady = true; REPORT_MSG (n_segments, "Finished checking the file"); return status; @@ -1147,23 +1148,22 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) } } - + IDS_StopLubrication(); return OK; } uint32_t IDS_StartLubrication(void) { IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + CurrentDispenserSpeed[LUBRICANT_DISPENSER] = lubricant_speed; REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); Lubricant_2Way_Valve (START); return OK; } uint32_t IDS_StopLubrication(void) { - if(DispenserUsedInJob[LUBRICANT_DISPENSER]) - { - IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); - REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); - Lubricant_2Way_Valve (STOP); - } + IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0; + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); + Lubricant_2Way_Valve (STOP); return OK; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index b5034a11c..96b2b372e 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -713,6 +713,9 @@ void JobRequestFunc(MessageContainer* requestContainer) char logmsg[254]; char infomsg[254]; uint8_t JobStatusBuffer[400]; +ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT; +JobResponse JobResponseMsg = JOB_RESPONSE__INIT; +JobStatus jobStatus = JOB_STATUS__INIT; void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Message) { @@ -734,9 +737,6 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes if (JobToken[0] != 0) { - ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT; - JobResponse response = JOB_RESPONSE__INIT; - JobStatus jobStatus = JOB_STATUS__INIT; if (Message) { @@ -756,9 +756,9 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes } else { - response.status = &jobStatus; - //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size); - responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer); + JobResponseMsg.status = &jobStatus; + //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size); + responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer); } container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); diff --git a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs index b896e9968..90d799ed5 100644 --- a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs +++ b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs @@ -55,11 +55,14 @@ configurationParameters.MidTankPressureCorrection = 0.0; configurationParameters.DispenserPresegmentWFCF = 80; configurationParameters.StartHeatingOnInitSequence = false; -Double checkHardLimitAlarms = new Double(1); +Double checkHardLimitAlarms = new Double(); +checkHardLimitAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkHardLimitAlarms); -Double checkCurrentAlarms = new Double(1); +Double checkCurrentAlarms = new Double(); +checkCurrentAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkCurrentAlarms); -Double checkTamperAlarms = new Double(1); +Double checkTamperAlarms = new Double(); +checkTamperAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkTamperAlarms); configurationParameters.CurrentAlarmLowLimit = 0.80; -- cgit v1.3.1 From 6764160829be092f9c31d8742a20d86d96d05477 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 15:23:14 +0300 Subject: mid tank should not stop a job --- Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c | 4 ++-- Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 5 +++-- 3 files changed, 6 insertions(+), 5 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 3361bfdaa..368c52436 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -584,7 +584,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) break; } } - if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm) + /*if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm) { if (AlarmState[Alarm_i].Status == true) { @@ -592,7 +592,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) AlarmId = Alarm_i; break; } - } + }*/ if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm) { if (AlarmState[Alarm_i].Status == true) diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index f0ce7397c..b12064915 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_breaksensorlimit = true; EmbeddedParameters.breaksensorlimit = 10; EmbeddedParameters.has_diagnosticcollectionlimit = true; - EmbeddedParameters.diagnosticcollectionlimit = 1; + EmbeddedParameters.diagnosticcollectionlimit = 2; EmbeddedParameters.has_overheatcountlimit = true; EmbeddedParameters.overheatcountlimit = 3; EmbeddedParameters.has_underheatcountlimit = true; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index be4328f4c..4402ec2f1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -846,9 +846,10 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } -// if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) + if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) + //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) { + Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); -- cgit v1.3.1 From be50a5b72cedd1afc0a14d36a468e8b04bf9a37f Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Tue, 30 Apr 2019 16:22:08 +0300 Subject: Add the funtion Ink_Cart_Led to control the Ink led --- Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c | 2 ++ Software/Embedded_SW/Embedded/Modules/General/buttons.c | 11 +++++++++++ Software/Embedded_SW/Embedded/Modules/General/buttons.h | 1 + 3 files changed, 14 insertions(+) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 193769265..916d33772 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -48,6 +48,7 @@ #include "Common/SWUpdate/FileSystem.h" #include "Communication/Connection.h" +#include "Modules/General/buttons.h" Task_Handle Millisecond_Task_Handle; /******************** Definitions ********************************************/ @@ -514,6 +515,7 @@ uint32_t MillisecLowLoop(uint32_t tick) { Speed_Data = Calculate_Speed_Sensor_Velocity(); Read_Buttons_Reg(); + Ink_Cart_Led(); for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++) { MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i)); diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index 74cb81aac..cfd44a6fa 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -603,6 +603,17 @@ uint32_t LoadStatMachine( button *pBtn) return OK; } +void Ink_Cart_Led()//temporary for ITMA +{ + if(Is_Cartridge_Present(CART_1) == true) + { + Pannel_Leds( CART_1, MODE_ON); + } + else + { + Pannel_Leds( CART_1, MODE_OFF); + } +} void test_avi() { diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index 2d14eb000..4d0df69e1 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -58,6 +58,7 @@ uint32_t Buttons_Init(void); uint32_t Button_load_Init(void); uint32_t Button_JOG_Init(void); bool SetPowerMachineState(PBmachineState state); +void Ink_Cart_Led(); -- cgit v1.3.1 From bd103be9febc3034bcb803b470adf37e67d326cb Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 16:55:54 +0300 Subject: small change --- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 2 +- Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 4402ec2f1..7aaab41c1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -849,7 +849,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) { - Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); + //Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index 96b2b372e..1bd07c06e 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -808,7 +808,10 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes if (done == true) { if (CurrentRequest!= NULL) + { job_request__free_unpacked(CurrentRequest,NULL); + CurrentRequest = NULL; + } JobStopReporting(); JobMessageStruc JobMessage; -- cgit v1.3.1 From 08316b86da18cce886b9269daec1f04cbe377fc3 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 17:54:36 +0300 Subject: 1.3.9.5 fix bug in heaters max temp --- Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- Software/Embedded_SW/Embedded/Embedded.cfg | 1 + Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 748b7fa4f..07175ae50 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,9,4}; +TangoVersion_t _gTangoVersion = {1,3,9,5}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 001fab666..5dd991512 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -188,6 +188,7 @@ Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams) var ReportTaskParams = new Task.Params(); ReportTaskParams.instance.name = "report"; +ReportTaskParams.stackSize = 2048; ReportTaskParams.priority = 7; Program.global.report = Task.create("&reportService", ReportTaskParams); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 7aaab41c1..127740e46 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -665,7 +665,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) MaxreadValue = max (MainPT100Read,SecondaryPT100Read); MinreadValue = min (MainPT100Read,SecondaryPT100Read); - if ((MinreadValue) >= HeaterControl[index].sensormaxvalue) + if (MaxreadValue >= HeaterControl[index].sensormaxvalue) { if (HeaterMaxTempFlag[index] == false) { @@ -679,7 +679,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } - if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue + if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue { if (HeaterControl[index].sensorminvalue > 0) { -- cgit v1.3.1 From f21b51571dd65e5c30c9709f4e84009d90b27154 Mon Sep 17 00:00:00 2001 From: Roy Ben-Shabat Date: Thu, 2 May 2019 10:43:02 +0300 Subject: MERGE. --- .../Android_Studio/ColorCapture/app/build.gradle | 8 +- .../integration/ExternalBridgeClient.java | 109 +++ .../integration/ExternalBridgeScanner.java | 58 +- .../sendtomachine/SendToMachineFragmentVM.java | 17 +- .../tango/pmr/common/MessageTypeOuterClass.java | 177 +++-- .../integration/ColorProfileRequestOuterClass.java | 777 +++++++++++++++++++++ .../ColorProfileResponseOuterClass.java | 506 ++++++++++++++ .../src/main/res/layout/external_machine_item.xml | 45 +- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c | 2 + Software/Embedded_SW/Embedded/Embedded.cfg | 1 + Software/Embedded_SW/Embedded/Main.c | 17 +- .../Embedded/Modules/Diagnostics/Diagnostics.c | 4 + .../Embedded/Modules/General/GeneralHardware.c | 2 +- .../Embedded/Modules/Heaters/Heaters_print.c | 6 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 3 + .../Embedded/Software Release Notes.txt | 17 + .../StateMachines/Initialization/PowerIdle.c | 2 +- .../Initialization/PowerOffSequence.c | 2 +- Software/Embedded_SW/Embedded/src/sysbios/makefile | 2 +- .../Embedded_SW/Embedded/src/sysbios/sysbios.aem4f | Bin 1751774 -> 1757826 bytes Software/PMR/Messages/Common/MessageType.proto | 3 + .../Visual_Studio/PPC/Tango.PPC.UI/app.manifest | 2 +- 23 files changed, 1637 insertions(+), 125 deletions(-) create mode 100644 Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeClient.java create mode 100644 Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileRequestOuterClass.java create mode 100644 Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileResponseOuterClass.java (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Android_Studio/ColorCapture/app/build.gradle b/Software/Android_Studio/ColorCapture/app/build.gradle index f21c20695..be070a573 100644 --- a/Software/Android_Studio/ColorCapture/app/build.gradle +++ b/Software/Android_Studio/ColorCapture/app/build.gradle @@ -23,7 +23,7 @@ android { buildTypes { debug { - buildConfigField "String", "WEB_SERVICE_ADDRESS", "\"http://192.168.1.86:45455/api/\"" + buildConfigField "String", "WEB_SERVICE_ADDRESS", "\"http://10.100.102.46:45455/api/\"" buildConfigField "String", "WEB_SERVICE_APP_ID", "\"Tdf793i4ughsiduf8749509237885ehgfdlkghlT\"" } @@ -96,6 +96,6 @@ task createPMR(type: Exec, description: 'Update all PMR files') { } } -//tasks.withType(JavaCompile) { -// compileTask -> compileTask.dependsOn createPMR -//} +tasks.withType(JavaCompile) { + compileTask -> compileTask.dependsOn createPMR +} diff --git a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeClient.java b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeClient.java new file mode 100644 index 000000000..3d4d80ccf --- /dev/null +++ b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeClient.java @@ -0,0 +1,109 @@ +package com.twine.colorcapture.integration; + +import com.google.protobuf.ByteString; +import com.twine.colorcapture.core.IAction; +import com.twine.colorcapture.core.IAction1; +import com.twine.colorcapture.web.messages.DetectionColor; +import com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer; +import com.twine.tango.pmr.common.MessageTypeOuterClass; +import com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest; +import com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse; +import com.twine.tango.pmr.tcc.DetectionColorOuterClass; + +import java.io.InputStream; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.net.SocketException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Arrays; +import java.util.UUID; + +public class ExternalBridgeClient +{ + private static final int EXTERNAL_BRIDGE_PORT = 1984; + + public void sendColorProfile(ExternalBridgeMachine machine, DetectionColor detectionColor, IAction success, IAction1 error) + { + try + { + Socket tcpClient = new Socket(); + tcpClient.connect(new InetSocketAddress(machine.getIpAddress(), EXTERNAL_BRIDGE_PORT), 2000); + + //Create detection color + DetectionColorOuterClass.DetectionColor.Builder color = DetectionColorOuterClass.DetectionColor.newBuilder(); + color.setR(detectionColor.getR()); + color.setG(detectionColor.getG()); + color.setB(detectionColor.getB()); + + //Create Message + ColorProfileRequest.Builder message = ColorProfileRequest.newBuilder(); + message.setAppID("SnapMatch"); + message.setDetectionColor(color); + + //Create container + MessageContainer.Builder container = MessageContainer.newBuilder(); + container.setToken(UUID.randomUUID().toString()); + container.setType(MessageTypeOuterClass.MessageType.ColorProfileRequest); + container.setData(ByteString.copyFrom(message.build().toByteArray())); + + //Create data + byte[] data = container.build().toByteArray(); + byte[] size = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(data.length).array(); + byte[] packet = concatByteArrays(size, data); + + //Write data + tcpClient.getOutputStream().write(packet); + + //Wait for response... + InputStream stream = tcpClient.getInputStream(); + + //Initializing expected message size. + size = new byte[4]; + + //Block reading from socket. + int read = stream.read(size, 0, size.length); + if (read == -1) + { + throw new SocketException("Error reading from TCP adapter."); + } + + //Get expected size. + int expectedSize = ByteBuffer.wrap(size).order(ByteOrder.LITTLE_ENDIAN).getInt(); + + //Init response message size. + data = new byte[expectedSize]; + read = 0; + + //Read the whole message. + while (read < expectedSize) + { + read += stream.read(data, read, Math.min(stream.available(), expectedSize - read)); + } + + //Init response container and message. + MessageContainer responseContainer = MessageContainer.parseFrom(data); + ColorProfileResponse response = ColorProfileResponse.parseFrom(responseContainer.getData()); + + if (response.getApproved()) + { + //Approved !!! + } + + tcpClient.close(); + + success.invoke(); + } + catch (Exception ex) + { + error.invoke(ex); + } + } + + private byte[] concatByteArrays(byte[] first, byte[] second) + { + byte[] result = Arrays.copyOf(first, first.length + second.length); + System.arraycopy(second, 0, result, first.length, second.length); + return result; + } +} diff --git a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeScanner.java b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeScanner.java index 390ccab3b..9c87987bd 100644 --- a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeScanner.java +++ b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/integration/ExternalBridgeScanner.java @@ -6,13 +6,10 @@ import com.twine.colorcapture.core.Event; import com.twine.colorcapture.core.IEventHandler; import com.twine.tango.pmr.integration.ExternalBridgeUdpDiscoveryPacketOuterClass.ExternalBridgeUdpDiscoveryPacket; -import org.joda.time.DateTime; -import org.joda.time.Seconds; -import org.joda.time.format.DateTimeFormat; -import org.joda.time.format.DateTimeFormatter; - import java.net.DatagramPacket; import java.net.DatagramSocket; +import java.net.InetSocketAddress; +import java.net.Socket; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.List; @@ -24,12 +21,15 @@ public class ExternalBridgeScanner private Thread udpDiscoveryThread; private boolean isStarted; private List machines; - private Event newMachineEvent; + private Event machineDiscoveredEvent; + private Event machineDisconnectedEvent; + private static final int EXTERNAL_BRIDGE_DISCOVERY_PORT = 8888; public ExternalBridgeScanner() { machines = new ArrayList<>(); - newMachineEvent = new Event<>(); + machineDiscoveredEvent = new Event<>(); + machineDisconnectedEvent = new Event<>(); } public void start() @@ -51,9 +51,14 @@ public class ExternalBridgeScanner } } - public void addNewMachineEventHandler(IEventHandler handler) + public void addMachineDiscoveredEventHandler(IEventHandler handler) + { + machineDiscoveredEvent.addListener(handler); + } + + public void addMachineDisconnectedEventHandler(IEventHandler handler) { - newMachineEvent.addListener(handler); + machineDisconnectedEvent.addListener(handler); } private void udpDiscoveryMethod() @@ -79,25 +84,36 @@ public class ExternalBridgeScanner ByteBuffer wrapper = ByteBuffer.wrap(message); wrapper.put(buffer, 0, message.length); - ExternalBridgeUdpDiscoveryPacket discoveryMessage = ExternalBridgeUdpDiscoveryPacket.parseFrom(message); - boolean hasTime = !discoveryMessage.getTime().equals(""); - - DateTimeFormatter formatter = DateTimeFormat.forPattern("dd/MM/yyyy HH:mm:ss"); - DateTime time = hasTime ? formatter.parseDateTime(discoveryMessage.getTime()) : DateTime.now(); + String address = packet.getAddress().toString().replaceAll("/", ""); - String address = packet.getAddress().toString().replaceAll("/",""); - - if (!hasTime || Seconds.secondsBetween(DateTime.now(), time).getSeconds() < 6) + try { - if (!stream(machines).any(x -> x.getSerialNumber().equals(discoveryMessage.getSerialNumber()) && x.getIpAddress().equals(address))) + Socket tcpClient = new Socket(); + tcpClient.connect(new InetSocketAddress(address, EXTERNAL_BRIDGE_DISCOVERY_PORT), 2000); + tcpClient.close(); + } + catch (Exception ex) + { + ExternalBridgeMachine disconnectedMachine = stream(machines).firstOrNull(x -> x.getSerialNumber().equals(discoveryMessage.getSerialNumber()) && x.getIpAddress().equals(address)); + + if (disconnectedMachine != null) { - ExternalBridgeMachine newMachine = new ExternalBridgeMachine(address, discoveryMessage.getSerialNumber()); - machines.add(0, newMachine); - newMachineEvent.invoke(this, newMachine); + machines.remove(disconnectedMachine); + machineDisconnectedEvent.invoke(this, disconnectedMachine); } + + continue; } + + if (!stream(machines).any(x -> x.getSerialNumber().equals(discoveryMessage.getSerialNumber()) && x.getIpAddress().equals(address))) + { + ExternalBridgeMachine newMachine = new ExternalBridgeMachine(address, discoveryMessage.getSerialNumber()); + machines.add(0, newMachine); + machineDiscoveredEvent.invoke(this, newMachine); + } + } catch (Exception e) { diff --git a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/views/sendtomachine/SendToMachineFragmentVM.java b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/views/sendtomachine/SendToMachineFragmentVM.java index c77e93a20..b89b3cdb9 100644 --- a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/views/sendtomachine/SendToMachineFragmentVM.java +++ b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/colorcapture/views/sendtomachine/SendToMachineFragmentVM.java @@ -1,11 +1,9 @@ package com.twine.colorcapture.views.sendtomachine; import android.databinding.ObservableArrayList; -import android.databinding.ObservableField; import android.databinding.ObservableList; import android.os.Handler; import android.os.Looper; -import android.util.Log; import android.view.View; import android.widget.AdapterView; @@ -37,10 +35,21 @@ public class SendToMachineFragmentVM extends ViewModelBaseStopApplicationLogsResponse = 1012; */ StopApplicationLogsResponse(1012), + /** + * ColorProfileRequest = 1013; + */ + ColorProfileRequest(1013), + /** + * ColorProfileResponse = 1014; + */ + ColorProfileResponse(1014), /** * 
      *Diagnostics
@@ -883,6 +891,18 @@ public final class MessageTypeOuterClass {
      * ActivateVersionResponse = 7023;
      */
     ActivateVersionResponse(7023),
+    /**
+     * 
+     *EmbeddedParameters
+     * 

+     *
+     * DispenserDataRequest = 8000;
+     */
+    DispenserDataRequest(8000),
+    /**
+     * DispenserDataResponse = 8001;
+     */
+    DispenserDataResponse(8001),
     UNRECOGNIZED(-1),
     ;
 
@@ -1374,6 +1394,14 @@ public final class MessageTypeOuterClass {
      * StopApplicationLogsResponse = 1012;
      */
     public static final int StopApplicationLogsResponse_VALUE = 1012;
+    /**
+     * ColorProfileRequest = 1013;
+     */
+    public static final int ColorProfileRequest_VALUE = 1013;
+    /**
+     * ColorProfileResponse = 1014;
+     */
+    public static final int ColorProfileResponse_VALUE = 1014;
     /**
      * 
      *Diagnostics
@@ -1750,6 +1778,18 @@ public final class MessageTypeOuterClass {
      * ActivateVersionResponse = 7023;
      */
     public static final int ActivateVersionResponse_VALUE = 7023;
+    /**
+     * 
+     *EmbeddedParameters
+     * 

+     *
+     * DispenserDataRequest = 8000;
+     */
+    public static final int DispenserDataRequest_VALUE = 8000;
+    /**
+     * DispenserDataResponse = 8001;
+     */
+    public static final int DispenserDataResponse_VALUE = 8001;
 
 
     public final int getNumber() {
@@ -1887,6 +1927,8 @@ public final class MessageTypeOuterClass {
         case 1010: return StartApplicationLogsResponse;
         case 1011: return StopApplicationLogsRequest;
         case 1012: return StopApplicationLogsResponse;
+        case 1013: return ColorProfileRequest;
+        case 1014: return ColorProfileResponse;
         case 2000: return StartDiagnosticsRequest;
         case 2001: return StartDiagnosticsResponse;
         case 2002: return MotorAbortHomingRequest;
@@ -1975,6 +2017,8 @@ public final class MessageTypeOuterClass {
         case 7021: return ValidateVersionResponse;
         case 7022: return ActivateVersionRequest;
         case 7023: return ActivateVersionResponse;
+        case 8000: return DispenserDataRequest;
+        case 8001: return DispenserDataResponse;
         default: return null;
       }
     }
@@ -2036,7 +2080,7 @@ public final class MessageTypeOuterClass {
       descriptor;
   static {
     java.lang.String[] descriptorData = {
-      "\n\021MessageType.proto\022\020Tango.PMR.Common*\236." +
+      "\n\021MessageType.proto\022\020Tango.PMR.Common*\212/" +
       "\n\013MessageType\022\010\n\004None\020\000\022\021\n\rErrorResponse" +
       "\020\001\022\024\n\020CalculateRequest\020\003\022\025\n\021CalculateRes" +
       "ponse\020\004\022\023\n\017ProgressRequest\020\005\022\024\n\020Progress" +
@@ -2122,70 +2166,73 @@ public final class MessageTypeOuterClass {
       "nse\020\360\007\022 \n\033StartApplicationLogsRequest\020\361\007" +
       "\022!\n\034StartApplicationLogsResponse\020\362\007\022\037\n\032S" +
       "topApplicationLogsRequest\020\363\007\022 \n\033StopAppl" +
-      "icationLogsResponse\020\364\007\022\034\n\027StartDiagnosti" +
-      "csRequest\020\320\017\022\035\n\030StartDiagnosticsResponse" +
-      "\020\321\017\022\034\n\027MotorAbortHomingRequest\020\322\017\022\035\n\030Mot" +
-      "orAbortHomingResponse\020\323\017\022\027\n\022MotorHomingR",
-      "equest\020\324\017\022\030\n\023MotorHomingResponse\020\325\017\022\030\n\023M" +
-      "otorJoggingRequest\020\326\017\022\031\n\024MotorJoggingRes" +
-      "ponse\020\327\017\022\035\n\030MotorAbortJoggingRequest\020\330\017\022" +
-      "\036\n\031MotorAbortJoggingResponse\020\331\017\022 \n\033Dispe" +
-      "nserAbortHomingRequest\020\332\017\022!\n\034DispenserAb" +
-      "ortHomingResponse\020\333\017\022\033\n\026DispenserHomingR" +
-      "equest\020\334\017\022\034\n\027DispenserHomingResponse\020\335\017\022" +
-      "\034\n\027DispenserJoggingRequest\020\336\017\022\035\n\030Dispens" +
-      "erJoggingResponse\020\337\017\022!\n\034DispenserAbortJo" +
-      "ggingRequest\020\340\017\022\"\n\035DispenserAbortJogging",
-      "Response\020\341\017\022\031\n\024SetDigitalOutRequest\020\342\017\022\032" +
-      "\n\025SetDigitalOutResponse\020\343\017\022\031\n\024ThreadJogg" +
-      "ingRequest\020\344\017\022\032\n\025ThreadJoggingResponse\020\345" +
-      "\017\022\036\n\031ThreadAbortJoggingRequest\020\346\017\022\037\n\032Thr" +
-      "eadAbortJoggingResponse\020\347\017\022\035\n\030SetCompone" +
-      "ntValueRequest\020\350\017\022\036\n\031SetComponentValueRe" +
-      "sponse\020\351\017\022\030\n\023ResolveEventRequest\020\352\017\022\031\n\024R" +
-      "esolveEventResponse\020\353\017\022\033\n\026StopDiagnostic" +
-      "sRequest\020\354\017\022\034\n\027StopDiagnosticsResponse\020\355" +
-      "\017\022#\n\036StartEventsNotificationRequest\020\356\017\022$",
-      "\n\037StartEventsNotificationResponse\020\357\017\022\"\n\035" +
-      "StopEventsNotificationRequest\020\360\017\022#\n\036Stop" +
-      "EventsNotificationResponse\020\361\017\022\032\n\025SetHeat" +
-      "erStateRequest\020\362\017\022\033\n\026SetHeaterStateRespo" +
-      "nse\020\363\017\022\032\n\025SetBlowerStateRequest\020\364\017\022\033\n\026Se" +
-      "tBlowerStateResponse\020\365\017\022\031\n\024SetValveState" +
-      "Request\020\366\017\022\032\n\025SetValveStateResponse\020\367\017\022\017" +
-      "\n\nJobRequest\020\270\027\022\020\n\013JobResponse\020\271\027\022\024\n\017Abo" +
-      "rtJobRequest\020\272\027\022\025\n\020AbortJobResponse\020\273\027\022#" +
-      "\n\036UploadProcessParametersRequest\020\274\027\022$\n\037U",
-      "ploadProcessParametersResponse\020\275\027\022\026\n\021Cur" +
-      "rentJobRequest\020\276\027\022\027\n\022CurrentJobResponse\020" +
-      "\277\027\022\034\n\027ResumeCurrentJobRequest\020\300\027\022\035\n\030Resu" +
-      "meCurrentJobResponse\020\301\027\022\031\n\024StartDebugLog" +
-      "Request\020\240\037\022\032\n\025StartDebugLogResponse\020\241\037\022\030" +
-      "\n\023StopDebugLogRequest\020\242\037\022\031\n\024StopDebugLog" +
-      "Response\020\243\037\022\'\n\"UploadHardwareConfigurati" +
-      "onRequest\020\210\'\022(\n#UploadHardwareConfigurat" +
-      "ionResponse\020\211\'\022\027\n\022SystemResetRequest\020\212\'\022" +
-      "\030\n\023SystemResetResponse\020\213\'\022\025\n\020KeepAliveRe",
-      "quest\020\360.\022\026\n\021KeepAliveResponse\020\361.\022\023\n\016Conn" +
-      "ectRequest\020\362.\022\024\n\017ConnectResponse\020\363.\022\026\n\021D" +
-      "isconnectRequest\020\364.\022\027\n\022DisconnectRespons" +
-      "e\020\365.\022\026\n\021FileUploadRequest\020\3306\022\027\n\022FileUplo" +
-      "adResponse\020\3316\022\033\n\026FileChunkUploadRequest\020" +
-      "\3326\022\034\n\027FileChunkUploadResponse\020\3336\022\032\n\025Exec" +
-      "uteProcessRequest\020\3346\022\033\n\026ExecuteProcessRe" +
-      "sponse\020\3356\022\027\n\022KillProcessRequest\020\3366\022\030\n\023Ki" +
-      "llProcessResponse\020\3376\022\022\n\rCreateRequest\020\3406" +
-      "\022\023\n\016CreateResponse\020\3416\022\022\n\rDeleteRequest\020\342",
-      "6\022\023\n\016DeleteResponse\020\3436\022\032\n\025GetStorageInfo" +
-      "Request\020\3446\022\033\n\026GetStorageInfoResponse\020\3456\022" +
-      "\024\n\017GetFilesRequest\020\3466\022\025\n\020GetFilesRespons" +
-      "e\020\3476\022\030\n\023FileDownloadRequest\020\3506\022\031\n\024FileDo" +
-      "wnloadResponse\020\3516\022\035\n\030FileChunkDownloadRe" +
-      "quest\020\3526\022\036\n\031FileChunkDownloadResponse\020\3536" +
-      "\022\033\n\026ValidateVersionRequest\020\3546\022\034\n\027Validat" +
-      "eVersionResponse\020\3556\022\033\n\026ActivateVersionRe" +
-      "quest\020\3566\022\034\n\027ActivateVersionResponse\020\3576B\034" +
-      "\n\032com.twine.tango.pmr.commonb\006proto3"
+      "icationLogsResponse\020\364\007\022\030\n\023ColorProfileRe" +
+      "quest\020\365\007\022\031\n\024ColorProfileResponse\020\366\007\022\034\n\027S" +
+      "tartDiagnosticsRequest\020\320\017\022\035\n\030StartDiagno" +
+      "sticsResponse\020\321\017\022\034\n\027MotorAbortHomingRequ",
+      "est\020\322\017\022\035\n\030MotorAbortHomingResponse\020\323\017\022\027\n" +
+      "\022MotorHomingRequest\020\324\017\022\030\n\023MotorHomingRes" +
+      "ponse\020\325\017\022\030\n\023MotorJoggingRequest\020\326\017\022\031\n\024Mo" +
+      "torJoggingResponse\020\327\017\022\035\n\030MotorAbortJoggi" +
+      "ngRequest\020\330\017\022\036\n\031MotorAbortJoggingRespons" +
+      "e\020\331\017\022 \n\033DispenserAbortHomingRequest\020\332\017\022!" +
+      "\n\034DispenserAbortHomingResponse\020\333\017\022\033\n\026Dis" +
+      "penserHomingRequest\020\334\017\022\034\n\027DispenserHomin" +
+      "gResponse\020\335\017\022\034\n\027DispenserJoggingRequest\020" +
+      "\336\017\022\035\n\030DispenserJoggingResponse\020\337\017\022!\n\034Dis",
+      "penserAbortJoggingRequest\020\340\017\022\"\n\035Dispense" +
+      "rAbortJoggingResponse\020\341\017\022\031\n\024SetDigitalOu" +
+      "tRequest\020\342\017\022\032\n\025SetDigitalOutResponse\020\343\017\022" +
+      "\031\n\024ThreadJoggingRequest\020\344\017\022\032\n\025ThreadJogg" +
+      "ingResponse\020\345\017\022\036\n\031ThreadAbortJoggingRequ" +
+      "est\020\346\017\022\037\n\032ThreadAbortJoggingResponse\020\347\017\022" +
+      "\035\n\030SetComponentValueRequest\020\350\017\022\036\n\031SetCom" +
+      "ponentValueResponse\020\351\017\022\030\n\023ResolveEventRe" +
+      "quest\020\352\017\022\031\n\024ResolveEventResponse\020\353\017\022\033\n\026S" +
+      "topDiagnosticsRequest\020\354\017\022\034\n\027StopDiagnost",
+      "icsResponse\020\355\017\022#\n\036StartEventsNotificatio" +
+      "nRequest\020\356\017\022$\n\037StartEventsNotificationRe" +
+      "sponse\020\357\017\022\"\n\035StopEventsNotificationReque" +
+      "st\020\360\017\022#\n\036StopEventsNotificationResponse\020" +
+      "\361\017\022\032\n\025SetHeaterStateRequest\020\362\017\022\033\n\026SetHea" +
+      "terStateResponse\020\363\017\022\032\n\025SetBlowerStateReq" +
+      "uest\020\364\017\022\033\n\026SetBlowerStateResponse\020\365\017\022\031\n\024" +
+      "SetValveStateRequest\020\366\017\022\032\n\025SetValveState" +
+      "Response\020\367\017\022\017\n\nJobRequest\020\270\027\022\020\n\013JobRespo" +
+      "nse\020\271\027\022\024\n\017AbortJobRequest\020\272\027\022\025\n\020AbortJob",
+      "Response\020\273\027\022#\n\036UploadProcessParametersRe" +
+      "quest\020\274\027\022$\n\037UploadProcessParametersRespo" +
+      "nse\020\275\027\022\026\n\021CurrentJobRequest\020\276\027\022\027\n\022Curren" +
+      "tJobResponse\020\277\027\022\034\n\027ResumeCurrentJobReque" +
+      "st\020\300\027\022\035\n\030ResumeCurrentJobResponse\020\301\027\022\031\n\024" +
+      "StartDebugLogRequest\020\240\037\022\032\n\025StartDebugLog" +
+      "Response\020\241\037\022\030\n\023StopDebugLogRequest\020\242\037\022\031\n" +
+      "\024StopDebugLogResponse\020\243\037\022\'\n\"UploadHardwa" +
+      "reConfigurationRequest\020\210\'\022(\n#UploadHardw" +
+      "areConfigurationResponse\020\211\'\022\027\n\022SystemRes",
+      "etRequest\020\212\'\022\030\n\023SystemResetResponse\020\213\'\022\025" +
+      "\n\020KeepAliveRequest\020\360.\022\026\n\021KeepAliveRespon" +
+      "se\020\361.\022\023\n\016ConnectRequest\020\362.\022\024\n\017ConnectRes" +
+      "ponse\020\363.\022\026\n\021DisconnectRequest\020\364.\022\027\n\022Disc" +
+      "onnectResponse\020\365.\022\026\n\021FileUploadRequest\020\330" +
+      "6\022\027\n\022FileUploadResponse\020\3316\022\033\n\026FileChunkU" +
+      "ploadRequest\020\3326\022\034\n\027FileChunkUploadRespon" +
+      "se\020\3336\022\032\n\025ExecuteProcessRequest\020\3346\022\033\n\026Exe" +
+      "cuteProcessResponse\020\3356\022\027\n\022KillProcessReq" +
+      "uest\020\3366\022\030\n\023KillProcessResponse\020\3376\022\022\n\rCre",
+      "ateRequest\020\3406\022\023\n\016CreateResponse\020\3416\022\022\n\rDe" +
+      "leteRequest\020\3426\022\023\n\016DeleteResponse\020\3436\022\032\n\025G" +
+      "etStorageInfoRequest\020\3446\022\033\n\026GetStorageInf" +
+      "oResponse\020\3456\022\024\n\017GetFilesRequest\020\3466\022\025\n\020Ge" +
+      "tFilesResponse\020\3476\022\030\n\023FileDownloadRequest" +
+      "\020\3506\022\031\n\024FileDownloadResponse\020\3516\022\035\n\030FileCh" +
+      "unkDownloadRequest\020\3526\022\036\n\031FileChunkDownlo" +
+      "adResponse\020\3536\022\033\n\026ValidateVersionRequest\020" +
+      "\3546\022\034\n\027ValidateVersionResponse\020\3556\022\033\n\026Acti" +
+      "vateVersionRequest\020\3566\022\034\n\027ActivateVersion",
+      "Response\020\3576\022\031\n\024DispenserDataRequest\020\300>\022\032" +
+      "\n\025DispenserDataResponse\020\301>B\034\n\032com.twine." +
+      "tango.pmr.commonb\006proto3"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
diff --git a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileRequestOuterClass.java b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileRequestOuterClass.java
new file mode 100644
index 000000000..659695a13
--- /dev/null
+++ b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileRequestOuterClass.java
@@ -0,0 +1,777 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ColorProfileRequest.proto
+
+package com.twine.tango.pmr.integration;
+
+public final class ColorProfileRequestOuterClass {
+  private ColorProfileRequestOuterClass() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  public interface ColorProfileRequestOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:Tango.PMR.Integration.ColorProfileRequest)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * string AppID = 1;
+     */
+    java.lang.String getAppID();
+    /**
+     * string AppID = 1;
+     */
+    com.google.protobuf.ByteString
+        getAppIDBytes();
+
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    boolean hasDetectionColor();
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor getDetectionColor();
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder getDetectionColorOrBuilder();
+  }
+  /**
+   * Protobuf type {@code Tango.PMR.Integration.ColorProfileRequest}
+   */
+  public  static final class ColorProfileRequest extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:Tango.PMR.Integration.ColorProfileRequest)
+      ColorProfileRequestOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use ColorProfileRequest.newBuilder() to construct.
+    private ColorProfileRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private ColorProfileRequest() {
+      appID_ = "";
+    }
+
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+    getUnknownFields() {
+      return this.unknownFields;
+    }
+    private ColorProfileRequest(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      this();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownFieldProto3(
+                  input, unknownFields, extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              java.lang.String s = input.readStringRequireUtf8();
+
+              appID_ = s;
+              break;
+            }
+            case 18: {
+              com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder subBuilder = null;
+              if (detectionColor_ != null) {
+                subBuilder = detectionColor_.toBuilder();
+              }
+              detectionColor_ = input.readMessage(com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.parser(), extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(detectionColor_);
+                detectionColor_ = subBuilder.buildPartial();
+              }
+
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.internal_static_Tango_PMR_Integration_ColorProfileRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.class, com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.Builder.class);
+    }
+
+    public static final int APPID_FIELD_NUMBER = 1;
+    private volatile java.lang.Object appID_;
+    /**
+     * string AppID = 1;
+     */
+    public java.lang.String getAppID() {
+      java.lang.Object ref = appID_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        appID_ = s;
+        return s;
+      }
+    }
+    /**
+     * string AppID = 1;
+     */
+    public com.google.protobuf.ByteString
+        getAppIDBytes() {
+      java.lang.Object ref = appID_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        appID_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int DETECTIONCOLOR_FIELD_NUMBER = 2;
+    private com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor detectionColor_;
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    public boolean hasDetectionColor() {
+      return detectionColor_ != null;
+    }
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    public com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor getDetectionColor() {
+      return detectionColor_ == null ? com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.getDefaultInstance() : detectionColor_;
+    }
+    /**
+     * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+     */
+    public com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder getDetectionColorOrBuilder() {
+      return getDetectionColor();
+    }
+
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (!getAppIDBytes().isEmpty()) {
+        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, appID_);
+      }
+      if (detectionColor_ != null) {
+        output.writeMessage(2, getDetectionColor());
+      }
+      unknownFields.writeTo(output);
+    }
+
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (!getAppIDBytes().isEmpty()) {
+        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, appID_);
+      }
+      if (detectionColor_ != null) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(2, getDetectionColor());
+      }
+      size += unknownFields.getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest)) {
+        return super.equals(obj);
+      }
+      com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest other = (com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest) obj;
+
+      boolean result = true;
+      result = result && getAppID()
+          .equals(other.getAppID());
+      result = result && (hasDetectionColor() == other.hasDetectionColor());
+      if (hasDetectionColor()) {
+        result = result && getDetectionColor()
+            .equals(other.getDetectionColor());
+      }
+      result = result && unknownFields.equals(other.unknownFields);
+      return result;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      hash = (37 * hash) + APPID_FIELD_NUMBER;
+      hash = (53 * hash) + getAppID().hashCode();
+      if (hasDetectionColor()) {
+        hash = (37 * hash) + DETECTIONCOLOR_FIELD_NUMBER;
+        hash = (53 * hash) + getDetectionColor().hashCode();
+      }
+      hash = (29 * hash) + unknownFields.hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code Tango.PMR.Integration.ColorProfileRequest}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:Tango.PMR.Integration.ColorProfileRequest)
+        com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequestOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.internal_static_Tango_PMR_Integration_ColorProfileRequest_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.class, com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.Builder.class);
+      }
+
+      // Construct using com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessageV3
+                .alwaysUseFieldBuilders) {
+        }
+      }
+      public Builder clear() {
+        super.clear();
+        appID_ = "";
+
+        if (detectionColorBuilder_ == null) {
+          detectionColor_ = null;
+        } else {
+          detectionColor_ = null;
+          detectionColorBuilder_ = null;
+        }
+        return this;
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor;
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest getDefaultInstanceForType() {
+        return com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.getDefaultInstance();
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest build() {
+        com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest buildPartial() {
+        com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest result = new com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest(this);
+        result.appID_ = appID_;
+        if (detectionColorBuilder_ == null) {
+          result.detectionColor_ = detectionColor_;
+        } else {
+          result.detectionColor_ = detectionColorBuilder_.build();
+        }
+        onBuilt();
+        return result;
+      }
+
+      public Builder clone() {
+        return (Builder) super.clone();
+      }
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return (Builder) super.setField(field, value);
+      }
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return (Builder) super.clearField(field);
+      }
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return (Builder) super.clearOneof(oneof);
+      }
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return (Builder) super.setRepeatedField(field, index, value);
+      }
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return (Builder) super.addRepeatedField(field, value);
+      }
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest) {
+          return mergeFrom((com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest other) {
+        if (other == com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest.getDefaultInstance()) return this;
+        if (!other.getAppID().isEmpty()) {
+          appID_ = other.appID_;
+          onChanged();
+        }
+        if (other.hasDetectionColor()) {
+          mergeDetectionColor(other.getDetectionColor());
+        }
+        this.mergeUnknownFields(other.unknownFields);
+        onChanged();
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest) e.getUnfinishedMessage();
+          throw e.unwrapIOException();
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+
+      private java.lang.Object appID_ = "";
+      /**
+       * string AppID = 1;
+       */
+      public java.lang.String getAppID() {
+        java.lang.Object ref = appID_;
+        if (!(ref instanceof java.lang.String)) {
+          com.google.protobuf.ByteString bs =
+              (com.google.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          appID_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * string AppID = 1;
+       */
+      public com.google.protobuf.ByteString
+          getAppIDBytes() {
+        java.lang.Object ref = appID_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          appID_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * string AppID = 1;
+       */
+      public Builder setAppID(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  
+        appID_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * string AppID = 1;
+       */
+      public Builder clearAppID() {
+        
+        appID_ = getDefaultInstance().getAppID();
+        onChanged();
+        return this;
+      }
+      /**
+       * string AppID = 1;
+       */
+      public Builder setAppIDBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  checkByteStringIsUtf8(value);
+        
+        appID_ = value;
+        onChanged();
+        return this;
+      }
+
+      private com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor detectionColor_ = null;
+      private com.google.protobuf.SingleFieldBuilderV3<
+          com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder> detectionColorBuilder_;
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public boolean hasDetectionColor() {
+        return detectionColorBuilder_ != null || detectionColor_ != null;
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor getDetectionColor() {
+        if (detectionColorBuilder_ == null) {
+          return detectionColor_ == null ? com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.getDefaultInstance() : detectionColor_;
+        } else {
+          return detectionColorBuilder_.getMessage();
+        }
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public Builder setDetectionColor(com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor value) {
+        if (detectionColorBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          detectionColor_ = value;
+          onChanged();
+        } else {
+          detectionColorBuilder_.setMessage(value);
+        }
+
+        return this;
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public Builder setDetectionColor(
+          com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder builderForValue) {
+        if (detectionColorBuilder_ == null) {
+          detectionColor_ = builderForValue.build();
+          onChanged();
+        } else {
+          detectionColorBuilder_.setMessage(builderForValue.build());
+        }
+
+        return this;
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public Builder mergeDetectionColor(com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor value) {
+        if (detectionColorBuilder_ == null) {
+          if (detectionColor_ != null) {
+            detectionColor_ =
+              com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.newBuilder(detectionColor_).mergeFrom(value).buildPartial();
+          } else {
+            detectionColor_ = value;
+          }
+          onChanged();
+        } else {
+          detectionColorBuilder_.mergeFrom(value);
+        }
+
+        return this;
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public Builder clearDetectionColor() {
+        if (detectionColorBuilder_ == null) {
+          detectionColor_ = null;
+          onChanged();
+        } else {
+          detectionColor_ = null;
+          detectionColorBuilder_ = null;
+        }
+
+        return this;
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder getDetectionColorBuilder() {
+        
+        onChanged();
+        return getDetectionColorFieldBuilder().getBuilder();
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      public com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder getDetectionColorOrBuilder() {
+        if (detectionColorBuilder_ != null) {
+          return detectionColorBuilder_.getMessageOrBuilder();
+        } else {
+          return detectionColor_ == null ?
+              com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.getDefaultInstance() : detectionColor_;
+        }
+      }
+      /**
+       * .Tango.PMR.TCC.DetectionColor DetectionColor = 2;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder> 
+          getDetectionColorFieldBuilder() {
+        if (detectionColorBuilder_ == null) {
+          detectionColorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColor.Builder, com.twine.tango.pmr.tcc.DetectionColorOuterClass.DetectionColorOrBuilder>(
+                  getDetectionColor(),
+                  getParentForChildren(),
+                  isClean());
+          detectionColor_ = null;
+        }
+        return detectionColorBuilder_;
+      }
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFieldsProto3(unknownFields);
+      }
+
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:Tango.PMR.Integration.ColorProfileRequest)
+    }
+
+    // @@protoc_insertion_point(class_scope:Tango.PMR.Integration.ColorProfileRequest)
+    private static final com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest();
+    }
+
+    public static com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      public ColorProfileRequest parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+          return new ColorProfileRequest(input, extensionRegistry);
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    public com.twine.tango.pmr.integration.ColorProfileRequestOuterClass.ColorProfileRequest getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_Tango_PMR_Integration_ColorProfileRequest_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\031ColorProfileRequest.proto\022\025Tango.PMR.I" +
+      "ntegration\032\024DetectionColor.proto\"[\n\023Colo" +
+      "rProfileRequest\022\r\n\005AppID\030\001 \001(\t\0225\n\016Detect" +
+      "ionColor\030\002 \001(\0132\035.Tango.PMR.TCC.Detection" +
+      "ColorB!\n\037com.twine.tango.pmr.integration" +
+      "b\006proto3"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public com.google.protobuf.ExtensionRegistry assignDescriptors(
+              com.google.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+          com.twine.tango.pmr.tcc.DetectionColorOuterClass.getDescriptor(),
+        }, assigner);
+    internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_Tango_PMR_Integration_ColorProfileRequest_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_Tango_PMR_Integration_ColorProfileRequest_descriptor,
+        new java.lang.String[] { "AppID", "DetectionColor", });
+    com.twine.tango.pmr.tcc.DetectionColorOuterClass.getDescriptor();
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileResponseOuterClass.java b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileResponseOuterClass.java
new file mode 100644
index 000000000..53e36224f
--- /dev/null
+++ b/Software/Android_Studio/ColorCapture/app/src/main/java/com/twine/tango/pmr/integration/ColorProfileResponseOuterClass.java
@@ -0,0 +1,506 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ColorProfileResponse.proto
+
+package com.twine.tango.pmr.integration;
+
+public final class ColorProfileResponseOuterClass {
+  private ColorProfileResponseOuterClass() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  public interface ColorProfileResponseOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:Tango.PMR.Integration.ColorProfileResponse)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * bool Approved = 1;
+     */
+    boolean getApproved();
+  }
+  /**
+   * Protobuf type {@code Tango.PMR.Integration.ColorProfileResponse}
+   */
+  public  static final class ColorProfileResponse extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:Tango.PMR.Integration.ColorProfileResponse)
+      ColorProfileResponseOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use ColorProfileResponse.newBuilder() to construct.
+    private ColorProfileResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private ColorProfileResponse() {
+      approved_ = false;
+    }
+
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+    getUnknownFields() {
+      return this.unknownFields;
+    }
+    private ColorProfileResponse(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      this();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownFieldProto3(
+                  input, unknownFields, extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 8: {
+
+              approved_ = input.readBool();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.internal_static_Tango_PMR_Integration_ColorProfileResponse_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.class, com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.Builder.class);
+    }
+
+    public static final int APPROVED_FIELD_NUMBER = 1;
+    private boolean approved_;
+    /**
+     * bool Approved = 1;
+     */
+    public boolean getApproved() {
+      return approved_;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (approved_ != false) {
+        output.writeBool(1, approved_);
+      }
+      unknownFields.writeTo(output);
+    }
+
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (approved_ != false) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBoolSize(1, approved_);
+      }
+      size += unknownFields.getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse)) {
+        return super.equals(obj);
+      }
+      com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse other = (com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse) obj;
+
+      boolean result = true;
+      result = result && (getApproved()
+          == other.getApproved());
+      result = result && unknownFields.equals(other.unknownFields);
+      return result;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      hash = (37 * hash) + APPROVED_FIELD_NUMBER;
+      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
+          getApproved());
+      hash = (29 * hash) + unknownFields.hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code Tango.PMR.Integration.ColorProfileResponse}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:Tango.PMR.Integration.ColorProfileResponse)
+        com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponseOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.internal_static_Tango_PMR_Integration_ColorProfileResponse_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.class, com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.Builder.class);
+      }
+
+      // Construct using com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessageV3
+                .alwaysUseFieldBuilders) {
+        }
+      }
+      public Builder clear() {
+        super.clear();
+        approved_ = false;
+
+        return this;
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor;
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse getDefaultInstanceForType() {
+        return com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.getDefaultInstance();
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse build() {
+        com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse buildPartial() {
+        com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse result = new com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse(this);
+        result.approved_ = approved_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder clone() {
+        return (Builder) super.clone();
+      }
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return (Builder) super.setField(field, value);
+      }
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return (Builder) super.clearField(field);
+      }
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return (Builder) super.clearOneof(oneof);
+      }
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return (Builder) super.setRepeatedField(field, index, value);
+      }
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return (Builder) super.addRepeatedField(field, value);
+      }
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse) {
+          return mergeFrom((com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse other) {
+        if (other == com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse.getDefaultInstance()) return this;
+        if (other.getApproved() != false) {
+          setApproved(other.getApproved());
+        }
+        this.mergeUnknownFields(other.unknownFields);
+        onChanged();
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse) e.getUnfinishedMessage();
+          throw e.unwrapIOException();
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+
+      private boolean approved_ ;
+      /**
+       * bool Approved = 1;
+       */
+      public boolean getApproved() {
+        return approved_;
+      }
+      /**
+       * bool Approved = 1;
+       */
+      public Builder setApproved(boolean value) {
+        
+        approved_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * bool Approved = 1;
+       */
+      public Builder clearApproved() {
+        
+        approved_ = false;
+        onChanged();
+        return this;
+      }
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFieldsProto3(unknownFields);
+      }
+
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:Tango.PMR.Integration.ColorProfileResponse)
+    }
+
+    // @@protoc_insertion_point(class_scope:Tango.PMR.Integration.ColorProfileResponse)
+    private static final com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse();
+    }
+
+    public static com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      public ColorProfileResponse parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+          return new ColorProfileResponse(input, extensionRegistry);
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    public com.twine.tango.pmr.integration.ColorProfileResponseOuterClass.ColorProfileResponse getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_Tango_PMR_Integration_ColorProfileResponse_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\032ColorProfileResponse.proto\022\025Tango.PMR." +
+      "Integration\"(\n\024ColorProfileResponse\022\020\n\010A" +
+      "pproved\030\001 \001(\010B!\n\037com.twine.tango.pmr.int" +
+      "egrationb\006proto3"
+    };
+    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public com.google.protobuf.ExtensionRegistry assignDescriptors(
+              com.google.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        }, assigner);
+    internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_Tango_PMR_Integration_ColorProfileResponse_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_Tango_PMR_Integration_ColorProfileResponse_descriptor,
+        new java.lang.String[] { "Approved", });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/Software/Android_Studio/ColorCapture/app/src/main/res/layout/external_machine_item.xml b/Software/Android_Studio/ColorCapture/app/src/main/res/layout/external_machine_item.xml
index c13fdaaef..24b2c0f7e 100644
--- a/Software/Android_Studio/ColorCapture/app/src/main/res/layout/external_machine_item.xml
+++ b/Software/Android_Studio/ColorCapture/app/src/main/res/layout/external_machine_item.xml
@@ -4,30 +4,45 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     
+
         
+            type="com.twine.colorcapture.integration.ExternalBridgeMachine" />
     
 
     
+        android:layout_height="wrap_content"
+        android:orientation="horizontal">
 
-        
+        
 
-        
+            android:background="@drawable/list_view_selectable"
+            android:orientation="vertical"
+            android:padding="5dp">
+
+            
+
+            
+        
     
 
\ No newline at end of file
diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 748b7fa4f..07175ae50 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,3,9,4};
+TangoVersion_t _gTangoVersion = {1,3,9,5};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
index 111db2ac7..0ba34deb6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
@@ -447,6 +447,8 @@ uint32_t DeActivateCleanerPump()
 
 void Power_Off()//Power Down
 {
+    ROM_WatchdogResetDisable(WATCHDOG0_BASE);
+
     F2_CTRL_Reg.ushort |= PDOWN_RL1_CTRL;
     F2_CTRL = F2_CTRL_Reg.ushort;
 }
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 001fab666..5dd991512 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -188,6 +188,7 @@ Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams)
 
 var ReportTaskParams = new Task.Params();
 ReportTaskParams.instance.name = "report";
+ReportTaskParams.stackSize = 2048;
 ReportTaskParams.priority = 7;
 Program.global.report = Task.create("&reportService", ReportTaskParams);
 
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index ad88a9ed2..7280a6b25 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -228,10 +228,11 @@ int main(void)
    Init_All_I2C();
 
 
-    #ifndef EVALUATION_BOARD
-        STATUS_GREEN_LED_ON;
-	    FPGA_Init();
-    #endif
+   #ifndef EVALUATION_BOARD
+   STATUS_RED_LED_OFF;
+   STATUS_GREEN_LED_ON;
+   FPGA_Init();
+   #endif
 
 	MAP_FPULazyStackingEnable();
 
@@ -262,6 +263,11 @@ int main(void)
     Heaters_Init();
     MotorsInit();
 //Shai    WHS_HW_test(); // for WHS sensor test
+
+    #ifndef EVALUATION_BOARD
+        Init_Machine_Leds();
+    #endif
+
    WHS_init();
    Buttons_Init();
     //IDS_ModuleInit();
@@ -298,9 +304,6 @@ int main(void)
 
     //Test_ADS120_Internal_Temperature_Sensor(0);
 
-    #ifndef EVALUATION_BOARD
-        Init_Machine_Leds();
-    #endif
 
 
     // Enable interrupts to the processor.
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 040803b7a..785d9fc3c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -70,7 +70,11 @@ int DiagnosticsIndex = 0;
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
+#ifdef REDUCED_DIAGNOSTICS
+int DiagnosticLimit =eOneSecond; //frequency of data collection
+#else
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
+#endif
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index b12064915..f0ce7397c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_breaksensorlimit = true;
             EmbeddedParameters.breaksensorlimit = 10;
             EmbeddedParameters.has_diagnosticcollectionlimit = true;
-            EmbeddedParameters.diagnosticcollectionlimit = 2;
+            EmbeddedParameters.diagnosticcollectionlimit = 1;
             EmbeddedParameters.has_overheatcountlimit = true;
             EmbeddedParameters.overheatcountlimit = 3;
             EmbeddedParameters.has_underheatcountlimit = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 7aaab41c1..5e61010dd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -172,7 +172,7 @@ void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHe
     Overheat_Count_Limit = OverHeatTimeout;
     Underheat_Count_Limit = UnderHeatTimeout;
 }
-void  Heaters_SetOperationLimits(acheatersloweroperationlimit,acheatersupperoperationlimit,dcheatersloweroperationlimit,dcheatersupperoperationlimit)
+void  Heaters_SetOperationLimits(int acheatersloweroperationlimit, int acheatersupperoperationlimit, int dcheatersloweroperationlimit, int dcheatersupperoperationlimit)
 {
     AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
     AcHeatersUpperoperationLimit =  acheatersupperoperationlimit;
@@ -665,7 +665,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
     MinreadValue = min (MainPT100Read,SecondaryPT100Read);
 
-    if ((MinreadValue) >= HeaterControl[index].sensormaxvalue)
+    if (MaxreadValue >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
@@ -679,7 +679,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return OK;
     }
-    if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
+    if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 30ad7d857..1e176a37a 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -394,6 +394,9 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                                          {
                                                              lookForLubrication = false;
                                                              lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse;
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond*100, "LUBRICANT nl / sec");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanoliterperpulse*100, "LUBRICANT nl / pulse");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision, "step division");
                                                              if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision
                                                                      != DISPENSER_STEP_DIVISION__Auto)
                                                              {
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 5caeae761..ba6219f67 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt	
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt	
@@ -1,3 +1,20 @@
+Embedded SW Release note - Version 1.3.9.5 - Itma Candidate 2
+=============================================================
+WATCHDOG Activated - embedded SW reset after 4 seconds of inactivity
+Flash size problem fixed
+Machine:
+	Cartridge buttons and leds fixed
+	midtank pressure calculation set according to Sergey's directions
+	support for new dispensers improved
+Modules:
+	Alarm handling - midtank level (does not prevent jobs or dispensers refill)
+	Diagnostics: thread information removed to reduce the trasmission quantities and MS load
+	Heaters algorithm improved (yet again)
+	IDS: lubricant handling adjusted
+		 file handling and brushstops activity fixed (large jobs)
+		 automatic homing CANCELLED
+	Stubs: added support for FFS recreating
+	
 Embedded SW Release note - Version 1.3.9.1 - Itma Candidate 1
 =============================================================
 Jobs:
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
index 16067dcdc..b3fc8c052 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
@@ -70,7 +70,7 @@ uint32_t PowerIdleCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
     if (machineActive == true)
         return OK;
-    if (powerIdleSecondsCounter%100 == 0)
+    if ((powerIdleSecondsCounter%100 == 0)&&(powerIdleSecondsCounter))
         Report("PowerIdle Idle counter ",__FILE__,__LINE__,(int)powerIdleSecondsLimit,RpWarning,(int)powerIdleSecondsCounter,0);
 
     if (++powerIdleSecondsCounter>=powerIdleSecondsLimit)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index fcb7b337a..d19be0f29 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -232,7 +232,7 @@ uint32_t PowerOffWaitForTemperatureCallback(uint32_t IfIndex, uint32_t BusyFlag)
         MaxTemp = readTemp;
 
 
-    if ((MaxTemp>PowerOffTemperatureThreshold)&&(WaitForProcessCounter++<1800))
+    if ((MaxTemp>PowerOffTemperatureThreshold)&&(WaitForProcessCounter++<3500))
     {
         Report("On going cooling down, wait for end of cooling",__FILE__,__LINE__,(int)MaxTemp,RpWarning,(int)WaitForProcessCounter,0);
         resetIdleCounter();
diff --git a/Software/Embedded_SW/Embedded/src/sysbios/makefile b/Software/Embedded_SW/Embedded/src/sysbios/makefile
index f4a2da405..a8c3dda94 100644
--- a/Software/Embedded_SW/Embedded/src/sysbios/makefile
+++ b/Software/Embedded_SW/Embedded/src/sysbios/makefile
@@ -4,7 +4,7 @@ XOPTS = -I"C:/TI/xdctools_3_32_00_06_core/packages/" -Dxdc_target_types__=C:/TI/
 vpath % C:/TI/tirtos_tivac_2_16_00_08/products/bios_6_45_01_29/packages/ti/sysbios/
 vpath %.c C:/TI/xdctools_3_32_00_06_core/packages/
 
-CCOPTS    = --endian=little -mv7M4 --abi=eabi --float_support=fpv4spd16 -q -ms --opt_for_speed=2  --program_level_compile -o3 -g --optimize_with_debug  -Dti_sysbios_knl_Task_minimizeLatency__D=FALSE -Dti_sysbios_knl_Clock_stopCheckNext__D=FALSE -Dti_sysbios_family_arm_m3_Hwi_enableException__D=TRUE -Dti_sysbios_family_arm_m3_Hwi_disablePriority__D=32U -Dti_sysbios_family_arm_m3_Hwi_numSparseInterrupts__D=0U
+CCOPTS    = --endian=little -mv7M4 --abi=eabi --float_support=fpv4spd16 -q -ms --opt_for_speed=2  --program_level_compile -o3 -g --optimize_with_debug  -Dxdc_FILE=__FILE__  -Dti_sysbios_knl_Task_minimizeLatency__D=FALSE -Dti_sysbios_knl_Clock_stopCheckNext__D=FALSE -Dti_sysbios_family_arm_m3_Hwi_enableException__D=TRUE -Dti_sysbios_family_arm_m3_Hwi_disablePriority__D=32U -Dti_sysbios_family_arm_m3_Hwi_numSparseInterrupts__D=0U
 
 XDC_ROOT  = C:/TI/xdctools_3_32_00_06_core/packages/
 
diff --git a/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f b/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f
index 117dea776..1b237d056 100644
Binary files a/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f and b/Software/Embedded_SW/Embedded/src/sysbios/sysbios.aem4f differ
diff --git a/Software/PMR/Messages/Common/MessageType.proto b/Software/PMR/Messages/Common/MessageType.proto
index f3344d6f8..9dab4b1e3 100644
--- a/Software/PMR/Messages/Common/MessageType.proto
+++ b/Software/PMR/Messages/Common/MessageType.proto
@@ -132,6 +132,9 @@ enum MessageType
 	StartApplicationLogsResponse = 1010;
 	StopApplicationLogsRequest = 1011;
 	StopApplicationLogsResponse = 1012;
+	ColorProfileRequest = 1013;
+	ColorProfileResponse = 1014;
+
 
 
 	//Diagnostics
diff --git a/Software/Visual_Studio/PPC/Tango.PPC.UI/app.manifest b/Software/Visual_Studio/PPC/Tango.PPC.UI/app.manifest
index d72e75011..efc5f8179 100644
--- a/Software/Visual_Studio/PPC/Tango.PPC.UI/app.manifest
+++ b/Software/Visual_Studio/PPC/Tango.PPC.UI/app.manifest
@@ -16,7 +16,7 @@
             Remove this element if your application requires this virtualization for backwards
             compatibility.
         -->
-        
+        
       
     
   
-- 
cgit v1.3.1


From f8cd5085cc7fcd85e694d026dfd656ff54ab91d3 Mon Sep 17 00:00:00 2001
From: Shlomo Hecht 
Date: Thu, 2 May 2019 11:18:08 +0300
Subject: job progress and winder logs

---
 Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c        | 4 ++--
 Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c | 6 +++---
 Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'Software/Embedded_SW/Embedded/Modules')

diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 30ad7d857..f2bae768c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -755,7 +755,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                                    (int) segmentfirst_speed);
                          //REPORT_MSG(segmentfirst_speed,IdsMessage);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                         SendJobProgress(0.0, 0, false, IdsMessage);
+                         //SendJobProgress(0.0, 0, false, IdsMessage);
                      }
                  }
              }
@@ -952,7 +952,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                           (int) segmentfirst_speed);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                SendJobProgress(0.0, 0, false, IdsMessage);
+                //SendJobProgress(0.0, 0, false, IdsMessage);
             }
             else
             {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 70f32ce6d..d65156066 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -242,7 +242,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.spoolbackingrate == 0)
         {
             ScrewNumberOfSteps--;
-            //REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
 
         }
     }
@@ -251,7 +251,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.SpoolBottomBackingRate == 0)
         {
             ScrewNumberOfSteps++;
-            //REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
         }
     }
     if (WinderMotorSpeedRollOver)
@@ -288,7 +288,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0);
         //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
         //REPORT_MSG(temp , "new winder speed");
-//        Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
+        Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
     }
 
     /********************************************************************************/
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index a4208ad25..c292f7dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -842,8 +842,8 @@ char Endstr[150];
      Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
-     TotalProcessedLength = 0.0;
-    SetOriginMotorSpeed(0);
+     //TotalProcessedLength = 0.0;
+     SetOriginMotorSpeed(0);
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogClose();
 #endif
-- 
cgit v1.3.1


From 25011c65a3081d256a6ae4672f737d51bc3c7464 Mon Sep 17 00:00:00 2001
From: Shlomo Hecht 
Date: Thu, 2 May 2019 14:40:11 +0300
Subject: fix job length bug. read screw encoder. better logging in IDS

---
 .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c  |  2 +-
 Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c  |  2 +-
 .../Embedded/Drivers/USB_Communication/USBCDCD.c   |  4 ++-
 .../Embedded/Modules/General/GeneralHardware.c     |  2 +-
 .../Embedded/Modules/Heaters/Heaters_print.c       |  1 +
 .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c   |  7 ++---
 .../Embedded/Modules/Thread/Thread_Winder.c        | 35 +++++++++++++++++-----
 .../Initialization/PowerOffSequence.c              |  2 +-
 .../Embedded/StateMachines/Printing/JobSTM.c       |  1 +
 .../Embedded/StateMachines/Printing/PrintingSTM.c  |  2 +-
 10 files changed, 40 insertions(+), 18 deletions(-)

(limited to 'Software/Embedded_SW/Embedded/Modules')

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 07175ae50..e4d325e71 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,3,9,5};
+TangoVersion_t _gTangoVersion = {1,3,9,6};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c
index 41a28b4c1..66370491d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c
@@ -443,8 +443,8 @@ typedef union
 {
     struct
     {
-         uint16_t M;
          uint16_t L;
+         uint16_t M;
     }Word;
     uint32_t Position;
 }SCREW_POS;
diff --git a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
index b3ab21f0a..2476e6ef3 100644
--- a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
+++ b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
@@ -482,6 +482,7 @@ uint16_t Usbindex = 0;
 // \return The return value is event-specific.
 //
 //*****************************************************************************
+uint32_t USBConn = 0; USBDisc = 0;
 uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData)
 {
 
@@ -505,6 +506,7 @@ uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValu
             HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 1;
 
             SetCommunicationPath(isUSB);
+            USBConn++;
             //
             // Flush our buffers.
             //
@@ -532,7 +534,7 @@ uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValu
             HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 0;
 
             //TODO: Notify disconnection!
-
+            USBDisc++;
             //
             // Set the command status update flag.
             //
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index f0ce7397c..b12064915 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_breaksensorlimit = true;
             EmbeddedParameters.breaksensorlimit = 10;
             EmbeddedParameters.has_diagnosticcollectionlimit = true;
-            EmbeddedParameters.diagnosticcollectionlimit = 1;
+            EmbeddedParameters.diagnosticcollectionlimit = 2;
             EmbeddedParameters.has_overheatcountlimit = true;
             EmbeddedParameters.overheatcountlimit = 3;
             EmbeddedParameters.has_underheatcountlimit = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 5e61010dd..3a9ce53d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -953,6 +953,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
             //        #warning PID is now only proportional (above)
 //             Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
+            //Report("AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 71aa161dd..668ab9dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -919,8 +919,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
             segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
                     / Dispensers[Dispenser_i]->nanoliterperpulse;
-            if (Dispensers[Dispenser_i]->dispenserstepdivision
-                    != DISPENSER_STEP_DIVISION__Auto)
+            if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
                 segmentfirst_speed /=
@@ -948,11 +947,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
-                          "Dispenser %d nl/sec %d nl/pulse %d speed %d",
+                          "Dispenser %d nl/sec %d nl/pulse %d speed %d steps %d/%d",
                           DispenserId,
                           (int) Dispensers[Dispenser_i]->nanolitterpersecond,
                           (int) Dispensers[Dispenser_i]->nanoliterperpulse,
-                          (int) segmentfirst_speed);
+                          (int) segmentfirst_speed,Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                 //SendJobProgress(0.0, 0, false, IdsMessage);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index d65156066..937ae63b7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -54,6 +54,9 @@ uint32_t ScrewControlId = 0xFF;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
 
+uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
+uint32_t ScrewLocationRun[3];
+
 uint32_t Winder_Init(void)
 {
     ScrewTimerInterruptInit();
@@ -109,6 +112,10 @@ uint32_t Winder_Prepare(void)
         AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
         return ERROR;
     }*/
+
+    ScrewLocationRun[0] = 0;
+    ScrewLocationRun[1] = 0;
+
     if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT)
     {
         //REPORT_MSG(LIMIT, "Winder_Prepare at limit");
@@ -136,6 +143,11 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
+    Read_Screw_Encoder();
+    ScrewLocationLimitSwitch = Screw_RotEnc.Position;
+    REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
+
+
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
     {
@@ -157,7 +169,13 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     //SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
 
+    Read_Screw_Encoder();
+    ScrewLocationStart = Screw_RotEnc.Position;
+
+    REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
+
     ScrewCurrentDirection = false;
+    ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
@@ -230,6 +248,10 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
+    //REPORT_MSG(ScrewLocationRun[1] - ScrewLocationRun[0], "Screw Run NumberOfSteps");
+    usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]));
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
+    Report(ScrewStr,__FILE__,__LINE__,ScrewLocationLimitSwitch,RpWarning,ScrewLocationStart, 0);
 
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
@@ -288,7 +310,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0);
         //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
         //REPORT_MSG(temp , "new winder speed");
-        Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
+        //Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
     }
 
     /********************************************************************************/
@@ -440,6 +462,9 @@ void ScrewTimerInterrupt(int ARG0)
     ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     ROM_IntMasterDisable();
 
+    Read_Screw_Encoder();
+    ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+
     if (SCREW_TimerActivated == true)
     {
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
@@ -455,13 +480,7 @@ void ScrewTimerInterrupt(int ARG0)
     }
     ROM_IntMasterEnable();
     Rotations+=0.03;
-    /*random++;
-    if (random >= 2)
-        random = -1;*/
-    //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0);
-    //
-    // Enable all interrupts.
-    //
+
     return ;
 
 }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index d19be0f29..e50286290 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -232,7 +232,7 @@ uint32_t PowerOffWaitForTemperatureCallback(uint32_t IfIndex, uint32_t BusyFlag)
         MaxTemp = readTemp;
 
 
-    if ((MaxTemp>PowerOffTemperatureThreshold)&&(WaitForProcessCounter++<3500))
+    if ((MaxTemp>PowerOffTemperatureThreshold)&&(WaitForProcessCounter++<3600))
     {
         Report("On going cooling down, wait for end of cooling",__FILE__,__LINE__,(int)MaxTemp,RpWarning,(int)WaitForProcessCounter,0);
         resetIdleCounter();
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 1bd07c06e..f1892f15b 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -628,6 +628,7 @@ void JobRequestFunc(MessageContainer* requestContainer)
             }
             status  = PASSED;
             JobEndReason = JOB_OK;
+            TotalProcessedLength = 0.0;
             JobAlarmReason = AlarmHandlingPrepareJob(CurrentJob);
             if (JobAlarmReason ==OK)
             {
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index c52ed8b4c..d238d2f82 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -222,7 +222,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile()
         LOG_ERROR (0, "f_read error brush stop size error");
         status = ERROR;
     }
-    REPORT_MSG(BrushStop->index,"BrushStop file Read Index");
+    //REPORT_MSG(BrushStop->index,"BrushStop file Read Index");
 
     return BrushStop;
 }
-- 
cgit v1.3.1


From d42d96fdb1656ed45abedf181ffbe9dd3f2f481e Mon Sep 17 00:00:00 2001
From: Shlomo Hecht 
Date: Thu, 2 May 2019 15:06:14 +0300
Subject: hide screw encoder reading

---
 .../Embedded/Modules/Thread/Thread_Winder.c            | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'Software/Embedded_SW/Embedded/Modules')

diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 937ae63b7..df88db3f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -143,9 +143,9 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
-    Read_Screw_Encoder();
-    ScrewLocationLimitSwitch = Screw_RotEnc.Position;
-    REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
+    //Read_Screw_Encoder();
+    //ScrewLocationLimitSwitch = Screw_RotEnc.Position;
+    //REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
 
 
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
@@ -169,8 +169,8 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     //SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
 
-    Read_Screw_Encoder();
-    ScrewLocationStart = Screw_RotEnc.Position;
+    //Read_Screw_Encoder();
+    //ScrewLocationStart = Screw_RotEnc.Position;
 
     REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
 
@@ -249,9 +249,9 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
     //REPORT_MSG(ScrewLocationRun[1] - ScrewLocationRun[0], "Screw Run NumberOfSteps");
-    usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]));
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]));
     //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
-    Report(ScrewStr,__FILE__,__LINE__,ScrewLocationLimitSwitch,RpWarning,ScrewLocationStart, 0);
+    //Report(ScrewStr,__FILE__,__LINE__,ScrewLocationLimitSwitch,RpWarning,ScrewLocationStart, 0);
 
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
@@ -462,8 +462,8 @@ void ScrewTimerInterrupt(int ARG0)
     ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     ROM_IntMasterDisable();
 
-    Read_Screw_Encoder();
-    ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+    //Read_Screw_Encoder();
+    //ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
 
     if (SCREW_TimerActivated == true)
     {
-- 
cgit v1.3.1


From 66c9f04ccf86a2d6b2c141e9634e02b93e67a407 Mon Sep 17 00:00:00 2001
From: Avi Levkovich 
Date: Thu, 2 May 2019 15:10:21 +0300
Subject: Gas sensor - Add stub + fix bug

---
 Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c       | 6 ++++--
 Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c | 8 ++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'Software/Embedded_SW/Embedded/Modules')

diff --git a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
index b9d8ee1f6..4e8dcb3c7 100644
--- a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
@@ -539,10 +539,12 @@ uint8_t  Calculate_Gas_Power_Consumption() // WHS
     {
         if(VSensor <= VOC_Vsensor[i])
         {
-            PPM = i;
+            return i;//PPM
         }
     }
-    return PPM;
+
+return 0xFF;//out of scale
+
 }
 
 uint32_t Read_Dryer_Heaters_Current(HEATERS_CURRENT Heater_ID) //
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 34cb61e27..c6f2526db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -11,6 +11,7 @@
 
 #include "drivers/Flash_Memory/FATFS/ff.h"
 #include "drivers/Flash_Memory/FATFS/Control_File_System.h"
+#include "drivers/adc_sampling/adc.h"
 
 //#include "graphics_adapter.h"
 
@@ -33,6 +34,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
             assert(iFResult);
         }
     }
+    else
+    if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
+    {
+        response.progress = (double)Calculate_Gas_Power_Consumption();
+        response.has_progress = true;
+
+    }
     else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
         PowerOffInit();
-- 
cgit v1.3.1