~aleteoryx/muditaos

ref: ea27e6871615172000db8664a9d11d1b6103c562 muditaos/module-bsp/board/rt1051/bsp/cellular/rt1051_cellular.hpp -rw-r--r-- 4.7 KiB
ea27e687 — Maciej Janicki [EGD-5748] Remake Cellular flow 5 years 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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

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

#pragma once

#include <FreeRTOS.h>
#include <message_buffer.h>
#include <timers.h>

#include "board.h"
#include "fsl_lpuart.h"
#include "fsl_lpuart_edma.h"

#include "bsp/cellular/bsp_cellular.hpp"
#include "bsp/cellular/CellularResult.hpp"
#include "bsp/BoardDefinitions.hpp"

#include "drivers/pll/DriverPLL.hpp"
#include "drivers/dmamux/DriverDMAMux.hpp"
#include "drivers/dma/DriverDMA.hpp"
#include "drivers/gpio/DriverGPIO.hpp"

namespace bsp
{
    class RT1051Cellular : public Cellular
    {
      private:
        bool pv_SendingAllowed = true;

        void logData(const std::string &title, uint8_t *buffer, size_t nbytes);

      public:
        RT1051Cellular();

        ~RT1051Cellular();

        void powerUp() override final;
        void powerDown() override final;
        void restart() override final;
        uint32_t wait(std::chrono::milliseconds timeoutMs) override final;
        ssize_t read(void *buffer, size_t nbytes, std::chrono::milliseconds timeoutMs) override final;
        ssize_t write(void *buf, size_t nbytes) override final;
        void informModemHostAsleep() override final;
        void informModemHostWakeup() override final;
        void enterSleep() override final;
        void exitSleep() override final;
        void setSpeed(uint32_t portSpeed) override final;
        void setSendingAllowed(bool state) override final;
        bool getSendingAllowed() const noexcept override final;
        void selectAntenna(bsp::cellular::antenna antenna) override final;
        bsp::cellular::antenna getAntenna() override final;

        static MessageBufferHandle_t uartRxBuffer;
        static lpuart_edma_handle_t uartDmaHandle;
        static bool RestartReceivingManually;
        static constexpr std::size_t RXdmaBufferSize = bsp::cellular::CellularResultStructMaxDataSize;
        static std::size_t RXdmaMaxReceivedCount;

        static constexpr std::uint32_t edgeIRQMaskEnable  = kLPUART_RxActiveEdgeInterruptEnable;
        static constexpr std::uint32_t idleIRQMaskEnable  = kLPUART_IdleLineInterruptEnable;
        static constexpr std::uint32_t edgeIRQMask        = kLPUART_RxActiveEdgeFlag;
        static constexpr std::uint32_t idleIRQMask        = kLPUART_IdleLineFlag;
        static constexpr std::uint32_t dataRegFullIRQMask = kLPUART_RxDataRegFullFlag;

        static bool sendRxDmaResult(bsp::cellular::CellularResultCode reason);
        static std::size_t getMaxBufferDataSize();
        static bool startReceive(std::size_t nbytes);

        static TaskHandle_t untilReceivedNewHandle;

      private:
        void MSPInit();
        void MSPDeinit();
        void DMAInit();
        void DMADeinit();

        static void uartDMACallback(LPUART_Type *base, lpuart_edma_handle_t *handle, status_t status, void *userData);

        static inline void enableRx(uint32_t irqMask = edgeIRQMaskEnable | idleIRQMaskEnable | dataRegFullIRQMask)
        {
            LPUART_ClearStatusFlags(CELLULAR_UART_BASE, 0xFFFFFFFF);
            LPUART_EnableInterrupts(CELLULAR_UART_BASE, irqMask);
            LPUART_EnableRx(CELLULAR_UART_BASE, true);
        }

        static inline void disableRx(uint32_t irqMask = edgeIRQMaskEnable | idleIRQMaskEnable | dataRegFullIRQMask)
        {
            LPUART_DisableInterrupts(CELLULAR_UART_BASE, irqMask);
            LPUART_ClearStatusFlags(CELLULAR_UART_BASE, irqMask);
            LPUART_EnableRx(CELLULAR_UART_BASE, false);
        }

        inline void enableTx()
        {
            LPUART_EnableTx(CELLULAR_UART_BASE, true);
        }

        inline void disableTx()
        {
            LPUART_EnableTx(CELLULAR_UART_BASE, false);
        }

        std::shared_ptr<drivers::DriverPLL> pll;
        std::shared_ptr<drivers::DriverGPIO> gpio_1;
        std::shared_ptr<drivers::DriverGPIO> gpio_2;
        std::shared_ptr<drivers::DriverGPIO> gpio_3;
        std::shared_ptr<drivers::DriverDMAMux> dmamux;
        std::shared_ptr<drivers::DriverDMA> dma;
        std::unique_ptr<drivers::DriverDMAHandle> txDMAHandle;
        std::unique_ptr<drivers::DriverDMAHandle> rxDMAHandle;

        static constexpr std::uint32_t baudrate                               = 115200;
        static constexpr std::uint32_t rxMessageBufferLength                  = 1024;
        static constexpr std::uint16_t messageBufferOverheadSize              = 4;
        static constexpr std::uint32_t CELLULAR_BSP_AP_READY_PIN_ACTIVE_STATE = 1;
        static constexpr std::uint32_t CELLULAR_BSP_ANTSEL_PIN_A_STATE        = 0;
        static constexpr std::uint32_t CELLULAR_BSP_ANTSEL_PIN_B_STATE        = 1;
    };
} // namespace bsp