//
// Created by cfif on 25.01.23.
//
#include "AtModemGonec.h"
#include "stdlib.h"
#include "time.h"
#include "string.h"

// Запись прошивки крипто-платы
AtCommandResult AtModem_CryptoSend(tAtCmd *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+WRITE=");
    AtCmdTxAddDecimalIntWithLimit(env, crc, 10);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, offset, 3);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, size, 4);
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, ">")) {
            AtCmdRxClear(env);

            AtCmdSend(env, pBuf, size);

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

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

    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STOP");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запуск ожидания маркерного сигнала
AtCommandResult AtModem_Start(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#START");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Останов задачи передачи
AtCommandResult AtModem_StopSendTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STOPSENDTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запуск задачи передачи
AtCommandResult AtModem_StartSendTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STARTSENDTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Останов задачи приема
AtCommandResult AtModem_StopRecvTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STOPRECVTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запуск задачи приема
AtCommandResult AtModem_StartRecvTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STARTRECVTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запуск регистрации
AtCommandResult AtModem_StartRegTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STARTREGTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Останов регистрации
AtCommandResult AtModem_StopRegTask(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STOPREGTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Запуск прошивки
AtCommandResult AtModem_RunModemOrCrypto(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+RUN");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Координаты
AtCommandResult AtModem_Coord(tAtCmd *env, int latitude, int longitude) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETCOORD=");
    AtCmdTxAddDecimalIntWithLimit(env, latitude, 4);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, longitude, 4);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


//
AtCommandResult AtModem_DelTasi(tAtCmd *env, uint32_t param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#DELTASI=");
    AtCmdTxAddDecimalIntWithLimit(env, param, 2);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_DelTasi(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#DELTASI=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#DELTASI: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#DELTASI:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Ввод сетевого адреса модема
AtCommandResult AtModem_NetAddress(tAtCmd *env, uint32_t adr) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#NETADDRESS=");
    AtCmdTxAddDecimalIntWithLimit(env, adr, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


AtCommandResult AtModem_Get_NetAddress(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#NETADDRESS=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#NETADDRESS: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#NETADDRESS:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Ввод каналов ожидания маркерного сигнала
AtCommandResult AtModem_MarkerCh(tAtCmd *env, uint32_t mc1, uint32_t mc2) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#MARKERCH=");
    AtCmdTxAddDecimalIntWithLimit(env, mc1, 3);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, mc2, 3);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


AtCommandResult AtModem_Get_MarkerCh(tAtCmd *env, uint32_t *mc1, uint32_t *mc2) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#MARKERCH=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#MARKERCH: ")) {
            isNotFound = false;

            char *front;
            char *div = env->rxBuffer.data + sizeof("#MARKERCH:") - 1;
            char *end = div + env->rxBuffer.len;

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *mc1 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *mc2 = atoi(front);
            }

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Разрешние расширенных логов
AtCommandResult AtModem_LogExtended(tAtCmd *env, uint32_t en) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SYSLOGENABLE=");
    AtCmdTxAddDecimalIntWithLimit(env, en, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_LogExtended(tAtCmd *env, uint32_t *en) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SYSLOGENABLE=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SYSLOGENABLE: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SYSLOGENABLE:");
            *en = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Выбор параметра мощности
AtCommandResult AtModem_SelectPWR(tAtCmd *env, uint32_t pwr) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SELECTPWR=");
    AtCmdTxAddDecimalIntWithLimit(env, pwr, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_SelectPWR(tAtCmd *env, uint32_t *pwr) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SELECTPWR=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SELECTPWR: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SELECTPWR:");
            *pwr = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Разрешние логов модема
AtCommandResult AtModem_LogEnable(tAtCmd *env, uint32_t en) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#LOGENABLE=");
    AtCmdTxAddDecimalIntWithLimit(env, en, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_LogEnable(tAtCmd *env, uint32_t *en) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#LOGENABLE=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#LOGENABLE: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#LOGENABLE:");
            *en = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Коррекция передатчика
AtCommandResult AtModem_TransmitterPWR(tAtCmd *env, uint32_t pwr1, uint32_t pwr2, uint32_t pwr3, uint32_t pwr4) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR=");
    AtCmdTxAddDecimalIntWithLimit(env, pwr1, 5);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, pwr2, 5);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, pwr3, 5);
    AtCmdTxAddStatic(env, ",");
    AtCmdTxAddDecimalIntWithLimit(env, pwr4, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult
AtModem_Get_TransmitterPWR(tAtCmd *env, uint32_t *pwr1, uint32_t *pwr2, uint32_t *pwr3, uint32_t *pwr4) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SETUPPWR: ")) {
            isNotFound = false;

            char *front;
            char *div = env->rxBuffer.data + sizeof("#SETUPPWR:") - 1;
            char *end = div + env->rxBuffer.len;

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *pwr1 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *pwr2 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *pwr3 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *pwr4 = atoi(front);
            }

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


/*
AtCommandResult AtModem_TransmitterPWR1(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR1=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_TransmitterPWR2(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR2=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_TransmitterPWR3(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR3=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_TransmitterPWR4(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR4=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
*/

AtCommandResult AtModem_TestAFU(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#TESTAFU");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


AtCommandResult AtModem_TestAPO(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#RSSIAPO");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Ввод тип адреса 1 - почта; 2 - гонец
AtCommandResult AtModem_AddressType(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#ADDRESSTYPE=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_AddressType(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#ADDRESSTYPE=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#ADDRESSTYPE: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#ADDRESSTYPE:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


AtCommandResult AtModem_PerDown(tAtCmd *env, uint32_t type) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#PERDOWN=");
    AtCmdTxAddDecimalIntWithLimit(env, type, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_PerDown(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#PERDOWN=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#PERDOWN: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#PERDOWN:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


/*
AtCommandResult AtModem_Get_TransmitterPWR1(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR1=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SETUPPWR1: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SETUPPWR1:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

AtCommandResult AtModem_Get_TransmitterPWR2(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR2=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SETUPPWR2: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SETUPPWR2:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

AtCommandResult AtModem_Get_TransmitterPWR3(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR3=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SETUPPWR3: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SETUPPWR3:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


AtCommandResult AtModem_Get_TransmitterPWR4(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETUPPWR4=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SETUPPWR4: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#SETUPPWR4:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}
*/

//
AtCommandResult
AtModem_Region(tAtCmd *env, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, uint32_t p5, uint32_t p6, uint32_t p7,
               uint32_t p8) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGION=");

    AtCmdTxAddDecimalIntWithLimit(env, p1, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p2, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p3, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p4, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p5, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p6, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p7, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, p8, 1);

    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


AtCommandResult
AtModem_Get_Region(tAtCmd *env, uint32_t *p1, uint32_t *p2, uint32_t *p3, uint32_t *p4, uint32_t *p5, uint32_t *p6,
                   uint32_t *p7,
                   uint32_t *p8) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGION=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#REGION: ")) {
            isNotFound = false;

            char *front;
            char *div = env->rxBuffer.data + sizeof("#REGION:") - 1;
            char *end = div + env->rxBuffer.len;

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p1 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p2 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p3 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p4 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p5 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p6 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p7 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *p8 = atoi(front);
            }

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Установка скоростей
AtCommandResult
AtModem_RxTxBitrate(tAtCmd *env, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#RXTXBITRATE=");

    AtCmdTxAddDecimalIntWithLimit(env, s1, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, s2, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, s3, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, s4, 1);

    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_RxTxBitrate(tAtCmd *env, uint32_t *s1, uint32_t *s2, uint32_t *s3, uint32_t *s4) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#RXTXBITRATE=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#RXTXBITRATE: ")) {
            isNotFound = false;

            char *front;
            char *div = env->rxBuffer.data + sizeof("#RXTXBITRATE:") - 1;
            char *end = div + env->rxBuffer.len;

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *s1 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *s2 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *s3 = atoi(front);
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *s4 = atoi(front);
            }

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Установка приоритета
AtCommandResult AtModem_Priority(tAtCmd *env, uint32_t prior) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#PRIORITY=");
    AtCmdTxAddDecimalIntWithLimit(env, prior, 1);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_Priority(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#PRIORITY=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#PRIORITY: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#PRIORITY:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

AtCommandResult AtModem_RestrictSc(tAtCmd *env, char *banned) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#RESTRICTSC=");
    AtCmdTxAdd(env, banned, strlen(banned));
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_RestrictSc(tAtCmd *env, char *banned, size_t len) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#RESTRICTSC=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#RESTRICTSC:")) {
            isNotFound = false;

            volatile int b = sizeof("#RESTRICTSC:");

            char *start = env->rxBuffer.data + sizeof("#RESTRICTSC:");
            if (env->rxBuffer.len > sizeof("#RESTRICTSC:") + 2) {
                memcpy(banned, start, env->rxBuffer.len - sizeof("#RESTRICTSC:") - 2);
            }
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

AtCommandResult AtModem_Reg(tAtCmd *env, char *banned) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGION=");
    AtCmdTxAdd(env, banned, strlen(banned));
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


AtCommandResult AtModem_Get_Reg(tAtCmd *env, char *banned, size_t len) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGION=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#REGION:")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#REGION:");
            if (env->rxBuffer.len > sizeof("#REGION:") + 2) {
                memcpy(banned, start, env->rxBuffer.len - sizeof("#REGION:") - 2);
            }
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

AtCommandResult AtModem_MaxDist(tAtCmd *env, uint32_t dist) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#MAXDIST=");
    AtCmdTxAddDecimalIntWithLimit(env, dist, 5);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_MaxDist(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#MAXDIST=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#MAXDIST: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#MAXDIST:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Установка региона
AtCommandResult AtModem_RegRegion(tAtCmd *env, uint32_t region) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGREGION=");
    AtCmdTxAddDecimalIntWithLimit(env, region, 2);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_RegRegion(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGREGION=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#REGREGION: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#REGREGION:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


//
AtCommandResult AtModem_RegTime(tAtCmd *env, uint32_t time) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGTIME=");
    AtCmdTxAddDecimalIntWithLimit(env, time, 6);
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

AtCommandResult AtModem_Get_RegTime(tAtCmd *env, uint32_t *param) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#REGTIME=?");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#REGTIME: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#REGTIME:");
            *param = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


//
AtCommandResult AtModem_DateTime(tAtCmd *env, time_t *timestamp) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#DATETIME=");

    struct tm dateTime;
    gmtime_r(timestamp, &dateTime);

    char buf[32];
    strftime(buf, sizeof(buf), "%d-%m-%Y,%T", &dateTime);

    AtCmdTxAdd(env, buf, strlen(buf));

    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Загрузка ключей
AtCommandResult AtModem_SetKey(tAtCmd *env, uint32_t key_num, char *buf, size_t buf_len) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#SETKEY=");
    AtCmdTxAddDecimalIntWithLimit(env, key_num, 2);
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, ">")) {
            AtCmdRxClear(env);
            AtCmdSend(env, buf, buf_len);
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "ERROR CRC")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;

}

// Проверка ключа
AtCommandResult AtModem_CheckKey(tAtCmd *env, uint32_t key_num) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#CHECKKEY=");
    AtCmdTxAddDecimalIntWithLimit(env, key_num, 2);
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "ERROR CRC")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}

// Запись текущих настроек и ключей
AtCommandResult AtModem_WriteMem(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdSendStatic(env, "AT#WRITEMEM\r\n");

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запрос слотов
AtCommandResult AtModem_Get_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#GETSENDSTATUS");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();


        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#SENDSTATUS: ")) {

            char *front;
            char *div = env->rxBuffer.data + sizeof("#SENDSTATUS:") - 1;
            char *end = div + env->rxBuffer.len;

            for (int i = 0; i < 16; ++i) {

                *id = i + 1;
                *status = 0;

                if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                    *status = atoi(front);
                }

                ++id;
                ++status;
            }
            AtCmdRxClear(env);
            continue;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


#include "SerialPorts.h"

void vSerialPortSendDMA(
        tSerialPortArtery *env,
        usart_type *uart,

        dma_type *DMA,
        dma_channel_type *DMA_CHANNEL,
        dmamux_channel_type *DMA_CHANNEL_MUX,
        dmamux_requst_id_sel_type DMAMUX_DMAREQ_ID,
        uint8_t *DMA_BUF,
        uint16_t DMA_BUF_LEN

);

// Запись данных в слот
AtCommandResult AtModem_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) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#WRITEPKT=");
    AtCmdTxAddDecimalIntWithLimit(env, id, 2);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, addressAT, 8);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, addressEND, 8);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, urgency, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, confirmation, 1);
    AtCmdTxAddStatic(env, ",");

    AtCmdTxAddDecimalIntWithLimit(env, size, 4);
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, ">")) {
            AtCmdRxClear(env);
            AtCmdSend(env, pBuf, size);
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Очистка слота передачи
AtCommandResult AtModem_Clear_Slot(tAtCmd *env, char *id) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#DELSENDPKT=");
    AtCmdTxAdd(env, id, strlen(id));
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Чтение данных из слота
AtCommandResult AtModem_Read_Recv_Slot(tAtCmd *env, uint16_t id, uint32_t *size, uint8_t *pBuf) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#READPKT=");
    AtCmdTxAddDecimalIntWithLimit(env, id, 2);
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "#READPKT: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#READPKT:")];

            *size = atoi(pSize); // Размер сообщения
            AtCmdRxClear(env); // Очистка приемного буфера

            if ((*size < 0) || (*size > 1300)) {
                return AT_ERROR;
            }

            AtCmdRxReadRAW(env, pBuf, *size, env->stdRxTimeout); // Чтение данных сообщения
            continue;
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Запрос слотов приема
AtCommandResult AtModem_Get_Recv_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#GETRECVSTATUS");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();


        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#RECVSTATUS: ")) {

            char *front;
            char *div = env->rxBuffer.data + sizeof("#RECVSTATUS:") - 1;
            char *end = div + env->rxBuffer.len;

            for (int i = 0; i < 16; ++i) {

                *id = i + 1;
                *status = 0;

                if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                    *status = atoi(front);
                }

                ++id;
                ++status;
            }
            AtCmdRxClear(env);
            continue;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Очистка слота приема
