Diff: Device.c

Revision:

161:efd949e8d536

Parent:

156:e68ee0bcdcda

Child:

166:c3c0b8a90d81

--- a/Device.c	Fri May 13 14:04:22 2016 +0000
+++ b/Device.c	Sun May 15 19:12:12 2016 +0000
@@ -10,6 +10,12 @@
   SystemInit1();  // Инициализация контроллера: установка тактовых частот
   SystemCoreClockUpdate1(); // расчет тактовой частоты процессора перед инициализацией UART - 100MHz
   
+  //Init host commununication protocol
+  InitUserProtocol();
+  //Init hash table
+  InitHashParamTable();
+  InitHashFuncTable();
+  
   //Load default settings
   DeviceInitAllWithDefaults();
   
@@ -23,27 +29,23 @@
 void DeviceStart(void){
   DeviceEnableMeasurementTimer();
   DeviceEnableRegularTimer();
-  DevicePhotoDetectorSetPotentiometers();
+  DeviceISACSSetPotentiometers();
   DeviceStartLightUp();
   DeviceStartDither();
 }
 
 void DeviceInitAllWithDefaults(void){
-  device.settings.address = 0;
-  
-  //Init transmitter variables
-  device.host.transmitter.position = 0;
+  device.user.address = 0;
   
   //Init controller
   InitControllerWithDefaults();
   
   //Init units
-  InitHostProtocolWithDefaults();
   InitCountersWithDefaults();
   InitLightUpWithDefaults();
-  InitPhotoDetectorWithDefaults();
   InitDitherWithDefaults();
   InitDACWithDefaults();
+  InitISACSWithDefaults();
   InitPathLengthControlSystemWithDefaults();
 }
 
@@ -66,18 +68,16 @@
   //Init controller
   InitController();
   
-  //Init host commununication protocol
-  InitHostProtocol();
   //Init counters
   InitCounters();
   //Init light-up and back light unit
   InitLightUp();
-  //Init photo detector
-  InitPhotoDetector();
   //Init dither
   InitDither();
   //Init DAC of hfo & plcs
   InitDAC();
+  //Init information signal amplitude control system
+  InitISACS();
   //Init path length control system
   InitPathLengthControlSystem();
 }
@@ -87,7 +87,7 @@
        device.regular.event1Hz--;
        device.regular.time1Hz++;
        
-       DeviceLightUpCycle();
+       DeviceLightUpDoCycle();
     }
 }
 
@@ -122,11 +122,11 @@
             device.regular.event1K++;
         }
         
-        if ((device.host.response.type == RESPONSE_DELAYED) || (device.host.response.type == RESPONSE_PERIODIC)){
-            device.host.response.counter += 100;
-            if (device.host.response.counter > device.host.response.trigger) {
-                device.host.response.triggered = 1;
-                device.host.response.counter = 0;
+        if ((device.user.response.type == RESPONSE_DELAYED) || (device.user.response.type == RESPONSE_PERIODIC)){
+            device.user.response.counter += 100;
+            if (device.user.response.counter > device.user.response.trigger) {
+                device.user.response.triggered = 1;
+                device.user.response.counter = 0;
             }
         }
     }
@@ -142,7 +142,7 @@
       device.regular.event10K++;
     }
     
-    DeviceDitherCycle(); //Set/reset vibro 1/2 pins
+    DeviceDitherDoCycle(); //Set/reset vibro 1/2 pins
   }
 }
 
@@ -151,6 +151,8 @@
   DeviceQEIRead();
   //Count
   DeviceCount();
+  //Detect dither phase
+  DeviceDitherDetectPhase();
   
   //Receive ADCs samples using SSP
   DeviceSSPReceive();
@@ -161,13 +163,13 @@
   device.measurement.counter++;
   if (device.measurement.counter == device.measurement.length) device.measurement.counter = 0;
   //Reset dither 10mks resolution counter
