<?xml version="1.0" encoding="ISO-8859-1"?>
<MBusData>
    <SlaveInformation>
        <Id>58630287</Id>
        <Manufacturer>DME</Manufacturer>
        <Version>65</Version>
        <ProductName></ProductName>
        <Medium>Heat: Inlet</Medium>
        <AccessNumber>5</AccessNumber>
        <Status>00</Status>
        <Signature>0000</Signature>
    </SlaveInformation>
    <DataRecord id="0">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Reserved (0x0d)</Unit>
        <Value>12667</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="1">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Tariff>1</Tariff>
        <Device>0</Device>
        <Unit>Reserved (0x0d)</Unit>
        <Value>0</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="2">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Tariff>2</Tariff>
        <Device>0</Device>
        <Unit>Reserved (0x0d)</Unit>
        <Value>0</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="3">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Volume (m m^3)</Unit>
        <Value>1476014</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="4">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Power (W)</Unit>
        <Value>0</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="5">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Volume flow (m m^3/h)</Unit>
        <Value>0</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="6">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Flow temperature (1e-1 deg C)</Unit>
        <Value>207</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="7">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Return temperature (1e-1 deg C)</Unit>
        <Value>208</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="8">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Operating time (days)</Unit>
        <Value>1323</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
    <DataRecord id="9">
        <Function>Instantaneous value</Function>
        <StorageNumber>0</StorageNumber>
        <Unit>Operating time (hours)</Unit>
        <Value>0</Value>
        <Timestamp>2021-06-08T11:36:35Z</Timestamp>
    </DataRecord>
</MBusData>

# Берем базовый образ из официального репозитория Golang.
FROM golang:1.16.2 AS buld_heatmeter
# Устанавливаем silent mode для пакетного менеджера (все значения будут установлены по умолчанию).
ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get upgrade -y
# Устанавливаем утилиты и инструменты сборки.
RUN apt-get install gcc-arm-linux-gnueabihf -y sudo -y make -y git -y autoconf -y libtool -y
RUN apt-get clean
# Отключаем запрос пароля при использовании sudo.
RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
# Создаем отдельного пользователя.
RUN useradd -rm -d /home/debian -s /bin/bash -g root -G sudo debian
USER debian
ARG HOME_DIR="/home/debian"
WORKDIR ${HOME_DIR}
# Копируем содержимое (предполагается, что исходные коды и скрипты сборки лежат в папке с Dockerfile).
COPY . heatmeter
# Меняем владельца созданной папки.
RUN sudo chown -R debian:root heatmeter
WORKDIR ${HOME_DIR}/heatmeter
# Запускаем скрипт сборки.
RUN bash build.sh
# Создаем отдельную фазу сборки (build stage), куда копируем артефакт сборки.
# При сборке контейнера указываем папку, куда сохранить артефакт на локальной машине.
# Пример: env DOCKER_BUILDKIT=1 docker build --output out .
# https://docs.docker.com/engine/reference/commandline/build/#custom-build-outputs
FROM scratch AS export-stage
COPY --from=buld_heatmeter /home/debian/heatmeter/heatmeter .

#!/bin/bash
# Клонируем репозиторий libmbus библиотеки в папку build.
BUILD_DIR=./build
if [ ! -d "$BUILD_DIR" ]; then
  REPO_URL="https://github.com/rscada/libmbus"
  git clone  $REPO_URL $BUILD_DIR
fi
pushd ${BUILD_DIR}
# Редактируем build.sh скрипт сборки библиотеки.
# 1. Отключаем сборку динамических библиотек. Линковать библиотеку с нашим приложением будем статически.
sed -i 's/^.*\&\& \.\/configure$/& --enable-shared=no/' build.sh
# 2. Указываем параметры кросс-компиляции https://gcc.gnu.org/onlinedocs/gccint/Configure-Terms.html
sed -i 's/^.*\&\& \.\/configure --enable-shared=no$/& --build=x86_64-ubuntu-linux --host=arm-linux-gnueabihf /' build.sh
# Собираем библиотеку.
./build.sh
popd
# Собираем наше приложение.
# Обязательно указываем компилятор и линковщик для cgo https://golang.org/cmd/cgo/.
# Указываем под какую операционную систему и архитектуру делать сборку.
env CC="arm-linux-gnueabihf-gcc" LD="arm-linux-gnueabihf-ld"  GOOS=linux GOARCH=arm GOARM=5 CGO_ENABLED=1 go build -v  .

