M5Stamp C3 Mateを試してみました【Arduino使用】

Wire.begin(0, 1);

#include <soc/dport_reg.h>

#if __has_include (<soc/dport_reg.h>)
#include <soc/dport_reg.h>
#endif

#include <Adafruit_NeoPixel.h>

#define LED_PIN 2

#define COLOR_REPEAT 2

// create a pixel strand with 1 pixel on PIN_NEOPIXEL
Adafruit_NeoPixel pixels(1, LED_PIN);

uint8_t color = 0, count = 0;
uint32_t colors[] = {pixels.Color(125, 0, 0), pixels.Color(0, 125, 0), pixels.Color(0, 0, 125), pixels.Color(125, 125, 125)};
const uint8_t COLORS_LEN = (uint8_t)(sizeof(colors) / sizeof(colors[0]));

void setup() {
  pixels.begin();  // initialize the pixel
}

void loop() {
  pixels.setPixelColor(0, colors[color]);
  pixels.show();
  
  delay(1000);
  
  pixels.clear();
  pixels.show();
  
  delay(1000);
  
  count++;

  if(count >= COLOR_REPEAT) {
    count = 0;
    color++;
    if(color >= COLORS_LEN) {
      color = 0;
    }
  }
}

#include <Adafruit_NeoPixel.h>

#define LED_PIN 2
#define MAX_BRIGHTNESS 255

Adafruit_NeoPixel pixels(1, LED_PIN);

int rgbValues[] = {MAX_BRIGHTNESS, 0, 0}; // 0=Red, 1=Green and 2=Blue
int upIndex = 0, downIndex = 1;

void setup()
{
  pixels.begin(); // initialize the pixel
}

void loop()
{
  rgbValues[upIndex] += 1;
  rgbValues[downIndex] -= 1;

  if (rgbValues[upIndex] > MAX_BRIGHTNESS)
  {
    rgbValues[upIndex] = MAX_BRIGHTNESS;
    upIndex = upIndex + 1;

    if (upIndex > 2)
    {
      upIndex = 0;
    }
  }

  if (rgbValues[downIndex] < 0)
  {
    rgbValues[downIndex] = 0;
    downIndex = downIndex + 1;

    if (downIndex > 2)
    {
      downIndex = 0;
    }
  }

  pixels.setPixelColor(0, pixels.Color(MAX_BRIGHTNESS - rgbValues[0], MAX_BRIGHTNESS - rgbValues[1], MAX_BRIGHTNESS - rgbValues[2]));
  pixels.show();

  delay(5);
}

#include <Adafruit_NeoPixel.h>

#define BTN 3

#define LED_PIN 2

#define TOGGLE_PERIOD (1000u)

#define LED_STAND_BY_COLOR 0xffffff
#define LED_READY_COLOR 0xff0000

Adafruit_NeoPixel pixels(1, LED_PIN);

uint8_t rgbValues[7][3] = {
    {255, 0, 0}, {255, 165, 0}, {255, 255, 0}, {0, 128, 0}, {0, 255, 255}, {0, 0, 255}, {128, 0, 128}};

int16_t randNumber;

int16_t brightness = 0;
int16_t fadeAmount = 10;

void toggleLED_nb(void)
{
  static bool toggle = true;
  static auto lastToggle = millis(); // saved between calls
  auto now = millis();

  if (now - lastToggle > TOGGLE_PERIOD)
  {
    if (toggle)
    {
      pixels.setPixelColor(0, LED_STAND_BY_COLOR);
      pixels.setBrightness(18);
      pixels.show();
    }
    else
    {
      pixels.clear();
      pixels.show();
    }
    toggle = !toggle;
    lastToggle = now;
  }
}

void readyLED()
{
  for (uint8_t i = 0; i < 3; i++)
  {
    brightness = 0;
    pixels.clear();
    pixels.show();
    delay(100);

    for (uint8_t j = 0; j < (100 / fadeAmount); j++)
    {
      pixels.setPixelColor(0, LED_READY_COLOR);
      pixels.setBrightness(brightness);
      pixels.show();

      brightness = brightness + fadeAmount;
      delay(80);
    }

    delay(1000);
  }
  brightness = 150;
  pixels.setPixelColor(0, LED_READY_COLOR);
  pixels.setBrightness(brightness);
  pixels.show();
  delay(3000);
}