AtCommandResult AtModem_Clear_Recv_Slot(tAtCmd *env, char *id) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#DELRECVPKT=");
    AtCmdTxAdd(env, id, strlen(id));
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Запуск получения альманаха
AtCommandResult AtModem_AlmaRun(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STARTALMANACTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Останов получения альманаха
AtCommandResult AtModem_AlmaStop(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STOPALMANACTASK");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Чтения состояния получения альманаха
AtCommandResult AtModem_Get_AlmaRun(tAtCmd *env, uint8_t *run) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#STATUSALMANACTASK");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#STATUSALMANACTASK: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#STATUSALMANACTASK:");
            *run = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Запрос состояния получения альманаха
AtCommandResult AtModem_AlmaStatus(tAtCmd *env, uint8_t *status) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#GETRESALMANACTASK");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#RESALMANACTASK: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#RESALMANACTASK:");
            *status = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Запрос состояния регистрации
AtCommandResult AtModem_RegStatus(tAtCmd *env, uint8_t *status) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#GETREGSTATUS");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    bool isNotFound = true;
    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            if (isNotFound)
                return AT_ERROR;

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#REGSTATUS: ")) {
            isNotFound = false;

            char *start = env->rxBuffer.data + sizeof("#REGSTATUS:");
            *status = atoi(start);
            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


// Чтение пакета альманаха
AtCommandResult AtModem_Read_Alma(tAtCmd *env, uint32_t *size, uint8_t *pBuf) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#ALMAREAD");
    AtCmdTxSendLn(env);

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "#ALMAREAD: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#ALMAREAD:")];
            *size = atoi(pSize);
            AtCmdRxClear(env);

            if ((*size < 0) || (*size > 1300)) {
                return AT_ERROR;
            }

            AtCmdRxReadRAW(env, pBuf, *size, env->stdRxTimeout);


        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}

