EHL-2 i2c library

.gitignore

@@ -189,3 +189,4 @@ venv.bak/
 
 # mypy
 .mypy_cache/
+.vscode/

debug.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+if [ $# -eq 0 ]
+then
+    echo "Usage: sudo $0 <module>"
+    exit 1
+fi
+
+if [ ! `ls elfs | grep "^$1\.elf$"` ]
+then
+    echo "No module called \"$1\""
+    exit 1
+fi
+
+openocd="sudo openocd -f board/ek-tm4c123gxl.cfg"
+serial="sleep 1; picocom -b 115200 /dev/ttyACM0"
+debug="sleep 2; ./flash.sh elfs/$1.elf"
+
+gnome-terminal --tab --command="bash -c '$openocd; $SHELL'" \
+               --tab --command="bash -c '$serial; $SHELL'" \
+               --tab --command="bash -c '$debug; $SHELL'" \
+               --disable-factory

src/libs/adc/CMakeLists.txt

@@ -0,0 +1,21 @@
+project(adc)
+cmake_minimum_required(VERSION 3.5)
+
+find_package(catkin REQUIRED
+        COMPONENTS ti)
+
+catkin_package(
+        INCLUDE_DIRS ./
+        LIBRARIES adc
+        CATKIN_DEPENDS ti
+)
+
+set(BUILD_TOOLS_DIR ../../../build-tools)
+include(../../../build-tools/build_env.cmake)
+
+add_library(adc STATIC adc.c)
+target_include_directories(adc PUBLIC
+        ${CMAKE_INCLUDE_PATH}
+        ./
+        ${catkin_INCLUDE_DIRS}
+)

src/libs/adc/DESIGNS

@@ -0,0 +1,12 @@
+Initialisation:
+    1. Enable ADC clock if not enabled
+    2. Enable GPIO clock if not enabled
+    3. Set GPIO AFSEL bit ?
+    4. Clear GPIO DEN bit in GPIODEN
+    5. Disable analogue isolation via GPIOAMSEL
+    6. Disable sample sequencer via ASENn in ADCACTSS
+    7. Append new source to sequencer via ADCSSCTLn
+    8. Enable sample sequencer via ASENn in ADCACTSS
+
+Notes
+    - ADC should use PIOSC for clock at 1 divider for clock

src/libs/adc/DIFFERENTIAL_PAIR

@@ -0,0 +1,11 @@
+Differential pair count = 4
+
+When VIN+ == VIN- the output will be 0x800
+
+Pair map
+    VIND0 <= AIN0 - AIN1
+    VIND1 <= AIN2 - AIN3
+    VIND2 <= AIN4 - AIN5
+    VIND3 <= AIN6 - AIN7
+
+

src/libs/adc/INTERNAL_TEMP_SENS

@@ -0,0 +1,6 @@
+The internal temperature sensor can be accessed as part of a sample
+sequence by setting the relevant TSn bit in ADCSSCTLn register.
+
+The sample can be converted into a temperature with:
+    TEMP = 147.5 - ((75 * (VREFP - VREFN) × ADC CODE ) / 4096)
+Accuracy is +- 5 degrees celsius.

src/libs/adc/PIN_DESCRIPTION

@@ -0,0 +1,33 @@
+Pin count = 9
+
+Pin map:
+    AIN0 => PE3
+    AIN1 => PE2
+    AIN2 => PE1
+    AIN3 => PE0
+    AIN4 => PD7
+    AIN5 => PD6
+    AIN6 => PD5
+    AIN7 => PD4
+    AIN20 => PE7
+
+Pin inputs:
+    GPIO
+        AIN0
+        AIN1
+        AIN2
+        AIN3
+        AIN4
+        AIN5
+        AIN6
+        AIN7
+        AIN20
+    Filtered input?
+        AIN0
+        AIN1
+        AIN2
+        AIN3
+    Current sensor
+        AIN7
+    Temperature sensor
+        AIN20

src/libs/adc/VREF

@@ -0,0 +1,2 @@
+VREFA+ => 3V from a precision voltage reference IC
+VREFA- => 0V from ground

src/libs/adc/adc.c

@@ -0,0 +1,180 @@
+//------------------------------INCLUDES------------------------------//
+#include "adc.h"
+
+//---------------------------ERROR_HANDLING---------------------------//
+
+//---------------------------SIZE_CONSTANTS---------------------------//
+#define PC 8              /* ADC pin count */
+#define GPIO_PORT_COUNT 2 /* number of GPIO ports used by ADC */
+
+
+//-------------------------------ENUMS--------------------------------//
+enum {
+    PRE_INIT,
+    POST_INIT
+};
+
+//------------------------------STRUCTS-------------------------------//
+struct gpio_port {
+    const uint32_t sysctl;
+    const uint32_t base;
+}; /* struct for data required for manipulating GPIO ports */
+
+struct gpio_pin {
+    const struct gpio_port port;
+    const uint8_t pin;
+};
+
+
+//---------------------SHARED_HARDWARE_CONSTANTS----------------------//
+/* ADC configuration arguments */
+const uint32_t adc_clock_div = 1;
+const uint32_t adc_clock_config =
+    ADC_CLOCK_SRC_PIOSC | ADC_CLOCK_RATE_FULL;
+const uint32_t sequence_num = 0;
+const uint32_t adc_sc_module = SYSCTL_PERIPH_ADC0;
+
+
+//----------------------BOARD_SPECIFIC_CONSTANTS----------------------//
+#ifdef PART_TM4C123GH6PM
+const uint32_t adc_reference = ADC_REF_INT;
+
+const struct gpio_pin gpio_lut[PC] = {
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_3},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_2},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_1},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_0},
+    {{SYSCTL_PERIPH_GPIOB, GPIO_PORTB_BASE}, GPIO_PIN_7},
+    {{SYSCTL_PERIPH_GPIOB, GPIO_PORTB_BASE}, GPIO_PIN_6},
+    {{SYSCTL_PERIPH_GPIOB, GPIO_PORTB_BASE}, GPIO_PIN_5},
+    {{SYSCTL_PERIPH_GPIOB, GPIO_PORTB_BASE}, GPIO_PIN_4}};
+#endif
+#ifdef PART_TM4C123GH6PGE
+const uint32_t adc_reference = ADC_REF_EXT_3V;
+
+const struct gpio_pin gpio_lut[PC] = {
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_3},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_2},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_1},
+    {{SYSCTL_PERIPH_GPIOE, GPIO_PORTE_BASE}, GPIO_PIN_0},
+    {{SYSCTL_PERIPH_GPIOD, GPIO_PORTD_BASE}, GPIO_PIN_7},
+    {{SYSCTL_PERIPH_GPIOD, GPIO_PORTD_BASE}, GPIO_PIN_6},
+    {{SYSCTL_PERIPH_GPIOD, GPIO_PORTD_BASE}, GPIO_PIN_5},
+    {{SYSCTL_PERIPH_GPIOD, GPIO_PORTD_BASE}, GPIO_PIN_4}};
+#endif
+
+
+//------------------------------GLOBALS-------------------------------//
+int status = PRE_INIT;
+uint8_t active_pins = 0;
+uint32_t *adc_buffer = (void *)0;
+void (*adc_callback)(void) = (void *)0;
+
+
+//--------------------------LOCAL_FUNCTIONS---------------------------//
+/* If a module is not already enabled: enables it, then waits until it
+ * is responding as ready. */
+void init_module(uint32_t sysctl_module) {
+    if (SysCtlPeripheralReady(sysctl_module) == false) {
+        SysCtlPeripheralEnable(sysctl_module);
+        while (SysCtlPeripheralReady(sysctl_module) == false)
+            ;
+    }
+}
+
+
+//-------------------------EXTERNAL_FUNCTIONS-------------------------//
+/* Interrupt handler that needs to be configured in a module's prx file
+ * if the interrupt mode is used.
+ */
+void adc_irq_handler(void) {
+    /* Clear interrupt flag so we don't instantly return to the handler */
+    ADCIntClear(ADC0_BASE, sequence_num);
+    ADCSequenceDataGet(ADC0_BASE, sequence_num, adc_buffer);
+    /* call the callback */
+    adc_callback();
+}
+
+enum adc_return adc_init_pins(enum adc_pin *pins, uint8_t num_pins, bool interrupt_mode) {
+//        adc_assert(status == PRE_INIT);
+//        adc_assert(num_pins < 9);
+//        adc_assert(pins != (void *)0);
+
+        active_pins = num_pins;
+
+        /* initialise ADC module */
+        init_module(adc_sc_module);
+        ADCIntDisable(ADC0_BASE, sequence_num);
+
+        /* configure ADC module */
+        ADCClockConfigSet(ADC0_BASE, adc_clock_config, adc_clock_div);
+        ADCReferenceSet(ADC0_BASE, adc_reference);
+
+        /* pin initialisation and configuration */
+        for (int i = 0; i < num_pins; i++) {
+            /* initialise GPIO module */
+            init_module(gpio_lut[pins[i]].port.sysctl);
+            /* configure ADC/GPIO pins */
+            GPIOPinTypeADC(gpio_lut[pins[i]].port.base, gpio_lut[pins[i]].pin);
+        }
+
+        /* disable before configuring sequencer */
+        ADCSequenceDisable(ADC0_BASE, sequence_num);
+
+        /* setup ADC sample sequencer, trigger manually in software */
+        ADCSequenceConfigure(ADC0_BASE, sequence_num,
+            ADC_TRIGGER_PROCESSOR, 0);
+
+        /* configure each step of sequence to be an analog input source */
+        int i = 0;
+        for (i = 0; i < num_pins-1; i++) {
+            ADCSequenceStepConfigure(ADC0_BASE, sequence_num, i, pins[i]);
+        }
+        /* last step is end of sequence, generate an interrupt here */
+        ADCSequenceStepConfigure(ADC0_BASE, sequence_num, i,
+            pins[i] | ADC_CTL_IE | ADC_CTL_END);
+        /* never use this function, echronos handles irq registration */
+        // ADCIntRegister(ADC0_BASE, sequence_num, adc_irq_handler);
+        ADCSequenceEnable(ADC0_BASE, sequence_num);
+        /* enable interrupts if in interrupt mode */
+        if (interrupt_mode) {
+            ADCIntEnable(ADC0_BASE, sequence_num);
+            IntEnable(INT_ADC0SS0);
+        }
+        /* ready for capture */
+        status = POST_INIT;
+        return ADC_SUCCESS;
+}
+
+enum adc_return adc_capture_interrupt(uint32_t *buffer, void (*callback)(void)) {
+//    adc_assert(status == POST_INIT);
+//    adc_assert(buffer != (void *)0);
+//    adc_assert(callback !=(void *)0);
+    adc_buffer = buffer;
+    adc_callback = callback;
+    ADCProcessorTrigger(ADC0_BASE, sequence_num);
+    return ADC_SUCCESS;
+}
+
+
+
+uint32_t adc_capture_polling(uint32_t *buffer) {
+//    adc_assert(status == POST_INIT);
+    ADCProcessorTrigger(ADC0_BASE, sequence_num);
+    while (!ADCIntStatus(ADC0_BASE, sequence_num, false)) {};
+    uint32_t num_samples = ADCSequenceDataGet(ADC0_BASE, sequence_num, buffer);
+    return num_samples;
+}
+
+
+enum adc_return adc_interrupt_disable() {
+    ADCIntDisable(ADC0_BASE, sequence_num);
+    IntDisable(INT_ADC0SS0);
+    return ADC_SUCCESS;
+}
+
+enum adc_return adc_interrupt_enable() {
+    ADCIntEnable(ADC0_BASE, sequence_num);
+    IntEnable(INT_ADC0SS0);
+    return ADC_SUCCESS;
+}