Microlino Forum

Code: Alles auswählen

esphome:
  name: microlino-can-sniffer
  friendly_name: Microlino CAN Sniffer

esp32:
  board: esp32dev
  framework:
    type: arduino

logger:
  level: INFO
  baud_rate: 115200

api:

ota:
  platform: esphome

wifi:
  ssid: "xxxxxxxx"
  password: "xxxxxxxx"

  ap:
    ssid: "Microlino CAN Fallback"
    password: "12345678"

captive_portal:

# BLE Beacon fuer Bermuda / Positionszuordnung
# Das Microlino-CAN-Board sendet als iBeacon.
esp32_ble_beacon:
  type: iBeacon
  uuid: "c0a80107-0000-4000-8000-000006080107"
  major: 107
  minor: 1
  measured_power: -59
  min_interval: 500ms
  max_interval: 1000ms

sensor:
  - platform: template
    name: "Microlino HV Spannung Kandidat"
    id: microlino_hv_voltage
    unit_of_measurement: "V"
    accuracy_decimals: 3
    device_class: voltage
    state_class: measurement
    icon: mdi:car-battery

  - platform: adc
    pin: GPIO36
    name: "Microlino Bordspannung"
    id: microlino_bordspannung
    attenuation: 12db
    unit_of_measurement: "V"
    accuracy_decimals: 2
    device_class: voltage
    state_class: measurement
    update_interval: 5s
    filters:
      - multiply: 12.0
      - median:
          window_size: 7
          send_every: 3

  - platform: template
    name: "Microlino CAN107 Byte0"
    id: microlino_can107_byte0
    accuracy_decimals: 0
    state_class: measurement

  - platform: template
    name: "Microlino CAN107 Byte1"
    id: microlino_can107_byte1
    accuracy_decimals: 0
    state_class: measurement

  - platform: template
    name: "Microlino CAN107 Byte2"
    id: microlino_can107_byte2
    accuracy_decimals: 0
    state_class: measurement

  - platform: template
    name: "Microlino CAN107 Byte3"
    id: microlino_can107_byte3
    accuracy_decimals: 0
    state_class: measurement

canbus:
  - platform: esp32_can
    id: microlino_can
    tx_pin: GPIO27
    rx_pin: GPIO26
    bit_rate: 500kbps
    can_id: 0x001
    use_extended_id: false

    on_frame:
      - can_id: 0x000
        can_id_mask: 0x000
        then:
          - lambda: |-
              struct CanState {
                uint32_t id;
                uint8_t len;
                uint8_t data[8];
                bool used;
              };

              static CanState states[128];

              int slot = -1;

              for (int i = 0; i < 128; i++) {
                if (states[i].used && states[i].id == can_id) {
                  slot = i;
                  break;
                }
              }

              if (slot == -1) {
                for (int i = 0; i < 128; i++) {
                  if (!states[i].used) {
                    slot = i;
                    states[i].used = true;
                    states[i].id = can_id;
                    states[i].len = 0;
                    memset(states[i].data, 0, 8);
                    break;
                  }
                }
              }

              if (slot == -1) {
                ESP_LOGW("CAN", "Kein freier Speicherplatz fuer ID 0x%03X", can_id);
                return;
              }

              bool changed = false;

              if (states[slot].len != x.size()) {
                changed = true;
              } else {
                for (uint8_t i = 0; i < x.size(); i++) {
                  if (states[slot].data[i] != x[i]) {
                    changed = true;
                    break;
                  }
                }
              }

              if (!changed)
                return;

              char old_data[40];
              char new_data[40];

              old_data[0] = '\0';
              new_data[0] = '\0';

              for (uint8_t i = 0; i < states[slot].len; i++) {
                char byte_text[5];
                sprintf(byte_text, "%02X ", states[slot].data[i]);
                strcat(old_data, byte_text);
              }

              for (uint8_t i = 0; i < x.size(); i++) {
                char byte_text[5];
                sprintf(byte_text, "%02X ", x[i]);
                strcat(new_data, byte_text);
              }

              ESP_LOGI(
                "CAN_CHANGE",
                "ID 0x%03X DLC %d: %s -> %s",
                can_id,
                x.size(),
                old_data,
                new_data
              );

              states[slot].len = x.size();
              memset(states[slot].data, 0, 8);

              for (uint8_t i = 0; i < x.size(); i++) {
                states[slot].data[i] = x[i];
              }

              // --------------------------------------------------
              // Microlino CAN107 Rohwerte fuer Analyse
              // --------------------------------------------------

              if (can_id == 0x107 && x.size() >= 4) {
                id(microlino_can107_byte0).publish_state(x[0]);
                id(microlino_can107_byte1).publish_state(x[1]);
                id(microlino_can107_byte2).publish_state(x[2]);
                id(microlino_can107_byte3).publish_state(x[3]);

                ESP_LOGI(
                  "CAN107_RAW",
                  "B0=%u B1=%u B2=%u B3=%u",
                  x[0],
                  x[1],
                  x[2],
                  x[3]
                );
              }

              // --------------------------------------------------
              // Microlino HV-Spannung Kandidat
              // CAN-ID 0x18D
              // --------------------------------------------------

              if (can_id == 0x18D && x.size() >= 5) {

                uint16_t raw1 =
                    ((uint16_t)x[4] << 8) |
                    x[3];

                float voltage1 =
                    raw1 / 1000.0f;

                uint16_t raw2 =
                    ((uint16_t)x[3] << 8) |
                    x[4];

                float voltage2 =
                    raw2 / 1000.0f;

                ESP_LOGI(
                  "HV_DEBUG",
                  "0x18D RAW1=%u (%.3fV) RAW2=%u (%.3fV)",
                  raw1,
                  voltage1,
                  raw2,
                  voltage2
                );

                float voltage = 0.0f;

                if (voltage1 > 40.0f && voltage1 < 70.0f) {
                  voltage = voltage1;
                } else if (voltage2 > 40.0f && voltage2 < 70.0f) {
                  voltage = voltage2;
                }

                if (voltage > 0.0f) {
                  id(microlino_hv_voltage).publish_state(voltage);

                  ESP_LOGI(
                    "HV_EST",
                    "Voltage=%.3fV",
                    voltage
                  );
                }
              }