// Очистка пакета альманаха
AtCommandResult AtModem_Clear_Alma(tAtCmd *env) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#ALMACLEAR");
    AtCmdTxSendLn(env);

    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Получение логов
AtCommandResult
AtModem_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) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT#GETLOG");
    AtCmdTxSendLn(env);

    *size = 0;
    *wasreboot = 0;
    *state = 0;
    *pwramp = 0;

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "#LOG: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#LOG:")];
            *size = atoi(pSize);
            AtCmdRxClear(env);

            if ((*size < 0) || (*size > 1024)) {
                return AT_ERROR;
            }


            AtCmdRxReadRAW(env, pBuf, *size, env->stdRxTimeout);
//            *size = env->rxBuffer.len - sizeof("#LOG:");
//            memcpy(pBuf, pSize, *size);
//            AtCmdRxClear(env);
            continue;
        } else if (AtCmdRxBeginWithStatic(env, "#RSSI: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#RSSI:")];
            *rssi = atoi(pSize);
            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "#TEMP: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#TEMP:")];
            *temp = atoi(pSize);
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "#PWRAMP: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#PWRAMP:")];
            *pwramp = atoi(pSize);
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "#STATE: ")) {
            char *pSize = &env->rxBuffer.data[sizeof("#STATE:")];
            *state = atoi(pSize);
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "#WASREBOOT")) {
            *wasreboot = 1;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return
            AT_ERROR;
}

AtCommandResult
AtModem_Get_Version(tAtCmd *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, uint8_t *sizeCrypto) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+VERSION");
    AtCmdTxSendLn(env);

    *sizeModem = 0;
    *sizeCrypto = 0;

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#VERSION: MODEM_")) {

            char *start = env->rxBuffer.data + sizeof("#VERSION:");
            *sizeModem = env->rxBuffer.len - sizeof("#VERSION: ");
            memcpy(versionModem, start, *sizeModem);

            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "#VERSION: AUTH_")) {

            char *start = env->rxBuffer.data + sizeof("#VERSION:");
            *sizeCrypto = env->rxBuffer.len - sizeof("#VERSION: ");
            memcpy(versionCrypto, start, *sizeCrypto);

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}