~aleteoryx/muditaos

muditaos/module-cellular/modem/mux/DLCChannel.h -rw-r--r-- 2.1 KiB
a405cad6 — Aleteoryx trim readme 6 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md

#pragma once

#include <string>
#include <utility>
#include <vector>
#include <functional>
#include <FreeRTOS.h>
#include <task.h>
#include <message_buffer.h>

#include <bsp/cellular/CellularResult.hpp>

#include "modem/ATCommon.hpp"
#include "CellularMuxTypes.h"

class DLCChannel : public at::Channel
{
  public:
    using Callback_t = std::function<void(std::string &data)>;

  private:
    std::string name;
    DLCI_t DLCI = -1;
    bool active = false;
    DLC_ESTABL_SystemParameters_t chanParams{};
    Callback_t pvCallback;
    bsp::Cellular *pvCellular = nullptr;

  public:
    DLCChannel(DLCI_t DLCI, const std::string &name, bsp::Cellular *cellular, const Callback_t &callback = nullptr);
    DLCChannel() : Channel{nullptr}, name{"none"}, DLCI{-1} {};

    virtual ~DLCChannel() = default;

    bool init();
    bool establish();
    void sendData(std::vector<uint8_t> &data);

    virtual void cmdInit() override final;
    virtual void cmdSend(std::string cmd) override final;
    virtual size_t cmdReceive(std::uint8_t *result, std::chrono::milliseconds timeout) override final;
    virtual void cmdPost() override final;

    std::vector<std::string> sendCommandPrompt(const char *cmd,
                                               size_t rxCount,
                                               std::chrono::milliseconds timeout = std::chrono::milliseconds{300});

    at::Result parseInputData(bsp::cellular::CellularResult *cellularResult) const;

    bool evaluateEstablishResponse(bsp::cellular::CellularResult &response) const;

    void callback(std::string &data)
    {
        pvCallback(data);
    }

    DLCI_t getDLCI() const noexcept
    {
        return DLCI;
    }
    std::string getName() const
    {
        return name;
    }
    bool getActive() const noexcept
    {
        return active;
    }

    void setCallback(Callback_t callback)
    {
        LOG_DEBUG("[%s] Setting up callback for channel", name.c_str());
        pvCallback = std::move(callback);
    }
};