・λ・

PCB design with KiCad

2025-04-25T00:00:00+09:00

KiCad is an open-source Electronic Design Automation (EDA) suite used for designing schematics and PCBs.

In this post, I will use a breathing LED circuit using NE555 as an example to show how to use the KiCad.

Project Setup

The first thing to do is to create a new project.

After creating the project, the “Project Files” pane on the left will show a project file with the extension .kicad_pro, a schematic file with the extension .kicad_sch and a schematic file with the extension .kicad_pcb.

Schematic Design

Setup the page
Add symbols by clicking the button or use the hotkey A. Symbols are automatically annotated when added to the schematic.
Arrange symbols by moving and rotating them. Then fill in the values of the component as needed.

You can change the value of the component by double-clicking the component to open the Symbol Properties window.

Assign footprints to symbols using the footprint assignment tool. Clicking Tools → Assign Footprints… or using the button in the top toolbar.

Select the symbol in the middle pane and double-click the desired footprint in the right pane. You can also preview the footprint by right-clicking the footprint’s name and selecting View selected footprint.

Connect components with wires.
Run an electrical rule check (ERC) to verify the design.

PCB Layout Design

Setup the page
Click Tools → Update PCB from Schematic… or using the button in the top toolbar to import the schematic design data into the layout.
Place the components and draw a board outline on the Edge.Cuts layer.
Route the connections (tracks) by clicking the button in the right toolbar or use the hotkey X.
Place the copper zones. Switch to the B.Cu layer and click the button in the right toolbar.

When you click on the PCB, the Copper Zone Properties dialog will appear, select the GND net.

Draw an outline that defines the boundaries of the zone, then right click it and select Zones → Draft Fill Selected Zone(s).

Zones can be hidden by click the button in the left toolbar.

Add silkscreen text, logos, or other markings.

Run a Design Rules Check (DRC) to verify the correctness of the layout.
Use the 3D viewer (View → 3D Viewer) to visualize the design.

Generate Fabrication Outputs

Click File → Plot… or File → Fabrication Outputs → Gerbers (.gbr)… to open the Plot dialog.

Click Plot to generate the Gerber files. Also click Generate Drill Files… to create drill files for through-holes and vias.

You can check the generated Gerber files with Gerber Viewer.

References

Building a handwired 9 key keyboard

2024-05-07T00:00:00+09:00

required hardware list

keyboard switches
1N4148 signal diodes
QMK compatible microcontroller board such as Arduino Pro Micro (Atmega32u4), Raspberry Pi Pico (RP2040), etc.
wire
keyboard plate and case
keycaps

I 3d printed the plate, case and keycaps.

For the keyboard board and case, I used the model from here and increased the height of the plate, since I soldered the pin headers to pro micro and soldered the row and column wires to the female headers.

As for keycaps, I used openSCAD’s keycap library KeyV2 to create the models. Currently, in order to use this library normally, you need to install the development snapshot of openSCAD. To create your own keycaps, just open keys.scad in openSCAD and modify it.

For example, my keycaps look like this:

To make printing easier, I used the g20 profile and printed upside down.

$stem_inner_slop = 0;

for (x = [0:1:2]) {
  for (y = [1:1:3]) {
    translate_u(y, -x) rounded_cherry() g20_row(3, 0) legend(str(y + 3 * x), size=9)
    upside_down() {
      $stem_support_type = "disable";
      key(true);
      dished() {
        legends($inset_legend_depth);
      }
    }
  }
}

QMK

environment setup

$ brew install qmk/qmk/qmk
$ brew install avr-gcc
$ qmk setup

create a new keyboard

$ qmk new-keyboard

Choose ortho_3x3 layout and atmega32u4 as MCU.

A new directory will be created under the qmk_firmware/keyboards/. Move to your keyboard directory and open the info.json.

diode_direction: specifies the direction the diode is pointing.
matrix_pins: GPIO pins connected to the matrix rows/columns.
bootloader: change from atmel-dfu to caterina.

keymap

Then open the keymap.c and customize the keyboard layout according to your liking. For example, my layout looks like the following. In addition to the one for defining numbers, I also added a layer to define macros.

#include QMK_KEYBOARD_H

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /*　LAYER 0
     * ┌───┬───┬───┐
     * │ 1 │ 2 │ 3 │
     * ├───┼───┼───┤
     * │ 4 │ 5 │ 6 │
     * ├───┼───┼───┤
     * │ 7 │ 8 │ 9 │
     * └───┴───┴───┘
     */
    [0] = LAYOUT_ortho_3x3(
        KC_1,       KC_2,      KC_3,
        KC_4,       KC_5,      KC_6,
        KC_7,       KC_8,      LT(1, KC_9)
    ),

    /* LAYER 1
    * ┌────────────────┬───────────────────┬─────────────────┐
    * │  input source  │ switch app window │   spotlight     │
    * ├────────────────┼───────────────────┼─────────────────┤
    * │ left alignment │     maximize      │ right alignment │
    * ├────────────────┼───────────────────┼─────────────────┤
    * │  power down    │        0          │                 │
    * └────────────────┴───────────────────┴─────────────────┘
    */
    [1] = LAYOUT_ortho_3x3(
        LCTL(KC_SPC),  LGUI(KC_F1), LGUI(KC_SPC),
        LCAG(KC_LEFT), LCAG(KC_M),  LCAG(KC_RGHT),
        KC_PWR,        KC_0,     KC_TRNS
    )
};