package mbus
import (
  "encoding/xml"
  "math"
  "strconv"
)
type Calories uint16
type CubicMetre float32
type Watt uint16
type CubicMetresPerHour float32
type Celsius uint64
type Seconds uint64
type Measurement struct {
  Energy        Calories
  Volume        CubicMetre
  Power         Watt
  VolumeFlow    CubicMetresPerHour
  FlowTemp      Celsius
  ReturnTemp    Celsius
  OperatingTime Seconds
  ErrorTime     Seconds
}
func (m *Measurement) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
  result := struct {
    Records []struct {
      Value string `xml:"Value"`
    } `xml:"DataRecord"`
  }{}
  if err := d.DecodeElement(&result, &start); err != nil {
    return err
  }
  {
    value, err := strconv.ParseFloat(result.Records[0].Value, 32)
    if err != nil {
      return err
    }
    m.Energy = Calories(math.Round(value))
  }
  {
    value, err := strconv.ParseFloat(result.Records[3].Value, 32)
    if err != nil {
      return err
    }
    m.Volume = CubicMetre(value)
  }
  {
    value, err := strconv.ParseFloat(result.Records[4].Value, 32)
    if err != nil {
      return err
    }
    m.Power = Watt(value)
  }
  {
    value, err := strconv.ParseFloat(result.Records[5].Value, 32)
    if err != nil {
      return err
    }
    m.VolumeFlow = CubicMetresPerHour(value)
  }
  {
    value, err := strconv.ParseFloat(result.Records[6].Value, 32)
    if err != nil {
      return err
    }
    m.FlowTemp = Celsius(math.Round(value))
  }
  {
    value, err := strconv.ParseFloat(result.Records[7].Value, 32)
    if err != nil {
      return err
    }
    m.ReturnTemp = Celsius(math.Round(value))
  }
  {
    value, err := strconv.ParseFloat(result.Records[8].Value, 32)
    if err != nil {
      return err
    }
    m.OperatingTime = Seconds(value)
  }
  {
    value, err := strconv.ParseFloat(result.Records[9].Value, 32)
    if err != nil {
      return err
    }
    m.ErrorTime = Seconds(value)
  }
  return nil
}

package mbus
/*
// Указываем линковщику, где находится библиотека mbus.
// Также линкуем Си библиотеку math, которая нужна mbus библиотеке.
#cgo LDFLAGS: -L../build/mbus/.libs/ -lmbus -lm
// Указываем компилятору, где искать заголовочные файлы.
#cgo CFLAGS:  -I../build
// Подключаем файл с нужными нам функциями.
#include "mbus/mbus-serial.h"
// Cи умеет неявно конвертировать из void* в конкретный тип (в данном случае mbus_frame*).
// void* в Go представлен как unsafe.Pointer.
// И так как в Go нет возможности конвертировать unsafe.Pointer в C.mbus_frame*,
// мы сделали для этого небольшую функцию-обертку.
mbus_frame* to_frame(void* p){
  return p;
}
*/
import "C"
import (
  "bytes"
  "encoding/xml"
  "errors"
  "fmt"
  "unsafe"
  "golang.org/x/net/html/charset"
)
type Reader struct {
  // Дескриптор, который инициализировала библиотека.
  // https://github.com/rscada/libmbus/blob/master/mbus/mbus-protocol-aux.h#L86
  handle  *C.mbus_handle
  // Первичный адрес slave-устройства.
  address C.int
}

