feat: ctmu functions and buffer fill/clear (#123)

Author: CloudyPadmal

pslab-core.X/commands.c

@@ -10,6 +10,7 @@
 #include "instruments/wavegenerator.h"
 #include "registers/system/pin_manager.h"
 #include "instruments/sensors.h"
+#include "registers/converters/ctmu.h"
 
 /**
  * This is used to check that a received secondary command does not exceed the
@@ -240,19 +241,19 @@ command_func_t* const cmd_table[NUM_PRIMARY_CMDS + 1][NUM_SECONDARY_CMDS_MAX + 1
     },
     { // 11 COMMON
      // 0                               1 GET_CTMU_VOLTAGE              2 GET_CAPACITANCE               3 GET_FREQUENCY
-        Undefined,                      Unimplemented,                  MULTIMETER_GetCapacitance,      Unimplemented,
+        Undefined,                      MULTIMETER_GetCTMUVolts,        MULTIMETER_GetCapacitance,      Unimplemented,
      // 4 GET_INDUCTANCE                5 GET_VERSION                   6                               7
         Unimplemented,                  DEVICE_GetVersion,              Undefined,                      Undefined,
      // 8 RETRIEVE_BUFFER               9 GET_HIGH_FREQUENCY            10 CLEAR_BUFFER                 11 SET_RGB1
-        BUFFER_Retrieve,                Unimplemented,                  Unimplemented,                  Removed,
+        BUFFER_Retrieve,                Unimplemented,                  BUFFER_Clear,                   Removed,
      // 12 READ_PROGRAM_ADDRESS         13 WRITE_PROGRAM_ADDRESS        14 READ_DATA_ADDRESS            15 WRITE_DATA_ADDRESS
         Removed,                        Removed,                        DEVICE_ReadRegisterData,        DEVICE_WriteRegisterData,
      // 16 GET_CAP_RANGE                17 SET_RGB2                     18 READ_LOG                     19 RESTORE_STANDALONE
         Unimplemented,                  Removed,                        Removed,                        DEVICE_Reset,
      // 20 GET_ALTERNATE_HIGH_FREQUENCY 21 SET_RGB_COMMON               22 SET_RGB3                     23 START_CTMU
-        Unimplemented,                  LIGHT_RGBPin,                   Removed,                        Unimplemented,
+        Unimplemented,                  LIGHT_RGBPin,                   Removed,                        CTMU_Start,
      // 24 STOP_CTMU                    25 START_COUNTING               26 FETCH_COUNT                  27 FILL_BUFFER
-        Unimplemented,                  SENSORS_StartCounter,           SENSORS_GetCounter,             Unimplemented,
+        CTMU_Stop,                      SENSORS_StartCounter,           SENSORS_GetCounter,             BUFFER_Fill,
     },
     { // 12 PASSTHROUGH
      // 0          1                        2          3

pslab-core.X/helpers/buffer.c

@@ -1,3 +1,4 @@
+#include <string.h>
 #include "../bus/uart/uart1.h"
 #include "../commands.h"
 #include "../registers/system/pin_manager.h"
@@ -15,3 +16,26 @@ response_t BUFFER_Retrieve(void) {
 
     return SUCCESS;
 }
+
+response_t BUFFER_Fill(void) {
+    
+    uint16_t start = UART1_ReadInt();
+    uint16_t end = UART1_ReadInt();
+    
+    uint16_t i;
+    for (i = start; i < start + end; i++) {
+        BUFFER[i] = UART1_ReadInt();
+    }
+    
+    return SUCCESS;
+}
+
+response_t BUFFER_Clear(void) {
+    
+    uint16_t start = UART1_ReadInt();
+    uint16_t end = UART1_ReadInt();
+    
+    memset((void *) &BUFFER[start], 0, end - start);
+    
+    return SUCCESS;
+}

pslab-core.X/helpers/buffer.h

@@ -23,6 +23,36 @@ extern "C" {
     * @return SUCCESS
     */
     response_t BUFFER_Retrieve(void);
+    
+    /**
+    * @brief Populate BUFFER array
+    * 
+    * @description
+    * This command function takes two arguments over serial:
+    * 1. The starting index in the buffer from which to fill values.
+    * 2. The number of values to be sent.
+    * 
+    * It does not return anything over serial.
+    * It sends an acknowledge byte (SUCCESS)
+    * 
+    * @return SUCCESS
+    */
+    response_t BUFFER_Fill(void);
+    
+    /**
+    * @brief Clear BUFFER array
+    * 
+    * @description
+    * This command function takes two arguments over serial:
+    * 1. The starting index in the buffer from which it should be emptied
+    * 2. The number of indices need cleared.
+    *
+    * It does not return anything over serial.
+    * It sends an acknowledge byte (SUCCESS)
+    * 
+    * @return SUCCESS
+    */
+    response_t BUFFER_Clear(void);
 
 #ifdef	__cplusplus
 }