compile the firmware

$ qmk compile -kb mac_9key -km default

the last few lines of output will look like the following:

Creating load file for flashing: .build/mac_9key_default.hex                                        [OK]
Copying mac_9key_default.hex to qmk_firmware folder                                                 [OK]
Checking file size of mac_9key_default.hex                                                          [OK]
 * The firmware size is fine - 16060/28672 (56%, 12612 bytes free)

flash the firmware

Now, use the .hex format firmware file to flash your keyboard. You can use the command line or QMK Toolbox to flash the firmware. Check the documentation for details.

$ qmk flash -kb mac_9key -km default

After flashing the firmware, you can start testing your keyboard.

Redis の RDB 永続化

2024-01-28T00:00:00+09:00

Redis には、RDB (Redis Database) と AOF (Append Only File) という 2 つのデータ永続化方式があります。

RDB 永続化は、ある時点で現在のデータのスナップショットを作成して、RDB ファイルとしてディスクに保存し、災害によるデータ損失を防ぐことができます。

RDB ファイルさえあれば、Redis はそれを使ってデータを復元することができます。Redis サーバを起動する際、RDB ファイルの存在を検出すると自動的に読み込まれます。

RDB 永続化はsaveオプションを設定することで、一定時間内に一定数の変更があったら、Redis は自動的にBGSAVEコマンドを実行します。例えば save 60 1000は、60 秒以内に少なくとも 1000回の変更が行われたら、BGSAVEコマンドが実行されます。手動でSAVEコマンドまたはBGSAVEコマンドを実行することもできます。

SAVEコマンドは、データベースを同期的にディスクに保存します。RDB ファイルが作成されるまでサーバプロセスをブロックします。
BGSAVEコマンドは、データベースを非同期的にディスクに保存します。fork()で子プロセスを生成し、子プロセスが RDB ファイルの作成を行い、親プロセス（サーバプロセス）は引き続きクライアントからの要求を処理し続けます。

BGSAVEコマンドはサーバプロセスをブロックしないため、サーバ設定のsaveオプションを通じて自動的に実行させることができます。

Redis のデフォルト設定では、RDB 永続化が有効になっています。save ""で無効にすることも可能です。 RDB 永続化を有効にしたままにする場合は、十分なメモリとディスク容量を確保する必要があります。そうしないと障害が発生する可能性が高いです。

十分なメモリ容量を確保する

BGSAVEコマンドの実行で子プロセスが生成された時、COW (Copy-On-Write) のおかげで、親プロセスのメモリ空間をコピーするのではなく、共有します。

しかし、書き込み操作が頻繁に行われた場合、書き込み内容を反映させるために大量の使用可能なメモリが必要になる場合があります。Redisサーバダウンを防ぐため、マシンのメモリが、Redis のデータ保存用メモリの 2 倍以上ある方が安全です。

メモリが不足になっている場合、Redis は OOM Killer に強制終了される可能性があります。

メモリ容量不足の場合

Redis サーバを立ち上げるマシンでは、直接ホストで Redis サーバを起動し、systemd によって管理されます。 systemctl コマンドで Redis の状態を確認すると、Redis が異常終了されました。

$ sudo systemctl status redis
● redis.service - Redis persistent key-value database
   Loaded: loaded (/usr/lib/systemd/system/redis.service; enabled; vendor preset: disabled)
  Drop-In: /etc/systemd/system/redis.service.d
           └─limit.conf
   Active: failed (Result: signal) since Wed 2024-01-10 18:14:25 JST; 29s ago
  Process: 8190 ExecStop=/usr/libexec/redis-shutdown (code=killed, signal=TERM)
  Process: 8254 ExecStart=/usr/bin/redis-server /etc/redis/redis.conf --daemonize no --supervised systemd (code=killed, signal=KILL)
 Main PID: 8254 (code=killed, signal=KILL)
   Status: "Ready to accept connections"

journalctl コマンドで systemd のログを確認し、OOM Killer によって Redis プロセスが強制終了されたことがわかります。

$ journalctl -b | less

以下はログの一部からの抜粋です。

Jan 10 18:14:24 localhost kernel: oom-kill:constraint=CONSTRAINT_NONE,nodemask=(null),cpuset=ec33a5e6da59ed697cdbc803f32a79b7d609ed286ce656c387a6dd
0332239063,mems_allowed=0,global_oom,task_memcg=/system.slice/redis.service,task=redis-server,pid=8254,uid=995
Jan 10 18:14:24 localhost kernel: Out of memory: Killed process 8254 (redis-server) total-vm:15947752kB, anon-rss:11803720kB, file-rss:0kB, shmem-r
ss:0kB, UID:995 pgtables:25756kB oom_score_adj:0
Jan 10 18:14:25 localhost systemd[1]: redis.service: main process exited, code=killed, status=9/KILL

