CAN通信の実装をArduinoで実演｜C言語での受信データの取り出し方

/*
 * can_rx.ino ---- CAN通信 受信側のサンプルプログラム（Arduino Uno + MCP2515）
 * ============================================================
 * 受信した1フレームが「C言語の値」になるまでを、3段階そのままの順で出す。
 *
 *   RAW   : 受信した生の8バイト（まだ意味を持たない数値の並び）
 *   FRAME : 構造体に入れた後（ID / 拡張フォーマットか / DLC）
 *   VALUE : マスクとシフトで取り出した物理値（車速・ギア段・警告灯）
 *
 * 配線（このボードには MCP2515モジュールを1枚だけつなぐ）
 *   VCC -> 5V      GND -> GND      ※VCCは3.3Vではない。TJA1050は5V動作
 *   SCK -> D13     SO  -> D12      SI -> D11    ※SIとSOの取り違えに注意
 *   CS  -> D10     INT -> D2
 *   CANH/CANL -> もう1台のモジュールの CANH/CANL へ（ネジ端子台）
 *   重要: 2台のArduinoの GND どうしも1本つなぐ。
 *         CANは差動信号だが、両ノードの0Vがずれていると差が読めない。
 *
 * シリアルモニタは 115200 baud で開く（9600のままだと文字化けする）。
 *
 * 動作確認済み: 2026-08-14 / UNO R4 送信・UNO R3 受信 / MCP2515 8MHz / 500kbps
 */

#include <SPI.h>        /* MCP2515とはSPIで話す。ライブラリが内部で使う */
#include <mcp_can.h>    /* coryjfowler / MCP_CAN_lib（IDEのライブラリマネージャで mcp_can） */

/* ============================================================
 * 1. 環境に合わせて変えるのはここだけ
 * ============================================================ */

/* 重要: モジュール基板に載っている水晶(銀色の部品)の刻印と必ず合わせる。
 *       8.000 なら MCP_8MHZ、16.000 なら MCP_16MHZ。
 *       ここが実物と違うとビットレートの計算がずれ、
 *       配線が完璧でも1フレームも通らない。最も多い詰まりどころ。 */
#define MCP_CLOCK   MCP_8MHZ
#define CAN_SPEED   CAN_500KBPS   /* 車載の高速CANでよく使う値 */

#define PIN_CS      10   /* SPIのチップセレクト。このモジュールを選ぶ線 */
#define PIN_INT     2    /* MCP2515が「受信した」と教えてくる線（受信でLOWになる） */

MCP_CAN CAN(PIN_CS);     /* CSピンを教えてインスタンスを作る */

/* ============================================================
 * 2. 型の定義
 *
 * 重要: .ino では構造体の typedef を「最初の関数より前」に置く。
 *       Arduino IDEはコンパイル前に、最初の関数定義の直前へ
 *       全関数のプロトタイプを自動で差し込む。型がそれより後ろにあると
 *         error: variable or field '...' declared void
 *         error: '...' was not declared in this scope
 *       で落ちる。ファイルを分けない .ino 特有の落とし穴。
 * ============================================================ */

#define CAN_PAYLOAD_MAX 8   /* クラシカルCANのデータ部は最大8バイト */

/* 受信した1フレームの置き場所。
 * ID・DLC・データはバラバラの変数で返ってくるが、
 * 持ち回ると引数が増えて渡し忘れるので、1つにまとめる。 */
typedef struct {
    /* IDは標準フォーマットなら11bit、拡張フォーマットなら29bit。
     * 後から拡張が来ても型を変えずに済むよう、最初から32bitで持つ。 */
    uint32_t id;
    bool     is_extended;            /* 拡張フォーマットで届いたら true */
    uint8_t  dlc;                    /* データが何バイト入っているか（0〜8） */
    uint8_t  data[CAN_PAYLOAD_MAX];  /* 中身。長さを決め打ちで確保する */
} can_frame_t;

/* 受信をためるリングバッファ。
 * フレームはこちらの都合と関係なく届くので、
 * 「受け取る瞬間」と「処理する瞬間」のずれをここで吸収する。 */
#define CAN_RX_QUEUE_LEN 8   /* 何件ためられるか。RAMと相談して決める */

