Platform: nordicnrf51
=======================================================
ID          MCU      Frequency Flash RAM  Name
----------- -------- --------- ----- ---- -------------
bbcmicrobit NRF51822 16MHz     256KB 16KB BBC micro:bit

Platform: nordicnrf52
===============================================================
ID             MCU      Frequency Flash RAM    Name
-------------- -------- --------- ----- -----  ----------------
bbcmicrobit_v2 NRF52833 64MHz     512KB 128KB  BBC micro:bit V2

[env:bbcmicrobit_v2]
platform = nordicnrf52
board = bbcmicrobit_v2
framework = arduino
platform_packages =
        toolchain-gccarmnoneeabi@~1.90301.0

boolean buttonA = false;
boolean buttonB = false;

void setup()
{  
	Serial.begin(115200);
	Serial.println("microbit is ready!");
	pinMode(PIN_BUTTON_A, INPUT);
	pinMode(PIN_BUTTON_B, INPUT);
}

void loop()
{
	if ((!digitalRead(PIN_BUTTON_A))&&(!buttonA)) {
		Serial.println("Button A pressed");
		buttonA = true;
	} else {
		buttonA = false;
	}
	if ((!digitalRead(PIN_BUTTON_B))&&(!buttonB)) {
		Serial.println("Button B pressed");
		buttonB = true;
	} else {
		buttonB = false;
	}
	delay(100);
}

const uint8_t cols[5] = {4, 7, 3, 6, 10};
const uint8_t rows[5] = {21, 22, 23, 24, 25};

void setup() {
	for (int i = 0; i < 5; i++) {
		pinMode(cols[i], OUTPUT);
		digitalWrite(cols[i], HIGH);
	}
	for (int i = 0; i < 5; i++) {
		pinMode(rows[i], OUTPUT);
		digitalWrite(rows[i], LOW);
	}
}

void loop() {
	for (int y = 0; y < 5; y++) {
		for (int x = 0; x < 5; x++) {
			digitalWrite(cols[x], LOW);
			digitalWrite(rows[y], HIGH);
			delay(200);
			digitalWrite(cols[x], HIGH);
			digitalWrite(rows[y], LOW);
		}
	}
}

#include <Wire.h>

void setup()
{
  Wire1.begin();
  Wire1.setClock(400000);    // I2C fast mode, 400kHz

  Serial.begin(115200);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}

void loop()
{
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    Wire1.beginTransmission(address);
    error = Wire1.endTransmission();
 
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);
}

#include <Wire.h>

void setup()
{
  Wire.begin();
  Wire.setClock(400000);    // I2C fast mode, 400kHz

  Serial.begin(115200);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}
 
 
void loop()
{
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);           // wait 5 seconds for next scan
}

#ifndef __STC8G1K08_H
#define __STC8G1K08_H

#include <Wire.h>

#define STC8G1K08_ADDR  0x30
#define LEFT_MOTOR_INA      0x03
#define LEFT_MOTOR_INB      0x04
#define RIGHT_MOTOR_INA     0x02
#define RIGHT_MOTOR_INB     0x01
#define LEFT_RED_REG        0x08
#define LEFT_GREEN_REG      0x07
#define LEFT_BLUE_REG       0x06
#define RIGHT_RED_REG       0x09
#define RIGHT_GREEN_REG     0x0A
#define RIGHT_BLUE_REG      0x05

class STC8G1K08
{
	private:
		TwoWire  *i2c;
		bool     write(uint8_t addr, uint8_t cmd, uint8_t value);

	public:
		STC8G1K08(TwoWire *wire);
		~STC8G1K08();
		void motor_pwm(int left, int right);
		void led_pwm(long left, long right);
};

#endif /*__STC8G1K08_H*/

#include "STC8G1K08.h"

STC8G1K08::STC8G1K08(TwoWire *wire) {
	i2c = wire;
}

STC8G1K08::~STC8G1K08() {}

bool STC8G1K08::write(uint8_t addr, uint8_t cmd, uint8_t value)
{
	uint8_t error;

	i2c->beginTransmission(addr);
	i2c->write(cmd);
	i2c->write(value);
	error = i2c->endTransmission(1);
	if (error==4) {
		return false;
	} else {
		return true;
	}
}