十分なディスク容量を確保する

子プロセスがデータベースを RDB ファイルに保存する際に、まずtemp-123.rdbのようなファイル名の末尾にプロセス ID が付いている一時ファイルを作成し、データをそのファイルにダンプします。正常にダンプされた場合、一時ファイルの名前を dump.rdb に変更します。

つまり、バックアップには現在のデータの約 2 倍のディスク容量が使用されます。その時、ディスク容量が不足していると、バックアップができなくなり、エラーが発生し、Redis にデータを書き込むことができなくなります。

ディスク容量不足の場合

Redisサーバのログで、ディスク容量不足のエラーが出ています。

1:M 10 Jan 2024 15:56:24.081 * 100 changes in 300 seconds. Saving...
1:M 10 Jan 2024 15:56:24.117 * Background saving started by pid 31
31:C 10 Jan 2024 15:57:02.745 # Write error saving DB on disk: No space left on device
1:M 10 Jan 2024 15:57:03.019 # Background saving error

クライアント側 (redis-py) では、以下のような ResponseError になります。Redis の設定stop-writes-on-bgsave-errorオプションのデフォルト値は「yes」になり、バックアップが失敗すると、書き込み操作ができません。

redis.exceptions.ResponseError:: MISCONF Redis is configured to save RDB snapshots, but it is currently not able to persist on disk. Commands that may modify the data set are disabled, because this instance is configured to report errors during writes if RDB snapshotting fails (stop-writes-on-bgsave-error option). Please check the Redis logs for details about the RDB error.

参考：https://redis.io/docs/management/persistence/

Arduinoを使ってATtiny85にプログラムを書き込む

2023-10-15T00:00:00+09:00

Arduino Nano を ISP (In-System Programmer) にする

Arduino IDE のファイルメニューの Examples から ArduinoISP のサンプルスケッチを開く。ボードとポートを選択し、スケッチを Arduino Nano にアップロードする。アップロードした後、Arduino と ATtiny85 の接続を開始できる。

以下は ATtiny85 のピン配置図です。VCC と GND、6 つの PB (Port B) ピンがある。

データシート: https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet-Summary.pdf

次の表のように Arduino と ATtiny85 を接続する。

Arduino Nano	ATtiny85
5V	VCC
GND	GND
D10 (SS)	PB5
D11 (MOSI)	PB0
D12 (MISO)	PB1
D13 (SCK)	PB2

また、ATtiny にプログラムをアップロードする際にリセットされないように、Arduino の RESET ピンと GND ピンの間に 10uF コンデンサを追加する。

ATtiny85 にブートローダを書き込む

まず、Arduino IDE で ATtiny へのサポートを有効にする必要がある。 Preferences の Additional Boards Manager URLs に次の URL を追加： https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

そしてボードマネージャに移動し、attiny を検索してインストールする。

インストールしたら、ブートローダを書き込むするための準備ができた。 Tools メニューで次のように設定し、”Burn Bootloader” を選択すると、ブートローダの書き込みが始まる。

Board: ATtiny25/45/85
Processor: ATtiny85
Clock: Internal 8 MHz
Programmer: Arduino as ISP

コードのアップロード

ブートローダを ATtiny85 に書き込んだ後、コードをアップロードできる。コードをアップロードするには、通常の Upload アイコンをクリックするのではなく、 Sketch メニューから Upload using programmer を選択する。

また、コードのアップロードを容易にするために、ユニバーサル基板や 8 ピン DIP ソケットなどで以下の画像のようなものを作った。

これでブートローダの書き込みとコードのアップロードが楽になる。

LCDに現在の温度・湿度を表示する

2023-09-09T00:00:00+09:00

Arduino Nano を使用して、DHT11 温湿度センサから現在の温度と湿度を読み取り、16x2 のキャラクタLCD に表示します。

DHT11 温湿度センサ

DHT11 センサは抵抗式湿度センサと NTC (Negative Temperature Coefficient) thermistor で構成されています。

DHT11 に加えて、DHT22 もあるが、DHT11 とは若干仕様が異なります。

DHT11 は 0°C〜50°C の温度（精度 ±2.0°C）、湿度 20%～90%（精度 ±5%）を測定できる。
DHT22 は -40°C〜80°C の温度（精度 ±0.5°C）、湿度 0%～100%（精度 ±2%）を測定できる。
DHT11のサンプリングレートは 1Hz、DHT22のサンプリングレートは 0.5Hz です。

DHT22 はより広い範囲を測定でき、精度も高くなります。

モジュールを使っているが、センサとの違いは、LED インジケータ、プルアップ抵抗やバイパスコンデンサが内蔵されていることです。センサーを直接使用する場合、通常は出力ピンに 10KΩ プルアップ抵抗を追加する必要があります。

DHT11 センサモジュールには、3 つのピンがあります。

VCC: センサーに電力を供給する。Arduino の 5V または 3.3V ピンに接続する。
DAT: データ出力。デジタルピンに接続する。
GND: グランドピン。

LCD に測定値を表示する

I2C LCD モジュールを使用します。LCD の裏側に I2C LCD アダプタがはんだ付けられています。このアダプタを使えば、SCL と SDA ピンだけで LCD を制御できます。