typedef struct {
    can_frame_t buf[CAN_RX_QUEUE_LEN];
    uint8_t     head;      /* 次に「書く」位置 */
    uint8_t     tail;      /* 次に「読む」位置 */
    uint8_t     count;     /* いま入っている数。headとtailだけでは空と満杯を区別できない */
    uint16_t    dropped;   /* あふれて捨てた数。これが無いと取りこぼしに気づけない */
} can_rx_queue_t;

/* ============================================================
 * 3. 8バイトの中の信号レイアウト（このプロジェクトの取り決め）
 *
 * ここに何を詰めるかはCANの規格の外。送る側と受け取る側で
 * 同じ表を共有していないと、値は永遠に一致しない。
 *
 *   Byte0 bit7..0 : 車速の上位8bit
 *   Byte1 bit7..4 : 車速の下位4bit   ← 合計12bit・0.1km/h刻み
 *   Byte1 bit3..2 : ギア段（0〜3）
 *   Byte1 bit1    : 警告灯（0=OFF / 1=ON）
 *   Byte1 bit0    : 予約（使っていないが、勝手に使わない）
 * ============================================================ */

/* 分解能。生の値1カウントが何km/hにあたるか。
 * 12bitで0〜409.5km/hを表せる。分解能を粗くしてビットを節約するのは
 * 8バイトしかないフレームでは普通の設計。 */
#define SPEED_RESOLUTION 0.1f

/* 車速（12bit）を組み立てる。バイトをまたぐ信号はこの形になる。
 *   上位側(data[0])を左シフトして下に空きを作り、
 *   下位側(data[1])を右シフトして下端まで下ろし、| で重ねる。
 *
 * 重要: (uint16_t) のキャストを外すと壊れる。
 *       data[0]は8bit変数なので、そのまま4bit左へずらすと上位4bitが消える。
 *       先に16bitへ広げてからずらすこと。 */
static uint16_t can_get_speed_raw(const can_frame_t *f)
{
    return (uint16_t)(((uint16_t)f->data[0] << 4) | (f->data[1] >> 4));
}

/* 生の値に分解能を掛けて、はじめて物理値(km/h)になる */
static float can_get_speed_kmh(const can_frame_t *f)
{
    return (float)can_get_speed_raw(f) * SPEED_RESOLUTION;
}

/* ギア段（Byte1のbit3..2）。
 *   >> 2   欲しいビットの一番下(bit2)の位置ぶん右へずらして端に寄せる
 *   & 0x03 残したい2bitぶんの1でマスクし、上位を落とす */
static uint8_t can_get_gear(const can_frame_t *f)
{
    return (uint8_t)((f->data[1] >> 2) & 0x03);
}

/* 警告灯（Byte1のbit1）。1bitなので >> 1 して & 0x01 */
static bool can_get_warning(const can_frame_t *f)
{
    return ((f->data[1] >> 1) & 0x01) != 0;
}

/* ============================================================
 * 4. リングバッファの操作
 * ============================================================ */

static can_rx_queue_t g_rx_queue;   /* 実体。static初期化で全メンバ0になる */

/* 1件書き込む。満杯なら「いちばん古いものを捨てて」新しいものを入れる。
 * 車速のように最新値だけが意味を持つ信号ではこれでよい。
 * 1件も落とせない用途なら、捨てずに失敗を返す作りにする。 */
static void can_queue_push(can_rx_queue_t *q, const can_frame_t *f)
{
    if (q->count == CAN_RX_QUEUE_LEN) {
        /* 満杯。読む位置を1つ進めて、いちばん古い1件を切り捨てる */
        q->tail = (uint8_t)((q->tail + 1) % CAN_RX_QUEUE_LEN);
        q->count--;
        q->dropped++;   /* 捨てた事実は必ず残す */
    }
    q->buf[q->head] = *f;
    /* 端(7)まで来たら (7+1) % 8 = 0 で先頭へ戻る。これが「リング」の由来 */
    q->head = (uint8_t)((q->head + 1) % CAN_RX_QUEUE_LEN);
    q->count++;
}

/* 1件取り出す。空なら false を返す（呼び側の while の終了条件になる） */
static bool can_queue_pop(can_rx_queue_t *q, can_frame_t *out)
{
    if (q->count == 0) {
        return false;
    }
    *out = q->buf[q->tail];
    q->tail = (uint8_t)((q->tail + 1) % CAN_RX_QUEUE_LEN);
    q->count--;
    return true;
}

/* ============================================================
 * 5. 3段ダンプ（変換の途中経過をそのまま見せる）
 * ============================================================ */

