ESP8266-01 не реагирует на AT-команды через UART с TM4C123GH6PM - PullRequest
Новая
       8

ESP8266-01 не реагирует на AT-команды через UART с TM4C123GH6PM

0 голосов
/ 07 апреля 2020

Я пытаюсь подключить свой микроконтроллер TM4C123GH6PM от Texas Instruments к своему смартфону и использовать его для управления будильником и светодиодными индикаторами. (светодиоды управляются через транзистор, который управляется через вывод GPIO). У меня есть некоторый опыт программирования на C ++ и TM4C123GH6PM, но я все еще многому учусь. Поэтому, пожалуйста, извините за некоторые глупые sh ошибки, которые я мог допустить.

Я хочу соединить ESP8266 с микроконтроллером, используя UART и TivaWare Framework. Я написал некоторый код, и мой UART работает правильно (я проверил его, отправив символы из UART с 4 по 3).

В соответствии с AT-командами ESP8266. Он должен ответить на «AT» с помощью «OK». Но всякий раз, когда я отправляю что-то в ESP, он отвечает именно тем, что я ему отправил. Я проверил проводку, и это не проблема. Или, по крайней мере, я так думаю. Пожалуйста, поправьте меня, если проводка неправильная. 

ESP -> TM4C123GH6PM:
GND -> GND
VCC -> 3.3V
Tx -> Rx (UART3 / PC6)
Rx -> Tx (UART4 / PC5)
CH_PD -> 3.3V

Я также проверил потребление энергии ESP. Все работает от USB-порта моего ноутбука, так как это помогает избежать путаницы в кабеле. Я отслеживаю энергопотребление с помощью (https://www.amazon.de/gp/product/B07C8CM5TG/ref=ppx_yo_dt_b_asin_title_o08_s00? Т.е. = UTF8 & psc = 1 ). ESP потребляет около 150 мА от компьютера, но порт может обеспечить гораздо больше. Я проверил с некоторыми светодиодами и 400 мА не проблема.

Кто-нибудь может мне помочь? Я работаю над этим уже более двух дней и не могу найти решение. В чем проблема с ESP, не отвечающим правильно на команду AT? Синий индикатор - один, когда код работает.

PS: прилагаемый код также содержит код для управления будильником и светодиоды. Я прикрепил его, так как это может быть частью проблемы, но некоторые из них закомментированы и большая часть не используется. 

#include<stdint.h>

#include<stdbool.h>

#include"inc/hw_ints.h"

#include"inc/hw_memmap.h"

#include"inc/hw_types.h"

#include"driverlib/gpio.h"

#include"driverlib/sysctl.h"

#include"driverlib/timer.h"

#include"driverlib/interrupt.h"

#include"driverlib/uart.h"

#include"driverlib/pin_map.h"

#include "driverlib/rom.h"

// stores the time since system start in ms
uint32_t systemTime_ms;

//bools or controling the alarm clock and LEDS
bool an_aus = false;
bool alarm_clock = false;

void InterruptHandlerTimer0A (void)
{
    // Clear the timer interrupt flag to avoid calling it up again directly
    TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    // increase the ms counter by 1 ms
    systemTime_ms++;
}

void clockSetup(void)
{
    uint32_t timerPeriod;
    //configure clock
    SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ| SYSCTL_OSC_MAIN);
    //activate peripherals for the timer
    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
    // configure timers as 32 bit timers in periodic mode
    TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
    // set the variable timerPeriod to the number of periods to generate a timeout every ms
    timerPeriod = (SysCtlClockGet()/1000);
    // pass the variable timerPeriod to the TIMER-0-A
    TimerLoadSet(TIMER0_BASE, TIMER_A, timerPeriod-1);
    // register the InterruptHandlerTimer0A function as an interrupt service routine
    TimerIntRegister(TIMER0_BASE, TIMER_A, &(InterruptHandlerTimer0A));
    // activate the interrupt on TIMER-0-A
    IntEnable(INT_TIMER0A);
    // generate an interrupt when TIMER-0-A generates a timeout
    TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    // all interrupts are activated
    IntMasterEnable();
    // start the timer
    TimerEnable(TIMER0_BASE, TIMER_A);
}

void UART (void)
{
       //configure UART 4:
       SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
       SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
       while(!SysCtlPeripheralReady(SYSCTL_PERIPH_UART4));

       //GPIO pins for transmitting and receiving
       GPIOPinConfigure(GPIO_PC4_U4RX);
       GPIOPinConfigure(GPIO_PC5_U4TX);
       GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);

       //configure UART 8Bit, no parity, baudrat 38400
       UARTConfigSetExpClk(UART4_BASE, SysCtlClockGet(), 38400, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));

       //configure UART 3:
       SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
       while(!SysCtlPeripheralReady(SYSCTL_PERIPH_UART3));
       GPIOPinConfigure(GPIO_PC6_U3RX);
       GPIOPinConfigure(GPIO_PC7_U3TX);
       GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7);
       UARTConfigSetExpClk(UART3_BASE, SysCtlClockGet(), 38400, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
}

void delay_ms(uint32_t waitTime)
{
    // Saves the current system time in ms
    uint32_t aktuell = systemTime_ms;
    // Wait until the current system time corresponds to the sum of the time at the start of the delay and the waiting time
    while(aktuell + waitTime > systemTime_ms);
}

void ex_int_handler(void)
{
    // press the button to start timer for alarm clock
    alarm_clock = true;
    GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_4);
}

int main(void)
{
    //Peripherals for LED and GPIO
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

    //UART
    UART();

    //Timer
    clockSetup();

    // button
    GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_4);
    GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_4,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);

    //OnboardLED
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1);
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_3);

    //Interrupt Timer
    GPIOIntDisable(GPIO_PORTF_BASE,GPIO_PIN_4);
    GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_4);
    GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4,GPIO_FALLING_EDGE);
    GPIOIntRegister(GPIO_PORTF_BASE,ex_int_handler);
    GPIOIntEnable(GPIO_PORTF_BASE,GPIO_PIN_4);

    //Transistor Gate
    GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE,GPIO_PIN_0);
    //GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_STRENGTH_6MA,GPIO_PIN_TYPE_STD_WPU);

    //debugging only: save all the received data from the ESP in an array to look at while debugging
    int32_t data[20] = {0};
    int32_t j = 0;

    //Code for debugging the UART and ESP8266
while(1){

    //Checks for Data in the FIFO
    while(!UARTCharsAvail(UART4_BASE));

    //send AT-command to ESP8266
    UARTCharPut(UART4_BASE, 'A');
    while(UARTBusy(UART4_BASE));
    UARTCharPut(UART4_BASE, 'T');
    while(UARTBusy(UART4_BASE));

    if(UARTCharsAvail(UART3_BASE))
    {
        while(UARTCharsAvail(UART3_BASE))
        {
            //Read data from the FIFO in UART3 -> received from ESP8266
            data[j] = UARTCharGet(UART3_BASE);
            j++;
        }
    }

    //clear array when its full
    if (j >= 20)
    {
        j = 0;
        for(int32_t a = 0; a <21; a++)
        {
            data[a] = 0;
        }
    }
}

//code to run the alarm clock and leds
    /*
    while(1)
    {
        if (alarm_clock)
        {
            GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_3,GPIO_PIN_3);
            //Wait
            delay_ms(30600000);
            GPIOPinWrite(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_PIN_0);
            alarm_clock = false;
            GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_3,0x00);
            //Start Red LED blinking when it is finished
             while(1)
            {
                GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_PIN_1);
                delay_ms(1000);
                GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1,0x00);
                delay_ms(1000);

            }
        }
    }
    */
}
...