-  if (device.measurement.counter == 0) device.dither.state.counter = 0; //First dither half period
-  if (device.measurement.counter == 16) device.dither.state.counter = 0;//Second dither half period
+  if (device.measurement.counter == 0) device.dither.pulse.state.counter = 0; //First dither half period
+  if (device.measurement.counter == 16) device.dither.pulse.state.counter = 0;//Second dither half period
 }
 
 void DeviceRegularInterruptHandler(void) {
   device.regular.event100K++;
-  device.dither.state.counter++; //Dither 10 mks resolution counter
+  device.dither.pulse.state.counter++; //Dither 10 mks resolution counter
 }
 
 /*
@@ -177,4 +179,481 @@
   }
   return -1;
 }
-*/
\ No newline at end of file
+*/
+
+void InitHashParamTable(void){
+  hashParamTable[0].hash = 0x1049db13;
+  hashParamTable[0].ref = &device.controller.uart[0].state.DLM;
+  hashParamTable[0].size = sizeof(device.controller.uart[0].state.DLM);
+  hashParamTable[1].hash = 0x12e884f8;
+  hashParamTable[1].ref = &device.plcs.regulator.state.enabled;
+  hashParamTable[1].size = sizeof(device.plcs.regulator.state.enabled);
+  hashParamTable[2].hash = 0x14ca9b91;
+  hashParamTable[2].ref = &device.controller.uart[0].state.LCR;
+  hashParamTable[2].size = sizeof(device.controller.uart[0].state.LCR);
+  hashParamTable[3].hash = 0x176344d;
+  hashParamTable[3].ref = &device.dac.settings.resolution;
+  hashParamTable[3].size = sizeof(device.dac.settings.resolution);
+  hashParamTable[4].hash = 0x179ae491;
+  hashParamTable[4].ref = &device.dither.noise.state.enabled;
+  hashParamTable[4].size = sizeof(device.dither.noise.state.enabled);
+  hashParamTable[5].hash = 0x18bf00d0;
+  hashParamTable[5].ref = &device.dither.noise.settings.phase;
+  hashParamTable[5].size = sizeof(device.dither.noise.settings.phase);
+  hashParamTable[6].hash = 0x18c9d3e9;
+  hashParamTable[6].ref = &device.controller.I2C.state.trigger;
+  hashParamTable[6].size = sizeof(device.controller.I2C.state.trigger);
+  hashParamTable[7].hash = 0x195d1e47;
+  hashParamTable[7].ref = &device.controller.uart[0].state.FCR;
+  hashParamTable[7].size = sizeof(device.controller.uart[0].state.FCR);
+  hashParamTable[8].hash = 0x1eb95b78;
+  hashParamTable[8].ref = &device.controller.I2C.state.position;
+  hashParamTable[8].size = sizeof(device.controller.I2C.state.position);
+  hashParamTable[9].hash = 0x1ef86a6a;
+  hashParamTable[9].ref = &device.dither.noise.settings.enabled;
+  hashParamTable[9].size = sizeof(device.dither.noise.settings.enabled);
+  hashParamTable[10].hash = 0x1f3f5760;
+  hashParamTable[10].ref = &device.controller.SSP.out[0];
+  hashParamTable[10].size = sizeof(device.controller.SSP.out[0]);
+  hashParamTable[11].hash = 0x1f99ad84;
+  hashParamTable[11].ref = &device.sensor.settings.id;
+  hashParamTable[11].size = sizeof(device.sensor.settings.id);
+  hashParamTable[12].hash = 0x1fd038c3;
+  hashParamTable[12].ref = &device.controller.I2C.state.buffer[4];
+  hashParamTable[12].size = sizeof(device.controller.I2C.state.buffer[4]);
+  hashParamTable[13].hash = 0x2481a096;
+  hashParamTable[13].ref = &device.isacs.regulator.settings.regular.scale;
+  hashParamTable[13].size = sizeof(device.isacs.regulator.settings.regular.scale);
+  hashParamTable[14].hash = 0x28d2accb;
+  hashParamTable[14].ref = &device.dither.carrier.state.error;
+  hashParamTable[14].size = sizeof(device.dither.carrier.state.error);
+  hashParamTable[15].hash = 0x321197dc;
+  hashParamTable[15].ref = &device.isacs.regulator.settings.enabled;
+  hashParamTable[15].size = sizeof(device.isacs.regulator.settings.enabled);
+  hashParamTable[16].hash = 0x323d398;
+  hashParamTable[16].ref = &device.dither.carrier.state.reference;
+  hashParamTable[16].size = sizeof(device.dither.carrier.state.reference);
+  hashParamTable[17].hash = 0x36ee331;
+  hashParamTable[17].ref = &device.isacs.regulator.state.enabled;
+  hashParamTable[17].size = sizeof(device.isacs.regulator.state.enabled);
+  hashParamTable[18].hash = 0x37da9fc5;
+  hashParamTable[18].ref = &device.plcs.reset.settings.heating.delay.center;
+  hashParamTable[18].size = sizeof(device.plcs.reset.settings.heating.delay.center);
+  hashParamTable[19].hash = 0x3a858c52;
+  hashParamTable[19].ref = &device.dither.noise.settings.range;
+  hashParamTable[19].size = sizeof(device.dither.noise.settings.range);
+  hashParamTable[20].hash = 0x41c3f057;
+  hashParamTable[20].ref = &device.plcs.modulator.settings.enabled;
+  hashParamTable[20].size = sizeof(device.plcs.modulator.settings.enabled);
+  hashParamTable[21].hash = 0x43914418;
+  hashParamTable[21].ref = &device.dither.carrier.settings.reference;
+  hashParamTable[21].size = sizeof(device.dither.carrier.settings.reference);
+  hashParamTable[22].hash = 0x45a15cba;
+  hashParamTable[22].ref = &device.sensor.settings.block;
+  hashParamTable[22].size = sizeof(device.sensor.settings.block);
+  hashParamTable[23].hash = 0x4977a07a;
+  hashParamTable[23].ref = &device.dither.pulse.state.counter;
+  hashParamTable[23].size = sizeof(device.dither.pulse.state.counter);
+  hashParamTable[24].hash = 0x498a9f45;
+  hashParamTable[24].ref = &device.controller.I2C.state.buffer[2];
+  hashParamTable[24].size = sizeof(device.controller.I2C.state.buffer[2]);
+  hashParamTable[25].hash = 0x4d41b2c1;
+  hashParamTable[25].ref = &device.dac.settings.reference;
+  hashParamTable[25].size = sizeof(device.dac.settings.reference);
+  hashParamTable[26].hash = 0x4df06184;
+  hashParamTable[26].ref = &device.dither.detector.settings.weight[19];
+  hashParamTable[26].size = sizeof(device.dither.detector.settings.weight[19]);
+  hashParamTable[27].hash = 0x4df39a9f;
+  hashParamTable[27].ref = &device.dither.detector.settings.weight[8];
+  hashParamTable[27].size = sizeof(device.dither.detector.settings.weight[8]);
+  hashParamTable[28].hash = 0x4e9b0985;
+  hashParamTable[28].ref = &device.plcs.amplifier.settings.gain;
+  hashParamTable[28].size = sizeof(device.plcs.amplifier.settings.gain);
+  hashParamTable[29].hash = 0x4fb6dfdd;
+  hashParamTable[29].ref = &device.dither.detector.settings.weight[29];
+  hashParamTable[29].size = sizeof(device.dither.detector.settings.weight[29]);
+  hashParamTable[30].hash = 0x5091ae04;
+  hashParamTable[30].ref = &device.controller.I2C.state.buffer[3];
+  hashParamTable[30].size = sizeof(device.controller.I2C.state.buffer[3]);
+  hashParamTable[31].hash = 0x525b6730;
+  hashParamTable[31].ref = &device.controller.I2C.state.enabled;
+  hashParamTable[31].size = sizeof(device.controller.I2C.state.enabled);
+  hashParamTable[32].hash = 0x542e0c62;
+  hashParamTable[32].ref = &device.controller.flash.settings.hashSector;
+  hashParamTable[32].size = sizeof(device.controller.flash.settings.hashSector);
+  hashParamTable[33].hash = 0x5489817b;
+  hashParamTable[33].ref = &device.dither.carrier.settings.scale;
+  hashParamTable[33].size = sizeof(device.dither.carrier.settings.scale);
+  hashParamTable[34].hash = 0x54e8abde;
+  hashParamTable[34].ref = &device.dither.detector.settings.weight[9];
+  hashParamTable[34].size = sizeof(device.dither.detector.settings.weight[9]);
+  hashParamTable[35].hash = 0x54eb50c5;
+  hashParamTable[35].ref = &device.dither.detector.settings.weight[18];
+  hashParamTable[35].size = sizeof(device.dither.detector.settings.weight[18]);
+  hashParamTable[36].hash = 0x5623a17a;
+  hashParamTable[36].ref = &device.dither.cycle.settings.enabled;
+  hashParamTable[36].size = sizeof(device.dither.cycle.settings.enabled);
+  hashParamTable[37].hash = 0x56adee9c;
+  hashParamTable[37].ref = &device.dither.detector.settings.weight[28];
+  hashParamTable[37].size = sizeof(device.dither.detector.settings.weight[28]);
+  hashParamTable[38].hash = 0x5a8f12ce;
+  hashParamTable[38].ref = &device.dither.cycle.state.enabled;
+  hashParamTable[38].size = sizeof(device.dither.cycle.state.enabled);
+  hashParamTable[39].hash = 0x5dd88c4f;
+  hashParamTable[39].ref = &device.plcs.regulator.state.reference;
+  hashParamTable[39].size = sizeof(device.plcs.regulator.state.reference);
+  hashParamTable[40].hash = 0x6246621;
+  hashParamTable[40].ref = &device.controller.SSP.out[1];
+  hashParamTable[40].size = sizeof(device.controller.SSP.out[1]);
+  hashParamTable[41].hash = 0x62a7cc86;
+  hashParamTable[41].ref = &device.controller.I2C.state.buffer[1];
+  hashParamTable[41].size = sizeof(device.controller.I2C.state.buffer[1]);
+  hashParamTable[42].hash = 0x634b9e76;
+  hashParamTable[42].ref = &device.isacs.regulator.settings.start.scale;
+  hashParamTable[42].size = sizeof(device.isacs.regulator.settings.start.scale);
+  hashParamTable[43].hash = 0x635b8d69;
+  hashParamTable[43].ref = &device.controller.I2C.settings.trigger;
+  hashParamTable[43].size = sizeof(device.controller.I2C.settings.trigger);
+  hashParamTable[44].hash = 0x664c6cbe;
+  hashParamTable[44].ref = &device.controller.timer[0].state.TCR;
+  hashParamTable[44].size = sizeof(device.controller.timer[0].state.TCR);
+  hashParamTable[45].hash = 0x667be78f;
+  hashParamTable[45].ref = &device.dac.state.out[1];
+  hashParamTable[45].size = sizeof(device.dac.state.out[1]);
+  hashParamTable[46].hash = 0x674eeb85;
+  hashParamTable[46].ref = &device.controller.uart[0].state.DLL;
+  hashParamTable[46].size = sizeof(device.controller.uart[0].state.DLL);
+  hashParamTable[47].hash = 0x6771d50;
+  hashParamTable[47].ref = &device.lightUp.settings.sequence;
+  hashParamTable[47].size = sizeof(device.lightUp.settings.sequence);
+  hashParamTable[48].hash = 0x688f56ab;
+  hashParamTable[48].ref = &device.isacs.regulator.state.scale;
+  hashParamTable[48].size = sizeof(device.isacs.regulator.state.scale);
+  hashParamTable[49].hash = 0x68ed9659;
+  hashParamTable[49].ref = &device.plcs.reset.settings.heating.level.center;
+  hashParamTable[49].size = sizeof(device.plcs.reset.settings.heating.level.center);
+  hashParamTable[50].hash = 0x6cb0982;
+  hashParamTable[50].ref = &device.controller.I2C.state.buffer[5];
+  hashParamTable[50].size = sizeof(device.controller.I2C.state.buffer[5]);
+  hashParamTable[51].hash = 0x712f5803;
+  hashParamTable[51].ref = &device.plcs.regulator.settings.scale;
+  hashParamTable[51].size = sizeof(device.plcs.regulator.settings.scale);
+  hashParamTable[52].hash = 0x749c63a6;
+  hashParamTable[52].ref = &device.isacs.potentiometers.state.a;
+  hashParamTable[52].size = sizeof(device.isacs.potentiometers.state.a);
+  hashParamTable[53].hash = 0x74b19550;
+  hashParamTable[53].ref = &device.dither.cycle.state.pin1;
+  hashParamTable[53].size = sizeof(device.dither.cycle.state.pin1);
+  hashParamTable[54].hash = 0x75bbf441;
+  hashParamTable[54].ref = &device.controller.timer[0].state.MCR;
+  hashParamTable[54].size = sizeof(device.controller.timer[0].state.MCR);
+  hashParamTable[55].hash = 0x7b92b7f4;
+  hashParamTable[55].ref = &device.dither.oscillation.state.error;
+  hashParamTable[55].size = sizeof(device.dither.oscillation.state.error);
+  hashParamTable[56].hash = 0x7bbcfdc7;
+  hashParamTable[56].ref = &device.controller.I2C.state.buffer[0];
+  hashParamTable[56].size = sizeof(device.controller.I2C.state.buffer[0]);
+  hashParamTable[57].hash = 0x7d95c657;
+  hashParamTable[57].ref = &device.isacs.potentiometers.settings.a;
+  hashParamTable[57].size = sizeof(device.isacs.potentiometers.settings.a);
+  hashParamTable[58].hash = 0x7f60d6ce;
+  hashParamTable[58].ref = &device.dac.state.out[0];
+  hashParamTable[58].size = sizeof(device.dac.state.out[0]);
+  hashParamTable[59].hash = 0x8208e177;
+  hashParamTable[59].ref = &device.plcs.regulator.settings.enabled;
+  hashParamTable[59].size = sizeof(device.plcs.regulator.settings.enabled);
+  hashParamTable[60].hash = 0x82aa732b;
+  hashParamTable[60].ref = &device.dither.pulse.state.rise;
+  hashParamTable[60].size = sizeof(device.dither.pulse.state.rise);
+  hashParamTable[61].hash = 0x82f85228;
+  hashParamTable[61].ref = &device.controller.uart[1].state.FCR;
+  hashParamTable[61].size = sizeof(device.controller.uart[1].state.FCR);
+  hashParamTable[62].hash = 0x83843183;
+  hashParamTable[62].ref = &device.user.address;
+  hashParamTable[62].size = sizeof(device.user.address);
+  hashParamTable[63].hash = 0x8529eb8c;
+  hashParamTable[63].ref = &device.dither.detector.settings.weight[11];
+  hashParamTable[63].size = sizeof(device.dither.detector.settings.weight[11]);
+  hashParamTable[64].hash = 0x852a1097;
+  hashParamTable[64].ref = &device.dither.detector.settings.weight[0];
+  hashParamTable[64].size = sizeof(device.dither.detector.settings.weight[0]);
+  hashParamTable[65].hash = 0x85ded725;
+  hashParamTable[65].ref = &device.controller.timer[0].state.MR0;
+  hashParamTable[65].size = sizeof(device.controller.timer[0].state.MR0);
+  hashParamTable[66].hash = 0x86ad3fe2;
+  hashParamTable[66].ref = &device.dither.detector.settings.weight[31];
+  hashParamTable[66].size = sizeof(device.dither.detector.settings.weight[31]);
+  hashParamTable[67].hash = 0x871249a3;
+  hashParamTable[67].ref = &device.controller.SSP.in[0];
+  hashParamTable[67].size = sizeof(device.controller.SSP.in[0]);
+  hashParamTable[68].hash = 0x876f55d5;
+  hashParamTable[68].ref = &device.dither.detector.settings.weight[21];
+  hashParamTable[68].size = sizeof(device.dither.detector.settings.weight[21]);
+  hashParamTable[69].hash = 0x88226cfe;
+  hashParamTable[69].ref = &device.dither.detector.state.error;
+  hashParamTable[69].size = sizeof(device.dither.detector.state.error);
+  hashParamTable[70].hash = 0x8997b45f;
+  hashParamTable[70].ref = &device.plcs.modulator.state.enabled;
+  hashParamTable[70].size = sizeof(device.plcs.modulator.state.enabled);
+  hashParamTable[71].hash = 0x8ad9720d;
+  hashParamTable[71].ref = &device.plcs.reset.settings.heating.delay.slope;
+  hashParamTable[71].size = sizeof(device.plcs.reset.settings.heating.delay.slope);
+  hashParamTable[72].hash = 0x8bec977c;
+  hashParamTable[72].ref = &device.controller.uart[1].state.DLM;
+  hashParamTable[72].size = sizeof(device.controller.uart[1].state.DLM);
+  hashParamTable[73].hash = 0x8f6fd7fe;
+  hashParamTable[73].ref = &device.controller.uart[1].state.LCR;
+  hashParamTable[73].size = sizeof(device.controller.uart[1].state.LCR);
+  hashParamTable[74].hash = 0x9020a8a4;
+  hashParamTable[74].ref = &device.dither.pulse.settings.rise;
+  hashParamTable[74].size = sizeof(device.dither.pulse.settings.rise);
+  hashParamTable[75].hash = 0x90d1dba3;
+  hashParamTable[75].ref = &device.plcs.reset.settings.cooling.delay.center;
+  hashParamTable[75].size = sizeof(device.plcs.reset.settings.cooling.delay.center);
+  hashParamTable[76].hash = 0x94360535;
+  hashParamTable[76].ref = &device.isacs.regulator.state.reference;
+  hashParamTable[76].size = sizeof(device.isacs.regulator.state.reference);
+  hashParamTable[77].hash = 0x958ecda;
+  hashParamTable[77].ref = &device.dither.oscillation.state.enabled;
+  hashParamTable[77].size = sizeof(device.dither.oscillation.state.enabled);
+  hashParamTable[78].hash = 0x96d795b;
+  hashParamTable[78].ref = &device.isacs.regulator.settings.reset.reference;
+  hashParamTable[78].size = sizeof(device.isacs.regulator.settings.reset.reference);
+  hashParamTable[79].hash = 0x97dea178;
+  hashParamTable[79].ref = &device.controller.QEI.state.position;
+  hashParamTable[79].size = sizeof(device.controller.QEI.state.position);
+  hashParamTable[80].hash = 0x9949353e;
+  hashParamTable[80].ref = &device.dither.carrier.state.scale;
+  hashParamTable[80].size = sizeof(device.dither.carrier.state.scale);
+  hashParamTable[81].hash = 0x9ae15d5f;
+  hashParamTable[81].ref = &device.dither.carrier.settings.enabled;
+  hashParamTable[81].size = sizeof(device.dither.carrier.settings.enabled);
+  hashParamTable[82].hash = 0x9c3121d6;
+  hashParamTable[82].ref = &device.dither.detector.settings.weight[1];
+  hashParamTable[82].size = sizeof(device.dither.detector.settings.weight[1]);
+  hashParamTable[83].hash = 0x9c32dacd;
+  hashParamTable[83].ref = &device.dither.detector.settings.weight[10];
+  hashParamTable[83].size = sizeof(device.dither.detector.settings.weight[10]);
+  hashParamTable[84].hash = 0x9e0978e2;
+  hashParamTable[84].ref = &device.controller.SSP.in[1];
+  hashParamTable[84].size = sizeof(device.controller.SSP.in[1]);
+  hashParamTable[85].hash = 0x9e746494;
+  hashParamTable[85].ref = &device.dither.detector.settings.weight[20];
+  hashParamTable[85].size = sizeof(device.dither.detector.settings.weight[20]);
+  hashParamTable[86].hash = 0x9ee1f9a5;
+  hashParamTable[86].ref = &device.isacs.regulator.settings.reset.scale;
+  hashParamTable[86].size = sizeof(device.isacs.regulator.settings.reset.scale);
+  hashParamTable[87].hash = 0x9ef65be2;
+  hashParamTable[87].ref = &device.controller.chip;
+  hashParamTable[87].size = sizeof(device.controller.chip);
+  hashParamTable[88].hash = 0x9fb60ea3;
+  hashParamTable[88].ref = &device.dither.detector.settings.weight[30];
+  hashParamTable[88].size = sizeof(device.dither.detector.settings.weight[30]);
+  hashParamTable[89].hash = 0xa08ff954;
+  hashParamTable[89].ref = &device.plcs.amplifier.settings.reference;
+  hashParamTable[89].size = sizeof(device.plcs.amplifier.settings.reference);
+  hashParamTable[90].hash = 0xa454a98f;
+  hashParamTable[90].ref = &device.dither.oscillation.settings.scale;
+  hashParamTable[90].size = sizeof(device.dither.oscillation.settings.scale);
+  hashParamTable[91].hash = 0xa80ee333;
+  hashParamTable[91].ref = &device.lightUp.state.sequence;
+  hashParamTable[91].size = sizeof(device.lightUp.state.sequence);
+  hashParamTable[92].hash = 0xa9dc4138;
+  hashParamTable[92].ref = &device.dac.settings.out[1];
+  hashParamTable[92].size = sizeof(device.dac.settings.out[1]);
+  hashParamTable[93].hash = 0xac3f1a60;
+  hashParamTable[93].ref = &device.controller.SSP.in[3];
+  hashParamTable[93].size = sizeof(device.controller.SSP.in[3]);
+  hashParamTable[94].hash = 0xac420616;
+  hashParamTable[94].ref = &device.dither.detector.settings.weight[22];
+  hashParamTable[94].size = sizeof(device.dither.detector.settings.weight[22]);
+  hashParamTable[95].hash = 0xae04b84f;
+  hashParamTable[95].ref = &device.dither.detector.settings.weight[12];
+  hashParamTable[95].size = sizeof(device.dither.detector.settings.weight[12]);
+  hashParamTable[96].hash = 0xae074354;
+  hashParamTable[96].ref = &device.dither.detector.settings.weight[3];
+  hashParamTable[96].size = sizeof(device.dither.detector.settings.weight[3]);
+  hashParamTable[97].hash = 0xaec845d3;
+  hashParamTable[97].ref = &device.dac.state.code[0];
+  hashParamTable[97].size = sizeof(device.dac.state.code[0]);
+  hashParamTable[98].hash = 0xb0c77079;
+  hashParamTable[98].ref = &device.dac.settings.out[0];
+  hashParamTable[98].size = sizeof(device.dac.settings.out[0]);
+  hashParamTable[99].hash = 0xb5188450;
+  hashParamTable[99].ref = &device.controller.timer[0].settings.match;
+  hashParamTable[99].size = sizeof(device.controller.timer[0].settings.match);
+  hashParamTable[100].hash = 0xb5242b21;
+  hashParamTable[100].ref = &device.controller.SSP.in[2];
+  hashParamTable[100].size = sizeof(device.controller.SSP.in[2]);
+  hashParamTable[101].hash = 0xb5593757;
+  hashParamTable[101].ref = &device.dither.detector.settings.weight[23];
+  hashParamTable[101].size = sizeof(device.dither.detector.settings.weight[23]);
+  hashParamTable[102].hash = 0xb71c7215;
+  hashParamTable[102].ref = &device.dither.detector.settings.weight[2];
+  hashParamTable[102].size = sizeof(device.dither.detector.settings.weight[2]);
+  hashParamTable[103].hash = 0xb71f890e;
+  hashParamTable[103].ref = &device.dither.detector.settings.weight[13];
+  hashParamTable[103].size = sizeof(device.dither.detector.settings.weight[13]);
+  hashParamTable[104].hash = 0xb7d37492;
+  hashParamTable[104].ref = &device.dac.state.code[1];
+  hashParamTable[104].size = sizeof(device.dac.state.code[1]);
+  hashParamTable[105].hash = 0xb858e634;
+  hashParamTable[105].ref = &device.plcs.reset.settings.heating.level.slope;
+  hashParamTable[105].size = sizeof(device.plcs.reset.settings.heating.level.slope);
+  hashParamTable[106].hash = 0xb90338b5;
+  hashParamTable[106].ref = &device.dither.oscillation.state.reference;
+  hashParamTable[106].size = sizeof(device.dither.oscillation.state.reference);
+  hashParamTable[107].hash = 0xbcfa14ae;
+  hashParamTable[107].ref = &device.controller.uart[1].settings.baudRate;
+  hashParamTable[107].size = sizeof(device.controller.uart[1].settings.baudRate);
+  hashParamTable[108].hash = 0xbd22c6cf;
+  hashParamTable[108].ref = &device.plcs.regulator.state.error;
+  hashParamTable[108].size = sizeof(device.plcs.regulator.state.error);
+  hashParamTable[109].hash = 0xc38048cc;
+  hashParamTable[109].ref = &device.controller.I2C.state.counter;
+  hashParamTable[109].size = sizeof(device.controller.I2C.state.counter);
+  hashParamTable[110].hash = 0xc6d70a1e;
+  hashParamTable[110].ref = &device.isacs.regulator.settings.regular.reference;
+  hashParamTable[110].size = sizeof(device.isacs.regulator.settings.regular.reference);
+  hashParamTable[111].hash = 0xc82ec312;
+  hashParamTable[111].ref = &device.dither.detector.settings.weight[26];
+  hashParamTable[111].size = sizeof(device.dither.detector.settings.weight[26]);
+  hashParamTable[112].hash = 0xca092e01;
+  hashParamTable[112].ref = &device.dither.oscillation.state.scale;
+  hashParamTable[112].size = sizeof(device.dither.oscillation.state.scale);
+  hashParamTable[113].hash = 0xca687d4b;
+  hashParamTable[113].ref = &device.dither.detector.settings.weight[16];
+  hashParamTable[113].size = sizeof(device.dither.detector.settings.weight[16]);
+  hashParamTable[114].hash = 0xca6b8650;
+  hashParamTable[114].ref = &device.dither.detector.settings.weight[7];
+  hashParamTable[114].size = sizeof(device.dither.detector.settings.weight[7]);
+  hashParamTable[115].hash = 0xcb95f3a;
+  hashParamTable[115].ref = &device.plcs.regulator.state.scale;
+  hashParamTable[115].size = sizeof(device.plcs.regulator.state.scale);
+  hashParamTable[116].hash = 0xceb6a575;
+  hashParamTable[116].ref = &device.plcs.reset.state.level;
+  hashParamTable[116].size = sizeof(device.plcs.reset.state.level);
+  hashParamTable[117].hash = 0xcfc8a2e9;
+  hashParamTable[117].ref = &device.lightUp.state.enabled;
+  hashParamTable[117].size = sizeof(device.lightUp.state.enabled);
+  hashParamTable[118].hash = 0xcfe6d23f;
+  hashParamTable[118].ref = &device.plcs.reset.settings.cooling.level.center;
+  hashParamTable[118].size = sizeof(device.plcs.reset.settings.cooling.level.center);
+  hashParamTable[119].hash = 0xd135f253;
+  hashParamTable[119].ref = &device.dither.detector.settings.weight[27];
+  hashParamTable[119].size = sizeof(device.dither.detector.settings.weight[27]);
+  hashParamTable[120].hash = 0xd14fa026;
+  hashParamTable[120].ref = &device.controller.flash.settings.dataSector;
+  hashParamTable[120].size = sizeof(device.controller.flash.settings.dataSector);
+  hashParamTable[121].hash = 0xd370b711;
+  hashParamTable[121].ref = &device.dither.detector.settings.weight[6];
+  hashParamTable[121].size = sizeof(device.dither.detector.settings.weight[6]);
+  hashParamTable[122].hash = 0xd3734c0a;
+  hashParamTable[122].ref = &device.dither.detector.settings.weight[17];
+  hashParamTable[122].size = sizeof(device.dither.detector.settings.weight[17]);
+  hashParamTable[123].hash = 0xd43ae1d0;
+  hashParamTable[123].ref = &device.plcs.reset.settings.cooling.level.slope;
+  hashParamTable[123].size = sizeof(device.plcs.reset.settings.cooling.level.slope);
+  hashParamTable[124].hash = 0xd914cf5e;
+  hashParamTable[124].ref = &device.isacs.regulator.state.error;
+  hashParamTable[124].size = sizeof(device.isacs.regulator.state.error);
+  hashParamTable[125].hash = 0xd99d2fe8;
+  hashParamTable[125].ref = &device.controller.uart[0].settings.baudRate;
+  hashParamTable[125].size = sizeof(device.controller.uart[0].settings.baudRate);
+  hashParamTable[126].hash = 0xdbe35c4a;
+  hashParamTable[126].ref = &device.dither.carrier.state.enabled;
+  hashParamTable[126].size = sizeof(device.dither.carrier.state.enabled);
+  hashParamTable[127].hash = 0xdbefbf30;
+  hashParamTable[127].ref = &device.dither.noise.settings.period;
+  hashParamTable[127].size = sizeof(device.dither.noise.settings.period);
+  hashParamTable[128].hash = 0xdc1b0dfc;
+  hashParamTable[128].ref = &device.plcs.regulator.settings.reference;
+  hashParamTable[128].size = sizeof(device.plcs.regulator.settings.reference);
+  hashParamTable[129].hash = 0xdf8421c1;
+  hashParamTable[129].ref = &device.dither.oscillation.settings.enabled;
+  hashParamTable[129].size = sizeof(device.dither.oscillation.settings.enabled);
+  hashParamTable[130].hash = 0xe01715be;
+  hashParamTable[130].ref = &device.dac.settings.unit;
+  hashParamTable[130].size = sizeof(device.dac.settings.unit);
+  hashParamTable[131].hash = 0xe1452e88;
+  hashParamTable[131].ref = &device.dither.detector.settings.weight[15];
+  hashParamTable[131].size = sizeof(device.dither.detector.settings.weight[15]);
+  hashParamTable[132].hash = 0xe146d593;
+  hashParamTable[132].ref = &device.dither.detector.settings.weight[4];
+  hashParamTable[132].size = sizeof(device.dither.detector.settings.weight[4]);
+  hashParamTable[133].hash = 0xe219f51b;
+  hashParamTable[133].ref = &device.dac.settings.code[1];
+  hashParamTable[133].size = sizeof(device.dac.settings.code[1]);
+  hashParamTable[134].hash = 0xe30390d1;
+  hashParamTable[134].ref = &device.dither.detector.settings.weight[25];
+  hashParamTable[134].size = sizeof(device.dither.detector.settings.weight[25]);
+  hashParamTable[135].hash = 0xe37e8ca7;
+  hashParamTable[135].ref = &device.controller.SSP.in[4];
+  hashParamTable[135].size = sizeof(device.controller.SSP.in[4]);
+  hashParamTable[136].hash = 0xe49c97ed;
+  hashParamTable[136].ref = &device.isacs.potentiometers.settings.b;
+  hashParamTable[136].size = sizeof(device.isacs.potentiometers.settings.b);
+  hashParamTable[137].hash = 0xe6bb75e9;
+  hashParamTable[137].ref = &device.plcs.reset.settings.cooling.delay.slope;
+  hashParamTable[137].size = sizeof(device.plcs.reset.settings.cooling.delay.slope);
+  hashParamTable[138].hash = 0xe6c6e9fd;
+  hashParamTable[138].ref = &device.plcs.reset.state.delay;
+  hashParamTable[138].size = sizeof(device.plcs.reset.state.delay);
+  hashParamTable[139].hash = 0xe7445461;
+  hashParamTable[139].ref = &device.dither.pulse.state.fall;
+  hashParamTable[139].size = sizeof(device.dither.pulse.state.fall);
+  hashParamTable[140].hash = 0xe7f0684b;
+  hashParamTable[140].ref = &device.isacs.regulator.settings.start.reference;
+  hashParamTable[140].size = sizeof(device.isacs.regulator.settings.start.reference);
+  hashParamTable[141].hash = 0xeae5bf6a;
+  hashParamTable[141].ref = &device.controller.I2C.state.CON0;
+  hashParamTable[141].size = sizeof(device.controller.I2C.state.CON0);
+  hashParamTable[142].hash = 0xed95321c;
+  hashParamTable[142].ref = &device.isacs.potentiometers.state.b;
+  hashParamTable[142].size = sizeof(device.isacs.potentiometers.state.b);
+  hashParamTable[143].hash = 0xedb8c4ea;
+  hashParamTable[143].ref = &device.dither.cycle.state.pin2;
+  hashParamTable[143].size = sizeof(device.dither.cycle.state.pin2);
+  hashParamTable[144].hash = 0xf49a6f2b;
+  hashParamTable[144].ref = &device.dither.detector.settings.offset;
+  hashParamTable[144].size = sizeof(device.dither.detector.settings.offset);
+  hashParamTable[145].hash = 0xf5ce8fee;
+  hashParamTable[145].ref = &device.dither.pulse.settings.fall;
+  hashParamTable[145].size = sizeof(device.dither.pulse.settings.fall);
+  hashParamTable[146].hash = 0xf5e09bfe;
+  hashParamTable[146].ref = &device.dither.oscillation.settings.reference;
+  hashParamTable[146].size = sizeof(device.dither.oscillation.settings.reference);
+  hashParamTable[147].hash = 0xf85de4d2;
+  hashParamTable[147].ref = &device.dither.detector.settings.weight[5];
+  hashParamTable[147].size = sizeof(device.dither.detector.settings.weight[5]);
+  hashParamTable[148].hash = 0xf85e1fc9;
+  hashParamTable[148].ref = &device.dither.detector.settings.weight[14];
+  hashParamTable[148].size = sizeof(device.dither.detector.settings.weight[14]);
+  hashParamTable[149].hash = 0xfa18a190;
+  hashParamTable[149].ref = &device.dither.detector.settings.weight[24];
+  hashParamTable[149].size = sizeof(device.dither.detector.settings.weight[24]);
+  hashParamTable[150].hash = 0xfb02c45a;
+  hashParamTable[150].ref = &device.dac.settings.code[0];
+  hashParamTable[150].size = sizeof(device.dac.settings.code[0]);
+  hashParamTable[151].hash = 0xfc0531d4;
+  hashParamTable[151].ref = &device.controller.QEI.state.delta;
+  hashParamTable[151].size = sizeof(device.controller.QEI.state.delta);
+  hashParamTable[152].hash = 0xfceba7ea;
+  hashParamTable[152].ref = &device.controller.uart[1].state.DLL;
+  hashParamTable[152].size = sizeof(device.controller.uart[1].state.DLL);
+}
+
+void InitHashFuncTable(void) {
+  hashFuncTable[0].hash = 0x71f16e12;
+  hashFuncTable[0].ref = DeviceFlashWriteAll;
+  hashFuncTable[0].resultSize = sizeof(void);
+  hashFuncTable[0].paramCount = 0;
+  hashFuncTable[1].hash = 0xd84a94cf;
+  hashFuncTable[1].ref = DeviceFlashReadAll;
+  hashFuncTable[1].resultSize = sizeof(void);
+  hashFuncTable[1].paramCount = 0;
+  hashFuncTable[2].hash = 0xd93b80f4;
+  hashFuncTable[2].ref = DeviceStartLightUp;
+  hashFuncTable[2].resultSize = sizeof(void);
+  hashFuncTable[2].paramCount = 0;
+}
\ No newline at end of file