void STC8G1K08::motor_pwm(int left, int right)
{
	int speed;
	if (left > 0 ) {
		speed = left;
		// left advanced
		write(STC8G1K08_ADDR, LEFT_MOTOR_INA, speed);
		write(STC8G1K08_ADDR, LEFT_MOTOR_INB,     0);
	} else if (left < 0) {
		speed = left * -1;
		// left back
		write(STC8G1K08_ADDR, LEFT_MOTOR_INA,     0);
		write(STC8G1K08_ADDR, LEFT_MOTOR_INB, speed);
	} else {
		// left stop
		write(STC8G1K08_ADDR, LEFT_MOTOR_INA,     0);
		write(STC8G1K08_ADDR, LEFT_MOTOR_INB,     0);
	}

	if (right > 0 ) {
		speed = right;
		// right advanced
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INB,     0);
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INA, speed);
	} else if (right < 0) {
		speed = right * -1;
		// right back
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INB, speed);
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INA,     0);
	} else {
		// right stop
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INB,     0);
		write(STC8G1K08_ADDR, RIGHT_MOTOR_INA,     0);
	}
}

void STC8G1K08::led_pwm(long left, long right)
{
	uint8_t redL, greenL, blueL;
	uint8_t redR, greenR, blueR;

	// LED lights are common anode,
	// 255 is the lowest value and 0 is the brightest value.
	redL   = 255 - ((left  >> 16) & 0xFF);
	greenL = 255 - ((left  >>  8) & 0xFF);
	blueL  = 255 - ((left       ) & 0xFF);
	redR   = 255 - ((right >> 16) & 0xFF);
	greenR = 255 - ((right >>  8) & 0xFF);
	blueR  = 255 - ((right      ) & 0xFF);

	write(STC8G1K08_ADDR, LEFT_RED_REG,    redL  );
	write(STC8G1K08_ADDR, LEFT_GREEN_REG,  greenL);
	write(STC8G1K08_ADDR, LEFT_BLUE_REG,   blueL );
	write(STC8G1K08_ADDR, RIGHT_RED_REG,   redR  );
	write(STC8G1K08_ADDR, RIGHT_GREEN_REG, greenR);
	write(STC8G1K08_ADDR, RIGHT_BLUE_REG,  blueR );
}

#include "STC8G1K08.h"
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	STC8G1K08 stc8(&Wire);
#elif defined (ARDUINO_ARCH_RP2040)
	STC8G1K08 stc8(&Wire1);
#endif

void setup()
{
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	Wire.begin();
#elif defined (ARDUINO_ARCH_RP2040)
	Wire1.setSDA(2);
	Wire1.setSCL(3);
	Wire1.begin();
#endif

	delay(5000);
	stc8.motor_pwm(   0,  0); // stop
	stc8.motor_pwm(  70, 70); // advanced
	delay(1000);
	stc8.motor_pwm( -70,-70); // back
	delay(1000);
	stc8.motor_pwm(  70,-70); // spin left
	delay(1000);
	stc8.motor_pwm( -70, 70); // spin right
	delay(1000);
	stc8.motor_pwm(  70, 30); // turn left
	delay(1000);
	stc8.motor_pwm(  30, 70); // turn right
	delay(1000);
	stc8.motor_pwm(   0,  0); // stop
}

void loop() {}

#include "STC8G1K08.h"
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	STC8G1K08 stc8(&Wire);
#elif defined (ARDUINO_ARCH_RP2040)
	STC8G1K08 stc8(&Wire1);
#endif

void setup()
{
#if defined (ARDUINO_BBC_MICROBIT_V2)
	Wire.begin();
#elif defined (ARDUINO_ARCH_RP2040)
	Wire1.setSDA(2);
	Wire1.setSCL(3);
	Wire1.begin();
#endif

	stc8.led_pwm(0,0); // BLACK
}

void loop()
{
	stc8.led_pwm(0xFF0000,0xFF0000); delay(1000);  // RED
	stc8.led_pwm(0x00FF00,0x00FF00); delay(1000);  // GREEN
	stc8.led_pwm(0x0000FF,0x0000FF); delay(1000);  // BLUE
	stc8.led_pwm(0x00FFFF,0x00FFFF); delay(1000);  // CYAN
	stc8.led_pwm(0xFF00FF,0xFF00FF); delay(1000);  // DARK RED
	stc8.led_pwm(0xFFFF00,0xFFFF00); delay(1000);  // YELLOW
	stc8.led_pwm(0xFFFFFF,0xFFFFFF); delay(1000);  // WHITE
}

#include "STC8G1K08.h"
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	STC8G1K08 stc8(&Wire);
	#define CDS_LEFT_PIN    1
	#define CDS_RIGHT_PIN   0
#elif defined (ARDUINO_ARCH_RP2040)
	STC8G1K08 stc8(&Wire1);
	#define CDS_LEFT_PIN    27
	#define CDS_RIGHT_PIN   26
#endif

unsigned short avgLeft  = 0;
unsigned short avgRight = 0;

unsigned short CDS_L;
unsigned short CDS_R;

void setup()
{
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	Wire.begin();
#elif defined (ARDUINO_ARCH_RP2040)
	Wire1.setSDA(2);
	Wire1.setSCL(3);
	Wire1.begin();
#endif

	for (int i = 0; i < 20; i++) {
		avgLeft  += analogRead(CDS_LEFT_PIN);
		avgRight += analogRead(CDS_RIGHT_PIN);
	}
	avgLeft  /= 20;
	avgRight /= 20;
}