void successLED()
{
  for (uint8_t i = 0; i < 8; i++)
  {
    for (uint8_t j = 0; j < 7; j++)
    {
      pixels.setPixelColor(0, pixels.Color(rgbValues[j][0], rgbValues[j][1], rgbValues[j][2]));
      pixels.setBrightness(18);
      pixels.show();
      delay(50);
    }
  }
}

void failureLED()
{
  while (0 < brightness)
  {
    pixels.setPixelColor(0, LED_READY_COLOR);
    pixels.setBrightness(brightness);
    pixels.show();

    brightness = brightness - fadeAmount;
    delay(80);
  }

  pixels.clear();
  pixels.show();
  delay(200);
  pixels.setPixelColor(0, LED_READY_COLOR);
  pixels.setBrightness(10);
  pixels.show();
  delay(150);
}

void setup()
{
  pinMode(BTN, INPUT_PULLUP);

  pixels.begin();
  while (digitalRead(BTN) == HIGH)
  {
    toggleLED_nb();
    delay(10);
  }

  // 抽選
  randomSeed(analogRead(0));
  randNumber = (int16_t)random(0xffff + 1);

  readyLED();

  if (randNumber < 0)
  {
    // おめでとう
    successLED();
  }
  else
  {
    // 残念
    failureLED();
  }

  pixels.clear();
  pixels.show();
}

void loop()
{
}

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <Adafruit_NeoPixel.h>

const char* ssid = "........";
const char* password = "........";

WebServer server(80);

#define LED_PIN 2
Adafruit_NeoPixel pixels(1, LED_PIN);

void led_on() {
  pixels.setPixelColor(0, pixels.Color(125, 0, 0));
  pixels.show();
}

void led_off() {
  pixels.clear();
  pixels.show();  
}

void handleRoot() {
  led_on();
  server.send(200, "text/plain", "hello from esp32!");
  led_off();
}

void handleNotFound() {
  led_on();
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
  led_off();
}

void setup(void) {
  pixels.begin();
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp32")) {
    Serial.println("MDNS responder started");
  }

  server.on("/", handleRoot);

  server.on("/inline", []() {
    server.send(200, "text/plain", "this works as well");
  });

  server.onNotFound(handleNotFound);

  server.begin();
  Serial.println("HTTP server started");
}

void loop(void) {
  server.handleClient();
  delay(2);//allow the cpu to switch to other tasks
}

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

BLEServer *pServer = NULL;
BLECharacteristic * pTxCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;

#define TXVALUE_SIZE 64
uint8_t txValue[TXVALUE_SIZE];
size_t size;

// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID           "6b02758a-24f2-11ed-861d-0242ac120002" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6b027832-24f2-11ed-861d-0242ac120002"
#define CHARACTERISTIC_UUID_TX "6b02797c-24f2-11ed-861d-0242ac120002"

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");
        for (int i = 0; i < rxValue.length(); i++)
          Serial.print(rxValue[i]);

        Serial.println();
        Serial.println("*********");
      }
    }
};


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

  // Create the BLE Device
  BLEDevice::init("ESP32-C3 UART Service");

  // Create the BLE Server
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Create the BLE Service
  BLEService *pService = pServer->createService(SERVICE_UUID);

  // Create a BLE Characteristic
  pTxCharacteristic = pService->createCharacteristic(
										CHARACTERISTIC_UUID_TX,
										BLECharacteristic::PROPERTY_NOTIFY
									);
                      
  pTxCharacteristic->addDescriptor(new BLE2902());

  BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
											 CHARACTERISTIC_UUID_RX,
											BLECharacteristic::PROPERTY_WRITE
										);

  pRxCharacteristic->setCallbacks(new MyCallbacks());

  // Start the service
  pService->start();

  // Start advertising
  pServer->getAdvertising()->start();
  Serial.println("Waiting a client connection to notify...");
}

