Verbesserung: I2C Buffer data sind jetzt globale structs

.settings/org.eclipse.core.resources.prefs

@@ -10,5 +10,7 @@ encoding//Debug/src/interfaces/subdir_rules.mk=UTF-8
 encoding//Debug/src/interfaces/subdir_vars.mk=UTF-8
 encoding//Debug/src/peripherals/adc/subdir_rules.mk=UTF-8
 encoding//Debug/src/peripherals/adc/subdir_vars.mk=UTF-8
+encoding//Debug/src/peripherals/dac/subdir_rules.mk=UTF-8
+encoding//Debug/src/peripherals/dac/subdir_vars.mk=UTF-8
 encoding//Debug/subdir_rules.mk=UTF-8
 encoding//Debug/subdir_vars.mk=UTF-8

main_target.c

@@ -6,6 +6,7 @@
 #include "src/peripherals/adc/adc.h"
 #include "src/peripherals/adc/adc_interface.h"
 #include "src/i2c_comm/mcu_slave_interface.h"
+#include "src/interfaces/i2c_controller_interface.h"
 
 
 #define DELAY_CYCLE  (100000000)
@@ -67,7 +68,7 @@ void I2C_controller_INST_IRQHandler(void) {
   switch (DL_I2C_getPendingInterrupt(I2C_controller_INST)) { 
     
     case DL_I2C_IIDX_CONTROLLER_START:
-        gRxADCcount = 0;
+        controllerRxPackage.count = 0;
         
         DL_I2C_flushControllerTXFIFO(I2C_controller_INST);
         break;
@@ -75,43 +76,43 @@ void I2C_controller_INST_IRQHandler(void) {
     case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER:
         /* Store bytes received from target in Rx Msg Buffer */
         while (DL_I2C_isControllerRXFIFOEmpty(I2C_controller_INST) != true) {
-            if (gRxADCcount < gRxADClen) {
-                gRxPacket[gRxADCcount] =
+            if (controllerRxPackage.count < controllerRxPackage.len) {
+                controllerRxPackage.packet[controllerRxPackage.count] =
                     DL_I2C_receiveControllerData(I2C_controller_INST);
                     ;
-                gRxADCcount++;
+                controllerRxPackage.count++;
 
             } else {
                 /* Ignore and remove from FIFO if the buffer is full */
                 DL_I2C_receiveControllerData(I2C_controller_INST);
             }
         }
-            if (gRxADCcount >= gRxADClen) {
-            gRxComplete = true;
+            if (controllerRxPackage.count >= controllerRxPackage.len) {
+            controllerRxPackage.complete = true;
             DL_I2C_enableInterrupt(I2C_controller_INST,
                                     DL_I2C_INTERRUPT_CONTROLLER_STOP);
             }
         break;
     /*TRANSMIT data to ADC*/
     case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER:
-        if (gTxADCcount < gTxADClen) {
+        if (controllerTxPackage.count < controllerTxPackage.len) {
             DL_I2C_fillControllerTXFIFO(I2C_controller_INST,
-                                                    &gTxPacket[gTxADCcount],
-                                                    (gTxADClen - gTxADCcount));
-            gTxADCcount++;
+                                        &controllerTxPackage.packet[controllerTxPackage.count],
+                                        (controllerTxPackage.len - controllerTxPackage.count));
+            controllerTxPackage.count++;
         } else {
             /*Prevent overflow and just ignore data*/
             DL_I2C_fillTargetTXFIFO(I2C_controller_INST, (uint8_t[]){0x00}, 1);
-            gTxComplete = true;
+            controllerTxPackage.complete = true;
         }
-        if(gTxADCcount >= gTxADClen){
-            gTxComplete= true;
+        if(controllerTxPackage.count >= controllerTxPackage.len){
+            controllerTxPackage.complete= true;
         }
         break;
     /*STOP condition*/
     case DL_I2C_IIDX_CONTROLLER_STOP:
-        gTxComplete = true;
-        gRxComplete = true;
+        controllerTxPackage.complete = true;
+        controllerRxPackage.complete = true;
         break;
     case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST:
         break;

src/interfaces/i2c_controller_interface.h

@@ -25,12 +25,33 @@ Reference:
 #include <stdint.h>
 #include <stdbool.h>
 
+//Maximum packet sizes
+#define I2C_TX_MAX_PACKET_SIZE (4)  
+#define I2C_RX_MAX_PACKET_SIZE (4)  
+
+typedef struct {
+    volatile bool complete;
+    uint8_t packet[I2C_RX_MAX_PACKET_SIZE];
+    uint8_t count;
+    uint8_t len;
+} I2CRxPackage;
+
+extern I2CRxPackage controllerRxPackage;
+
+typedef struct {
+    volatile bool complete;
+    uint8_t packet[I2C_TX_MAX_PACKET_SIZE];
+    uint8_t count;
+    uint8_t len;
+} I2CTxPackage;
+extern I2CTxPackage controllerTxPackage;
+
 /*
 * Since C does not allows to add functions in typedef struct, however a function pointer can be included in Structure in C. This interface provides a standard features of i2c_hal
 */
 typedef struct{
-    bool (*write)(uint8_t const TARGET_ADDRESS, const uint8_t *const Data, uint8_t const Data_length);
-    bool (*read) (uint8_t const TARGET_ADDRESS, uint8_t const Data_length);
+    bool (*write)(uint8_t const TARGET_ADDRESS);
+    bool (*read) (uint8_t const TARGET_ADDRESS);
 } I2C_Interface;
 
 extern I2C_Interface i2c_hal;

src/interfaces/i2c_hal.c

@@ -8,6 +8,13 @@
 #include "ti_msp_dl_config.h"
 #include <stdio.h>
 
+volatile bool gRxComplete;
+volatile bool gTxComplete;
+uint8_t gTxPacket[I2C_TX_MAX_PACKET_SIZE];
+uint8_t gRxPacket[I2C_RX_MAX_PACKET_SIZE];
+uint8_t gTxADClen, gTxADCcount;
+uint8_t gRxADClen, gRxADCcount;
+
 /*
 static function is for implementing Data Hiding, access to the static function
 is restricted to the file where they are declared const keyword for
@@ -15,9 +22,10 @@ is restricted to the file where they are declared const keyword for
 const Data: means the pointer to the variable and the value of Data is immutable
 */
 
-static bool msp_i2c_write(uint8_t const TARGET_ADDRESS,
-                          const uint8_t *const Data,
-                          uint8_t const Data_length) {
+I2CRxPackage controllerRxPackage;
+I2CTxPackage controllerTxPackage;
+
+static bool msp_i2c_write(uint8_t const TARGET_ADDRESS) {
   // Flush any stale data in TX FIFO:
   DL_I2C_flushControllerTXFIFO(I2C_controller_INST);
 
@@ -36,11 +44,13 @@ static bool msp_i2c_write(uint8_t const TARGET_ADDRESS,
 
   // **Start I2C Write Transaction**
   DL_I2C_startControllerTransfer(I2C_controller_INST, TARGET_ADDRESS,
-                                 DL_I2C_CONTROLLER_DIRECTION_TX, Data_length);
+                                 DL_I2C_CONTROLLER_DIRECTION_TX, controllerTxPackage.len);
 
   // **Load Configuration Byte into TX FIFO**
-  DL_I2C_fillControllerTXFIFO(I2C_controller_INST, (uint8_t *)Data,
-                              Data_length);
+  DL_I2C_fillControllerTXFIFO(I2C_controller_INST, controllerTxPackage.packet, controllerTxPackage.len);
+  for (uint8_t i = 0; i < controllerTxPackage.len; i++) {
+      printf("Sending 0x%02X\n", controllerTxPackage.packet[i]);
+  }
 
   // ** Wait for the I2C Bus to be FREE **
   while (DL_I2C_getControllerStatus(I2C_controller_INST) &
@@ -67,8 +77,7 @@ static bool msp_i2c_write(uint8_t const TARGET_ADDRESS,
   return true;
 }
 
-static bool msp_i2c_read(uint8_t const TARGET_ADDRESS,
-                         uint8_t const Data_length) {
+static bool msp_i2c_read(uint8_t const TARGET_ADDRESS) {
 
   
  // Flush any stale data in TX FIFO:
@@ -77,7 +86,7 @@ static bool msp_i2c_read(uint8_t const TARGET_ADDRESS,
          DL_I2C_CONTROLLER_STATUS_BUSY_BUS)
     ;
   DL_I2C_startControllerTransfer(I2C_controller_INST, TARGET_ADDRESS,
-                                 DL_I2C_CONTROLLER_DIRECTION_RX, Data_length);
+                                 DL_I2C_CONTROLLER_DIRECTION_RX, controllerRxPackage.len);
 
   while (DL_I2C_getControllerStatus(I2C_controller_INST) &
          DL_I2C_CONTROLLER_STATUS_BUSY_BUS)

src/peripherals/adc/adc.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include "src/peripherals/adc/adc_interface.h"
+#include "src/interfaces/i2c_controller_interface.h"
 
 
 //static ADC_Params adc_params;
@@ -22,7 +23,6 @@ void updateADCReading_multichannel(uint8_t slot, uint8_t channel) {
             adc_params.gain = 1;
             //printf("Config: Memory address of batteries: %p\n", &batteries[0]);
             adc_hal.configure(slot, &adc_params);
-            delay_cycles(500000);
             //adc_state = ADC_STATE_WAIT;
             adc_state = ADC_STATE_READ;
             break;
@@ -51,6 +51,15 @@ void updateADCReading_multichannel(uint8_t slot, uint8_t channel) {
                 adc_state = ADC_STATE_DONE;
                 printf("[ADC] Battery Current in slot %d is %d mA.\n", slot, batteries[slot].current);
                 //printf("current: Memory address of batteries: %p\n", &batteries[0]);
+            } else if (channel == 2) {
+
+                int16_t raw_adc_voltage = adc_hal.read_raw(slot, &adc_params);
+                batteries[slot].voltage =
+                    adc_hal.convert_voltage(raw_adc_voltage, &adc_params); 
+                adc_state = ADC_STATE_DONE;
+                printf("[ADC] Ch3 Voltage in slot %d is %d mV.\n", slot, batteries[slot].voltage);
+                //printf("voltage: Memory address of batteries: %p\n", &batteries[0].voltage);
+
             }
             break;
         default:

src/peripherals/adc/adc_hal.c

@@ -54,13 +54,6 @@ D15.
 #include "ti_msp_dl_config.h"
 #include <stdio.h>
 
-volatile bool gRxComplete;
-volatile bool gTxComplete;
-uint8_t gTxPacket[I2C_TX_MAX_PACKET_SIZE];
-uint8_t gRxPacket[I2C_RX_MAX_PACKET_SIZE];
-uint8_t gTxADClen, gTxADCcount;
-uint8_t gRxADClen, gRxADCcount;
-
 /*
 * Creating Configuartion Register as mentioned in the datasheet: https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/22226a.pdf
 * Under section 5.2 Configuration Register
@@ -116,31 +109,24 @@ static uint8_t construct_config_byte(ADC_Params *params) {
  * I2C*/
 
 static bool adc_configure(uint8_t slot_id, ADC_Params *params) {
-  /*printf("Configuring for channel: %d\n", params->channel);
-  printf("Configuring for resolution: %d\n", params->resolution);
-  printf("Configuring for gain: %d\n", params->gain); 
-  printf("Continuous or Single: %d\n", params->continuous);
-  */
-  uint8_t config_byte = construct_config_byte(params);
-  printf("Config Byte: 0x%02X\n", config_byte);
+  controllerTxPackage.packet[0] = construct_config_byte(params);
+  printf("Config Byte: 0x%02X\n", controllerTxPackage.packet[0]);
   // Wait for I2C Bus to be Free**
   while (DL_I2C_getControllerStatus(I2C_controller_INST) &
          DL_I2C_CONTROLLER_STATUS_BUSY_BUS)
     ;
-  if(config_byte == 0xFF){
+  if(controllerTxPackage.packet[0] == 0xFF){
     printf("[ADC] Unable to send config bytes\n");
     return false;
   } 
-  // Prepare TX Buffer:
-  gTxPacket[0] = config_byte;
-  gTxADClen = 1;
-  gTxADCcount = 0;
-  gTxComplete = false;
-  i2c_hal.write(ADC_TARGET_BASE_ADDRESS, gTxPacket, gTxADClen);
-  while(!gTxComplete);
-  printf("ADC Config:: gTxADClen: %d, gTxADCcount: %d\n", gTxADClen, gTxADCcount);
+  // Prepare TX Buffer
+  controllerTxPackage.len = 1;
+  controllerTxPackage.count = 0;
+  controllerTxPackage.complete = false;
+  i2c_hal.write(ADC_TARGET_BASE_ADDRESS);
+  
+  while(!controllerTxPackage.complete);
   return true;
-  //return i2c_hal.write(ADC_TARGET_BASE_ADDRESS + slot_id, &config_byte, 1);
 }
 
 
@@ -157,22 +143,18 @@ Conversion mode, writing this bit to “1” initiates a new conversion.
 
 static bool adc_is_ready(uint8_t slot_id, ADC_Params *params) {
   uint8_t adc_address = ADC_TARGET_BASE_ADDRESS + slot_id;
-  gRxADClen = 3;
-  gRxADCcount = 0;
-  gRxComplete = false;
+  controllerRxPackage.len = 3;
+  controllerRxPackage.count = 0;
+  controllerRxPackage.complete = false;
 
-  gRxPacket[0] = 0;
-  gRxPacket[1] = 0;
-  gRxPacket[2] = 0;
-
-  i2c_hal.read(adc_address, gRxADClen);
+  i2c_hal.read(adc_address);
   //i2c_hal.read(ADC_TARGET_BASE_ADDRESS + slot_id, 3);
   // Ready bit is bit 7
-  while(!gRxComplete);
-  uint8_t config_adc_byte = gRxPacket[2];
+  while(!controllerRxPackage.complete);
+  uint8_t config_adc_byte = controllerRxPackage.packet[2];
   bool ready = (config_adc_byte & 0x80) == 1;
-  printf("Bytes: 0x%02X 0x%02X 0x%02X (%d %d %d)\n", gRxPacket[0], gRxPacket[1],  gRxPacket[2], gRxPacket[0], gRxPacket[1],  gRxPacket[2]);
-  printf("ADC Ready:: gRxADClen: %d, gRxADCcount: %d ready? %d\n", gRxADClen, gRxADCcount, ready);
+  printf("Bytes: 0x%02X 0x%02X 0x%02X (%d %d %d)\n", controllerRxPackage.packet[0], controllerRxPackage.packet[1],  controllerRxPackage.packet[2], controllerRxPackage.packet[0], controllerRxPackage.packet[1],  controllerRxPackage.packet[2]);
+  printf("ADC Ready:: gRxADClen: %d, gRxADCcount: %d ready? %d\n", controllerRxPackage.len, controllerRxPackage.count, ready);
   return ready;
 }
 
@@ -182,21 +164,17 @@ static int16_t read_adc_raw_data(uint8_t slot_id, ADC_Params *params) {
   // Buffer for ADC data (MSB, LSB, Config Byte)
   int16_t raw_adc = 0;
 
-  gRxADClen = 3;
-  gRxADCcount = 0;
-  gRxComplete = false;
-
-  gRxPacket[0] = 0;
-  gRxPacket[1] = 0;
-  gRxPacket[2] = 0;
+  controllerRxPackage.len = 3;
+  controllerRxPackage.count = 0;
+  controllerRxPackage.complete = false;
   
-  i2c_hal.read(ADC_TARGET_BASE_ADDRESS + slot_id, gRxADClen);
-  while(!gRxComplete);
-  printf("ADC Read:: gRxADClen: %d, gRxADCcount: %d\n", gRxADClen, gRxADCcount);
-  printf("Bytes: 0x%02X 0x%02X 0x%02X (%d %d %d)\n", gRxPacket[0], gRxPacket[1],  gRxPacket[2], gRxPacket[0], gRxPacket[1],  gRxPacket[2]);
-  uint8_t msb = gRxPacket[0];
-  uint8_t lsb = gRxPacket[1];
-  uint8_t config_adc_byte = gRxPacket[2];
+  i2c_hal.read(ADC_TARGET_BASE_ADDRESS + slot_id);
+  while(!controllerRxPackage.complete);
+  printf("ADC Read:: gRxADClen: %d, gRxADCcount: %d\n", controllerRxPackage.len, controllerRxPackage.count);
+  printf("Bytes: 0x%02X 0x%02X 0x%02X (%d %d %d)\n", controllerRxPackage.packet[0], controllerRxPackage.packet[1],  controllerRxPackage.packet[2], controllerRxPackage.packet[0], controllerRxPackage.packet[1],  controllerRxPackage.packet[2]);
+  uint8_t msb = controllerRxPackage.packet[0];
+  uint8_t lsb = controllerRxPackage.packet[1];
+  uint8_t config_adc_byte = controllerRxPackage.packet[2];
 
   if (params->resolution == 12) {
     raw_adc = ((msb & 0b00001111) << 8) | lsb;

src/peripherals/adc/adc_interface.h

@@ -7,21 +7,6 @@
 #define ADC_TARGET_BASE_ADDRESS (0x68)
 #define ADC_VREF_MV (2048)
 
-//Maximum packet sizes
-#define I2C_TX_MAX_PACKET_SIZE (4)  
-#define I2C_RX_MAX_PACKET_SIZE (4)  
-
-//Flag for READ and WRITE
-extern volatile bool gRxComplete;
-extern volatile bool gTxComplete;
-extern uint8_t gTxPacket[I2C_TX_MAX_PACKET_SIZE];
-extern uint8_t gRxPacket[I2C_RX_MAX_PACKET_SIZE];
-
-/*Counters for Tx and Rx length and bytes sent*/
-/*Reduced variable size for ADC count and len*/
-extern uint8_t gTxADClen, gTxADCcount;
-extern uint8_t gRxADClen, gRxADCcount;
-
 typedef struct {
     uint8_t channel;
     uint8_t resolution;

src/peripherals/dac/dac.c

@@ -47,8 +47,10 @@ bool DAC_SingleWrite(uint16_t channel_value) {
            output_buffer_SingleWrite[1],
            output_buffer_SingleWrite[2]);
 
+
+  // @TODO FIXME to right global variables!!
   // Write data to DAC
-  if (!i2c_hal.write(DAC_TARGET_BASE_ADDRESS, output_buffer_SingleWrite, data_length)) {
+  if (!i2c_hal.write(DAC_TARGET_BASE_ADDRESS)) {
         printf("I2C DAC Write Error: Failed to write to DAC.\n");
         return false;
     }