SCL: I2C クロック。Arduino Nano の A5 ピンに接続する。
SDA: I2C データ入出力。Arduino Nano の A4 ピンに接続する。

Arduino サンプルコード

DHT sensor library と LiquidCrystal_I2C ライブラリを使っています。

DHT11 を D7 ピンに接続しているので、DHTPIN を 7 に指定します。

#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

#define DHTPIN 7
#define DHTTYPE DHT11

#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args)  write(args);
#else
#define printByte(args)  print(args,BYTE);
#endif

LiquidCrystal_I2C lcd(0x27, 16, 2);  // set the I2C address of the 16x2 LCD to 0x27

DHT dht(DHTPIN, DHTTYPE);

void setup()
{
  dht.begin();
  lcd.init();

  lcd.backlight();
  delay(300);
  lcd.noBacklight();

  lcd.home();
}


void loop()
{
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(t);
  // hexadecimal escape sequence \xdf followed by the character C
  lcd.print("\xdf""C");  // degree Celsius

  lcd.setCursor(0, 1);
  lcd.print("RH: ");
  lcd.print(h);
  lcd.print("\x25");  // percent

  delay(5000);
}

カスタムキャラクタの作成

LCD に表示される各キャラクタは 5x8 のピクセルグリッドで構成されています。

以下は HTML の <canvas> 要素で描かれた 5x8 のピクセルグリッドです。任意のピクセルをクリックして、create ボタンをクリックすると、キャラクタの 16 進数データが生成されます。

hex:

LCD にカスタムキャラクタを表示するには、生成した 16 進数データから uint8_t 型の配列を作成：

uint8_t heart[8] = {0x00,0x0a,0x1f,0x1f,0x0e,0x04,0x00,0x00};

setup() で createChar() 関数を使用してカスタムキャラクタを作成する。

lcd.createChar(0, heart);

loop() 関数でカスタムキャラクタを表示するには、printByte() を呼び出して、キャラクタの番号を渡す。

lcd.printByte(0);

ESP8266とリレーモジュールでLED電球を制御する

2023-07-15T00:00:00+09:00

リレーはコイルと、コイルに通電することで開閉する接点で構成されて、低入力電圧で高電圧デバイスを制御することができます。

リレーモジュールはリレー以外、LEDインジケータ、トランジスタ、還流ダイオードなどの電子部品も含まれて、制御が容易になります。

リレーモジュール pinout

次の図は 5V シングルチャンネルリレーモジュールです。

出力側の端子台には COM (common), NC (normally closed), NO (normally open) の 3 つの端子があります。

COM 端子は共通端子。
NC（常閉）端子は常に COM 端子に接続する。
NO（常開）端子は常に開いているため、回路を閉じない限り COM に接続しない。

電球は長時間使用しないなので、NO 端子に接続します。

入力側は VCC、GND、IN の 3 つのピンがあります。 IN ピンは NodeMCU の GPIO ピンに接続し、リレーを制御します。active-low ピンなので、LOW にするとリレーが動作します。

NodeMCU V3 を使っているので、USB から給電する場合、5V リレーモジュールに電力を供給するには、VU (Vusb) ピンを使用します。リレーモジュールの VCC ピンを VU ピンに接続します。ちなみに一部のリレーモジュールは 3.3V ピンに接続しても動作します。

以下は 2 チャンネルリレーモジュールを使用した例です。

開発環境構築

非同期通信で電球の ON/OFF を制御したいため、ESPAsyncWebServer というライブラリを利用します。

私は PlatformIO IDE for VSCode を使っているので、platformio.ini で lib_deps パラメーターをこのライブラリ名に設定します。

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
board_build.f_cpu = 80000000L
upload_speed = 115200
monitor_speed = 115200
platform_packages =
    platformio/framework-arduinoespressif8266 @ https://github.com/esp8266/Arduino.git

lib_deps = ESP Async WebServer

コード

コードは以下となります。

PROGMEM を使って、フラッシュメモリに HTML コードを保存します。注意すべき点は、rawliteral は 2 つの % 記号の間をプレースホルダーとして扱うので、 CSS コードでパーセントを指定する場合、%% で % をエスケープする必要があります。例えば translate(-50%, -50%) は translate(-50%%, -50%%) になります。

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncWebServer.h>

const char *ssid = "SSID";
const char *password = "PASSWORD";
const char *PARAM_STATE = "state";
const int relayPin = 5;  // D1
boolean relayNO = true;  // whether the relay is normally open