static void print_frame(const can_frame_t *f)
{
    char line[64];   /* 固定長。sprintf先のサイズは必ず自分で決める */

    /* RAW: 届いた生のバイト列。まだ意味を持たない数値の並び */
    Serial.print(F("RAW   : "));   /* F() で文字列をRAMでなくFlashへ置く */
    for (uint8_t i = 0; i < f->dlc; i++) {
        snprintf(line, sizeof(line), "%02X ", f->data[i]);
        Serial.print(line);
    }
    Serial.println();

    /* FRAME: 構造体に入れた後。ここまでがライブラリから受け取った情報 */
    snprintf(line, sizeof(line), "FRAME : id=0x%03lX ext=%d dlc=%u",
             (unsigned long)f->id, (int)f->is_extended, f->dlc);
    Serial.println(line);

    /* VALUE: マスクとシフトで取り出した物理値。ここが最終目的地 */
    Serial.print(F("VALUE : speed="));
    Serial.print(can_get_speed_kmh(f), 1);   /* 第2引数は小数点以下の桁数 */
    Serial.print(F(" km/h  gear="));
    Serial.print(can_get_gear(f));
    Serial.print(F("  warn="));
    Serial.println(can_get_warning(f) ? F("ON") : F("OFF"));

    Serial.println();
}

/* ============================================================
 * 6. 初期化
 * ============================================================ */

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

    /* 第1引数 MCP_ANY は「受け取るIDを絞らない」指定。
     * MCP2515は特定IDだけ通すフィルタを持つが、まずは全部受ける。 */
    if (CAN.begin(MCP_ANY, CAN_SPEED, MCP_CLOCK) != CAN_OK) {
        Serial.println(F("初期化に失敗しました。配線と水晶の設定を確認してください"));
        /* 重要: 初期化に失敗したまま先へ進ませない。
         *       通信できない状態で本処理を動かしても、
         *       原因の分からない誤動作になるだけ。 */
        while (1) {
            ;
        }
    }

    /* 重要: MCP2515は電源投入直後、設定変更モードに入っている。
     *       ここで通常モードへ移さないとバスに参加せず、
     *       初期化は成功しているのに1フレームも届かない。 */
    CAN.setMode(MCP_NORMAL);

    /* INTピンは入力。フレームが届くとMCP2515がここをLOWへ落とす */
    pinMode(PIN_INT, INPUT);

    Serial.println(F("受信ノード: CAN 500kbps で開始しました"));
    Serial.println();
}

/* ============================================================
 * 7. メインループ
 *
 * 「受け取る」と「処理する」を分ける。
 * 受信のところで時間のかかるSerial出力をやると、
 * その間に届いた次のフレームを取りこぼす。
 * ============================================================ */

void loop()
{
    can_frame_t f;

    /* --- 受け取る側：届いていたら読み出してキューへ積むだけ --- */
    if (digitalRead(PIN_INT) == LOW) {   /* LOW = 未読のフレームがある */
        unsigned long rx_id = 0;                   /* ← フレームのID   が入る */
        byte          len   = 0;                   /* ← フレームのDLC  が入る */
        byte          buf[CAN_PAYLOAD_MAX] = {0};  /* ← フレームのデータが入る */

        /* readMsgBufが返すのはこの3つだけ。
         * SOF・RTR・制御・CRC・ACK・EOF はコントローラが検査して捨てた後で、
         * 変数としてすら出てこない。 */
        if (CAN.readMsgBuf(&rx_id, &len, buf) == CAN_OK) {
            memset(&f, 0, sizeof(f));   /* 前回の値が残らないよう先に0で埋める */

            /* このライブラリは拡張フレームのとき、返すIDの最上位ビット
             * (0x80000000) を立てて知らせてくる。IDは最大29bitなので
             * 上の3bitが空いているのを目印に使っている。
             * この判定を飛ばすと、拡張フレームのIDが 0x80000123 のように
             * 見えて、どのIDとも一致しなくなる。 */
            f.is_extended = (rx_id & 0x80000000UL) != 0;   /* 目印だけを見る */
            f.id          = rx_id & 0x1FFFFFFFUL;          /* 1が29個並んだマスク */

            /* DLCは受け取った値をそのまま信じない。
             * 配列の大きさを超えていたら丸める（バッファあふれの防止）。 */
            f.dlc = (len > CAN_PAYLOAD_MAX) ? CAN_PAYLOAD_MAX : len;
            memcpy(f.data, buf, f.dlc);

            can_queue_push(&g_rx_queue, &f);
        }
    }

    /* --- 処理する側：たまっているぶんをまとめて捌く --- */
    while (can_queue_pop(&g_rx_queue, &f)) {
        print_frame(&f);
    }
}

