made classes for drivers

diff --git a/.gitignore b/.gitignore
index 1746b7609ab30c216c17177ed8e39af1e608db2c..ccfe58214cad0bbfa48e462218e5b9705518a77f 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 build
 ChibiOS_*
+**/.*
 

diff --git a/source/adc.cpp b/source/adc.cpp
new file mode 100644 (file)
index 0000000..6ddabb6
--- /dev/null
+++ b/source/adc.cpp
@@ -0,0 +1,42 @@
+#include "adc.hpp"
+
+const GPTConfig ADCd::m_gpt_config = {
+  .frequency    =  1000000,
+  .callback     =  NULL,
+  .cr2          =  TIM_CR2_MMS_1,   /* MMS = 010 = TRGO on Update Event.    */
+  .dier         =  0
+};
+
+void ADCd::start()
+{
+    initPins();
+    gptStart(m_gptd, &m_gpt_config);
+
+    m_adc_config.difsel = 0;
+    m_adc_config.adcdinst = this;
+
+    adcStart(m_adcd, &m_adc_config);
+    adcSTM32EnableVREF(m_adcd);
+}
+
+adcsample_t *ADCd::getSamples(adcsample_t *buffer, size_t count)
+{
+    m_is_adc_finished = false;
+    adcStartConversion(m_adcd, &m_adc_group_config, buffer, count);
+    gptStartContinuous(m_gptd, 100); // 10kHz
+    while (!m_is_adc_finished);
+    return buffer;
+}
+
+void ADCd::initPins()
+{
+    palSetPadMode(GPIOA, 0, PAL_MODE_INPUT_ANALOG);
+}
+
+void ADCd::adcEndCallback(ADCDriver *adcd)
+{
+    auto *_this = reinterpret_cast<const ADCdConfig *>(adcd->config)->adcdinst;
+    gptStopTimer(_this->m_gptd);
+    _this->m_is_adc_finished = true;
+}
+

diff --git a/source/adc.hpp b/source/adc.hpp
new file mode 100644 (file)
index 0000000..6b1789d
--- /dev/null
+++ b/source/adc.hpp
@@ -0,0 +1,57 @@
+#ifndef STMDSP_ADC_HPP_
+#define STMDSP_ADC_HPP_
+
+#include "hal.h"
+
+class ADCd;
+
+struct ADCdConfig : public ADCConfig
+{
+    ADCd *adcdinst;
+};
+
+class ADCd
+{
+public:
+    constexpr explicit ADCd(ADCDriver& adcd, GPTDriver& gptd) :
+        m_adcd(&adcd), m_gptd(&gptd), m_adc_config{},
+        m_adc_group_config(ADC_GROUP_CONFIG),
+        m_is_adc_finished(false) {}
+
+    void start();
+    adcsample_t *getSamples(adcsample_t *buffer, size_t count);
+
+private:
+    static const GPTConfig m_gpt_config;
+
+    ADCDriver *m_adcd;
+    GPTDriver *m_gptd;
+    ADCdConfig m_adc_config;
+    ADCConversionGroup m_adc_group_config;
+
+    bool m_is_adc_finished;
+
+    void initPins();
+    static void adcEndCallback(ADCDriver *adcd);
+
+    constexpr static const ADCConversionGroup ADC_GROUP_CONFIG = {
+        .circular = false,
+        .num_channels = 1,
+        .end_cb = ADCd::adcEndCallback,
+        .error_cb = nullptr,
+        .cfgr = ADC_CFGR_EXTEN_RISING |
+                ADC_CFGR_EXTSEL_SRC(12),  /* TIM4_TRGO */
+        .cfgr2 = 0,
+        .tr1 = ADC_TR(0, 4095),
+        .smpr = {
+            ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_247P5), 0
+        },
+        .sqr = {
+            ADC_SQR1_SQ1_N(ADC_CHANNEL_IN5),
+            0, 0, 0
+        }
+    };
+};
+
+#endif // STMDSP_ADC_HPP_
+