void loop()
{
	CDS_L = analogRead(CDS_LEFT_PIN);
	CDS_R = analogRead(CDS_RIGHT_PIN);

	if ((CDS_L >= (avgLeft * 1.2)) && (CDS_R < avgRight)) {
		stc8.motor_pwm(70,-70); // spin left
	} else if ((CDS_L < avgLeft) && (CDS_R >= (avgRight * 1.2))) {
		stc8.motor_pwm(-70,70); // spin right
	} else if ((CDS_L > (avgLeft * 1.2)) && (CDS_R > (avgRight * 1.2))) {
		stc8.motor_pwm(70,70); // advanced
	} else {
		stc8.motor_pwm(0,0); // stop
	}
}

#include "STC8G1K08.h"
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	STC8G1K08 stc8(&Wire);
	#define TCRT5K_LEFT_PIN  13
	#define TCRT5K_RIGHT_PIN 12
#elif defined (ARDUINO_ARCH_RP2040)
	STC8G1K08 stc8(&Wire1);
	#define TCRT5K_LEFT_PIN  20
	#define TCRT5K_RIGHT_PIN 19
#endif

uint8_t sensor_L;
uint8_t sensor_R;

void setup()
{
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	Wire.begin();
#elif defined (ARDUINO_ARCH_RP2040)
	Wire1.setSDA(2);
	Wire1.setSCL(3);
	Wire1.begin();
#endif

	Serial.begin(115200);

	pinMode(TCRT5K_LEFT_PIN,  INPUT_PULLUP);
	pinMode(TCRT5K_RIGHT_PIN, INPUT_PULLUP);
}

void loop()
{
	sensor_L = digitalRead(TCRT5K_LEFT_PIN);
	sensor_R = digitalRead(TCRT5K_RIGHT_PIN);
	Serial.print("sensor_L:");
	Serial.println(sensor_L);
	Serial.print("sensor_R:");
	Serial.println(sensor_R);

	// When both side sensors are on the black line
	if ((sensor_L == 1) && (sensor_R == 1)) {
		stc8.motor_pwm(100,100); // advanced

	// If the right sensor is on the black line and
	// the left sensor is on the white paper, turn right.
	} else if ((sensor_L == 0) && (sensor_R == 1)) {
		stc8.motor_pwm(-100,100); // spin right

	// If the right sensor is on the white paper and
	//  the left sensor is on the black line, turn left.
	} else if ((sensor_L == 1) && (sensor_R == 0)) {
		stc8.motor_pwm(100,-100); // spin left

	// If both side sensors are off the black line
	} else {
		stc8.motor_pwm(   0,  0); // stop
	}
}

#include "STC8G1K08.h"
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	STC8G1K08 stc8(&Wire);
	#define TRIG_PIN 14
	#define ECHO_PIN 15
#elif defined (ARDUINO_ARCH_RP2040)
	STC8G1K08 stc8(&Wire1);
	#define TRIG_PIN 21
	#define ECHO_PIN 22
#endif

#include "SRF05.h"
SRF05 SRF(TRIG_PIN, ECHO_PIN);

void setup()
{
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	Wire.begin();
#elif defined (ARDUINO_ARCH_RP2040)
	Wire1.setSDA(2);
	Wire1.setSCL(3);
	Wire1.begin();
#endif

	Serial.begin(115200);
	SRF.setCorrectionFactor(1.035);
	SRF.setModeAverage(10);
}

int  cm;

void loop()
{
	cm = SRF.getMillimeter() / 10;
  Serial.print(cm);
  Serial.print("cm : ");

	if (cm <= 15) {
		Serial.println("Fall Back");
		stc8.motor_pwm( -70,-70); // back
	} else if ( (cm > 15) && (cm <= 30) ) {
		Serial.println("Spin Left");
		stc8.motor_pwm(  70,-70); // spin left
	} else if ( (cm > 30) && (cm <= 80) ) {
		Serial.println("Go Advanced");
		stc8.motor_pwm(100,100); // advanced
	} else {
		Serial.println("Stop");
		stc8.motor_pwm(0,0); // stop
	}
  delay(100);
}

#include "PinDefinitionsAndMore.h"
#include <IRremote.hpp>

void printRawData(uint32_t raw)
{
	for (int step = 16; step >=0; step-=8) {
		uint8_t hex = (raw>>step)&0xFF;
		if (hex & 0xF0) {
			Serial.print(hex>>4, HEX);
		} else {
			Serial.print("0");
		}
		if (hex & 0x0F) {
			Serial.print((hex & 0x0F), HEX);
		} else {
			Serial.print("0");
		}
	}
}