AsyncWebServer server(80);

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Control LED</title>
    <style>
      .center { position: absolute; top: 50%%; left: 50%%; transform: translate(-50%%, -50%%); }
      .switch { position: relative; display: inline-block; width: 80px; height: 40px; }
      .switch input { display: none; }
      .slider { position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0; background-color: #e0e0e0; border-radius: 40px; transition: 0.3s; }
      .slider::before { position: absolute; content: ""; height: 30px; width: 30px; top: 5px; left: 5px; background-color: #fff; border-radius: 50%; transition: 0.3s; }
      input:checked + .slider { background-color: #4caf50; }
      input:focus + .slider { box-shadow: 0 0 1px #4caf50; }
      input:checked + .slider:before { transform: translateX(40px); }
    </style>
  </head>
  <body>
    <div class="center">
      <h3 id="title">%LED_STATE%</h3>
      <label class="switch">
        <input type="checkbox" onchange="toggleSwitch(this)" %IS_CHECKED%/>
        <span class="slider"></span>
      </label>
    </div>
    <script>
      function toggleSwitch(e) {
        const req = new XMLHttpRequest();
        const title = document.getElementById("title");
        if (e.checked) { req.open("GET", "/light?state=1", true); title.innerHTML =  "LED Lamp ON"; }
        else { req.open("GET", "/light?state=0", true); title.innerHTML =  "LED Lamp OFF"; }
        req.send();
      }
    </script>
  </body>
</html>
)rawliteral";

String processor(const String &var) {
    if (var == "LED_STATE") {
        String stateVal;
        if (relayNO) {
            stateVal = (digitalRead(relayPin)) ? "OFF" : "ON";
        } else {
            stateVal = (digitalRead(relayPin)) ? "ON" : "OFF";
        }
        String stateText = "LED Lamp " + stateVal;
        return stateText;
    } else if (var == "IS_CHECKED") {
        String checkbox;
        if (relayNO) {
            checkbox = (digitalRead(relayPin)) ? "" : "checked";
        } else {
            checkbox = (digitalRead(relayPin)) ? "checked" : "";
        }
        return checkbox;
    }

    return String();
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, password);
    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
        Serial.printf("WiFi Failed!\n");
        return;
    }

    Serial.println("");
    Serial.print("Connected to ");
    Serial.println(ssid);
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());

    pinMode(relayPin, OUTPUT);
    if (relayNO) {
        digitalWrite(relayPin, HIGH);
    } else {
        digitalWrite(relayPin, LOW);
    }

    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
        request->send_P(200, "text/html", index_html, processor);
    });

    server.on("/light", HTTP_GET, [](AsyncWebServerRequest *request) {
        String state;
        if (request->hasParam(PARAM_STATE)) {
            state = request->getParam(PARAM_STATE)->value();
            if (relayNO) {
                digitalWrite(relayPin, !state.toInt());
            } else {
                digitalWrite(relayPin, state.toInt());
            }
        } else {
            state = "No state sent";
        }
        request->send(200, "text/plain", "[GET]: " + state);
    });

    server.begin();
}

void loop() {}

IP アドレスはシリアルモニターで出力されます。

ブラウザからこの IP アドレスにアクセスすると、トグルスイッチが画面に表示されます。このスイッチの ON/OFF で LED 電球を点滅できます。

AWS CDKでECSサービスのオートスケーリングのリソースを作成

2023-06-19T00:00:00+09:00

AWS CDK (Cloud Development Kit) は IaC ツールで、コードを書くことでインフラストラクチャのプロビジョニングを行います。好きなプログラミング言語でインフラストラクチャを定義し、CloudFormation テンプレートを自動生成できます。抽象化レベルが高いので、コード量が少ないです。

CDK 開発環境の構築

nvm で node.js をインストール

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash
$ . ~/.nvm/nvm.sh
$ nvm install 16

cdk コマンドラインツール AWS CDK Toolkit のインストール
```
$ npm install -g aws-cdk
```
Python の CDK パッケージのインストール
```
$ pip install aws-cdk-lib
```

AWS アカウントとリージョンを環境変数に設定

$ echo "export AWS_REGION=$(curl -s 169.254.169.254/latest/dynamic/instance-identity/document | jq -r .region)" >> ~/.bashrc
$ echo "export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)" >> ~/.bashrc

AWS CDK Toolkit (CLI) コマンド

CDK プロジェクトの作成
```
$ cdk init app --language python
```
CDK アプリから CloudFormation テンプレートを生成する
```
$ cdk synth
```
ブートストラップスタックのデプロイ。CDK アプリを AWS 環境（AWS アカウントとリージョン）に初めてデプロイする前に実行する必要がある。
```
$ cdk bootstrap
```
CDK アプリのデプロイ
```
$ cdk deploy
```

CDK でリソースを作成

EC2 起動タイプで ECS サービスのオートスケーリングを行います。

まずは、ECS クラスター、Auto Scaling グループとキャパシティープロバイダーの作成です。以下のようになります。

import os

import boto3
from aws_cdk import (
    App,
    Tags,
    Stack,
    Duration,
    Environment,
    aws_ecs as ecs,
    aws_ec2 as ec2,
    aws_ecr as ecr,
    aws_iam as iam,
    aws_autoscaling as autoscaling,
    aws_cloudwatch as cloudwatch,
    aws_applicationautoscaling as appscaling
)
from constructs import Construct