diff --git a/source/dac.cpp b/source/dac.cpp
new file mode 100644 (file)
index 0000000..c7c250d
--- /dev/null
+++ b/source/dac.cpp
@@ -0,0 +1,27 @@
+#include "dac.hpp"
+
+//static const DACConversionGroup dacGroupConfig = {
+//  .num_channels = 1,
+//  .end_cb       = NULL,
+//  .error_cb     = NULL,
+//  .trigger      = DAC_TRG(0)
+//};
+
+void DACd::init()
+{
+    initPins();
+    dacStart(m_driver, &m_config);
+}
+
+void DACd::write(unsigned int channel, uint16_t value)
+{
+    if (channel < 2)
+        dacPutChannelX(m_driver, channel, value);
+}
+
+void DACd::initPins()
+{
+    palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG);     // DAC out1, out2
+    palSetPadMode(GPIOA, 5, PAL_MODE_INPUT_ANALOG);
+}
+

diff --git a/source/dac.hpp b/source/dac.hpp
new file mode 100644 (file)
index 0000000..687e8cf
--- /dev/null
+++ b/source/dac.hpp
@@ -0,0 +1,24 @@
+#ifndef STMDSP_DAC_HPP_
+#define STMDSP_DAC_HPP_
+
+#include "hal.h"
+
+class DACd
+{
+public:
+    constexpr explicit DACd(DACDriver& driver, const DACConfig& config) :
+        m_driver(&driver), m_config(config) {}
+
+    void init();
+
+    void write(unsigned int channel, uint16_t value);
+
+private:
+    DACDriver *m_driver;
+    DACConfig m_config;
+
+    void initPins();
+};
+
+#endif // STMDSP_DAC_HPP_
+

diff --git a/source/main.cpp b/source/main.cpp
index eb77a5d281e319ee8affa21cbb00850c275f0e12..16ca7a86e693c564bb613bf88effbc9ba448480f 100644 (file)
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,92 +1,9 @@
 #include "ch.h"\r
 #include "hal.h"\r
-#include "usbcfg.h"\r
 \r
-class dDAC\r
-{\r
-public:\r
-    constexpr dDAC(DACDriver& driver, const DACConfig& config) :\r
-        m_driver(&driver), m_config(config) {}\r
-\r
-    void init() {\r
-        dacStart(m_driver, &m_config);\r
-    }\r
-\r
-    void writeX(unsigned int channel, uint16_t value) {\r
-        if (channel < 2)\r
-            dacPutChannelX(m_driver, channel, value);\r
-    }\r
-\r
-private:\r
-    DACDriver *m_driver;\r
-    DACConfig m_config;\r
-};\r
-\r
-//static const DACConversionGroup dacGroupConfig = {\r
-//  .num_channels = 1,\r
-//  .end_cb       = NULL,\r
-//  .error_cb     = NULL,\r
-//  .trigger      = DAC_TRG(0)\r
-//};\r
-\r
-class dGPT {\r
-public:\r
-    constexpr dGPT(GPTDriver& driver, const GPTConfig& config) :\r
-        m_driver(&driver), m_config(config) {}\r
-\r
-    void init() {\r
-        gptStart(m_driver, &m_config);\r
-    }\r
-\r
-    void startContinuous(unsigned int interval) {\r
-        gptStartContinuous(m_driver, interval);\r
-    }\r
-\r
-    void stop() {\r
-        gptStopTimer(m_driver);\r
-    }\r
-\r
-private:\r
-    GPTDriver *m_driver;\r
-    GPTConfig m_config;\r
-};\r
-\r
-static dGPT gpt (GPTD4, {\r
-  .frequency    =  1000000,\r
-  .callback     =  NULL,\r
-  .cr2          =  TIM_CR2_MMS_1,   /* MMS = 010 = TRGO on Update Event.    */\r
-  .dier         =  0\r
-});\r
-\r
-static const ADCConfig adcConfig = {\r
-  .difsel = 0\r
-};\r
-\r
-volatile bool adcFinished = false;\r
-void adcEndCallback(ADCDriver *adcd)\r
-{\r
-    (void)adcd;\r
-    gpt.stop();\r
-    adcFinished = true;\r
-}\r
-\r
-static const ADCConversionGroup adcGroupConfig = {\r
-  .circular     = false,\r
-  .num_channels = 1,\r
-  .end_cb       = adcEndCallback,\r
-  .error_cb     = NULL,\r
-  .cfgr         = ADC_CFGR_EXTEN_RISING |\r
-                  ADC_CFGR_EXTSEL_SRC(12),  /* TIM4_TRGO */\r
-  .cfgr2        = 0,\r
-  .tr1          = ADC_TR(0, 4095),\r
-  .smpr         = {\r
-    ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_247P5), 0\r
-  },\r
-  .sqr          = {\r
-    ADC_SQR1_SQ1_N(ADC_CHANNEL_IN5),\r
-    0, 0, 0\r
-  }\r
-};\r
+#include "adc.hpp"\r
+#include "dac.hpp"\r
+#include "usbserial.hpp"\r
 \r
 #if CACHE_LINE_SIZE > 0\r
 CC_ALIGN(CACHE_LINE_SIZE)\r
