ALT Firmware

.vscode/.cortex-debug.peripherals.state.json

@@ -1 +1 @@
-[{"node":"FLASH","expanded":true,"format":0,"pinned":false}]
+[{"node":"FLASH","expanded":true,"format":0,"pinned":false},{"node":"FLASH.ACR","expanded":true,"format":0},{"node":"FLASH.KEYR","expanded":true,"format":0},{"node":"FLASH.SR","expanded":true,"format":0},{"node":"FLASH.OPTCR","expanded":true,"format":0}]

.vscode/c_cpp_properties.json

@@ -4,7 +4,8 @@
             "name": "Mac",
             "compilerPath": "/opt/homebrew/bin/arm-none-eabi-gcc",
             "defines": [
-                "USE_HAL_DRIVER"
+                "USE_HAL_DRIVER",
+                "STM32F446xx"
             ],
             "includePath": [
                 "${workspaceFolder}/API/*",
@@ -23,12 +24,13 @@
                 "${workspaceFolder}/Drivers/STM32F4xx_HAL_Driver/*",
                 "${workspaceFolder}/Drivers/STM32F4xx_HAL_Driver/Inc/*",
                 "${workspaceFolder}/Drivers/STM32F4xx_HAL_Driver/Src/*",
+                "${workspaceFolder}/Drivers/CMSIS/Device/ST/STM32F4xx/Include",
+                "${workspaceFolder}/Drivers/CMSIS/Device/ST/STM32F4xx/Source",
                 "${workspaceFolder}/middleware/FreeRTOS/Source/*",
                 "${workspaceFolder}/middleware/FreeRTOS/Source/portable/GCC/ARM_CM4F/*",
                 "${workspaceFolder}/middleware/FreeRTOS/Source/portable/MemMang/*",
                 "${workspaceFolder}/middleware/FreeRTOS/Source/CMSIS_RTOS_V2/*",
                 "${workspaceFolder}/middleware/FreeRTOS/Source/include/*",
-                "${workspaceFolder}/etl/include/**",
                 "${workspaceFolder}/ok-drivers/**",
                 "${workspaceFolder}/System/*",
                 "${workspaceFolder}/System/Inc/*",

.vscode/settings.json

@@ -68,6 +68,9 @@
         "forward_list": "cpp",
         "list": "cpp",
         "condition_variable": "cpp",
-        "mutex": "cpp"
+        "mutex": "cpp",
+        "ranges": "cpp",
+        "ranges": "cpp",
+        "span": "cpp"
     }
 }

API/Inc/Flash.h

@@ -69,14 +69,19 @@ class Flash {
     HAL_StatusTypeDef erase(uint32_t address);
 
     HAL_StatusTypeDef write(uint32_t address, uint32_t *data, int size);
+    void write(uint32_t address, uint32_t data);
+
+    void copySector(uint32_t sourceSector, uint32_t targetSector, uint32_t size);
 
     void read(uint32_t address, uint32_t *rxBuffer, int size);
+    uint32_t read_word(void *address);
 
     uint32_t getSector(uint32_t Address);
     bool validate(uint32_t *data, int size);
 
-private:
-    static Mutex _mutex;
     HAL_StatusTypeDef unlock(uint32_t sector);
     HAL_StatusTypeDef lock();
+
+  private:
+    static Mutex _mutex;
 };

API/Inc/SuperClock.h

@@ -10,7 +10,8 @@
 #define PPQN 96
 #endif
 
-#define PPQN_ERROR (PPQN - (PPQN / 6))
+#define PPQN_8th (PPQN / 2)
+#define PPQN_16th (PPQN / 4)
 
 #ifndef EXT_CLOCK_INPUT
 #define EXT_CLOCK_INPUT PA_3
