//
// Created by cfif on 25.01.23.
//

#include "ModemGonec.h"
#include <AtCmdCommonProtected.h>
#include <SystemDelayInterface.h>
#include "AtGsmCommon.h"
#include "AtGsmSim800f.h"
#include "string.h"

// Запись прошивки крипто-платы
bool Modem_CryptoSend(tAtCmd *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size) {
    AtCommandResult result = AtModem_CryptoSend(env, pBuf, crc, offset, size);

    if (result != AT_OK)
        return false;

    return true;
}

// Останов ожидания маркерного сигнала
bool Modem_Stop(tAtCmd *env) {
    AtCommandResult result = AtModem_Stop(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Запуск ожидания маркерного сигнала
bool Modem_Start(tAtCmd *env) {
    AtCommandResult result = AtModem_Start(env);

    if (result != AT_OK)
        return false;

    return true;
}


// Останов задачи приема
bool Modem_StopRecvTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StopRecvTask(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Запуск задачи приема
bool Modem_StartRecvTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StartRecvTask(env);

    if (result != AT_OK)
        return false;

    return true;
}


// Останов задачи передачи
bool Modem_StopSendTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StopSendTask(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Запуск задачи передачи
bool Modem_StartSendTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StartSendTask(env);

    if (result != AT_OK)
        return false;

    return true;
}

//
bool Modem_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_DelTasi(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_DelTasi(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Ввод сетевого адреса модема
bool Modem_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_NetAddress(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_NetAddress(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Ввод каналов ожидания маркерного сигнала
bool Modem_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2) {
    *isWriteMem = false;

    uint32_t oldMc1;
    uint32_t oldMc2;

    AtCommandResult result = AtModem_Get_MarkerCh(env, &oldMc1, &oldMc2);

    if (result != AT_OK)
        return false;

    if ((mc1 != oldMc1) || (mc2 != oldMc2)) {
        result = AtModem_MarkerCh(env, mc1, mc2);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Ввод тип адреса 1 - почта; 2 - гонец
bool Modem_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_AddressType(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_AddressType(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}


// Периодичность запроса на съем, МС
bool Modem_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_PerDown(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_PerDown(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Периодичность запроса на съем, МС
bool Modem_Get_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_PerDown(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}


bool Modem_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_LogEnable(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_LogEnable(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

bool Modem_Get_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_LogEnable(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}


bool Modem_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_LogExtended(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_LogExtended(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

bool Modem_Get_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_LogExtended(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}


// Коррекция передатчика PWR
bool Modem_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4) {
    *isWriteMem = false;

    uint32_t oldValue1;
    uint32_t oldValue2;
    uint32_t oldValue3;
    uint32_t oldValue4;
    AtCommandResult result = AtModem_Get_TransmitterPWR(env, &oldValue1, &oldValue2, &oldValue3, &oldValue4);

    if (result != AT_OK)
        return false;

    if ((value1 != oldValue1) || (value2 != oldValue2) || (value3 != oldValue3) || (value4 != oldValue4)) {
        result = AtModem_TransmitterPWR(env, value1, value2, value3, value4);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Коррекция передатчика
bool Modem_Get_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4,
                              uint32_t *oldValue1, uint32_t *oldValue2, uint32_t *oldValue3, uint32_t *oldValue4) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_TransmitterPWR(env, oldValue1, oldValue2, oldValue3, oldValue4);

    if (result != AT_OK)
        return false;

    if ((value1 != *oldValue1) || (value2 != *oldValue2) || (value3 != *oldValue3) || (value4 != *oldValue4))
        *isWriteMem = true;

    return true;
}


/*
// Коррекция передатчика PWR1
bool Modem_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_TransmitterPWR1(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_TransmitterPWR1(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Коррекция передатчика PWR2
bool Modem_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_TransmitterPWR2(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_TransmitterPWR2(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Коррекция передатчика PWR3
bool Modem_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_TransmitterPWR3(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_TransmitterPWR3(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Коррекция передатчика PWR4
bool Modem_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_TransmitterPWR4(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_TransmitterPWR4(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}
*/

//
bool
Modem_Region(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, uint32_t p5,
             uint32_t p6, uint32_t p7,
             uint32_t p8) {
    *isWriteMem = false;

    uint32_t oldP1;
    uint32_t oldP2;
    uint32_t oldP3;
    uint32_t oldP4;
    uint32_t oldP5;
    uint32_t oldP6;
    uint32_t oldP7;
    uint32_t oldP8;

    AtCommandResult result = AtModem_Get_Region(env, &oldP1, &oldP2, &oldP3, &oldP4, &oldP5, &oldP6, &oldP7, &oldP8);

    if (result != AT_OK)
        return false;

    if ((p1 != oldP1) || (p2 != oldP2) || (p3 != oldP3) || (p4 != oldP4) || (p5 != oldP5) || (p6 != oldP6) ||
        (p7 != oldP7) || (p8 != oldP8)) {
        result = AtModem_Region(env, p1, p2, p3, p4, p5, p6, p7, p8);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}


// Установка скоростей
bool Modem_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4) {
    *isWriteMem = false;

    uint32_t oldP1;
    uint32_t oldP2;
    uint32_t oldP3;
    uint32_t oldP4;

    AtCommandResult result = AtModem_Get_RxTxBitrate(env, &oldP1, &oldP2, &oldP3, &oldP4);

    if (result != AT_OK)
        return false;

    if ((p1 != oldP1) || (p2 != oldP2) || (p3 != oldP3) || (p4 != oldP4)) {
        result = AtModem_RxTxBitrate(env, p1, p2, p3, p4);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;

}



// Установка приоритета
bool Modem_Priority(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_Priority(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_Priority(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

//
bool Modem_RestrictSc(tAtCmd *env, bool *isWriteMem, char *value) {
    *isWriteMem = false;

    char oldValue[255];
    memset(oldValue, 0, sizeof(oldValue));
    AtCommandResult result = AtModem_Get_RestrictSc(env, oldValue, sizeof(oldValue));

    if (result != AT_OK)
        return false;

    if (strcmp(value, oldValue) != 0) {
        result = AtModem_RestrictSc(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

bool Modem_Reg(tAtCmd *env, bool *isWriteMem, char *value) {
    *isWriteMem = false;

    char oldValue[255];
    memset(oldValue, 0, sizeof(oldValue));
    AtCommandResult result = AtModem_Get_Reg(env, oldValue, sizeof(oldValue));

    if (result != AT_OK)
        return false;

    if (strcmp(value, oldValue) != 0) {
        result = AtModem_Reg(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

bool Modem_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_MaxDist(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_MaxDist(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Установка региона
bool Modem_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_RegRegion(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_RegRegion(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

// Время жизни регистрации
bool Modem_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_RegTime(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_RegTime(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}

//
bool Modem_DateTime(tAtCmd *env, time_t *timestamp) {
    AtCommandResult result = AtModem_DateTime(env, timestamp);

    if (result != AT_OK)
        return false;

    return true;
}

bool Modem_WriteMem(tAtCmd *env) {
    AtCommandResult result = AtModem_WriteMem(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Загрузка ключей с проверкой
bool Modem_LoadKey(tAtCmd *env, uint32_t key_num, char *buf, size_t buf_len) {

    // Загрузка ключей
    AtCommandResult result = AtModem_SetKey(env, key_num, buf, buf_len);
    if (result != AT_OK)
        return false;

    // Проверка ключа
//    result = AtModem_CheckKey(env, key_num);

//    if (result != AT_OK)
//        return false;

    // Запись текущих настроек и ключей
//    result = AtModem_WriteMem(env);

//    if (result != AT_OK)
//        return false;

    return true;
}




















//
bool Modem_Get_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_DelTasi(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Ввод сетевого адреса модема
bool Modem_Get_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_NetAddress(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Ввод каналов ожидания маркерного сигнала
bool
Modem_Get_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2, uint32_t *oldMc1, uint32_t *oldMc2) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_MarkerCh(env, oldMc1, oldMc2);

    if (result != AT_OK)
        return false;

    if ((mc1 != *oldMc1) || (mc2 != *oldMc2))
        *isWriteMem = true;

    return true;
}

// Ввод тип адреса 1 - почта; 2 - гонец
bool Modem_Get_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_AddressType(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

/*
// Коррекция передатчика 1
bool Modem_Get_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_TransmitterPWR1(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Коррекция передатчика 2
bool Modem_Get_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_TransmitterPWR2(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Коррекция передатчика 3
bool Modem_Get_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_TransmitterPWR3(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Коррекция передатчика 4
bool Modem_Get_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_TransmitterPWR4(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}
*/

// Установка скоростей
bool Modem_Get_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4,
                           uint32_t *oldP1, uint32_t *oldP2, uint32_t *oldP3, uint32_t *oldP4) {
    *isWriteMem = false;


    AtCommandResult result = AtModem_Get_RxTxBitrate(env, oldP1, oldP2, oldP3, oldP4);

    if (result != AT_OK)
        return false;

    if ((p1 != *oldP1) || (p2 != *oldP2) || (p3 != *oldP3) || (p4 != *oldP4))
        *isWriteMem = true;

    return true;
}



// Установка приоритета
bool Modem_Get_Priority(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_Priority(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

//
bool Modem_Get_RestrictSc(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]) {
    *isWriteMem = false;

    memset(oldValue, 0, 255);
    AtCommandResult result = AtModem_Get_RestrictSc(env, oldValue, 255);

    if (result != AT_OK)
        return false;

    if (strcmp(value, oldValue) != 0)
        *isWriteMem = true;

    return true;
}

bool Modem_Get_Reg(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]) {
    *isWriteMem = false;

    memset(oldValue, 0, 255);
    AtCommandResult result = AtModem_Get_Reg(env, oldValue, 255);

    if (result != AT_OK)
        return false;

    if (strcmp(value, oldValue) != 0)
        *isWriteMem = true;

    return true;
}

//  Максимальная дальность до КА
bool Modem_Get_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_MaxDist(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}


// Установка региона
bool Modem_Get_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_RegRegion(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

// Время жизни регистрации
bool Modem_Get_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_RegTime(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;
}

bool Modem_Get_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) {
    *isWriteMem = false;

    AtCommandResult result = AtModem_Get_SelectPWR(env, oldValue);

    if (result != AT_OK)
        return false;

    if (value != *oldValue)
        *isWriteMem = true;

    return true;

}

bool Modem_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value) {
    *isWriteMem = false;

    uint32_t oldValue;
    AtCommandResult result = AtModem_Get_SelectPWR(env, &oldValue);

    if (result != AT_OK)
        return false;

    if (value != oldValue) {
        result = AtModem_SelectPWR(env, value);

        if (result != AT_OK)
            return false;

        *isWriteMem = true;
    }

    return true;
}


// Запрос слотов
bool Modem_Get_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) {

    AtCommandResult result = AtModem_Get_Slot(env, id, status, count);

    if (result != AT_OK)
        return false;

    return true;
}

// Запись данных в слот
bool Modem_Write_Slot(tAtCmd *env, uint32_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency,
                      uint32_t confirmation, uint32_t size, uint8_t *pBuf) {

    AtCommandResult result = AtModem_Write_Slot(env, id, addressAT, addressEND, urgency, confirmation, size, pBuf);

    if (result != AT_OK)
        return false;

    return true;
}


// Чтение данных из слота
bool Modem_Read_Recv_Slot(tAtCmd *env, uint8_t id, uint32_t *size, uint8_t *pBuf) {

    AtCommandResult result = AtModem_Read_Recv_Slot(env, id, size, pBuf);

    if (result != AT_OK)
        return false;

    return true;
}

// Запрос слотов приема
bool Modem_Get_Recv_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) {

    AtCommandResult result = AtModem_Get_Recv_Slot(env, id, status, count);

    if (result != AT_OK)
        return false;

    return true;
}

// Очистка слота приема
bool Modem_Clear_Recv_Slot(tAtCmd *env, char *id) {

    AtCommandResult result = AtModem_Clear_Recv_Slot(env, id);

    if (result != AT_OK)
        return false;

    return true;
}

// Очистка слота
bool Modem_Clear_Slot(tAtCmd *env, char *id) {

    AtCommandResult result = AtModem_Clear_Slot(env, id);

    if (result != AT_OK)
        return false;

    return true;
}


// Запуск получения альманаха
bool Modem_AlmaRun(tAtCmd *env) {
    AtCommandResult result = AtModem_AlmaRun(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Останов получения альманаха
bool Modem_AlmaStop(tAtCmd *env) {
    AtCommandResult result = AtModem_AlmaStop(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Чтения состояния получения альманаха
bool Modem_Get_AlmaRun(tAtCmd *env, uint8_t *run) {
    AtCommandResult result = AtModem_Get_AlmaRun(env, run);

    if (result != AT_OK)
        return false;

    return true;
}

// Запрос состояния получения альманаха
bool Modem_AlmaStatus(tAtCmd *env, uint8_t *status) {
    AtCommandResult result = AtModem_AlmaStatus(env, status);

    if (result != AT_OK)
        return false;

    return true;
}

// Запрос состояния регистрации
bool Modem_RegStatus(tAtCmd *env, uint8_t *status) {
    AtCommandResult result = AtModem_RegStatus(env, status);

    if (result != AT_OK)
        return false;

    return true;
}


// Чтение пакета альманаха
bool Modem_Read_Alma(tAtCmd *env, uint32_t *size, uint8_t *pBuf) {

    AtCommandResult result = AtModem_Read_Alma(env, size, pBuf);

    if (result != AT_OK)
        return false;

    return true;
}

// Очистка пакета альманаха
bool Modem_Clear_Alma(tAtCmd *env) {
    AtCommandResult result = AtModem_Clear_Alma(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Запуск регистрации
bool Modem_StartRegTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StartRegTask(env);

    if (result != AT_OK)
        return false;

    return true;
}

// Останов регистрации
bool Modem_StopRegTask(tAtCmd *env) {
    AtCommandResult result = AtModem_StopRegTask(env);

    if (result != AT_OK)
        return false;

    return true;
}


// Запуск прошивкиы
bool Modem_RunModemOrCrypto(tAtCmd *env) {
    AtCommandResult result = AtModem_RunModemOrCrypto(env);

    if (result != AT_OK)
        return false;

    return true;
}


// Координаты
bool Modem_Coord(tAtCmd *env, int latitude, int longitude) {
    AtCommandResult result = AtModem_Coord(env, latitude, longitude);

    if (result != AT_OK)
        return false;

    return true;
}

// Получение логов
bool Modem_Get_Log(tAtCmd *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp,  uint32_t *state, uint32_t *wasreboot, uint32_t *size, uint8_t *pBuf) {
    AtCommandResult result = AtModem_Get_Log(env, rssi, temp, pwramp, state, wasreboot, size, pBuf);

    if (result != AT_OK)
        return false;

    return true;
}















// Чтение версии
bool
Modem_Get_Version(tAtCmd *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, uint8_t *sizeCrypto) {

    AtCommandResult result = AtModem_Get_Version(env, versionModem, sizeModem, versionCrypto, sizeCrypto);

    if (result != AT_OK)
        return false;

    return true;
}



bool Modem_TestAFU(tAtCmd *env) {

    AtCommandResult result = AtModem_TestAFU(env);

    if (result != AT_OK)
        return false;

    return true;
}


bool Modem_TestAPO(tAtCmd *env) {

    AtCommandResult result = AtModem_TestAPO(env);

    if (result != AT_OK)
        return false;

    return true;
}