void loop() {

    if (deviceConnected) {
      while (Serial.available())
      {
        size = Serial.readBytes(txValue, TXVALUE_SIZE);
        pTxCharacteristic->setValue(txValue, size);
        pTxCharacteristic->notify();
      }
      delay(10); // bluetooth stack will go into congestion, if too many packets are sent
    }

    // disconnecting
    if (!deviceConnected && oldDeviceConnected) {
        delay(500); // give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); // restart advertising
        Serial.println("start advertising");
        oldDeviceConnected = deviceConnected;
    }
    // connecting
    if (deviceConnected && !oldDeviceConnected) {
		// do stuff here on connecting
        oldDeviceConnected = deviceConnected;
    }
}

https://github.com/earlephilhower/arduino-littlefs-upload/releases

#include <LittleFS.h>
#include <LovyanGFX.hpp>

// グラフィックボードのピン配置(M5Stamp C3)
#define TFT_MISO -1
#define TFT_MOSI 6
#define TFT_SCLK 4
// #define TFT_CS 7   // Chip select control pin
#define TFT_DC 8    // Data Command control pin
#define TFT_RST 10  // Reset pin (could connect to RST pin)
// ST7789の場合バックライト(ピン)はプルアップされるのでコメント
// #define TFT_BL 22

// ST7789 1.3インチ CSなし
class LGFX : public lgfx::LGFX_Device {
  lgfx::Panel_ST7789 _panel_instance;
  lgfx::Bus_SPI _bus_instance;  // SPIバスのインスタンス

public:
  LGFX(void) {
    {                                     // バス制御の設定を行います。
      auto cfg = _bus_instance.config();  // バス設定用の構造体を取得します。

      // SPIバスの設定
      cfg.spi_host = SPI2_HOST;
      cfg.spi_mode = 0;           // SPI通信モードを設定 (0 ~ 3)
      cfg.freq_write = 40000000;  // 送信時のSPIクロック (最大80MHz, 80MHzを整数で割った値に丸められます)
      cfg.freq_read = 20000000;   // 受信時のSPIクロック

      //      cfg.spi_3wire  = true;        // 受信をMOSIピンで行う場合はtrueを設定
      //      cfg.use_lock   = true;        // トランザクションロックを使用する場合はtrueを設定
      cfg.dma_channel = SPI_DMA_CH_AUTO;  // 使用するDMAチャンネルを設定 (0=DMA不使用 / 1=1ch / 2=ch / SPI_DMA_CH_AUTO=自動設定)

      cfg.pin_sclk = TFT_SCLK;  // SPIのSCLKピン番号を設定
      cfg.pin_mosi = TFT_MOSI;  // SPIのMOSIピン番号を設定
      cfg.pin_miso = TFT_MISO;  // SPIのMISOピン番号を設定 (-1 = disable)
      cfg.pin_dc = TFT_DC;      // SPIのD/Cピン番号を設定  (-1 = disable)

      _bus_instance.config(cfg);               // 設定値をバスに反映します。
      _panel_instance.setBus(&_bus_instance);  // バスをパネルにセットします。
    }

    {                                       // 表示パネル制御の設定を行います。
      auto cfg = _panel_instance.config();  // 表示パネル設定用の構造体を取得します。

      cfg.pin_cs = -1;    // CSが接続されているピン番号   (-1 = disable)
      cfg.pin_rst = -1;   // RSTが接続されているピン番号  (-1 = disable)
      cfg.pin_busy = -1;  // BUSYが接続されているピン番号 (-1 = disable)

      cfg.panel_width = 240;   // 実際に表示可能な幅
      cfg.panel_height = 240;  // 実際に表示可能な高さ

      cfg.invert = true;  // パネルの明暗が反転してしまう場合 trueに設定
      // cfg.rgb_order = true; // パネルの赤と青が入れ替わってしまう場合 trueに設定

      _panel_instance.config(cfg);
    }

    setPanel(&_panel_instance);  // 使用するパネルをセットします。

    lgfx::pinMode(TFT_RST, lgfx::pin_mode_t::output);
    lgfx::pinMode(TFT_SCLK, lgfx::pin_mode_t::output);

    lgfx::gpio_lo(TFT_RST);
    lgfx::gpio_hi(TFT_SCLK);
    lgfx::gpio_hi(TFT_RST);
  }
};