class ECSAutoScaling(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs):
        super().__init__(scope, construct_id, **kwargs)

        # 既存のVPC、サブネット、セキュリティグループ、IAMロールを使用
        vpc = ec2.Vpc.from_lookup(self, 'vpc', vpc_id='vpc-xxx')
        security_group = ec2.SecurityGroup.from_security_group_id(
            self, 'SG', 'sg-xxx')
        subnet_ids = [
            'subnet-xxx',
            'subnet-yyy',
        ]
        subnets = [ec2.Subnet.from_subnet_id(
            self, f'subnet{idx}', sid) for idx, sid in enumerate(subnet_ids)]
        asg_role = iam.Role.from_role_name(
            self, 'AsgRole', 'role_name')
        task_role = iam.Role.from_role_name(
            self, 'TaskRole', 'role_name')

        # ECSクラスターの作成
        cluster = ecs.Cluster(
            self, 'Cluster',
            cluster_name='cluster_name',
            vpc=vpc)

        # AutoScalingGroupの作成
        asg = autoscaling.AutoScalingGroup(
            self, "ASG",
            auto_scaling_group_name='auto_scaling_group_name',
            vpc=vpc,
            role=asg_role,
            vpc_subnets=ec2.SubnetSelection(subnets=subnets),
            instance_type=ec2.InstanceType("c6g.16xlarge"),
            machine_image=ecs.EcsOptimizedImage.amazon_linux2(
                ecs.AmiHardwareType.ARM),
            min_capacity=0,
            max_capacity=5,
            desired_capacity=0,
            security_group=security_group
        )
        # キャパシティープロバイダーの作成とクラスターへの関連付け
        capacity_provider = ecs.AsgCapacityProvider(
            self, 'AsgCapacityProvider',
            capacity_provider_name='capacity_provider_name',
            auto_scaling_group=asg
        )
        cluster.add_asg_capacity_provider(capacity_provider)

タスク定義とサービスの作成。

# タスク定義の作成
task_def = ecs.Ec2TaskDefinition(
    self, "TaskDef",
    family='task_family_name',
    network_mode=ecs.NetworkMode.BRIDGE,
    task_role=task_role,
    execution_role=task_role,
)
# 既存のECRリポジトリを使用
repository = ecr.Repository.from_repository_name(
    self, 'Repository', 'repository_name')
task_def.add_container(
    'Container',
    container_name='container_name',
    image=ecs.ContainerImage.from_ecr_repository(
        repository, tag='latest'),
    memory_limit_mib=1024,
    logging=ecs.LogDrivers.aws_logs(stream_prefix='cdk')
)

# サービスのキャパシティープロバイダー戦略
capacity_provider_strategy = ecs.CapacityProviderStrategy(
    capacity_provider=capacity_provider.capacity_provider_name,
    weight=1,
    base=0
)
# ECSサービスの作成
ecs_service = ecs.Ec2Service(
    self, 'Service',
    service_name='service_name',
    cluster=cluster,
    task_definition=task_def,
    desired_count=0,
    capacity_provider_strategies=[capacity_provider_strategy]
)

CloudWatch メトリクスとアラーム、ステップスケーリングポリシーの作成。

メトリクスは、boto3 か AWS CLI を使って最初のデータポイントを発行した後に作成されます。

cw = boto3.client('cloudwatch', region_name=os.getenv('AWS_REGION'))
cw.put_metric_data(
    Namespace='Namespace',
    MetricData=[{
        'MetricName': 'MetricName',
        'Value': 0,
        'Unit': 'Count',
    }]
)

Metric クラスはメトリクスを参照します。メトリクス自体を作成しないです。

This class does not represent a resource, so hence is not a construct. Instead, Metric is an abstraction that makes it easy to specify metrics for use in both alarms and graphs.

参考：https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_cloudwatch/Metric.html

# カスタムメトリクスの参照
metric = cloudwatch.Metric(
    namespace='namespace',
    metric_name='metric_name',
    period=Duration.minutes(1),
    unit=cloudwatch.Unit.COUNT
)
# アラームを作成
alarm = metric.create_alarm(
    self, 'Alarm',
    alarm_name='alarm_name',
    evaluation_periods=1,
    threshold=0,
)

# ECSサービスのタスクスケーリングポリシーの追加
scalable_target = ecs_service.auto_scale_task_count(
    max_capacity=5,
    min_capacity=0
)
scaling_steps = [
    appscaling.ScalingInterval(change=0, upper=0),
    appscaling.ScalingInterval(change=1, lower=1, upper=10),
    appscaling.ScalingInterval(change=2, lower=10, upper=20),
    appscaling.ScalingInterval(change=5, lower=20),
]
scalable_target.scale_on_metric(
    'AutoScalingPolicy',
    metric=alarm.metric,
    scaling_steps=scaling_steps,
    adjustment_type=appscaling.AdjustmentType.EXACT_CAPACITY,
    cooldown=Duration.minutes(3)
)

app: App = App()
stack = ECSAutoScaling(
    app, "ECSAutoScaling",
    env=Environment(
        account=os.getenv('AWS_ACCOUNT_ID'),
        region=os.getenv('AWS_REGION')
    )
)
# リソースのタグ付け
Tags.of(stack).add('key', 'value', include_resource_types=['AWS::ECS::TaskDefinition'])

app.synth()

3Dプリンタをプロッタにする

2023-05-28T00:00:00+09:00

