【Arduino】ESP32-S3 DevkitC-1を使う

#define IO_PIN    (4)

void setup()
{
  pinMode(IO_PIN, OUTPUT);
}

void loop()
{
  while(1)
  {
    digitalWrite(IO_PIN, HIGH);
    digitalWrite(IO_PIN, LOW);
  }
}

#define BUTTON_PIN    (5)
#define LED_PIN       (4)

void setup()
{
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLDOWN);
}

void loop()
{
  digitalWrite(LED_PIN, digitalRead(BUTTON_PIN));
}

#define PWM_PIN     (0)

void setup()
{
  int16_t tblPWM[] = {(0xff * 0.25), (0xff * 0.50), (0xff * 0.75)};
  int16_t tableCount = sizeof(tblPWM) / sizeof(int16_t);

  pinMode(PWM_PIN, OUTPUT);

  while(1)
  {
    for(int16_t i = 0; i < tableCount; i ++)
    {
      analogWrite(PWM_PIN, tblPWM[i]);
      delay(1000);
    }
  }
}

void loop()
{
}

#define ADC_PIN   (A0)

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

  pinMode(ADC_PIN, INPUT);

  while(1)
  {
    delay(2);
    Serial.println(analogRead(ADC_PIN));
  }
}

void loop()
{
}

#define UART_TX    (19)
#define UART_RX    (20)

void setup()
{
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, UART_RX, UART_TX);
}

void loop()
{
  if(Serial1.available() != 0)
  {
      Serial1.printf("Serial1 %c\r\n", Serial1.read());
  }

  if(Serial.available() != 0)
  {
      Serial.printf("Serial %c\r\n", Serial.read());
  }
}

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

#define OLED_RESET     -1
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define PIN_SDA    (8)
#define PIN_SCL    (9)                                   
void setup()
{
//  Wire.setPins(PIN_SDA, PIN_SCL);

  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    for(;;);
  }

  display.clearDisplay();
  
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(20, 5);
  display.print(F("TAMANEGI"));
  display.setCursor(20, 25);
  display.print(F("ESP32-S3"));
  display.setCursor(15, 45);
  display.print(F("DevKitC-1"));

  display.display();
}

void loop()
{
}

#include <Adafruit_GFX.h> 
#include <Adafruit_ST7796S.h>
#include <SPI.h>

#define TFT_CS     (SS)
#define TFT_RST    (4)
#define TFT_DC     (5)
#define TFT_MOSI   (MOSI)
#define TFT_SCK    (SCK)

#define LCD_WIDTH     (320)
#define LCD_HEIGHT    (480)


Adafruit_ST7796S tft = Adafruit_ST7796S(&SPI, TFT_CS, TFT_DC, TFT_RST);

void setup(void) 
{
  //SPI ピン変更をする場合コメントを解除
//  SPI.begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
  tft.init(LCD_WIDTH, LCD_HEIGHT, 0, 0, ST7796S_BGR);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);
  
  tft.setRotation(1);
  tft.setTextSize(4);
  
  tft.setCursor(0, 10);
  tft.setTextColor(ST77XX_GREEN);
  tft.printf("TAMANEGI\n");

  tft.setTextSize(3);
  tft.setTextColor(ST77XX_RED);
  tft.printf("\n3.5inch LCD\n");
  tft.setTextColor(ST77XX_YELLOW);
  tft.printf("Res=%d x %d\n", LCD_WIDTH, LCD_HEIGHT);
  tft.setTextColor(ST77XX_BLUE);
  tft.printf("ST7796S\n");
}

void loop()
{
}

#include <Adafruit_NeoPixel.h>

#define DIN_PIN     (48)
#define LED_COUNT   (9)
#define BRIGHTNESS  (16)

Adafruit_NeoPixel pixels(LED_COUNT, DIN_PIN, NEO_GRB + NEO_KHZ800);

