//
// Created by cfif on 25.01.23.
//
#include "AtGsmSim800f.h"
#include "stdlib.h"
#include "memory.h"

// начало-------------------------- Служебные ----------------------------------------------------------------------
// начало-------------------------- Служебные ----------------------------------------------------------------------
// начало-------------------------- Служебные ----------------------------------------------------------------------

// IMEI
AtCommandResult AtGsm_Simcom800f_GET_CGSN(tAtCmd *env, char *acpString, size_t *acpStringLen) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CGSN");
    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, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "AT+CGSN")) {
            while (AtCmdReceiveNextLine(env, 1000) == AT_OK) {
                *acpStringLen = env->rxBuffer.len - 2;
                memcpy(acpString, env->rxBuffer.data, *acpStringLen);
                AtCmdRxClear(env);
                return AtCmdOkErrAnswer(env, env->stdRxTimeout);
            }
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}

AtCommandResult AtGsm_Simcom800f_CCID(tAtCmd *env, char *acpString, size_t *acpStringLen) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CCID");
    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, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "+CCID: ")) {
            while (AtCmdReceiveNextLine(env, 1000) == AT_OK) {
                char *start = env->rxBuffer.data + sizeof("+CCID:");
                *acpStringLen = env->rxBuffer.len - sizeof("+CCID:") - 2;
                memcpy(acpString, start, *acpStringLen);
                AtCmdRxClear(env);
                return AtCmdOkErrAnswer(env, env->stdRxTimeout);
            }

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

    return AT_TIMEOUT;
}


// конец-------------------------- Служебные ----------------------------------------------------------------------
// конец-------------------------- Служебные ----------------------------------------------------------------------
// конец-------------------------- Служебные ----------------------------------------------------------------------

// начало-------------------------- Инициализация ----------------------------------------------------------------------
// начало-------------------------- Инициализация ----------------------------------------------------------------------
// начало-------------------------- Инициализация ----------------------------------------------------------------------

// Проверка готовности SIM-карты
AtCommandResult AtGsm_Simcom800f_PINStatus(tAtCmd *env, tAtGsm_PINStatus *state) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CPIN?");
    AtCmdTxSendLn(env);

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

    *state = SIM_SIM_NOT_FOUND_ERROR;

    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, "+CPIN: READY")) {
            *state = SIM_READY;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "+CPIN: SIM PIN")) {
            *state = SIM_SIM_PIN;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "+CPIN: SIM PUK")) {
            *state = SIM_SIM_PUK;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "+CPIN: PH_SIM PIN")) {
            *state = SIM_PH_SIM_PIN;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "+CPIN: PH_SIM PUK")) {
            *state = SIM_PH_SIM_PUK;
            AtCmdRxClear(env);
        } else if (AtCmdRxBeginWithStatic(env, "+CPIN: SIM PUK2")) {
            *state = SIM_SIM_PIN2;
            AtCmdRxClear(env);
        } else {

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

    return AT_TIMEOUT;
}


// Уровень сигнала
AtCommandResult AtGsm_Simcom800f_SignalQualityReport(tAtCmd *env, uint32_t *rssi, int *error) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CSQ");
    AtCmdTxSendLn(env);


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

    *rssi = 0;
    *error = -1;

    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, "+CME ERROR: ")) {
            char *start = env->rxBuffer.data + sizeof("+CME ERROR:");
            *error = atoi(start);
            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "+CSQ: ")) {
            char *start = env->rxBuffer.data + sizeof("+CSQ:");
            *rssi = atoi(start);
            AtCmdRxClear(env);

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

    return AT_TIMEOUT;
}


// Проверка наличия регистрации в сети GSM.
AtCommandResult AtGsm_Simcom800f_NetworkRegistrationStatusGSM(
        tAtCmd *env,
        tAtGsm_NetworkRegistrationReportMode *mode,
        tAtGsm_NetworkRegistrationState *state,
        int *error
) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CREG?");
    AtCmdTxSendLn(env);

    uint32_t timeout = 5000;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    *error = -1;

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

        if (AtCmdRxBeginWithStatic(env, "AT+CLCC")) {
            AtCmdRxClear(env);
            continue;

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

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

        } else if (AtCmdRxBeginWithStatic(env, "+CME ERROR: ")) {
            char *start = env->rxBuffer.data + sizeof("+CME ERROR:");
            *error = atoi(start);
            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "+CREG: ")) {

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

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *(char *) mode = *front;
            }

            if (iAsciiStringMoveToNextParsingBlock(&front, &div, end, ',')) {
                *(char *) state = *front;
            }

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

    return AT_TIMEOUT;
}