@@ -29,15 +30,19 @@ class SuperClock {
 public:
 
     int pulse;              // the current PPQN
+    uint8_t step;           // current step. Will never exceed value of stepsPerBar
     uint16_t ticksPerStep;  // how many TIM2 ticks per one step / quarter note
     uint16_t ticksPerPulse; // how many TIM2 ticks for one PPQN
+    uint8_t stepsPerBar;    // value represents the number of quarter notes per bar (ie. 3/4, 4/4, 5/4, 6/4, 7/4)
     bool externalInputMode;
 
     Callback<void()> tickCallback;           // this callback gets executed at a frequency equal to tim1_freq
-    Callback<void()> input_capture_callback; // this callback gets executed every on the rising edge of external input
+    Callback<void()> barResetCallback;       // executes when clock.step exceeds the set time signature (ie. one bar)
+    Callback<void()> input_capture_callback; // this callback gets executed on the rising edge of an external input signal
     Callback<void(uint8_t pulse)> ppqnCallback; // this callback gets executed at a rate equal to input capture / PPQN. It passes the current tick values as arguments
+    Callback<void(uint16_t step)> stepCallback; // executes every step
     Callback<void(uint8_t pulse)> resetCallback;
-    Callback<void()> overflowCallback;       // callback executes when all when a full step completes
+    Callback<void()> overflowCallback;       // callback executes when a full step completes
 
     /**
      * TODO: initial inputCapture value should be the product of TIM1 and TIM2 prescaler values combined with 120 BPM
@@ -48,12 +53,17 @@ class SuperClock {
         instance = this;
         ticksPerStep = 11129;
         ticksPerPulse = ticksPerStep / PPQN;
+        stepsPerBar = 4;
     };
 
     void init();
     void initTIM2(uint16_t prescaler, uint32_t period);
     void initTIM4(uint16_t prescaler, uint16_t period);
+
     void start();
+    void reset();
+    void setStepsPerBar(int steps);
+    void handleStep();
 
     void setPulseFrequency(uint32_t ticks);
     uint16_t convertADCReadToTicks(uint16_t min, uint16_t max, uint16_t value);
@@ -63,8 +73,12 @@ class SuperClock {
     // Callback Setters
     void attachInputCaptureCallback(Callback<void()> func);
     void attachPPQNCallback(Callback<void(uint8_t pulse)> func);
+    void attachStepCallback(Callback<void(uint16_t step)> func) {
+        stepCallback = func;
+    }
     void attachResetCallback(Callback<void(uint8_t pulse)> func);
-
+    void attachBarResetCallback(Callback<void()> func);
+
     // Low Level HAL interupt handlers
     void handleInputCaptureCallback();
     void handleOverflowCallback();

API/Inc/logger.h

@@ -11,6 +11,21 @@
 #define OK_UART_TX (PinName) PC_10
 #endif
 
+#define MAX_MESSAGE_LENGTH 50
+
+typedef union
+{
+    bool boolValue;
+    int intValue;
+    char *charValue;
+} QueueMessage;
+
+void logger_queue_message(char const *message);
+void logger_queue_message(int num);
+void logger_queue_message_ISR(char const *message);
+void logger_queue_message_ISR(int num);
+void task_logger(void *params);
+
 void logger_init();
 
 void logger_log(char const *str);
@@ -46,8 +61,4 @@ void logger_log_arr(T arr[], int length)
 void logger_log_system_config();
 
 void logger_log_task_watermark(void);
-void logger_log_task_watermark(TaskHandle_t task_handle);
-
-void logger_queue_message(uint16_t message);
-
-void TASK_logger(void *params);
+void logger_log_task_watermark(TaskHandle_t task_handle);

API/Src/Flash.cpp

@@ -83,6 +83,16 @@ HAL_StatusTypeDef Flash::erase(uint32_t address)
     return status;
 }
 
+/**
+ * @brief Write to flash memory
+ * @note flash memory can only be written to by changing its value from a 1 to a 0.
+ * Once a bit in the flash memory is set to 0, it cannot be changed back to 1 without erasing the entire sector.
+ *
+ * @param address flash memory address you wish to write to
+ * @param data pointer to an array containing the data you want to store in flash
+ * @param size size of data array
+ * @return HAL_StatusTypeDef
+ */
 HAL_StatusTypeDef Flash::write(uint32_t address, uint32_t *data, int size)
 {
     HAL_StatusTypeDef status;
@@ -111,7 +121,7 @@ HAL_StatusTypeDef Flash::write(uint32_t address, uint32_t *data, int size)
             flashError = HAL_FLASH_GetError();
         } else {
             size--;
-            address += 4;
+            address += 4; // 1 "word" == 4 bytes
             data++;
         }
     }
@@ -123,8 +133,40 @@ HAL_StatusTypeDef Flash::write(uint32_t address, uint32_t *data, int size)
     return status;
 }
 