/*
 * can_tx.ino ---- CAN通信 送信側のサンプルプログラム（Arduino Uno + MCP2515）
 * ============================================================
 * 100ミリ秒ごとに、ID 0x123 のフレームを1本送るだけ。
 * 中身は「車速 62.0km/h、ギア段 2、警告灯 ON」を8バイトに詰めたもの。
 *
 * 配線（このボードには MCP2515モジュールを1枚だけつなぐ）
 *   VCC -> 5V      GND -> GND      ※VCCは3.3Vではない
 *   SCK -> D13     SO  -> D12      SI -> D11
 *   CS  -> D10     INT -> D2（送信だけなのでこのスケッチでは使わない）
 *   CANH/CANL -> もう1台のモジュールの CANH/CANL へ
 *   重要: 2台のArduinoの GND どうしも1本つなぐ
 *
 * 重要: モジュール上の水晶が 8MHz か 16MHz かで MCP_CLOCK を変える。
 *       間違えるとビットレートがずれて1フレームも通らない。
 *
 * 動作確認済み: 2026-08-14 / UNO R4 送信・UNO R3 受信 / MCP2515 8MHz / 500kbps
 */

#include <SPI.h>
#include <mcp_can.h>

/* --- 環境に合わせて変えるのはここだけ --- */
#define MCP_CLOCK   MCP_8MHZ      /* 水晶が16MHzなら MCP_16MHZ */
#define CAN_SPEED   CAN_500KBPS

#define PIN_CS      10
#define SEND_ID     0x123         /* このフレームの名前。宛先ではない */
#define SEND_CYCLE  100           /* 送信周期[ミリ秒]。周期送信は車載の基本形 */

MCP_CAN CAN(PIN_CS);

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

    if (CAN.begin(MCP_ANY, CAN_SPEED, MCP_CLOCK) != CAN_OK) {
        Serial.println(F("初期化に失敗しました。配線と水晶の設定を確認してください"));
        while (1) {
            ;
        }
    }

    /* 電源投入直後は設定変更モード。通常モードへ移さないとバスに出ない */
    CAN.setMode(MCP_NORMAL);

    Serial.println(F("送信ノード: CAN 500kbps で開始しました"));
}

void loop()
{
    static uint32_t last_send = 0;   /* 前回送った時刻。static なので値が残る */

    /* delay() で待たない。待っている間ほかの処理が止まるため、
     * 経過時間を見て「まだなら何もせず戻る」形にする */
    if (millis() - last_send < SEND_CYCLE) {
        return;
    }
    last_send = millis();

    /* 8バイトの中身（受信側と同じ表を共有していないと値が一致しない）
     *   Byte0        : 車速の上位8bit
     *   Byte1 bit7..4: 車速の下位4bit   合計12bit・0.1km/h刻み
     *   Byte1 bit3..2: ギア段
     *   Byte1 bit1   : 警告灯
     *   Byte1 bit0   : 予約（0のまま）
     *
     * 値からバイトを組み立てると、受信側の逆の手順になる。
     *   車速 62.0km/h -> 620 (0x26C) -> 上位8bit=0x26 / 下位4bit=0xC
     *   ギア段 2  -> bit3..2 へ入れるので 2 << 2 = 0x08
     *   警告灯 ON -> bit1 へ入れるので   1 << 1 = 0x02
     *   Byte1 = 0xC0 | 0x08 | 0x02 = 0xCA
     */
    uint8_t tx[8] = {0};   /* 使わないバイトは0で埋める */
    tx[0] = 0x26;
    tx[1] = 0xCA;

    /* 第2引数の 0 は「標準フォーマット（11bitのID）で送る」の意味。
     * 拡張フォーマット（29bit）で送るなら 1 にする。 */
    if (CAN.sendMsgBuf(SEND_ID, 0, sizeof(tx), tx) != CAN_OK) {
        /* CANは受け手がACKを返さないと送信が完了しない。
         * ここが出続けるときは受信側が動いていない可能性が高い。 */
        Serial.println(F("送信できませんでした。相手が応答しているか確認してください"));
    }
}