// Проверка получения доступа к услугам пакетной передачи данных.
AtCommandResult AtGsm_Simcom800f_AttachOrDetachFromGPRSService(
        tAtCmd *env,
        tAtGsm_AttachOrDetachFromGPRSService *state,
        int *error
) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CGATT?");
    AtCmdTxSendLn(env);

    uint32_t timeout = 5000;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    *error = -1;

    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, "+CME ERROR: ")) {
            char *start = env->rxBuffer.data + sizeof("+CME ERROR:");
            *error = atoi(start);
            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "+CGATT: ")) {
            char *start = env->rxBuffer.data + sizeof("+CGATT:");
            *(char *) state = *start;
            AtCmdRxClear(env);

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

    return AT_TIMEOUT;
}

// Установка количества соединений с сокетом - 0
AtCommandResult AtGsm_Simcom800f_StartUpMultiIPConnection(tAtCmd *env, uint8_t count) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPMUX=");
    AtCmdTxAddDecimalIntWithLimit(env, count, 1);
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Режим передачи данных 0 - Ручной
AtCommandResult AtGsm_Simcom800f_SelectTCPIPApplicationMode(tAtCmd *env, uint8_t mode) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPMODE=");
    AtCmdTxAddDecimalIntWithLimit(env, mode, 1);
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Режим передачи данных 0 - Ручной
AtCommandResult AtGsm_Simcom800f_SelectDataTransmittingMode(tAtCmd *env, uint8_t mode) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPQSEND=");
    AtCmdTxAddDecimalIntWithLimit(env, mode, 1);
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Режим приема данных 1 - Ручной
AtCommandResult AtGsm_Simcom800f_GetDataFromNetworkManuallySet(tAtCmd *env, uint8_t mode) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPRXGET=");
    AtCmdTxAddDecimalIntWithLimit(env, mode, 1);
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
// конец----------------------------------- Инициализация --------------------------------------------------------------
// конец----------------------------------- Инициализация --------------------------------------------------------------
// конец----------------------------------- Инициализация --------------------------------------------------------------


// начало---------------------- Настройка контекста и открытие соединения -----------------------------------
// начало---------------------- Настройка контекста и открытие соединения -----------------------------------
// начало---------------------- Настройка контекста и открытие соединения -----------------------------------

// Деактивация контекста
AtCommandResult AtGsm_Simcom800f_DeactivateGPRSPDPContext(tAtCmd *env) {

    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPSHUT");
    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, "SHUT OK")) {
            AtCmdRxClear(env);
            return AT_OK;

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

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

    return AT_TIMEOUT;
}

// Настройка точки доступа APN
AtCommandResult AtGsm_Simcom800f_StartTaskAndSetAPN(tAtCmd *env, char *apn, int apnLen) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CSTT=");
    AtCmdTxAdd(env, apn, apnLen);
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}


// Запрос текущего статуса соединения
AtCommandResult AtGsm_Simcom800f_QueryCurrentConnectionStatus(tAtCmd *env, tAtGsm_QueryCurrentConnectionStatus *state) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPSTATUS");
    AtCmdTxSendLn(env);

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

    *state = PDP_NOT_FOUND_ERROR;

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

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

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

        } else if (AtCmdRxBeginWithStatic(env, "STATE: IP INITIAL")) {
            *state = IP_INITIAL;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: IP START")) {
            *state = IP_START;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: IP CONFIG")) {
            *state = IP_CONFIG;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: IP GPRSACT")) {
            *state = IP_GPRSACT;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: IP STATUS")) {
            *state = IP_STATUS;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: TCP CONNECTING")) {
            *state = TCP__CONNECTING;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: UDP CONNECTING")) {
            *state = UDP_CONNECTING;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: SERVER LISTENING")) {
            *state = SERVER_LISTENING;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: CONNECT OK")) {
            *state = CONNECT_OK;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: TCP CLOSING")) {
            *state = TCP_CLOSING;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: UDP CLOSING")) {
            *state = UDP_CLOSING;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: TCP CLOSED")) {
            *state = TCP_CLOSED;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: UDP CLOSED")) {
            *state = UDP_CLOSED;
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "STATE: PDP DEACT")) {
            *state = PDP_DEACT;
            AtCmdRxClear(env);
            return AT_OK;
        } else {

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

    return AT_TIMEOUT;
}