func (r *Reader) Open(device string, primaryAddress uint8, baudrate uint16) error {
  dev := C.CString(device)
  defer C.free(unsafe.Pointer(dev))
  // Выделяем память для структур предназначенных для работы с последовательным портом.
  r.handle = C.mbus_context_serial(dev)
  // Открываем и настраиваем порт.
  // https://en.wikipedia.org/wiki/Serial_port#Settings
  if C.mbus_connect(r.handle) != 0 {
    return fmt.Errorf("failed to setup connection to M-bus gateway: %s", device)
  }
  // Устанавливаем скорость обмена данными.
  if C.mbus_serial_set_baudrate(r.handle, C.long(baudrate)) != 0 {
    return fmt.Errorf("failed to set baud rate: %d", baudrate)
  }
  r.address = C.int(primaryAddress)
  // Установка handshake. Отправляется датаграмма с control field SND_NKE (40h).
  // Если slave успешно принял SND_NKE, он отвечает датаграммой из одного символа E5h.
  if C.mbus_send_ping_frame(r.handle, r.address, 1) != 0 {
    return fmt.Errorf("failed to setup handshake for address: %d", primaryAddress)
  }
  return nil
}

func (r *Reader) Close() error {
  defer C.mbus_context_free(r.handle)
  if C.mbus_disconnect(r.handle) != 0 {
    return errors.New("failed to disconnect")
  }
  return nil
}

func (r *Reader) ReadData() (*Measurement, error) {
  // Функция отправляет датаграмму с control information кодом равным 50h.
  // Это делает сброс application layer к значениям по умолчанию.
  // Так же есть опциональный параметр после этого кода — application reset subcode.
  // Этот параметр определяет какие данные будут отправлены при последующем запросе.
  // Именно его мы будем использовать. Установка subcode равным 50h (instant values) при следующем запросе будет возвращать нужные значение.
  // Список subcod'ов: https://m-bus.com/documentation-wired/06-application-layer#application-reset-subcode-
  // Какие именно значение для 50h (instant values) возвращаются я посмотрел в руководстве к своему счетчику.
  subcode := 0x50
  if C.mbus_send_application_reset_frame(r.handle, r.address, C.int(subcode)) == -1 {
    return nil, fmt.Errorf("failed to send reset frame: %s", C.GoString(C.mbus_error_str()))
  }
  // Получаем ответ и проверяем его на ошибки.
  var reply C.mbus_frame
  ret := C.mbus_recv_frame(r.handle, &reply)
  if ret == C.MBUS_RECV_RESULT_TIMEOUT {
    return nil, fmt.Errorf("failed to get a reply from device: timeout expired")
  }
  if C.mbus_frame_type(&reply) != C.MBUS_FRAME_TYPE_ACK {
    return nil, fmt.Errorf("unexpected frame type, receiving ACK telegram is failed")
  }
  // Делаем запрос на получение данных и сохраняем полученные в ответе датаграммы.
  const maxFrames C.int = 16
  if C.mbus_sendrecv_request(r.handle, r.address, &reply, maxFrames) != 0 {
    C.mbus_frame_free(C.to_frame(reply.next))
    return nil, fmt.Errorf("failed to send/receive M-Bus request: %s", C.GoString(C.mbus_error_str()))
  }
  // Десериализуем датаграммы в объект mbus_frame_data.
  var frameData C.mbus_frame_data
  if C.mbus_frame_data_parse(&reply, &frameData) != 0 {
    return nil, fmt.Errorf("M-bus data parse error: %s", C.GoString(C.mbus_error_str()))
  }
  // Сериализуем данные в xml формат.
  xmlOutput := C.mbus_frame_data_xml_normalized(&frameData)
  defer C.free(unsafe.Pointer(xmlOutput))
  if frameData.data_var.record != nil {
    defer C.mbus_data_record_free(frameData.data_var.record)
  }
  if xmlOutput == nil {
    return nil, fmt.Errorf("failed to generate XML output of the frame: %s", C.GoString(C.mbus_error_str()))
  }
  // Десереализуем xml в структуру mbus.Measurement.
  reader := bytes.NewReader([]byte(C.GoString(xmlOutput)))
  decoder := xml.NewDecoder(reader)
  decoder.CharsetReader = charset.NewReaderLabel
  var measurement Measurement
  err := decoder.Decode(&measurement)
  if err != nil {
    return nil, fmt.Errorf("failed to unmarshal XML output: %w", err)
  }
  return &measurement, nil
}