void setup()
{
	Serial.begin(115200);
#if defined (ARDUINO_BBC_MICROBIT_V2)
	IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
#elif defined (ARDUINO_ARCH_RP2040)
	IrReceiver.begin(28, ENABLE_LED_FEEDBACK);
#endif
}

void loop()
{
	uint32_t rawCode, rawData;

	if (IrReceiver.decode()) {  // Grab an IR code
//	IrReceiver.printIRResultShort(&Serial);
		Serial.print(F(" Address=0x"));
		Serial.print(IrReceiver.decodedIRData.address, HEX);
		Serial.print(F(", Command="));
		Serial.print(IrReceiver.decodedIRData.command);
		Serial.print(F(", Raw-Data=0x"));
		rawCode = IrReceiver.decodedIRData.decodedRawData;
		rawData  = (rawCode <<  8) & 0xFF0000;
		rawData |= (rawCode >>  8) & 0x00FF00;
		rawData |= (rawCode >> 24) & 0x0000FF;
		printRawData(rawData);
		Serial.println("");
		delay(50);
		IrReceiver.resume();  // Prepare for the next IR frame
	}
}

// The micro:bit v2 has a speaker connected to pin 0
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	#define PIN_BUZZER    2
	#define PIN_PUSH_BTN  PIN_BUTTON_A
#elif defined (ARDUINO_ARCH_RP2040)
	#define PIN_BUZZER    6
	#define PIN_PUSH_BTN  11
#endif

void setup()
{
	pinMode(PIN_BUZZER,   OUTPUT);
#if defined (ARDUINO_BBC_MICROBIT_V2) 
	pinMode(PIN_PUSH_BTN, INPUT_PULLUP);
#elif defined (ARDUINO_ARCH_RP2040)
	pinMode(PIN_PUSH_BTN, INPUT);
#endif
}

void beep(int hz, int ms)
{
	long loop = (ms / 1000) * hz;
	long us = 500000 / hz;
	// tone(SPEAKER_PIN, 262, 1000);
	// 1000Hz (Period 1ms = 1000us) -> HIGH 500us, LOW 500us
	for (long lng = 0; lng < loop; lng++) {
		digitalWrite(PIN_BUZZER, HIGH);
		delayMicroseconds(us);
		digitalWrite(PIN_BUZZER, LOW);
		delayMicroseconds(us);
	}
}