// Активация контекста
AtCommandResult AtGsm_Simcom800f_BringUpWirelessConnectionWithGPRS(tAtCmd *env) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIICR");
    AtCmdTxSendLn(env);
    return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

// Установление TCP соединения
AtCommandResult AtGsm_Simcom800f_StartUpTCPOrUDPConnection(tAtCmd *env, char *url, int urlLen, uint16_t port) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPSTART=\"TCP\",\"");
    AtCmdTxAdd(env, url, urlLen);
    AtCmdTxAddStatic(env, "\",\"");
    AtCmdTxAddDecimalIntWithLimit(env, port, 5);
    AtCmdTxAddStatic(env, "\"");
    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);
            continue;
        } else if (AtCmdRxBeginWithStatic(env, "CONNECT OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "ALREADY CONNECT")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "CONNECT FAIL")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "+CME ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}

// Закрытие соединения
AtCommandResult AtGsm_Simcom800f_CloseTCPorUDPConnection(tAtCmd *env) {
    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+CIPCLOSE");
    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);
            continue;
        } else if (AtCmdRxBeginWithStatic(env, "CLOSE OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}


// конец---------------------------- Настройка контекста и открытие соединения -----------------------------------------
// конец---------------------------- Настройка контекста и открытие соединения -----------------------------------------
// конец---------------------------- Настройка контекста и открытие соединения -----------------------------------------


// начало----------------------- Передача данных с подтверждением в командном режиме -----------------------------------
// начало----------------------- Передача данных с подтверждением в командном режиме -----------------------------------
// начало----------------------- Передача данных с подтверждением в командном режиме -----------------------------------

// Начать отправку данных на сервер
AtCommandResult AtGsm_Simcom800f_SendDataThroughTCPOrUDPConnection(tAtCmd *env, uint8_t *pBuf, uint16_t size) {

    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdSendStatic(env, "AT+CIPSEND=");
    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, "+CME ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;
        } else if (AtCmdRxBeginWithStatic(env, "SEND OK")) {
            AtCmdRxClear(env);
            return AT_OK;
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}

// конец----------------------- Передача данных с подтверждением в командном режиме -----------------------------------
// конец----------------------- Передача данных с подтверждением в командном режиме -----------------------------------
// конец----------------------- Передача данных с подтверждением в командном режиме -----------------------------------


// начало----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------
// начало----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------
// начало----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------

// Получить количества данных готовых для чтения
AtCommandResult AtGsm_Simcom800f_GetDataFromNetworkManuallyGetSize(tAtCmd *env, uint16_t *size) {

    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdSendStatic(env, "AT+CIPRXGET=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, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;

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

        } else if (AtCmdRxBeginWithStatic(env, "+CIPRXGET: 4,")) {
            char *start = env->rxBuffer.data + sizeof("+CIPRXGET: 4,") - 1;
            *size = atoi(start);
            AtCmdRxClear(env);
        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_TIMEOUT;
}

// Получить данные готовые для чтения из сокета
AtCommandResult
AtGsm_GetDataFromNetworkManuallyGet(tAtCmd *env, uint8_t *pBuf, uint16_t sizeRead, uint16_t *sizeRealRead) {

    AtCmdPrepare(env);

    AtCmdTxClear(env);
    AtCmdSendStatic(env, "AT+CIPRXGET=2,");
    AtCmdTxAddDecimalIntWithLimit(env, sizeRead, 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, "OK")) {
            AtCmdRxClear(env);
            return AT_OK;

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

        } else if (AtCmdRxBeginWithStatic(env, "+CIPRXGET: 4,")) {
            char *start = env->rxBuffer.data + sizeof("+CIPRXGET: 4,") - 1;
            *sizeRealRead = atoi(start);
            AtCmdRxClear(env);

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

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

    return AT_TIMEOUT;
}


// конец----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------
// конец----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------
// конец----------------------- Прием данных в командном режиме, ручной вывод принятых данных -------------------------