merge elf loading and adc streaming

diff --cc source/adc.cpp
index e754e0e3c083e6590b87434aabde737f081f2515,609ffce7f222ab55573bc1f981ef43adcba68515..f2903c39fbd21f16c643917dadbe88c4e04cfd18
--- 1/source/adc.cpp
--- 2/source/adc.cpp
+++ b/source/adc.cpp
@@@ -45,96 -45,65 +45,99 @@@ constexpr static const GPTConfig gpt_co
  };
  
  static bool adc_is_read_finished = false;
- static bool adc_is_read_continuous = false;
 -
 -void adc_read_callback([[maybe_unused]] ADCDriver *driver)
 -{
 -    gptStopTimer(gptd);
 -    adc_is_read_finished = true;
 -}
 +static adcsample_t *adc_current_buffer = nullptr;
 +static size_t adc_current_buffer_size = 0;
- static adc_operation_t adc_operation_func = nullptr;
++static adc::operation_t adc_operation_func = nullptr;
  
- void adc_init()
+ namespace adc
  {
-     palSetPadMode(GPIOA, 0, PAL_MODE_INPUT_ANALOG);
- 
-     gptStart(gptd, &gpt_config);
-     adcStart(adcd, &adc_config);
-     adcSTM32EnableVREF(adcd);
- }
- 
- adcsample_t *adc_read(adcsample_t *buffer, size_t count)
- {
-     adc_is_read_finished = false;
-     adc_is_read_continuous = false;
-     adc_group_config.circular = false;
-     adcStartConversion(adcd, &adc_group_config, buffer, count);
-     gptStartContinuous(gptd, 100); // 10kHz
-     while (!adc_is_read_finished);
-     return buffer;
- }
- 
- void adc_read_start(adc_operation_t operation_func, adcsample_t *buffer, size_t count)
- {
-     adc_is_read_continuous = true;
-     adc_current_buffer = buffer;
-     adc_current_buffer_size = count;
-     adc_operation_func = operation_func;
-     adc_group_config.circular = true;
-     adcStartConversion(adcd, &adc_group_config, buffer, count);
-     gptStartContinuous(gptd, 100); // 10kHz
- }
+     void init()
+     {
+         palSetPadMode(GPIOA, 0, PAL_MODE_INPUT_ANALOG);
+     
+         gptStart(gptd, &gpt_config);
+         adcStart(adcd, &adc_config);
+         adcSTM32EnableVREF(adcd);
+     }
+     
+     adcsample_t *read(adcsample_t *buffer, size_t count)
+     {
+         adc_is_read_finished = false;
++        adc_group_config.circular = false;
+         adcStartConversion(adcd, &adc_group_config, buffer, count);
+         gptStartContinuous(gptd, 100); // 10kHz
+         while (!adc_is_read_finished);
+         return buffer;
+     }
 +
- void adc_read_stop()
- {
-     adc_is_read_continuous = false;
-     gptStopTimer(gptd);
++    void read_start(operation_t operation_func, adcsample_t *buffer, size_t count)
++    {
++        adc_current_buffer = buffer;
++        adc_current_buffer_size = count;
++        adc_operation_func = operation_func;
++        adc_group_config.circular = true;
++        adcStartConversion(adcd, &adc_group_config, buffer, count);
++        gptStartContinuous(gptd, 100); // 10kHz
++    }
++    
++    void read_stop()
++    {
++        gptStopTimer(gptd);
++        adc_group_config.circular = false;
++        adc_current_buffer = nullptr;
++        adc_current_buffer_size = 0;
++        adc_operation_func = nullptr;
++    }
+  
+     void set_rate(rate r)
+     {
+         uint32_t val = 0;
+     
+         switch (r) {
+         case rate::R2P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_2P5);
+             break;
+         case rate::R6P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_6P5);
+             break;
+         case rate::R12P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_12P5);
+             break;
+         case rate::R24P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_24P5);
+             break;
+         case rate::R47P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_47P5);
+             break;
+         case rate::R92P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_92P5);
+             break;
+         case rate::R247P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_247P5);
+             break;
+         case rate::R640P5:
+             val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_640P5);
+             break;
+         }
+     
+         adc_group_config.smpr[0] = val;
+     }
  }
  