void loop() {
  // When button A is pressed, LOW is output.
#if defined (ARDUINO_BBC_MICROBIT_V2) 
  if (digitalRead(PIN_PUSH_BTN) == LOW) {
#elif defined (ARDUINO_ARCH_RP2040)
  if (digitalRead(PIN_PUSH_BTN) == HIGH) {
#endif
		beep(262,1000); // Play a 262Hz C note for 1000ms
		beep(440,1000); // Play a 440Hz A note for 1000ms
  }
}

Platform: intel_mcs51
===============================================================
ID         MCU        Frequency Flash RAM    Name
---------- ---------- --------- ----- ------ ------------------
STC8G1K08  STC8G1K08  11MHz     8KB   1.25KB Generic STC8G1K08
STC8G1K08A STC8G1K08A 11MHz     8KB   1.25KB Generic STC8G1K08A
STC8G1K08T STC8G1K08T 11MHz     8KB   1.25KB Generic STC8G1K08T

{
  "build": {
    "core": "naked",
    "extra_flags": "-DSTC8G1KXX -DSTC8G1K08 -DNAKED_ARCH_MCS51 -DNAKED_MCS51_STC8G1KXX",
    "f_cpu": "11059200L",
    "size_iram": 256,
    "size_xram": 1024,
    "size_code": 8192,
    "size_heap": 128,
    "mcu": "stc8g1k08",
    "cpu": "mcs51",
    "variant": "stc8g1kxx"
  },
  "frameworks": [],
  "upload": {
    "maximum_ram_size": 1280,
    "maximum_size": 8192,
    "protocol": "stcgal",
    "stcgal_protocol": "stc8",
    "protocols": [
      "stcgal"
    ]
  },
  "name": "Generic STC8G1K08",
  "url": "http://www.stcmicro.com/stc/stc8g1k08.html",
  "vendor": "STC"
}

上部ヘッダーピン   Pico         エッジコネクタ
PIN_SERIAL1_TX ←   1 GP0
PIN_SERIAL1_RX ←   2 GP1
GND            ←  GND
                    4 GP2 PIN_WIRE1_SDA → P20 STC8G1K08
                    5 GP3 PIN_WIRE1_SCL → P19 STC8G1K08
PIN_WIRE0_SDA  ←   6 GP4
PIN_WIRE0_SCL  ←   7 GP5
               ←  GND
                    9 GP6     → P2
                   10 GP7     → P3
                   11 GP8     → P4
                   12 GP9     → P5
              ←   GND
              ←   14 GP10
                   15 GP11    → P7
PIN_SPI1_MISO ←   16 GP12
PIN_SPI1_SS   ←   17 GP13
GND           ←   GND
PIN_SPI1_SCK  ←   19 GP14
PIN_SPI1_MOSI ←   20 GP15
                   21 GP16     → P8
                   22 GP17     → P9
                   GND
                   24 GP18     → P10
                   25 GP19     → P12 TCRT5K(right)
                   26 GP20     → P13 TCRT5K(left)
                   27 GP21     → P14 TRIG
                   GND
                   29 GP22     → P15 ECHO
                   RUN
                   31 GP26     → P0 Photoresistor(right)
                   32 GP27     → P1 Photoresistor(left)
                   GND
                   34 GP28     → P16 IR Receiver
                   VREF
                   3V3(OUT)    → 3V3
                   3V3_EN
                   GND       ←→ GND
                   VSYS        ← 3V3
                   VBUS(5V)

Platform: raspberrypi
===================================================
ID   MCU    Frequency Flash RAM   Name
---- ------ --------- ----- ----- -----------------
pico RP2040 133MHz    2MB   264KB Raspberry Pi Pico

{
    "build": {
        "arduino": {
            "earlephilhower": {
                "boot2_source": "boot2_w25q080_2_padded_checksum.S",
                "usb_vid": "0x2E8A",
                "usb_pid": "0xF00A"
            }
        },
        "core": "earlephilhower",
        "cpu": "cortex-m0plus",
        "extra_flags": "-DARDUINO_RASPBERRY_PI_PICO_W -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250  -DPICO_CYW43_SUPPORTED=1 -DCYW43_PIN_WL_DYNAMIC=1",
        "f_cpu": "133000000L",
        "hwids": [
            [
                "0x2E8A",
                "0x00C0"
            ],
            [
                "0x2E8A",
                "0xF00A"
            ]
        ],
        "mcu": "rp2040",
        "variant": "rpipicow"
    },
    "debug": {
        "jlink_device": "RP2040_M0_0",
        "openocd_target": "rp2040.cfg",
        "svd_path": "rp2040.svd"
    },
    "frameworks": [
        "arduino",
        "picosdk"
    ],
    "name": "Pico W",
    "upload": {
        "maximum_ram_size": 262144,
        "maximum_size": 2097152,
        "require_upload_port": true,
        "native_usb": true,
        "use_1200bps_touch": true,
        "wait_for_upload_port": false,
        "protocol": "picotool",
        "protocols": [
            "blackmagic",
            "cmsis-dap",
            "jlink",
            "raspberrypi-swd",
            "picotool",
            "picoprobe"
        ]
    },
    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
    "vendor": "Raspberry Pi"

#pragma once

// Pin definitions taken from:
//    https://datasheets.raspberrypi.org/pico/pico-datasheet.pdf

#include 

// LEDs
#define PIN_LED        (64u)

// Serial
#define PIN_SERIAL1_TX (0u)
#define PIN_SERIAL1_RX (1u)

#define PIN_SERIAL2_TX (8u)
#define PIN_SERIAL2_RX (9u)

// SPI
#define PIN_SPI0_MISO  (16u)
#define PIN_SPI0_MOSI  (19u)
#define PIN_SPI0_SCK   (18u)
#define PIN_SPI0_SS    (17u)

#define PIN_SPI1_MISO  (12u)
#define PIN_SPI1_MOSI  (15u)
#define PIN_SPI1_SCK   (14u)
#define PIN_SPI1_SS    (13u)

// Wire
#define PIN_WIRE0_SDA  (4u)
#define PIN_WIRE0_SCL  (5u)

#define PIN_WIRE1_SDA  (26u)
#define PIN_WIRE1_SCL  (27u)

#define SERIAL_HOWMANY (3u)
#define SPI_HOWMANY    (2u)
#define WIRE_HOWMANY   (2u)

#include "../generic/common.h"

#pragma once

#include 

#define PINS_COUNT          (30u)
#define NUM_DIGITAL_PINS    (30u)
#define NUM_ANALOG_INPUTS   (4u)
#define NUM_ANALOG_OUTPUTS  (0u)
#define ADC_RESOLUTION      (12u)
#define WIRE_INTERFACES_COUNT (WIRE_HOWMANY)

#ifdef PIN_LED
#define LED_BUILTIN PIN_LED
#endif

#ifdef __PIN_D0
static const uint8_t D0 = __PIN_D0;
#else
static const uint8_t D0 = (0u);
#endif
#ifdef __PIN_D1
static const uint8_t D1 = __PIN_D1;
#else
static const uint8_t D1 = (1u);
#endif
#ifdef __PIN_D2
static const uint8_t D2 = __PIN_D2;
#else
static const uint8_t D2 = (2u);
#endif
#ifdef __PIN_D3
static const uint8_t D3 = __PIN_D3;
#else
static const uint8_t D3 = (3u);
#endif
#ifdef __PIN_D4
static const uint8_t D4 = __PIN_D4;
#else
static const uint8_t D4 = (4u);
#endif
#ifdef __PIN_D5
static const uint8_t D5 = __PIN_D5;
#else
static const uint8_t D5 = (5u);
#endif
#ifdef __PIN_D6
static const uint8_t D6 = __PIN_D6;
#else
static const uint8_t D6 = (6u);
#endif
#ifdef __PIN_D7
static const uint8_t D7 = __PIN_D7;
#else
static const uint8_t D7 = (7u);
#endif
#ifdef __PIN_D8
static const uint8_t D8 = __PIN_D8;
#else
static const uint8_t D8 = (8u);
#endif
#ifdef __PIN_D9
static const uint8_t D9 = __PIN_D9;
#else
static const uint8_t D9 = (9u);
#endif
#ifdef __PIN_D10
static const uint8_t D10 = __PIN_D10;
#else
static const uint8_t D10 = (10u);
#endif
#ifdef __PIN_D11
static const uint8_t D11 = __PIN_D11;
#else
static const uint8_t D11 = (11u);
#endif
#ifdef __PIN_D12
static const uint8_t D12 = __PIN_D12;
#else
static const uint8_t D12 = (12u);
#endif
#ifdef __PIN_D13
static const uint8_t D13 = __PIN_D13;
#else
static const uint8_t D13 = (13u);
#endif
#ifdef __PIN_D14
static const uint8_t D14 = __PIN_D14;
#else
static const uint8_t D14 = (14u);
#endif
#ifdef __PIN_D15
static const uint8_t D15 = __PIN_D15;
#else
static const uint8_t D15 = (15u);
#endif
#ifdef __PIN_D16
static const uint8_t D16 = __PIN_D16;
#else
static const uint8_t D16 = (16u);
#endif
#ifdef __PIN_D17
static const uint8_t D17 = __PIN_D17;
#else
static const uint8_t D17 = (17u);
#endif
#ifdef __PIN_D18
static const uint8_t D18 = __PIN_D18;
#else
static const uint8_t D18 = (18u);
#endif
#ifdef __PIN_D19
static const uint8_t D19 = __PIN_D19;
#else
static const uint8_t D19 = (19u);
#endif
#ifdef __PIN_D20
static const uint8_t D20 = __PIN_D20;
#else
static const uint8_t D20 = (20u);
#endif
#ifdef __PIN_D21
static const uint8_t D21 = __PIN_D21;
#else
static const uint8_t D21 = (21u);
#endif
#ifdef __PIN_D22
static const uint8_t D22 = __PIN_D22;
#else
static const uint8_t D22 = (22u);
#endif
#ifdef __PIN_D23
static const uint8_t D23 = __PIN_D23;
#else
static const uint8_t D23 = (23u);
#endif
#ifdef __PIN_D24
static const uint8_t D24 = __PIN_D24;
#else
static const uint8_t D24 = (24u);
#endif
#ifdef __PIN_D25
static const uint8_t D25 = __PIN_D25;
#else
static const uint8_t D25 = (25u);
#endif
#ifdef __PIN_D26
static const uint8_t D26 = __PIN_D26;
#else
static const uint8_t D26 = (26u);
#endif
#ifdef __PIN_D27
static const uint8_t D27 = __PIN_D27;
#else
static const uint8_t D27 = (27u);
#endif
#ifdef __PIN_D28
static const uint8_t D28 = __PIN_D28;
#else
static const uint8_t D28 = (28u);
#endif
#ifdef __PIN_D29
static const uint8_t D29 = __PIN_D29;
#else
static const uint8_t D29 = (29u);
#endif

#if defined(PICO_RP2040) || (defined(PICO_RP2350) && PICO_RP2350A)

#ifdef __PIN_A0
static const uint8_t A0 = __PIN_A0;
#else
static const uint8_t A0 = (26u);
#endif

#ifdef __PIN_A1
static const uint8_t A1 = __PIN_A1;
#else
static const uint8_t A1 = (27u);
#endif

#ifdef __PIN_A2
static const uint8_t A2 = __PIN_A2;
#else
static const uint8_t A2 = (28u);
#endif

#ifdef __PIN_A3
static const uint8_t A3 = __PIN_A3;
#else
static const uint8_t A3 = (29u);
#endif

#elif defined(PICO_RP2350) && !PICO_RP2350A // RP2350B

#ifdef __PIN_D30
static const uint8_t D30 = __PIN_D30;
#else
static const uint8_t D30 = (30u);
#endif
#ifdef __PIN_D31
static const uint8_t D31 = __PIN_D31;
#else
static const uint8_t D31 = (31u);
#endif
#ifdef __PIN_D32
static const uint8_t D32 = __PIN_D32;
#else
static const uint8_t D32 = (32u);
#endif
#ifdef __PIN_D33
static const uint8_t D33 = __PIN_D33;
#else
static const uint8_t D33 = (33u);
#endif
#ifdef __PIN_D34
static const uint8_t D34 = __PIN_D34;
#else
static const uint8_t D34 = (34u);
#endif
#ifdef __PIN_D35
static const uint8_t D35 = __PIN_D35;
#else
static const uint8_t D35 = (35u);
#endif
#ifdef __PIN_D36
static const uint8_t D36 = __PIN_D36;
#else
static const uint8_t D36 = (36u);
#endif
#ifdef __PIN_D37
static const uint8_t D37 = __PIN_D37;
#else
static const uint8_t D37 = (37u);
#endif
#ifdef __PIN_D38
static const uint8_t D38 = __PIN_D38;
#else
static const uint8_t D38 = (38u);
#endif
#ifdef __PIN_D39
static const uint8_t D39 = __PIN_D39;
#else
static const uint8_t D39 = (39u);
#endif
#ifdef __PIN_D40
static const uint8_t D40 = __PIN_D40;
#else
static const uint8_t D40 = (40u);
#endif
#ifdef __PIN_D41
static const uint8_t D41 = __PIN_D41;
#else
static const uint8_t D41 = (41u);
#endif
#ifdef __PIN_D42
static const uint8_t D42 = __PIN_D42;
#else
static const uint8_t D42 = (42u);
#endif
#ifdef __PIN_D43
static const uint8_t D43 = __PIN_D43;
#else
static const uint8_t D43 = (43u);
#endif
#ifdef __PIN_D44
static const uint8_t D44 = __PIN_D44;
#else
static const uint8_t D44 = (44u);
#endif
#ifdef __PIN_D45
static const uint8_t D45 = __PIN_D45;
#else
static const uint8_t D45 = (45u);
#endif
#ifdef __PIN_D46
static const uint8_t D46 = __PIN_D46;
#else
static const uint8_t D46 = (46u);
#endif
#ifdef __PIN_D47
static const uint8_t D47 = __PIN_D47;
#else
static const uint8_t D47 = (47u);
#endif

#ifdef __PIN_A0
static const uint8_t A0 = __PIN_A0;
#else
static const uint8_t A0 = (40u);
#endif

#ifdef __PIN_A1
static const uint8_t A1 = __PIN_A1;
#else
static const uint8_t A1 = (41u);
#endif

#ifdef __PIN_A2
static const uint8_t A2 = __PIN_A2;
#else
static const uint8_t A2 = (42u);
#endif

#ifdef __PIN_A3
static const uint8_t A3 = __PIN_A3;
#else
static const uint8_t A3 = (43u);
#endif

#ifdef __PIN_A4
static const uint8_t A4 = __PIN_A4;
#else
static const uint8_t A4 = (44u);
#endif

#ifdef __PIN_A5
static const uint8_t A5 = __PIN_A5;
#else
static const uint8_t A5 = (45u);
#endif

#ifdef __PIN_A6
static const uint8_t A6 = __PIN_A6;
#else
static const uint8_t A6 = (46u);
#endif

#ifdef __PIN_A7
static const uint8_t A7 = __PIN_A7;
#else
static const uint8_t A7 = (47u);
#endif

#endif


static const uint8_t SS = PIN_SPI0_SS;
static const uint8_t MOSI = PIN_SPI0_MOSI;
static const uint8_t MISO = PIN_SPI0_MISO;
static const uint8_t SCK = PIN_SPI0_SCK;

static const uint8_t SDA = PIN_WIRE0_SDA;
static const uint8_t SCL = PIN_WIRE0_SCL;

上部ヘッダ   Nano ESP32     エッジコネクタ
3:SCK    ←   1 D13/SCK
5:3V3    ←   2 3V3(OUT)  → 3V3
              3 GPIO46 B0
              4 GPIO1  A0/DAC0
              5 GPIO2  A1        → P0 Photoresistor(right)
              6 GPIO3  A2        → P1 Photoresistor(left)
              7 GPIO4  A3        → P7
              8 GPIO11 A4/SDA    → P20 STC8G1K08
              9 GPIO12 A5/SCL    → P19 STC8G1K08
             10 GPIO13 A6        → P12 TCRT5K(right)
             11 GPIO14 A7        → P13 TCRT5K(left)
             12 VBUS(OUT)
             13 GPIO0  B1
             14 GND       → GND
             15 VIN(IN)   ← 3V3
Qwiic:TX ←  16 GPIO43 D1/TX0
Qwiic:RX ←  17 GPIO44 D0/RX0
4:RST    ←  18 RESET
8:GND    ←  19 GND
             20 GPIO5  D2        → P2
             21 GPIO6  D3        → P3
             22 GPIO7  D4        → P4
             23 GPIO8  D5        → P5
7:DC     ←  24 GPIO9  D6        
6:SS     ←  25 GPIO10 D7
             26 GPIO17 D8        → P14 TRIG
             27 GPIO18 D9        → P15 ECHO
             28 GPIO21 D10       → P16 IR Receiver
2:MOSI    ← 29 GPIO38 D11/MOSI
1:MISO    ← 30 GPIO47 D12/MISO

========================================================================
ID                  MCU      Frequency  Flash  RAM    Name
------------------  -------  ---------  -----  -----  ------------------
arduino_nano_esp32  ESP32S3  240MHz     16MB   320KB  Arduino Nano ESP32

"extra_flags": [
  "-DARDUINO_NANO_ESP32",
  "-DBOARD_HAS_PIN_REMAP", ← 削除
  "-DBOARD_HAS_PSRAM",^

#if defined(BOARD_HAS_PIN_REMAP) && !defined(BOARD_USES_HW_GPIO_NUMBERS)
// Arduino style definitions (API uses Dx)
static constexpr uint8_t D0         = 0; // also RX
static constexpr uint8_t D1         = 1; // also TX
......
#else
// ESP32-style definitions (API uses GPIOx)
static constexpr uint8_t D0         = 44; // also RX
static constexpr uint8_t D1         = 43; // also TX
......

[env:arduino_nano_esp32]
platform = espressif32
board = arduino_nano_esp32
framework = arduino
board_build.partitions = default_16MB.csv
build_flags =
        -mfix-esp32-psram-cache-issue
        -DCORE_DEBUG_LEVEL=4
board_build.arduino.memory_type = qio_opi
board_build.f_flash = 80000000L
board_build.flash_mode = dio
monitor_speed = 115200
upload_protocol = dfu
upload_port = /dev/ttyACM0

........
Checking size .pio/build/arduino_nano_esp32/firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM:   [=         ]   9.4% (used 30656 bytes from 327680 bytes)
Flash: [          ]   4.5% (used 292693 bytes from 6553600 bytes)
Building .pio/build/arduino_nano_esp32/firmware.bin
esptool.py v4.9.0
Creating esp32s3 image...
Merged 2 ELF sections
Successfully created esp32s3 image.
Configuring upload protocol...
AVAILABLE: cmsis-dap, dfu, esp-bridge, esp-builtin, esp-prog, espota, esptool, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa
CURRENT: upload_protocol = esptool
Looking for upload port...
Using manually specified: /dev/ttyACM0
Uploading .pio/build/arduino_nano_esp32/firmware.bin
esptool.py v4.9.0
Serial port /dev/ttyACM0
Connecting....
Chip is ESP32-S3 (QFN56) (revision v0.2)
Features: WiFi, BLE, Embedded PSRAM 8MB (AP_3v3)
Crystal is 40MHz
MAC: xx:xx:xx:xx:xx:xx
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 460800
Changed.
Configuring flash size...
Flash will be erased from 0x00000000 to 0x00003fff...
Flash will be erased from 0x00008000 to 0x00008fff...
Flash will be erased from 0x0000e000 to 0x0000ffff...
Flash will be erased from 0x00010000 to 0x00057fff...
SHA digest in image updated
Compressed 14032 bytes to 9808...
Writing at 0x00000000... (100 %)
Wrote 14032 bytes (9808 compressed) at 0x00000000 in 0.3 seconds (effective 373.8 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 146...
Writing at 0x00008000... (100 %)
Wrote 3072 bytes (146 compressed) at 0x00008000 in 0.0 seconds (effective 1563.9 kbit/s)...
Hash of data verified.
Compressed 8192 bytes to 47...
Writing at 0x0000e000... (100 %)
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (effective 2494.9 kbit/s)...
Hash of data verified.
Compressed 293056 bytes to 167702...
Writing at 0x00010000... (9 %)
Writing at 0x0001b94e... (18 %)
Writing at 0x00024795... (27 %)
Writing at 0x00029e7f... (36 %)
Writing at 0x0002f315... (45 %)
Writing at 0x0003469d... (54 %)
Writing at 0x00039d90... (63 %)
Writing at 0x0004269c... (72 %)
Writing at 0x0004ae71... (81 %)
Writing at 0x0005048b... (90 %)
Writing at 0x0005601c... (100 %)
Wrote 293056 bytes (167702 compressed) at 0x00010000 in 3.9 seconds (effective 596.7 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...