@@ -94,47 +11,29 @@ CC_ALIGN(CACHE_LINE_SIZE)
 adcsample_t samples[CACHE_SIZE_ALIGN(adcsample_t, 10)];\r
 \r
 int main(void) {\r
-       halInit();\r
-       chSysInit();\r
-\r
-       palSetPadMode(GPIOA, 5,  PAL_MODE_OUTPUT_PUSHPULL); // LED\r
-       palSetPadMode(GPIOA, 11, PAL_MODE_ALTERNATE(10));   // USB\r
-       palSetPadMode(GPIOA, 12, PAL_MODE_ALTERNATE(10));\r
-    palSetPadMode(GPIOA, 0,  PAL_MODE_INPUT_ANALOG);    // Channel A in (1in5)\r
+    halInit();\r
+    chSysInit();\r
 \r
-    palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG);     // DAC out1, out2\r
-    palSetPadMode(GPIOA, 5, PAL_MODE_INPUT_ANALOG);\r
+    palSetPadMode(GPIOA, 5,  PAL_MODE_OUTPUT_PUSHPULL); // LED\r
 \r
-    gpt.init();\r
+    ADCd adc (ADCD1, GPTD4);\r
+    adc.start();\r
 \r
-    //dDAC dac (DACD1, {\r
+    //DACd dac (DACD1, {\r
     //    .init         = 0,\r
     //    .datamode     = DAC_DHRM_12BIT_RIGHT,\r
     //    .cr           = 0\r
     //});\r
+    //dac.start();\r
+    //dac.write(0, 1024);\r
 \r