package main
import (
  "fmt"
  "heatmeter/mbus"
  "log"
  "os"
  "strconv"
)
func main() {
  var device, mbusIDVar, baudrateVar string
  if device = os.Getenv("HM_DEVICE"); device == "" {
    log.Fatal("HM_DEVICE variable is not set")
  }
  if mbusIDVar = os.Getenv("HM_MBUS_ID"); mbusIDVar == "" {
    log.Fatal("HM_MBUS_ID variable is not set")
  }
  mbusID, err := strconv.Atoi(mbusIDVar)
  if err != nil {
    log.Fatalf("Wrong mbus ID: %s, %s", mbusIDVar, err)
  }
  if baudrateVar = os.Getenv("HM_BAUDRATE"); baudrateVar == "" {
    log.Fatal("HM_BAUDRATE variable is not set")
  }
  baudrate, err := strconv.Atoi(baudrateVar)
  if err != nil {
    log.Fatalf("Wrong baudrate: %s, %s", baudrateVar, err)
  }
  var reader mbus.Reader
  err = reader.Open(device, uint8(mbusID), uint16(baudrate))
  defer reader.Close()
  if err != nil {
    log.Fatal(err)
  }
  measurement, err := reader.ReadData()
  if err != nil {
    log.Fatal("Unable to get measurement: ", err)
  }
  errorHoursStr := strconv.Itoa(int(measurement.ErrorTime) / 3600)
  operatingDaysStr := strconv.Itoa(int(measurement.OperatingTime) / 3600 / 24)
  flowTempStr := strconv.Itoa(int(measurement.FlowTemp))
  returnTempStr := strconv.Itoa(int(measurement.ReturnTemp))
  powerStr := strconv.Itoa(int(measurement.Power))
  energyStr := fmt.Sprintf("%.3f", float32(measurement.Energy)/1000)
  volumeStr := fmt.Sprintf("%.3f", measurement.Volume)
  volumeFlowStr := fmt.Sprintf("%.3f", measurement.VolumeFlow/1000)
  fmt.Printf("\n Energy: %s, volume: %s, volume flow: %s, power: %s, flow temperature: %s, return temperature: %s, operating days: %s, error hours: %s",
    energyStr,
    volumeStr,
    volumeFlowStr,
    powerStr,
    flowTempStr,
    returnTempStr,
    operatingDaysStr,
    errorHoursStr)
}

{
  "ok": true,
  "result": [
    {
      "update_id": 999999999,
      "message": {
        "message_id": 12,
        "from": {
          "id": 8888888888,
          "is_bot": false,
          "first_name": "John",
          "username": "john_doe"
        },
        "chat": {
          "id": 191191191,
          "first_name": "John",
          "username": "john_doe",
          "type": "private"
        },
        "date": 1624002263,
        "text": "/start",
        "entities": [
          {
            "offset": 0,
            "length": 6,
            "type": "bot_command"
          }
        ]
      }
    }
  ]
}

package logger
import (
  "fmt"
  "log"
  "os"
  tgram "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
type TelegramLogger struct {
  bot    *tgram.BotAPI
  chatID int64
}
func NewTelegram(token string, chatID int64) (*TelegramLogger, error) {
  bot, err := tgram.NewBotAPI(token)
  if err != nil {
    return nil, err
  }
  bot.Debug = true
  log.Printf("Authorized on account %s", bot.Self.UserName)
  logger := TelegramLogger{bot, chatID}
  return &logger, nil
}
func (t *TelegramLogger) Write(data []byte) (int, error) {
  str := string(data)
  m := tgram.NewMessage(t.chatID, str)
  // Отправляем сообщение в чат с ботом.
  _, err := t.bot.Send(m)
  // Дублируем сообщение в стандартный поток вывода ошибок.
  n, stdErr := os.Stderr.WriteString(str)
  return n, fmt.Errorf("%v: %v", err, stdErr)
}

logger, err := logger.NewTelegram("<your bot's token>", 191191191)
  if err != nil {
    log.Fatal("unable to create bot: ", err)
  }
  log.SetOutput(logger)