#define ESP32 // so that settings.h works for all boards

#include "utils.h"

// Either: For using the C exercises, define this macro
// or: For using the Cpp exercises, uncomment this macro
// #define C_BEISPIELE

#ifdef C_BEISPIELE
  #include "c-exercises.h"
  namespace N_Beispiele=N_C_Beispiele;
#else
  #include "cpp-exercises.h"
  namespace N_Beispiele=N_Cpp_Beispiele;
#endif

void setup() 
{
  Serial.println("ESP32 circuit for Embedded C++ (www.rkaiser.de)");
  N_Beispiele::setup();
}

void loop()
{
  N_Beispiele::loop();
}


sketch.ino

diagram.json

#ifndef UTILS_EMBEDDED_CPP_H
#define UTILS_EMBEDDED_CPP_H


#include <cstdint> // for uint32_t etc.
#include <iostream>


/* alt, raus
void setup_serial_port() // ??? noch nach utils
{
  Serial.begin(115200); // Initialize the serial port.
  //   Baud rate: The number of bits transmitted per
  //   second. Typical values are e.g. 9600 or 19'200.
  //   High values like 115.200 are ok for most boards
  while (!Serial)  // Wait for the serial port to connect.
    ;              // This is only necessary for older boards.
  // Serial.println("Greetings from setup");
  Serial.println("Embedded C++ (www.rkaiser.de)");
}
*/

void setup_serial_port() // ??? ..\Beispiele\Embedded-Cpp\Wokwi-Libraries\utils.h -- 3.2
{
  Serial.begin(115200); // Initialize the serial port. 
  //   Baud rate: The number of bits transmitted per 
  //   second. Typical values are e.g. 9600 or 19200. 
  //   High values like 115200 are ok for most boards
  while (!Serial) // Wait for the serial port to connect.
    ;              // This is only necessary for older boards.
  delay(100);   // For some boards you have to wait a little more
  Serial.println("Embedded C++ (www.rkaiser.de) - serial port ready");
}



namespace N_Pins // Pin numbers for the Wokwi circuits from section 
{ // 2.3.1. Use the onboard-LED symbols if they are defined. The
  // macros for the projects are defined in the ino-file.
  // ??? D:\cpp-2015.boo\Beispiele\Embedded-Cpp\Utils.h
#ifdef RASPI_PICO_W // macro for the Raspberry project 
  const uint32_t pin_onboard_LED = PICO_DEFAULT_LED_PIN; // 25
  const uint32_t pin_onboard_PushButton = 25; // ???
#elif defined ESP32 // macro defined in *.ino for the ESP32 project
  const uint32_t pin_onboard_LED = 2; // ESP32
  const uint32_t pin_onboard_PushButton = 2; // ???
#elif defined STM32_NUCLEO // macro for the STM32 project
  const uint32_t pin_onboard_LED = LED_BUILTIN; // STM32 Nucleo 32: 23, 64: 52, 144: 117
  const uint32_t pin_onboard_PushButton = 13; // ???
#elif defined _DESKTOP_APP
 // no pins
  const uint32_t A0 = 0; // 
#else
#error You have to define a macro for the board you are working with in the ino file of your project, e.g. #define MY_BOARD
  const uint32_t pin_onboard_LED = 0;        // Take the values 
  const uint32_t pin_onboard_PushButton = 0; // for your board
#endif 
  // Global variables should always be const (C++ core guidelines 
  // I.2, R.6). Prefer variables to macros. Some syntactic variants
  const uint32_t pin_red_light = 2; // traditional syntax with =    ??? nur red_light
  const uint32_t pin_yellow_light = { 4 };//initializer list with = 
  const uint32_t pin_green_light{ 5 };   // initializer list with {}
  const uint32_t pin_potentiometer = { A0 }; // ??? korrigiert
  const uint32_t pin_HC_SR04_trigger = 12;
  const uint32_t pin_HC_SR04_echo = 13;
  const uint32_t pin_pushButton = 14;
  // Macros used only in the first traffic light example in C. You 
  // can comment them out if you are not working with this example. 
#define RED 2    // It has no effect that these macros 
#define YELLOW 4 // are inside a namespace
#define GREEN 5

  namespace N_typesafe_pin_type // only an excercise
  {
    class TypeSafe
    {
    public:
      enum class Pins
      {
        pin_red_light = pin_red_light,
        pin_yellow_light = pin_yellow_light,
        pin_green_light = pin_green_light,
        pin_potentiometer = pin_potentiometer,
        pin_HC_SR04_trigger = pin_HC_SR04_trigger,
        pin_HC_SR04_echo = pin_HC_SR04_echo,
        pin_pushButton = pin_pushButton
      };

      enum class State { High = HIGH, Low = LOW };

      static void DigitalWrite(Pins pin, State state)
      {
        digitalWrite(static_cast<uint32_t>(pin), static_cast<uint32_t>(state));
      }

      void test()
      {
        TypeSafe::DigitalWrite(Pins::pin_green_light, State::High);
      }
    };
  }

} // namespace N_Pins

namespace N_Traffic_Lights
{ // Values common to the traffic light examples
  // There will be examples where the duration needs to be modified
  uint32_t duration_red_phase{ 5000 };       // therefore not const 
  uint32_t duration_red_yellow_phase{ 1000 };
  uint32_t duration_green_phase{ 5000 };
  uint32_t duration_yellow_phase{ 1000 };
} // namespace N_Traffic_Lights

void show_gcc_version()
{ // In a Wokwi project for a Raspberry Pi Pico, you eventually have
  // to use 'Serial1' instead of 'Serial' (see section 3.2.1.2)
  Serial.println("Examples: Various ways to print the GCC Version ");
  Serial.print("1. Serial.println GCC Version: ");
  Serial.print(__GNUC__); Serial.print(".");
  Serial.print(__GNUC_MINOR__); Serial.print(".");
  Serial.println(__GNUC_PATCHLEVEL__);
  // the same with printf in the C way
  printf("2. Printf GCC Version: %d.%d.%d\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
  // the same with std::cout, requires #include <iostream>
  // and a board with enough memory (see section 3.2.1.1)
#ifndef SMALL_MEMORY // A board with not enough memory for std::cout
  std::cout << "3. std::cout GCC Version: " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__ << std::endl;
#endif
  std::string vs = "std::string GCC Version: " +
    std::to_string(__GNUC__) +
    "." + std::to_string(__GNUC_MINOR__) +
    "." + std::to_string(__GNUC_PATCHLEVEL__);
  printf("%s\n", ("4. printf " + vs).c_str()); // printf in the C++ way
  Serial.println(("5. Serial.println " + vs).c_str());
  // 5. Serial.println accepts char* arguments, but not std::string
}                                                     // arguments 

#endif // UTILS_EMBEDDED_CPP_H
