組込みシステム(くみこみしすてむ)&IoTプログラミング完全ガイド2025:ファームウェア、RTOS、通信プロトコル

const int LED_PIN = 13;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

static const char *TAG = "main";

void app_main(void) {
    ESP_LOGI(TAG, "Hello ESP32!");
    while (1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void sensor_task(void *pv) {
    while (1) {
        float temp = read_temperature();
        printf("T: %.2f\n", temp);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void) {
    xTaskCreate(sensor_task, "sensor", 4096, NULL, 5, NULL);
}

QueueHandle_t xQ;

typedef struct {
    float temperature;
    float humidity;
} sensor_data_t;

void producer(void *pv) {
    sensor_data_t d;
    while (1) {
        d.temperature = read_temp();
        d.humidity = read_humid();
        xQueueSend(xQ, &d, pdMS_TO_TICKS(100));
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void consumer(void *pv) {
    sensor_data_t d;
    while (1) {
        if (xQueueReceive(xQ, &d, portMAX_DELAY)) {
            printf("T=%.1f H=%.1f\n", d.temperature, d.humidity);
        }
    }
}

SemaphoreHandle_t xMutex;
int counter = 0;

void task(void *pv) {
    while (1) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            counter++;
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void *p = pvPortMalloc(256);
if (p) vPortFree(p);
printf("Free: %u\n", xPortGetFreeHeapSize());

#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>

#define LED0_NODE DT_ALIAS(led0)
static const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(LED0_NODE, gpios);

int main(void) {
    gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE);
    while (1) {
        gpio_pin_toggle_dt(&led);
        k_msleep(1000);
    }
    return 0;
}

#include "driver/gpio.h"

void cfg_gpio(void) {
    gpio_config_t c = {
        .intr_type = GPIO_INTR_POSEDGE,
        .mode = GPIO_MODE_INPUT,
        .pin_bit_mask = (1ULL << 4),
        .pull_up_en = 1,
    };
    gpio_config(&c);
}

#include "driver/i2c.h"
#define SENSOR_ADDR 0x76

esp_err_t i2c_init(void) {
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = 21,
        .scl_io_num = 22,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = 400000,
    };
    i2c_param_config(0, &conf);
    return i2c_driver_install(0, conf.mode, 0, 0, 0);
}

#include "driver/spi_master.h"

void spi_init(void) {
    spi_bus_config_t cfg = {
        .miso_io_num = 19,
        .mosi_io_num = 23,
        .sclk_io_num = 18,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4096,
    };
    spi_bus_initialize(HSPI_HOST, &cfg, SPI_DMA_CH_AUTO);
}

#include "driver/uart.h"

void uart_init(void) {
    uart_config_t c = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
    };
    uart_param_config(UART_NUM_1, &c);
    uart_driver_install(UART_NUM_1, 1024, 0, 0, NULL, 0);
}

#include "esp_adc/adc_oneshot.h"

adc_oneshot_unit_handle_t h;

void adc_init(void) {
    adc_oneshot_unit_init_cfg_t init = { .unit_id = ADC_UNIT_1 };
    adc_oneshot_new_unit(&init, &h);
    adc_oneshot_chan_cfg_t cfg = {
        .bitwidth = ADC_BITWIDTH_12,
        .atten = ADC_ATTEN_DB_12,
    };
    adc_oneshot_config_channel(h, ADC_CHANNEL_0, &cfg);
}

#include "driver/ledc.h"

void pwm_init(void) {
    ledc_timer_config_t t = {
        .duty_resolution = LEDC_TIMER_13_BIT,
        .freq_hz = 5000,
    };
    ledc_timer_config(&t);
}

#include <DHT.h>
#define DHTPIN 4
DHT dht(DHTPIN, DHT22);

void setup() {
  Serial.begin(115200);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  Serial.printf("T:%.1f H:%.1f\n", t, h);
  delay(2000);
}

#include <MPU6050.h>

MPU6050 mpu;

void setup() {
  Wire.begin();
  mpu.initialize();
}

void loop() {
  int16_t ax, ay, az, gx, gy, gz;
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  delay(100);
}

#include <TinyGPS++.h>
TinyGPSPlus gps;

void loop() {
  while (Serial2.available()) {
    if (gps.encode(Serial2.read()) && gps.location.isValid()) {
      Serial.printf("%.6f %.6f\n", gps.location.lat(), gps.location.lng());
    }
  }
}

#include "esp_wifi.h"

void wifi_init_sta(void) {
    esp_netif_init();
    esp_event_loop_create_default();
    esp_netif_create_default_wifi_sta();
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);
    wifi_config_t wc = {
        .sta = { .ssid = "MyWiFi", .password = "MyPass" },
    };
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_set_config(WIFI_IF_STA, &wc);
    esp_wifi_start();
}

#include "mqtt_client.h"

esp_mqtt_client_handle_t client;

static void mqtt_event_handler(void *args, esp_event_base_t base,
                                int32_t id, void *data) {
    esp_mqtt_event_handle_t e = data;
    switch ((esp_mqtt_event_id_t)id) {
    case MQTT_EVENT_CONNECTED:
        esp_mqtt_client_subscribe(client, "device/cmd", 1);
        break;
    case MQTT_EVENT_DATA:
        printf("%.*s\n", e->data_len, e->data);
        break;
    default: break;
    }
}

void mqtt_start(void) {
    esp_mqtt_client_config_t cfg = {
        .broker.address.uri = "mqtts://mqtt.example.com:8883",
    };
    client = esp_mqtt_client_init(&cfg);
    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
    esp_mqtt_client_start(client);
}

#include "LoRaWan_APP.h"
uint8_t devEui[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };

void setup() {
  Mcu.begin();
  LoRaWAN.init(loraWanClass, loraWanRegion);
}

void loop() {
  if (deviceState == DEVICE_STATE_SEND) {
    prepareTxFrame(appPort);
    LoRaWAN.send();
  }
  LoRaWAN.cycle(txDutyCycleTime);
}

#include <BLEDevice.h>
#include <BLEServer.h>

BLECharacteristic *pChar;

void setup() {
  BLEDevice::init("ESP32_Sensor");
  BLEServer *s = BLEDevice::createServer();
  BLEService *svc = s->createService("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
  pChar = svc->createCharacteristic(
    "beb5483e-36e1-4688-b7f5-ea07361b26a8",
    BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
  );
  svc->start();
  s->getAdvertising()->start();
}

#include "esp_https_ota.h"

void ota_task(void *pv) {
    esp_http_client_config_t cfg = {
        .url = "https://ota.example.com/firmware.bin",
        .cert_pem = (char *)server_cert_pem_start,
    };
    esp_https_ota_config_t ota = { .http_config = &cfg };
    if (esp_https_ota(&ota) == ESP_OK) {
        esp_restart();
    }
    vTaskDelete(NULL);
}

#include "esp_sleep.h"

RTC_DATA_ATTR int boot_count = 0;

void app_main(void) {
    boot_count++;
    esp_sleep_enable_timer_wakeup(30 * 60 * 1000000ULL);
    esp_deep_sleep_start();
}

#include "tensorflow/lite/micro/micro_interpreter.h"

constexpr int kTensorArenaSize = 100 * 1024;
uint8_t tensor_arena[kTensorArenaSize];

void setup() {
  const tflite::Model* model = tflite::GetModel(g_model);
  static tflite::MicroMutableOpResolver<5> resolver;
  static tflite::MicroInterpreter interpreter(
    model, resolver, tensor_arena, kTensorArenaSize);
  interpreter.AllocateTensors();
  interpreter.Invoke();
}

esp_mqtt_client_config_t cfg = {
    .broker.address.uri = "mqtts://broker.example.com:8883",
    .broker.verification.certificate = (const char*)server_ca_pem,
    .credentials.authentication.certificate = (const char*)client_cert_pem,
    .credentials.authentication.key = (const char*)client_key_pem,
};