+void Flash::write(uint32_t address, uint32_t data)
+{
+    HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, (uint64_t)data);
+}
+
+/**
+ * @brief Copy contents of a sector in flash into another sector in flash. Requires no buffer
+ * as it copies word by word
+ * 
+ * @param sourceSector sector you wish to copy
+ * @param targetSector sector you wish to store the copy in
+ * @param size how much of the source you want to copy
+ */
+void Flash::copySector(uint32_t sourceSector, uint32_t targetSector, uint32_t size)
+{
+    // Step 1: clear Sector 6
+    this->erase(targetSector);
+
+    // Step 2: copy all data from Sector 7 into Sector 6
+    this->unlock(sourceSector);
+    uint32_t read_address = sourceSector;
+    uint32_t write_address = targetSector;
+    while (read_address < (sourceSector + size))
+    {
+        uint32_t word = this->read_word((void *)read_address);
+        this->write(write_address, word);
+        read_address += 4;
+        write_address += 4;
+    }
+    this->lock();
+}
+
 /**
- * @brief Read data starting at defined address
+ * @brief Read data starting at defined address and load it into a buffer
  * 
  * @param address Address to begin reading from
  * @param rxBuffer The buffer to read data into. Must be of type uint32_t
@@ -141,6 +183,17 @@ void Flash::read(uint32_t address, uint32_t *rxBuffer, int size)
     }
 }
 
+/**
+ * @brief read a single 32-bit word at a specific memory address and return it
+ * 
+ * @param address 
+ * @return uint32_t 
+ */
+uint32_t Flash::read_word(void *address)
+{
+    return *(uint32_t *)address;
+}
+
 /**
  * @brief Check if data read from flash has been cleared / not written too by testing contents of buffer
  *
@@ -150,11 +203,19 @@ void Flash::read(uint32_t address, uint32_t *rxBuffer, int size)
  */
 bool Flash::validate(uint32_t *data, int size)
 {
-    size = size > 65000 ? 65000 : size; // protect
-    uint32_t validator = 0;
-    for (int i = 0; i < size; i++)
-        validator += (uint16_t)data[i]; // uint16 for overflow
-    return validator == size * 0xFFFF ? true : false;
+    bool dataIsClear = false;
+    for (int i = 0; i < size; i++) {
+        if (data[i] == 0xFFFFFFFF)
+        {
+            dataIsClear = true;
+        }
+        else
+        {
+            dataIsClear = false;
+            break;
+        }
+    }
+    return dataIsClear;
 }
 
 /**

API/Src/SuperClock.cpp

@@ -19,6 +19,26 @@ void SuperClock::start()
     error_handler(status);
 }
 
+void SuperClock::reset()
+{
+    __HAL_TIM_SetCounter(&htim2, 0); // not certain this has to happen, just assuming
+    __HAL_TIM_SetCounter(&htim4, 0);
+    if (!externalInputMode) { // special for timing!
+        this->pulse = 0;
+    }
+    this->step = 0;
+}
+
+void SuperClock::setStepsPerBar(int steps) {
+    if (steps < 3) {
+        return;
+    } else if (steps > 7) {
+        return;
+    } else {
+        stepsPerBar = steps;
+    }
+}
+
 /**
  * @brief initialize TIM2 as a slave to TIM1
  * @param prescaler setting to 1 should be best
@@ -141,10 +161,10 @@ void SuperClock::setPulseFrequency(uint32_t ticks)
  */
 void SuperClock::handleInputCaptureCallback()
 {
-    // almost always, there will need to be at least 1 pulse not yet executed prior to an input capture, 
-    // so you must execute all remaining until
-    if (pulse < PPQN)
+    // almost always, there will need to be at least 1 pulse not yet executed prior to an input capture, so you must execute all remaining until
+    if (pulse < PPQN - 1)
     {
+        handleStep();
         if (resetCallback)
         {
             resetCallback(pulse);
@@ -185,26 +205,41 @@ void SuperClock::handleOverflowCallback()
 {
     if (ppqnCallback)
         ppqnCallback(pulse); // when clock inits, this ensures the 0ith pulse will get handled
-
+    
     // by checking this first, you have the chance to reset any sequences prior to executing their 0ith pulse
-    // if (pulse == 0) {
-    //     if (resetCallback)
-    //         resetCallback();
-    // }
+    if (pulse == 0) {
+        if (stepCallback)
+            stepCallback(step);
+    }
 
     if (pulse < PPQN - 1) {
         pulse++;
     } else {
         if (externalInputMode)
         {
-            __HAL_TIM_DISABLE(&htim4); // halt TIM4
             // external input will reset pulse to 0 and resume TIM4 in input capture callback
+            __HAL_TIM_DISABLE(&htim4); // halt TIM4
+            handleStep();
         } else {
             pulse = 0;
+            handleStep();
         }
     }
 }
 
+void SuperClock::handleStep() {
+    if (step < stepsPerBar - 1)
+    {
+        step++;
+    }
+    else
+    {
+        step = 0;
+        if (barResetCallback)
+            barResetCallback();
+    }
+}
+
 void SuperClock::attachInputCaptureCallback(Callback<void()> func)
 {
     input_capture_callback = func;
@@ -220,6 +255,10 @@ void SuperClock::attachResetCallback(Callback<void(uint8_t pulse)> func)
     resetCallback = func;
 }
 
+void SuperClock::attachBarResetCallback(Callback<void()> func) {
+    barResetCallback = func;
+}
+
 void SuperClock::RouteOverflowCallback(TIM_HandleTypeDef *htim)
 {
     if (htim == &htim4)