3D プリンタは G-code によって制御されます。G-code は CNC プログラミング言語であり、機械にどこに、どのように移動するかなどを指示します。

ペンを押出機のホットエンドキットにアタッチし、フィラメントを押し出さないようにして、移動コマンドを実行することでペンプロッタとして絵を描くことができます。

ここでは、SVG > STL > G-code という方式を紹介します。

まず、Inkscape を使ってビットマップ画像をベクタ画像に変換します。 Inkscape で画像をベクタ化するには：

メニューから Path > Trace Bitmap を選択し、画像をトレースします。
Single scan タブで Brightness Cutoff オプションを選択します。輪郭だけをベクタ化したい場合、Edge detection を選択します。
適当なしきい値を設定します。
「Apply」をクリックしてベクタオブジェクトを作成します。
SVG ファイルとして保存します

ちなみに、Inkscape はパスから G-code を生成できるプラグインもあります。例えば GcodePlot というプラグイン。ダウンロードして、Inkscape の extensions ディレクトリ（macOS の場合は /Applications/Inkscape.app/Contents/Resources/share/inkscape/extensions）に置けば使えます。

次に SVG を STL に変換します。私は Tinkercad を使っています。描画は 2D で、レイヤーは 1 つだけなので、モデルの高さはノズル径に合わせて設定します。

最後に、STL から G-code を生成します。スライサーソフト Cura を使います。設定は以下のスクリーンショットに示されています。

レイヤーの高さはノズル径 0.4mm に設定しています。
z hop height は、ペンを移動する際に、ペンを何ミリ上げるかを指定します。

ペン先とノズル間の Z オフセットは Cura のプラグイン Z Offset Setting を利用します。画面右上隅の「Marketplace」をクリックし、プラグインを追加できます。

描いた絵はこんな感じです。

ESP8266 NodeMCU V3 を使い始める

2023-05-04T00:00:00+09:00

NodeMCU は ESP8266 の開発ボードで、USB-UART ブリッジや電圧レギュレータなどが組み込まれています。

CH340 ドライバのインストール

NodeMCU V3 には、USB-UART 変換IC CH340 を搭載しています。NodeMCU を Mac に接続する際、まず、CH340 ドライバをインストールします。最新のドライバは、こちらからダウンロードできます。

インストール完了後、次のコマンドを実行すると、Mac の COM ポートに接続されているデバイスの一覧が表示されます。CH340 は、/dev/cu.wchusbserial...として表示されます。表示されていない場合は、別のUSBケーブルを試してみましょう。

$ ls /dev/cu.*

NodeMCU ファームウェアをビルドする

cloud builder (https://nodemcu-build.com) で簡単にビルドできます。ビルドが完了したら、ファームウェアのダウンロードリンクが記載されたメールが届きます。整数版と浮動小数点数版の両方を提供しています。どちらを使うかについて、整数版の方はメモリフットプリントが少なく、実行速度が速いですが、浮動小数点演算をサポートしていません。

We recommend using the floating point build, even though the integer variant uses less RAM for storing variables, as there is little runtime difference between the two variants. Furthermore, the floating point variant handles non-integer values properly and this greatly simplifies numeric calculations.

参考：https://nodemcu.readthedocs.io/en/latest/getting-started/#cloud-builder

ファームウェアの書き込み

最新の NodeMCU ファームウェアを ESP8266 に書き込むには、 esptool.py かまたは NodeMCU PyFlasher という esptool.py をベースにした GUI ツールを使用します。

esptool.py

$ python esptool.py \
    --port /dev/cu.wchusbserial220 \
    --baud 115200 \
    write_flash -fm dio 0x0 <nodemcu-firmware>.bin

NodeMCU PyFlasher

Arduino IDE に ESP8266 アドオンをインストールする

Arduino IDE で Arduino > Settings を開きます。 Additional Boards Manager URLs にリンク (http://arduino.esp8266.com/stable/package_esp8266com_index.json) を追加します。

そして、Tools > Board > Boards Manager でボードマネージャを開き、esp8266 を検索してインストールします。

コードのアップロード

ボードは NODEMCU 1.0 (ESP-12E Module) を選択します。
ポートは /dev/cu.wchusbserial... を選択します。

まず、LED を点滅させるサンプルコードをアップロードし、動作テストを行います。 GPIO 5 は D1 ピンに対応します。

const int ledPin = 5;

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

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

以上の動作を確認できたら、次に、WiFi に接続し、ESP8266 を Web サーバにし、ウェブページから LED の点灯と消灯を制御しましょう。以下のコードをアップロードし、シリアルモニターを開いて IP アドレスを確認します。

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

#ifndef STASSID
#define STASSID "SSID"
#define STAPSK "PASSWORD"
#endif

const char* ssid = STASSID;
const char* password = STAPSK;

ESP8266WebServer server(80);

const int led = 5;

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML>
<html>
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Control LED</title>
  <style>
  .button {
    display: inline-block;
    background-color: #4CAF50;
    color: white;
    text-align: center;
    cursor: pointer;
    border: 1px solid transparent;
    padding: 0.3rem 1.5rem;
    margin: 1rem;
    font-size: 1.5rem;
    line-height: 2;
    border-radius: 0.25rem;
  }

  .center {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
  }
</style>
</head>
<body>
  <div class="center">
    <a href="/led/on"><button class="button">LED ON</button></a>
    <a href="/led/off"><button class="button">LED OFF</button></a>
  </div>
</body>
</html>
)rawliteral";

void handleRoot() {
  digitalWrite(led, 1);
  server.send(200, "text/html", index_html);
  digitalWrite(led, 0);
}

void handleNotFound() {
  digitalWrite(led, 1);
  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);
  digitalWrite(led, 0);
}