pslab-core.X/instruments/multimeter.c

@@ -6,6 +6,7 @@
 #include "../registers/memory/dma.h"
 #include "../registers/system/pin_manager.h"
 #include "../registers/timers/tmr5.h"
+#include "multimeter.h"
 
 #define CHARGE      0
 #define DISCHARGE   1
@@ -70,6 +71,30 @@ void GetCapacitance_ConfigADC_CTMU_TMR5() {
     TMR5_WaitForInterruptEvent();
 }
 
+uint16_t GetVoltage_Summed(uint8_t channel) {
+    
+    ADC1_SetOperationMode(ADC1_12BIT_AVERAGING_MODE, channel, 0);
+
+    ADC1_Enable();
+    DELAY_us(20);
+    ADC1_AutomaticSamplingEnable();
+
+    ADC1_WaitForInterruptEvent();
+
+    while (!ADC1_IsConversionComplete());
+
+    ADC1_AutomaticSamplingDisable();
+    ADC1_Disable();
+
+    uint16_t voltage_sum =
+            (ADC1BUF0) + (ADC1BUF1) + (ADC1BUF2) + (ADC1BUF3) +
+            (ADC1BUF4) + (ADC1BUF5) + (ADC1BUF6) + (ADC1BUF7) +
+            (ADC1BUF8) + (ADC1BUF9) + (ADC1BUFA) + (ADC1BUFB) +
+            (ADC1BUFC) + (ADC1BUFD) + (ADC1BUFE) + (ADC1BUFF);
+    
+    return voltage_sum;
+}
+
 response_t MULTIMETER_GetVoltage(void) {
 
     uint8_t channel = UART1_Read();
@@ -113,26 +138,8 @@ response_t MULTIMETER_GetVoltage(void) {
 response_t MULTIMETER_GetVoltageSummed(void) {
 
     uint8_t channel = UART1_Read();
-
-    ADC1_SetOperationMode(ADC1_12BIT_AVERAGING_MODE, channel, 0);
-
-    ADC1_Enable();
-    DELAY_us(20);
-    ADC1_AutomaticSamplingEnable();
-
-    ADC1_WaitForInterruptEvent();
-
-    while (!ADC1_IsConversionComplete());
-
-    ADC1_AutomaticSamplingDisable();
-    ADC1_Disable();
-
-    uint16_t voltage_sum =
-            (ADC1BUF0) + (ADC1BUF1) + (ADC1BUF2) + (ADC1BUF3) +
-            (ADC1BUF4) + (ADC1BUF5) + (ADC1BUF6) + (ADC1BUF7) +
-            (ADC1BUF8) + (ADC1BUF9) + (ADC1BUFA) + (ADC1BUFB) +
-            (ADC1BUFC) + (ADC1BUFD) + (ADC1BUFE) + (ADC1BUFF);
-
+    
+    uint16_t voltage_sum = GetVoltage_Summed(channel);
     UART1_WriteInt(voltage_sum);
 
     return SUCCESS;
@@ -185,3 +192,32 @@ response_t MULTIMETER_GetCapacitance(void) {
 
     return SUCCESS;
 }
+
+response_t MULTIMETER_GetCTMUVolts(void) {
+    
+    uint8_t config = UART1_Read();
+    
+    CTMU_Initialize();
+    // Edge delay generation
+    CTMUCON1bits.TGEN = (config >> 7) & 0x1;
+    // Current source output
+    CTMUICONbits.IRNG = (config >> 5) & 0x3;
+    
+    // Internal temperature
+    if ((config & 0x1F) == 30) CTMU_EnableEdge2();
+    
+    CTMU_Enable();
+    DELAY_us(1000);
+    CTMU_DrainOutput();
+    DELAY_us(1500);
+    CTMU_FloatOutput();
+    CTMU_EnableEdge1();
+    
+    uint16_t result = GetVoltage_Summed(config & 0x1F);
+
+    CTMU_DisableModule();
+    
+    UART1_WriteInt(result);
+    
+    return SUCCESS;
+}

pslab-core.X/instruments/multimeter.h

@@ -28,6 +28,30 @@ extern "C" {
      * @return SUCCESS
      */
     response_t MULTIMETER_GetCapacitance(void);
+    
+    /**
+     * @brief Measurements using Charge Time Measurement Unit
+     *
+     * @description
+     * This command function takes one argument over serial:
+     * 1. (uint8)  Configuration byte:
+     *             | 7  | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+     *             | DG |  CSO  |      CHANNEL      |
+     *             DG: Delay generator enable/disable (1/0)
+     *             CSO: Current source output:
+     *                    00: Base * 1000
+     *                    01: Base = 0.53 uA
+     *                    10: Base * 10
+     *                    11: Base * 100
+     *             CHANNEL: CTMU channel
+     * 
+     * It returns nothing over serial.
+     * It sends an acknowledge byte (SUCCESS). This will be available only after
+     * no less than 2.5 milliseconds.
+     * 
+     * @return SUCCESS
+     */
+    response_t MULTIMETER_GetCTMUVolts(void);
 
 #ifdef	__cplusplus
 }

pslab-core.X/registers/converters/ctmu.c

@@ -1,3 +1,6 @@
+#include "../../bus/uart/uart1.h"
+#include "../../commands.h"
+#include "../../helpers/delay.h"
 #include "ctmu.h"
 
 void CTMU_Initialize(void) {
@@ -34,14 +37,35 @@ void CTMU_InitializeCON2(void) {
     CTMUCON2bits.EDG1POL = 0;
     // Edge 1 source is Timer 1 module
     CTMUCON2bits.EDG1SEL = 0b0000;
-    // Edge 1 has not occured
+    // Edge 1 has not occurred
     CTMUCON2bits.EDG1STAT = 0;
     // Edge 2 is level sensitive
     CTMUCON2bits.EDG2MOD = 0;
     // Edge 2 is programmed for a negative edge response
     CTMUCON2bits.EDG2POL = 0;
     // Edge 2 source is IC1 module
     CTMUCON2bits.EDG2SEL = 0b0000;
-    // Edge 2 has not occured
+    // Edge 2 has not occurred
     CTMUCON2bits.EDG2STAT = 0;
 }
+
+response_t CTMU_Start(void) {
+    
+    uint8_t config = UART1_Read();
+    uint8_t current_trim = UART1_Read();
+    
+    CTMU_Initialize();
+    CTMUCON1bits.TGEN = (config >> 7) & 0x1;
+    CTMUICONbits.ITRIM = current_trim;
+    CTMUICONbits.IRNG = config & 0x7F;
+    CTMU_Enable();
+    DELAY_us(1000);
+    CTMU_EnableEdge1();
+    
+    return SUCCESS;
+}
+    
+response_t CTMU_Stop(void) {
+    CTMU_DisableModule();
+    return SUCCESS;
+}

pslab-core.X/registers/converters/ctmu.h

@@ -20,6 +20,83 @@ extern "C" {
         CTMUCON1bits.CTMUEN = 0;
     }
 
+    inline static void CTMU_DrainOutput(void) {
+        CTMUCON1bits.IDISSEN = 1;
+    }
+    
+    inline static void CTMU_FloatOutput(void) {
+        CTMUCON1bits.IDISSEN = 0;
+    }
+    
+    inline static void CTMU_EnableEdge1(void) {
+        CTMUCON2bits.EDG1STAT = 1;
+    }
+    
+    inline static void CTMU_DisableEdge1(void) {
+        CTMUCON2bits.EDG1STAT = 0;
+    }
+    
+    inline static void CTMU_EnableEdge2(void) {
+        CTMUCON2bits.EDG2STAT = 1;
+    }
+    
+    inline static void CTMU_DisableEdge2(void) {
+        CTMUCON2bits.EDG2STAT = 0;
+    }
+    
+    inline static void CTMU_EnableEdgeDelayGeneration(void) {
+        CTMUCON1bits.TGEN = 1;
+    }
+    
+    inline static void CTMU_DisableEdgeDelayGeneration(void) {
+        CTMUCON1bits.TGEN = 0;
+    }
+    
+    inline static void CTMU_DisableModule(void) {
+        CTMU_Disable();
+        CTMU_DisableEdge1();
+        CTMU_DisableEdge2();
+        CTMU_DisableEdgeDelayGeneration();
+    }
+    
+    /**
+     * @brief Start Charge Time Measurement Unit
+     *
+     * @description
+     * This command function takes two arguments over serial:
+     * 1. (uint8)  Configuration byte:
+     *             | 7  | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+     *             | DG |            CSO            |
+     *             DG: Delay generator enable/disable (1/0)
+     *             CSO: Current source output:
+     *                    00: Base * 1000
+     *                    01: Base = 0.53 uA
+     *                    10: Base * 10
+     *                    11: Base * 100
+     * 2. (uint8) Current trim
+     * 
+     * It returns nothing over serial.
+     * It sends an acknowledge byte (SUCCESS).
+     * 
+     * @return SUCCESS
+     */
+    response_t CTMU_Start(void);
+    
+    /**
+     * @brief Stop Charge Time Measurement Unit
+     *
+     * @description
+     * This command function does not take any arguments over serial. It stops
+     * and disables CTMU module.
+     * 
+     * It returns nothing over serial.
+     * It sends an acknowledge byte (SUCCESS).
+     * 
+     * @return SUCCESS
+     */
+    response_t CTMU_Stop(void);
+    
+    
 #ifdef	__cplusplus
 }
 #endif /* __cplusplus */