Best practices when accessing outside main.cpp

cameron200sx · July 3, 2022, 12:52am

I’m pretty new to PlatformIO and CPP. I have a question regarding organization of code and best practices.

In ‘main.cpp’ we have setup() and loop(). Lets say in setup we have opened a namespace in eeprom to write to. Now, lets say I have a function ‘myfunc.cpp’ that needs to write to eeprom. Of course it has no idea about this as is separate.

Is best practice to create an extern in ‘myfunc.h’ and do the writing back in ‘main.cpp’? Create some sort of ‘main.h’ maybe?

Can’t seem to get my head around accessing things in other functions outside main that are setup inside main’s setup()… If ya get what I mean

Thanks

zapta · March 6, 2023, 6:12pm

When I put functions in a separate .cpp file, I also add a .h file which declares the functions that the .cpp file exports. This is optional but I also put those functions in a namespace that match the file names. Here is an example

This line in setup()

github.com

zapta/ble_stepper_motor_analyzer/blob/6c7dda01dfd17002c12019c417565a9f11afdd45/platformio/src/main.cpp#L90


      
          analyzer::Settings settings;
          if (!nvs_config::read_acquisition_settings(&settings)) {
            ESP_LOGE(TAG, "Failed to read settings, will use default.");
            settings = kDefaultSettings;
          }
          ESP_LOGI(TAG, "Settings: %d, %d, %d", settings.offset1, settings.offset2,
              settings.is_reverse_direction);
          
          
// Init acquisition.
          analyzer::setup(settings);
          adc_task::setup();
          
          
// Determine the confiuration to pass to ble host.
          const uint8_t hardware_config = io::read_hardware_config();
          ESP_LOGI(TAG, "Hardware config: %hhu", hardware_config);
          const uint16_t adc_ticks_per_amp =
              determine_adc_ticks_per_amp(hardware_config);
          if (!adc_ticks_per_amp) {
            ESP_LOGE(TAG, "Invalid hardware config: %hhu", hardware_config);
            assert(0);
          }

Uses this function which is declared and implemented in a .h and .cpp file respectively

github.com

zapta/ble_stepper_motor_analyzer/blob/main/platformio/src/acquisition/adc_task.h#L7


      
          #pragma once
          
          
#include "esp_adc/adc_continuous.h"
          
          
namespace adc_task {
          
          
void setup();
          void dump_stats();
          
          
}  // namespace adc_task

github.com

zapta/ble_stepper_motor_analyzer/blob/main/platformio/src/acquisition/adc_task.cpp#L161


      
              samples_to_snapshot += kValuePairsPerBuffer;
              if (samples_to_snapshot >= 800) {
                analyzer::isr_snapshot_state();
                samples_to_snapshot = 0;
              }
              xSemaphoreGive(stats_mutex);
              analyzer::exit_mutex();
            }
          }
          
          
void setup() {
            stats_mutex = xSemaphoreCreateMutex();
            assert(stats_mutex);
          
          
  ESP_ERROR_CHECK(adc_continuous_new_handle(&continious_config, &handle));
            ESP_ERROR_CHECK(adc_continuous_config(handle, &dig_cfg));
            ESP_ERROR_CHECK(adc_continuous_start(handle));
          
          
  TaskHandle_t xHandle = NULL;
            // Create the task, storing the handle.  Note that the passed parameter
            // ucParameterToPass must exist for the lifetime of the task, so in this case

The namespaces are optional, to improve readability. Also, for functions and global variables that you don’t want to allow other files to use, also add ‘static’ at the beginning of the line.