void setup(void) {
  pinMode(led, OUTPUT);
  digitalWrite(led, 0);
  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("esp8266")) { Serial.println("MDNS responder started"); }

  server.on("/", handleRoot);

  server.on("/led/on", []() {
    digitalWrite(led, 1);
    server.send(200, "text/plain", "LED ON");
  });

  server.on("/led/off", []() {
    digitalWrite(led, 0);
    server.send(200, "text/plain", "LED OFF");
  });

  server.onNotFound(handleNotFound);

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

void loop(void) {
  server.handleClient();
  MDNS.update();
}

ブラウザでこの IP アドレスにアクセスすると、次のような画面が表示されます。ボタンをクリックすることで、LED のオン・オフを制御できます。

Training a text classification model with Create ML

2023-04-16T00:00:00+09:00

In this post, we’ll use Create ML framework from Playgrounds to create a sentiment analysis model. Sentiment analysis is a common use of text classification to identify the sentiment of text (positive, negative, etc.).

We will use the Movie Review Data, you can download the dataset from here. It’s a CSV file with two columns as shown in the image below.

Launch Xcode and create a blank macOS Playground, CreateML is not available in iOS Playgrounds. You can check the selected platform in the File Inspector.

Create a URL object of the CSV file and then pass it to the DataFrame.

import CreateML
import Foundation
import TabularData

let inputFilePath = "/Users/zion/datasets/movie-pang02.csv"
let outputModelPath = "/Users/zion/Desktop/SentimentClassifier.mlmodel"

let dataURL = URL(fileURLWithPath: inputFilePath)
let data = try DataFrame(contentsOfCSVFile: dataURL)

Split the data into train and test sets, 80% of the data is trainingData.

let (trainingData, testingData) = data.stratifiedSplit(by: 0.8, randomSeed: 7)

Use MLTextClassifier to train the model. The column names in the CSV file are “text” and “class”, so we specify them as shown in the following code. After training the classifier, we also check the training accuracy and the validation accuracy. Then evaluate the model using the test data and save the model with a .mlmodel extension so we can use it in an iOS app.

do {
    // training the classifier
    let sentimentClassifier = try MLTextClassifier(
        trainingData: trainingData,
        textColumn: "text",
        labelColumn: "class",
        parameters: MLTextClassifier.ModelParameters(validation: .split(strategy: .automatic))
    )

    // check the training accuracy and the validation accuracy
    let trainingAccuracy = round((1.0 - sentimentClassifier.trainingMetrics.classificationError) * 10000) / 100
    let validationAccuracy = round((1.0 - sentimentClassifier.validationMetrics.classificationError) * 10000) / 100
    print("Training Accuracy: \(trainingAccuracy)%\n"
          + "Validation Accuracy: \(validationAccuracy)%")
    
    // evaluating the model
    let evaluationMetrics = sentimentClassifier.evaluation(
        on: testingData,
        textColumn: "text",
        labelColumn: "class"
    )
    let evaluationAccuracy = round((1.0 - evaluationMetrics.classificationError) * 10000) / 100
    print("Evaluation Accuracy: \(evaluationAccuracy)%")
    
    // export the Core ML model
    let metadata = MLModelMetadata(
        author: "zion",
        shortDescription: "A sentiment analysis model",
        version: "1.0"
    )
    try sentimentClassifier.write(
        to: URL(fileURLWithPath: outputModelPath),
        metadata: metadata
    )
} catch {
    print("Error:", error)
}

After running the above code, you can see the following output in the console.

Tokenizing data and extracting features
20% complete
40% complete
60% complete
80% complete
100% complete
Starting MaxEnt training with 1513 samples
Iteration 1 training accuracy 0.499009
Iteration 2 training accuracy 0.940516
Iteration 3 training accuracy 0.984137
Finished MaxEnt training in 0.21 seconds
Training Accuracy: 100.0%
Validation Accuracy: 82.76%
Evaluation Accuracy: 85.25%
Trained model successfully saved at /Users/zion/Desktop/SentimentClassifier.mlmodel.

To use the Core ML model in an iOS app, drag and drop it into the project. Xcode will automatically generates a class for the model. Create an NLModel from the MLModel like below, then you can call predictedLabel(for:) to make a prediction on the input text.

private lazy var nlModel: NLModel? = {
    do {
        let mlModel = try SentimentClassifier(configuration: MLModelConfiguration()).model
        return try NLModel(mlModel: mlModel)
    } catch {
        print("Failed to create NLModel: \(error)")
        return nil
    }
}()