-     if (!adc_is_read_continuous) {
 +void adc_read_callback(ADCDriver *driver)
 +{
- void adc_set_rate(ADCRate rate)
- {
-     uint32_t val = 0;
- 
-     switch (rate) {
-     case ADCRate::R2P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_2P5);
-         break;
-     case ADCRate::R6P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_6P5);
-         break;
-     case ADCRate::R12P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_12P5);
-         break;
-     case ADCRate::R24P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_24P5);
-         break;
-     case ADCRate::R47P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_47P5);
-         break;
-     case ADCRate::R92P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_92P5);
-         break;
-     case ADCRate::R247P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_247P5);
-         break;
-     case ADCRate::R640P5:
-         val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_640P5);
-         break;
-     }
- 
-     adc_group_config.smpr[0] = val;
- }
- 
++    if (!adc_group_config.circular) {
 +        gptStopTimer(gptd);
 +        adc_is_read_finished = true;
 +    } else if (adc_operation_func != nullptr) {
 +        auto half_size = adc_current_buffer_size / 2;
 +        if (driver->state == ADC_ACTIVE) {
 +            // Half full
 +            adc_operation_func(adc_current_buffer, half_size);
 +        } else if (driver->state == ADC_COMPLETE) {
 +            // Second half full
 +            adc_operation_func(adc_current_buffer + half_size, half_size);
 +        }
 +    }
 +}
 +

diff --cc source/adc.hpp
index 15e343a859950741a6b0fb4cc7ebead9318644d3,e026d0c42a17fb3df7a31f7073d7a5f78f4a6385..376b1562ef8b39d6c49125c9081770dbd3169d08
--- 1/source/adc.hpp
--- 2/source/adc.hpp
+++ b/source/adc.hpp
@@@ -14,24 -14,23 +14,27 @@@
  
  #include "hal.h"
  
- enum class ADCRate {
-     R2P5,
-     R6P5,
-     R12P5,
-     R24P5,
-     R47P5,
-     R92P5,
-     R247P5,
-     R640P5
- };
+ namespace adc
+ {
++    using operation_t = void (*)(adcsample_t *buffer, size_t count);
 +
- using adc_operation_t = void (*)(adcsample_t *buffer, size_t count);
- 
- void adc_init();
- adcsample_t *adc_read(adcsample_t *buffer, size_t count);
- void adc_read_start(adc_operation_t operation_func, adcsample_t *buffer, size_t count);
- void adc_read_stop();
- void adc_set_rate(ADCRate rate);
+     enum class rate {
+         R2P5,
+         R6P5,
+         R12P5,
+         R24P5,
+         R47P5,
+         R92P5,
+         R247P5,
+         R640P5
+     };
+     
+     void init();
+     adcsample_t *read(adcsample_t *buffer, size_t count);
++    void read_start(operation_t operation_func, adcsample_t *buffer, size_t count);
++    void read_stop();
+     void set_rate(rate r);
+ }
  
  #endif // STMDSP_ADC_HPP_
  

diff --cc source/main.cpp
index 07c73ba35712791e7fcc7804b166b3a6f54152d8,b5ebf862fb41f68e881bfd7ce7f13c17298ce84e..f1170a6bf54939cd9f8b058a1aa60b82211ff5d0
--- 1/source/main.cpp
--- 2/source/main.cpp
+++ b/source/main.cpp
@@@ -41,26 -39,20 +41,26 @@@ int main(
  
      static unsigned int dac_sample_count = 2048;
        while (true) {
-         if (usbserial_is_active()) {
+         if (usbserial::is_active()) {
              // Expect to receive a byte command 'packet'.
-             if (char cmd[3]; usbserial_read(&cmd, 1) > 0) {
+             if (char cmd[3]; usbserial::read(&cmd, 1) > 0) {
                  switch (cmd[0]) {
                  case 'r': // Read in analog signal
-                     if (usbserial_read(&cmd[1], 2) < 2)
+                     if (usbserial::read(&cmd[1], 2) < 2)
                          break;
                      if (auto count = std::min(static_cast<unsigned int>(cmd[1] | (cmd[2] << 8)), adc_samples.size()); count > 0) {
-                         adc_read(&adc_samples[0], count);
-                         usbserial_write(adc_samples.data(), count * sizeof(adcsample_t));
+                         adc::read(&adc_samples[0], count);
+                         usbserial::write(adc_samples.data(), count * sizeof(adcsample_t));
                      }
                      break;
-                     adc_read_start(signal_operate, &adc_samples[0], adc_samples.size() * sizeof(adcsample_t));
 +                case 'R':
-                     adc_read_stop();
++                    adc::read_start(signal_operate, &adc_samples[0], adc_samples.size() * sizeof(adcsample_t));
 +                    break;
 +                case 'S':
++                    adc::read_stop();
 +                    break;
                  case 'W':
-                     if (usbserial_read(&cmd[1], 2) < 2)
+                     if (usbserial::read(&cmd[1], 2) < 2)
                          break;
                      if (auto count = std::min(static_cast<unsigned int>(cmd[1] | (cmd[2] << 8)), dac_samples.size()); count > 0)
                          dac_sample_count = count;