-    //dac.init();\r
-    //dac.writeX(0, 1024);\r
-\r
-    adcStart(&ADCD1, &adcConfig);\r
-    adcSTM32EnableVREF(&ADCD1);\r
-\r
-       sduObjectInit(&SDU1);\r
-       sduStart(&SDU1, &serusbcfg);\r
-       usbDisconnectBus(serusbcfg.usbp);\r
-       chThdSleepMilliseconds(1500);\r
-       usbStart(serusbcfg.usbp, &usbcfg);\r
-       usbConnectBus(serusbcfg.usbp);\r
+    USBSeriald usbd (SDU1);\r
+    usbd.start();\r
 \r
        while (true) {\r
-        if (SDU1.config->usbp->state == USB_ACTIVE) {\r
-            BaseSequentialStream *bss = (BaseSequentialStream *)&SDU1;\r
-            char c = 0;\r
-            if (streamRead(bss, (uint8_t *)&c, 1) > 0 && c == 's') {\r
-                adcFinished = false;\r
-                adcStartConversion(&ADCD1, &adcGroupConfig, samples, 10);\r
-                gpt.startContinuous(100);\r
-                while (!adcFinished);\r
+        if (usbd.active()) {\r
+            if (char c; usbd.read(&c) > 0 && c == 's') {\r
+                adc.getSamples(samples, 10);\r
                 for (int i = 0; i < 10; i++) {\r
                     uint8_t str[5] = {\r
                         static_cast<uint8_t>(samples[i] / 1000 % 10 + '0'),\r
@@ -143,9 +42,9 @@ int main(void) {
                         static_cast<uint8_t>(samples[i] % 10 + '0'),\r
                         ' '\r
                     };\r
-                    streamWrite(bss, str, 5);\r
+                    usbd.write(str, 5);\r
                 }\r
-                streamWrite(bss, (uint8_t *)"\r\n", 2);\r
+                usbd.write("\r\n", 2);\r
             }\r
         }\r
                chThdSleepMilliseconds(250);\r

diff --git a/source/usbcfg.h b/source/usbcfg.h
index 886cd022274fb44c2bad508be7308a75e5c13598..2fceccb48be5ef8e971f11a944f7ea6f9c246b23 100644 (file)
--- a/source/usbcfg.h
+++ b/source/usbcfg.h
@@ -17,6 +17,8 @@
 #ifndef USBCFG_H\r
 #define USBCFG_H\r
 \r
+#include "hal.h"\r
+\r
 extern const USBConfig usbcfg;\r
 extern SerialUSBConfig serusbcfg;\r
 extern SerialUSBDriver SDU1;\r

diff --git a/source/usbserial.cpp b/source/usbserial.cpp
new file mode 100644 (file)
index 0000000..cead28a
--- /dev/null
+++ b/source/usbserial.cpp
@@ -0,0 +1,41 @@
+#include "usbserial.hpp"
+
+#include "hal.h"
+
+void USBSeriald::start()
+{
+    initPins();
+
+    sduObjectInit(m_driver);
+    sduStart(m_driver, &serusbcfg);
+
+    // Reconnect bus so device can re-enumerate on reset
+    usbDisconnectBus(serusbcfg.usbp);
+    chThdSleepMilliseconds(1500);
+    usbStart(serusbcfg.usbp, &usbcfg);
+    usbConnectBus(serusbcfg.usbp);
+}
+
+bool USBSeriald::active() const
+{
+    return m_driver->config->usbp->state == USB_ACTIVE;
+}
+
+std::size_t USBSeriald::read(void *buffer, std::size_t count)
+{
+    auto *bss = reinterpret_cast<BaseSequentialStream *>(m_driver);
+    return streamRead(bss, static_cast<uint8_t *>(buffer), count);
+}
+
+std::size_t USBSeriald::write(const void *buffer, std::size_t count)
+{
+    auto *bss = reinterpret_cast<BaseSequentialStream *>(m_driver);
+    return streamWrite(bss, static_cast<const uint8_t *>(buffer), count);
+}
+
+void USBSeriald::initPins()
+{
+    palSetPadMode(GPIOA, 11, PAL_MODE_ALTERNATE(10));
+    palSetPadMode(GPIOA, 12, PAL_MODE_ALTERNATE(10));
+}
+

diff --git a/source/usbserial.hpp b/source/usbserial.hpp
new file mode 100644 (file)
index 0000000..a65190b
--- /dev/null
+++ b/source/usbserial.hpp
@@ -0,0 +1,28 @@
+#ifndef STMDSP_USBSERIAL_HPP_
+#define STMDSP_USBSERIAL_HPP_
+
+#include "usbcfg.h"
+
+#include <cstddef>
+
+class USBSeriald
+{
+public:
+    constexpr explicit USBSeriald(SerialUSBDriver& driver) :
+        m_driver(&driver) {}
+
+    void start();
+
+    bool active() const;
+
+    std::size_t read(void *buffer, std::size_t count = 1);
+    std::size_t write(const void *buffer, std::size_t count = 1);
+
+private:
+    SerialUSBDriver *m_driver;
+
+    void initPins();
+};
+
+#endif // STMDSP_USBSERIAL_HPP_
+