const unsigned long displayDuration = 2000;  // Display time (2 seconds)

LGFX lcd;  // LGFX instance
std::vector<String> fileList;
int currentIndex = 0;
int32_t screenWidth;
int32_t screenHeight;

void initFileSystem() {
  if (!LittleFS.begin()) {
    Serial.println("Failed to mount LittleFS");
    for (;;) yield();
  }
}

void createFileList() {
  File root = LittleFS.open("/", "r");
  File file = root.openNextFile();

  while (file) {
    String filePath = file.path();
    if (filePath.endsWith(".jpg") || filePath.endsWith(".png")) {
      fileList.push_back(filePath);
    }
    file = root.openNextFile();
  }
  root.close();

  if (fileList.empty()) {
    Serial.println("No image files found in LittleFS.");
    for (;;) yield();
  }
}

// Get JPEG image size
bool getJpgSize(File &file, int &width, int &height) {
  uint8_t data[5];
  file.read(data, 2);

  if (data[0] == 0xFF && data[1] == 0xD8) {
    while (file.read(data, 4) == 4) {
      if (data[0] == 0xFF && (data[1] >= 0xC0 && data[1] <= 0xC3)) {
        file.read(data, 5);
        height = data[1] << 8 | data[2];
        width = data[3] << 8 | data[4];
        return true;
      } else {
        uint16_t size = data[2] << 8 | data[3];
        file.seek(file.position() + size - 2);
      }
    }
  }
  return false;
}

// Get PNG image size
bool getPngSize(File &file, int &width, int &height) {
  uint8_t data[24];
  if (file.read(data, 24) == 24) {
    if (data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47) {
      width = data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19];
      height = data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23];
      return true;
    }
  }
  return false;
}

void drawImage(const String &fileName) {
  File file = LittleFS.open(fileName, "r");
  if (!file) {
    Serial.println("Failed to open file: " + fileName);
    return;
  }

  int imgWidth = 0, imgHeight = 0;
  bool validImage = false;
  bool isJpg = false;

  // 画像サイズ取得
  if (fileName.endsWith(".jpg")) {
    validImage = getJpgSize(file, imgWidth, imgHeight);
    isJpg = true;
  } else if (fileName.endsWith(".png")) {
    validImage = getPngSize(file, imgWidth, imgHeight);
  }

  if (!validImage) {
    file.close();
    Serial.println("Invalid or unsupported image format.");
    return;
  }

  // ファイル開始位置を戻す
  file.seek(0);

  // スケーリング
  float scaleX = static_cast<float>(screenWidth) / imgWidth;
  float scaleY = static_cast<float>(screenHeight) / imgHeight;
  float scale = min(scaleX, scaleY);

  // x座標 センタリング
  int32_t x = (screenWidth - imgWidth * scale) / 2;

  lcd.startWrite();
  lcd.clear();
  if (isJpg) {
    lcd.drawJpg(&file, x, 0, screenWidth, screenHeight, 0, 0, scale);
  } else {
    lcd.drawPng(&file, x, 0, screenWidth, screenHeight, 0, 0, scale);
  }
  lcd.endWrite();
  file.close();
}

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

#ifdef TFT_BL
  // バックライトを設定
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);
#endif

  // LCD初期化
  lcd.init();
  screenWidth = lcd.width();
  screenHeight = lcd.height();

  // LittleFSのファイルリストを作成
  initFileSystem();
  createFileList();
}

void loop() {
  // 画像を描画
  drawImage(fileList[currentIndex]);
  // 次の画像(インデックス)
  currentIndex = (currentIndex + 1) % fileList.size();
  delay(displayDuration);
}