Attempt to add ADC calib to flash, pops correctly from shared memory, but not after arduino power cycle.

Author: markzakharyan

m4/src/Peripherals/ADC/ADCBoard.h

@@ -73,7 +73,7 @@ class ADCBoard {
   int cs_pin;
   int data_ready_pin;
   int reset_pin;
-  int conversion_times[NUM_CHANNELS_PER_ADC_BOARD];
+  int board_idx;
   PeripheralCommsController commsController;
 
   void waitDataReady() {
@@ -90,8 +90,8 @@ class ADCBoard {
  public:
   bool data_ready = false;
 
-  ADCBoard(int cs_pin, int data_ready_pin, int reset_pin)
-      : cs_pin(cs_pin), data_ready_pin(data_ready_pin), reset_pin(reset_pin), commsController(cs_pin) {}
+  ADCBoard(int cs_pin, int data_ready_pin, int reset_pin, int board_idx )
+      : cs_pin(cs_pin), data_ready_pin(data_ready_pin), reset_pin(reset_pin), board_idx(board_idx), commsController(cs_pin) {}
 
   void setup() {
     pinMode(reset_pin, OUTPUT);
@@ -173,6 +173,11 @@ class ADCBoard {
     uint32_t zeroScaleCalibrations[NUM_CHANNELS_PER_ADC_BOARD];
     uint32_t fullScaleCalibrations[NUM_CHANNELS_PER_ADC_BOARD];
 
+    float conversion_times[NUM_CHANNELS_PER_ADC_BOARD];
+    for (int i = 0; i < NUM_CHANNELS_PER_ADC_BOARD; i++) {
+      conversion_times[i] = getConversionTime(i); 
+    }
+
     for(int i = 0; i<NUM_CHANNELS_PER_ADC_BOARD; i++) {
       zeroScaleCalibrations[i] = getZeroScaleCalibration(i);
       fullScaleCalibrations[i] = getFullScaleCalibration(i);
@@ -190,6 +195,7 @@ class ADCBoard {
   }
 
   int getDataReadyPin() const { return data_ready_pin; }
+  int getBoardIndex() const { return board_idx; }
 
   void setReadyFlag() { data_ready = true; }
   void clearReadyFlag() { data_ready = false; }
@@ -353,6 +359,28 @@ class ADCBoard {
     return (status & (1 << adc_channel)) != 0;
   }
 
+  void hardReset() {
+    digitalWrite(reset_pin, HIGH);
+    digitalWrite(reset_pin, LOW);
+    delay(5);
+    digitalWrite(reset_pin, HIGH);
+
+    for (int i = 0; i < NUM_CHANNELS_PER_ADC_BOARD; i++) {
+      idleMode(i);
+    }
+  }
+
+  void restoreCalibrationFromFlash() {
+    CalibrationData data;
+    m4ReceiveCalibrationData(data);
+    int boardIndex = getBoardIndex();
+
+    for (int i = 0; i < NUM_CHANNELS_PER_ADC_BOARD; i++) {
+      setZeroScaleCalibration(i, data.adc_offset[NUM_CHANNELS_PER_ADC_BOARD * boardIndex + i]);
+      setFullScaleCalibration(i, data.adc_gain[NUM_CHANNELS_PER_ADC_BOARD * boardIndex + i]);
+    }
+  }
+
   void reset() {
     digitalWrite(reset_pin, HIGH);
     digitalWrite(reset_pin, LOW);
@@ -372,6 +400,8 @@ class ADCBoard {
     data[0] = WRITE | ADDR_IO;
     data[1] = 0b00010001;
     commsController.transferADC(data, 2);
+
+    restoreCalibrationFromFlash();
   }
 
   uint8_t talkADC(byte command) {
@@ -412,8 +442,6 @@ class ADCBoard {
     // could've done the calculation with user-given values but it's good to check
     float time_us = getConversionTime(channel, moreThanOneChannelActive);
 
-    conversion_times[channel] = time_us;
-
     delayMicroseconds(100);
 
     return time_us;
@@ -503,6 +531,17 @@ class ADCBoard {
     #endif
     commsController.transferADC(data, 2);
     waitDataReady();
+
+    // wait for the data ready flag to be set then store the calibration data in flash 
+    int boardIndex = getBoardIndex();
+
+    uint32_t zeroScaleCalibration = getZeroScaleCalibration(channel);
+
+    CalibrationData calibrationData;
+    m4ReceiveCalibrationData(calibrationData);
+    calibrationData.adc_offset[NUM_CHANNELS_PER_ADC_BOARD * boardIndex + channel] = zeroScaleCalibration;
+    m4SendCalibrationData(calibrationData);
+    
   }
 
   void fullScaleChannelSystemSelfCalibration(int channel) {
@@ -514,6 +553,16 @@ class ADCBoard {
     #endif
     commsController.transferADC(data, 2);
     waitDataReady();
+
+    // wait for the data ready flag to be set then store the calibration data in flash
+    int boardIndex = getBoardIndex();
+
+    uint32_t fullScaleCalibration = getFullScaleCalibration(channel);
+
+    CalibrationData calibrationData;
+    m4ReceiveCalibrationData(calibrationData);
+    calibrationData.adc_gain[NUM_CHANNELS_PER_ADC_BOARD * boardIndex + channel] = fullScaleCalibration;
+    m4SendCalibrationData(calibrationData);
   }
 };
 

m4/src/Peripherals/ADC/ADCController.h

@@ -71,11 +71,12 @@ class ADCController {
     registerMemberFunction(setChZeroScaleCalibration, "SET_ZERO_SCALE_CAL");
     registerMemberFunction(setChFullScaleCalibration, "SET_FULL_SCALE_CAL");
     registerMemberFunction(resetToPreviousConversionTimesSerial,"RESET_MAINTAIN");
+    registerMemberFunction(hardResetAllADCBoards, "HARD_RESET");
   }
 
   inline static void addBoard(int cs_pin, int data_ready,
-                              int reset_pin) {
-    ADCBoard newBoard = ADCBoard(cs_pin, data_ready, reset_pin);
+                              int reset_pin, int board_idx) {
+    ADCBoard newBoard = ADCBoard(cs_pin, data_ready, reset_pin, board_idx);
     adc_boards.push_back(newBoard);
   }
 
@@ -249,6 +250,20 @@ class ADCController {
     return result.substring(0, result.length() - 1);
   }
 
+  inline static OperationResult hardResetAllADCBoards() {
+    for (auto& board : adc_boards) {
+      board.hardReset();
+    }
+    
+    // Tell system is not calibrated
+    CalibrationData data;
+    m4ReceiveCalibrationData(data);
+    data.adcCalibrated = false;
+    m4SendCalibrationData(data);
+
+    return OperationResult::Success("All ADC boards have been hard reset");
+  }
+
   inline static OperationResult resetAllADCBoards() {
     for (auto board : adc_boards) {
       board.reset();
@@ -289,7 +304,7 @@ class ADCController {
     return OperationResult::Success("CALIBRATION_FINISHED");
   }
 
-  static OperationResult setConversionTime(int adc_channel, int time_us) {
+  static OperationResult setConversionTime(int adc_channel, float time_us) {
     if (!isChannelIndexValid(adc_channel)) {
       return OperationResult::Failure("Invalid channel index");
     }

m4/src/Peripherals/God.h

@@ -139,8 +139,7 @@ class God {
 
     // Attach interrupts for each ADC board's data ready pin
     for (int i = 0; i < numAdcBoards; i++) {
-      uint8_t boardIndex = adcBoards[i];
-      attachInterrupt(digitalPinToInterrupt(ADCController::getDataReadyPin(boardIndex)), isrFunctions[boardIndex], FALLING);
+      attachInterrupt(digitalPinToInterrupt(ADCController::getDataReadyPin(adcBoards[i])), isrFunctions[i], FALLING);
     }
     #endif
 

m4/src/UserIOHandler.h

@@ -40,7 +40,7 @@ struct UserIOHandler {
   // I HIGHLY recommend using the following format: __SERIAL_NUMBER__ {2 characters representing the instrument} {4 digits for the year} {3 characters for the device ID}
   // The serial number ideally should be set to a default value here and then changed post-compile time using the firmware_uploader.py or patch_serial_number.py scripts.
   __attribute__((section(".serial_number")))
-  inline static const char serial_number[29] = "__SERIAL_NUMBER__DA_2025_ABC";
+  inline static const char serial_number[29] = "__SERIAL_NUMBER__DA_2025_001";
 
   static OperationResult serialNumber() {
     return OperationResult::Success(serial_number + 17);

m4/src/Utils/CalibrationData.h

@@ -3,4 +3,8 @@
 struct CalibrationData {
   float gain[16];
   float offset[16];
+
+  bool adcCalibrated = false;
+  uint32_t adc_offset[16];
+  uint32_t adc_gain[16];
 };

m4/src/Utils/TimingUtil.h

@@ -115,21 +115,34 @@ struct TimingUtil {
     TIM8->CR1 |= TIM_CR1_CEN;
   }
 
-  inline static void setupTimersTimeSeries(uint32_t dac_period_us,
-                                           uint32_t adc_period_us) {
+  inline static void setupTimersTimeSeries(uint32_t dac_period_us, uint32_t adc_period_us) {
+    //******************************************************************/
+    // setupTimersTimeSeries takes in two periods in microseconds and 
+    // setups two individual timers to trigger interrupts based on their 
+    // respective counter over flow.  The two timers run indpendent of
+    // each other, but are synchronized to the same clock source.
+    // The first timer (TIM1) is used for DAC updates, and the second timer
+    // (TIM8) is used for ADC sampling. 
+    //******************************************************************/
     resetTimers();
 
     // Enable TIM1 and TIM8 clocks
    __HAL_RCC_TIM1_CLK_ENABLE();
     __HAL_RCC_TIM8_CLK_ENABLE();
 
+    // Get the timer clock frequency
     uint64_t timerClock = 2 * HAL_RCC_GetPCLK2Freq();
 
+    // Calculate total timer ticks for the desired periods (in µs)
     uint64_t total_ticks_dac = (dac_period_us * timerClock) / 1000000;
 
     uint16_t psc_dac;
     uint16_t arr_dac;
 
+    // Determine prescaler and 16-bit auto-reload value for TIM1 (DAC)
+    // If total_ticks_dac is less than or equal to 65536, no prescaling is needed and we can use the full 16-bit resolution of the timer.
+    // Otherwise, we need to compute the minimal prescaler (clock division = (PSC+1)) so that ARR <= 65535 and adjust the ARR value accordingly.
+    
     if (total_ticks_dac <= 65536) {
         psc_dac = 0;                // No prescaling
         arr_dac = total_ticks_dac - 1;    // Full resolution within 16 bits
@@ -140,6 +153,7 @@ struct TimingUtil {
         arr_dac = (total_ticks_dac / prescaler_dac) - 1;  // ARR counts from 0 to ARR, hence subtract 1
     }
 
+    // Determine prescaler and 16-bit auto-reload value for TIM8 (ADC)
     uint64_t total_ticks_adc = (adc_period_us * timerClock) / 1000000;
 
     uint16_t psc_adc;
@@ -161,21 +175,19 @@ struct TimingUtil {
     TIM1->CR1 = TIM_CR1_ARPE;
     TIM1->DIER |= TIM_DIER_UIE;
 
+    // Clear update interrupt flag and enable update event generation flags for TIM1
     TIM1->EGR |= 0x01;
     TIM1->SR &= ~TIM_SR_UIF;
-    TIM1->EGR |= 0x02;
-    TIM1->CCR1 &= ~TIM_SR_CC1IF;
 
     // Configure TIM8
     TIM8->PSC = psc_adc;
     TIM8->ARR = arr_adc;
     TIM8->CR1 = TIM_CR1_ARPE;
     TIM8->DIER |= TIM_DIER_UIE;
 
+    // Clear update interrupt flag and enable update event generation flags for TIM8
     TIM8->EGR |= 0x01;
     TIM8->SR &= ~TIM_SR_UIF;
-    TIM8->EGR |= 0x02;
-    TIM8->CCR1 &= ~TIM_SR_CC1IF;
 
     // Enable interrupts
     NVIC_SetPriority(TIM1_UP_IRQn, 2);
@@ -252,15 +264,21 @@ struct TimingUtil {
       // No phase shift: use the update interrupt for ADC triggering.
       TIM8->DIER |= TIM_DIER_UIE;
     }
+    // Clear update interrupt flag and enable update event generation flags for TIM1
     TIM1->EGR |= 0x01;
     TIM1->SR &= ~TIM_SR_UIF;
     TIM1->EGR |= 0x02;
-    TIM1->CCR1 &= ~TIM_SR_CC1IF;
+    TIM1->SR &= ~TIM_SR_CC1IF;
+
+    //Clear update interrupt flag and enable update event generation flags for TIM8
+    TIM8->EGR |= 0x01;
+    TIM8->SR &= ~TIM_SR_UIF;
+    TIM8->EGR |= 0x02;
+    TIM8->SR &= ~TIM_SR_CC1IF;
 
     NVIC_SetPriority(TIM1_UP_IRQn, 2);
     NVIC_EnableIRQ(TIM1_UP_IRQn);
 
-
     NVIC_SetPriority(TIM8_CC_IRQn, 3);
     NVIC_EnableIRQ(TIM8_CC_IRQn);
 

m4/src/main.cpp

@@ -43,7 +43,7 @@ void setup() {
   }
 
   for (int i=0; i<NUM_ADC_BOARDS; i++) {
-    ADCController::addBoard(adc_cs_pins[i], drdy[i], reset[i]);
+    ADCController::addBoard(adc_cs_pins[i], drdy[i], reset[i], i);
   }
 
   DACController::setup();
@@ -67,9 +67,27 @@ void setup() {
     DACController::setCalibration(i, calibrationData.offset[i], calibrationData.gain[i]);
   }
 
-}
+  // Set calibrations for ADC
+  if (!calibrationData.adcCalibrated) {
+    // If ADC is not calibrated, reset ADC to all initial values
+    ADCController::hardResetAllADCBoards();
+    for (int i = 0; i < NUM_ADC_BOARDS * NUM_CHANNELS_PER_ADC_BOARD; i++) {
+      uint32_t zeroScaleCalibration = ADCController::getChZeroScaleCalibration(i).getMessage().toInt();
+      uint32_t fullScaleCalibration = ADCController::getChFullScaleCalibration(i).getMessage().toInt();
 
+      calibrationData.adc_offset[i] = zeroScaleCalibration;
+      calibrationData.adc_gain[i] = fullScaleCalibration;
 
+      calibrationData.adcCalibrated = true;
+    }
+    m4SendCalibrationData(calibrationData);
+  } else {
+    for (int i=0; i<NUM_ADC_BOARDS * NUM_CHANNELS_PER_ADC_BOARD; i++) {
+      ADCController::setChZeroScaleCalibration(i, calibrationData.adc_offset[i]);
+      ADCController::setChFullScaleCalibration(i, calibrationData.adc_gain[i]);
+    }
+  }
+}
 
 void loop() {
   UserIOHandler::handleUserIO();

m7/src/Utils/CalibrationData.h

@@ -3,4 +3,8 @@
 struct CalibrationData {
   float gain[16];
   float offset[16];
+
+  bool adcCalibrated = false; // Flag to indicate if ADC calibration is done
+  uint32_t adc_offset[16];
+  uint32_t adc_gain[16];
 };

m7/src/main.cpp

@@ -157,6 +157,9 @@ void setup()
     {
       calibrationData.gain[i] = 1.0f;
       calibrationData.offset[i] = 0.0f;
+      calibrationData.adc_offset[i] = 0x800000; // Default ADC offset
+      calibrationData.adc_gain[i] = 0x200000; // Default ADC gain
+      
     }
   }
   else