void setup(void) 
{
  pixels.begin();

  pixels.setPixelColor(0, pixels.Color(1, 1, 1));
  pixels.setPixelColor(1, pixels.Color(BRIGHTNESS, 0, 0));
  pixels.setPixelColor(2, pixels.Color(0, BRIGHTNESS, 0));
  pixels.setPixelColor(3, pixels.Color(BRIGHTNESS, BRIGHTNESS, 0));
  pixels.setPixelColor(4, pixels.Color(0, 0, BRIGHTNESS));
  pixels.setPixelColor(5, pixels.Color(BRIGHTNESS, 0, BRIGHTNESS));
  pixels.setPixelColor(6, pixels.Color(0, BRIGHTNESS, BRIGHTNESS));
  pixels.setPixelColor(7, pixels.Color(BRIGHTNESS, BRIGHTNESS, BRIGHTNESS));
  pixels.setPixelColor(8, pixels.Color(BRIGHTNESS / 2, BRIGHTNESS / 2, BRIGHTNESS / 2));

  pixels.show();
}

void loop(void)
{
}

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

#define BUFFER 64

BLEServer *pServer = NULL;
BLECharacteristic * pTxCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint8_t txValue[BUFFER] = "";

// See the following for generating UUIDs:
// https://www.uuidgenerator.net/

#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"


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("BLE UART");

  // 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() {

  //以下修正箇所　COMからデータを読み取り、BLEに送信
  if (deviceConnected == true)
  {
    if(Serial.available() != 0)
    {
      size_t bufSize = Serial.read(txValue, Serial.available());
      pTxCharacteristic->setValue(txValue, bufSize);
      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;
    }
}

#include <WiFi.h>

const char* ssid = "your SSID";
const char* password = "your password";
const int ledPin = 2;

WiFiServer server(80);

void setup()
{
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected.");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());

  server.begin();
}

void loop()
{
  WiFiClient client = server.available();
  if (client)
  {
    String request = "";
      while (client.connected())
      {
        if (client.available())
        {
          char c = client.read();
          request += c;
          if (c == '\n') break;
        }
      }

      if (request.indexOf("GET /on") != -1)
      {
        digitalWrite(ledPin, HIGH);
      }
      else if (request.indexOf("GET /off") != -1)
      {
        digitalWrite(ledPin, LOW);
      }

      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println();
      client.println("<html><body>");
      client.println("<h1>ESP32S3 DevkitC-1 LED off/on</h1>");
      client.println("<button onclick=\"location.href='/on'\">LED ON</button>");
      client.println("<button onclick=\"location.href='/off'\">LED OFF</button>");
      client.println("</body></html>");
      client.stop();

    }
}

#include <WiFi.h>

const char *ssid = "SSID";
const char *password = "password";
const uint16_t port = 5000;

WiFiServer server(port);

void setup()
{
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(1000);
    Serial.print(".");
  }
  Serial.print("Connected : ");
  Serial.println(WiFi.localIP());
  server.begin();
}

void loop()
{   
  WiFiClient client = server.available();

  if (client)
  {
    String message = client.readStringUntil('\n');
    Serial.println("Received : " + message);
 
    message.toUpperCase();
    Serial.println("Send : " + message);
    client.print(message);

    client.stop();
  }
}

#include <WiFi.h>

const char *ssid = "SSID";
const char *password = "password";
const uint16_t port = 5000;
char host[128] = "";

void setup()
{
  Serial.begin(115200);
  delay(1000);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("Connected");
  
  while(1)
  {
    if(Serial.available())
    {  
      String buf = Serial.readStringUntil('\n');
      buf.toCharArray(host, sizeof(buf));
      Serial.println("Host IP : " + buf);
      break;
    }
  }
}

void loop()
{
  WiFiClient client;
  
  if(Serial.available())
  {  
    String buf = Serial.readStringUntil('\n');
    if (client.connect(host, port))
    {
      Serial.println("Send : " + buf);
      client.println(buf);

      String response = client.readStringUntil('\n');
      Serial.println("Received: " + response);
      client.stop();
    }
    else
    {
      Serial.println("Connection failed");
    }
  }
}