UART Communication Between STM32F03 and ESP-8266-01

I'm attempting to get a smartphone app to communicate with an MCU (STM32F030R8). The step I'm currently on is getting the WiFi module to talk with the MCU. I'm able use the AT firmware to configure the ESP when using an Arduino Uno/PC terminal, but want to essentially do the same via the STM board.

When I load the code to the STM and use Tera Term to send data to the STM it should be able to send AT commands to the ESP, but it isn't working. Right now I'm at a loss as to why this isn't working. I'm looking for pointers on the code that I've probably missed or other principles I've overlooked/am unaware of.

I've searched around on the internet the past couple days and haven't come up with much that helps. This is effectively the sum of my experience with C. Thanks for your help!

The hardware is set up as follows...

STM32     ESP
PA10      TX
PA9       RX
3.3V      VCC
3.3V      CH_PD
GND       GND

UNO       ESP
TX        TX
RX        RX
3.3V      VCC
3.3V      CH_PD
GND       GND

The code I've frankenstein'd together is below. I'm using Keil uVision 5.

#include "stm32f0xx.h"
#include <stdio.h>
#include <string.h>

void USART1_Init(void);
void USART2_Init(void);
void USART1_Write(char ch[]);
char USART1_Read(void);

int main(void)
{
    // disable the interrupt detection
    __disable_irq();

    RCC->AHBENR |= 0x00020000;                      // enable port A clock
    GPIOA->MODER |= 0x00000400;                     // set mode for PA5

    USART1_Init();
    USART2_Init();

    char strCommand[50];

    NVIC_EnableIRQ(USART1_IRQn);
    __enable_irq();

    printf("\r\nInterface for ESP8266 AT commands.\r\n");
    printf("Please enter the AT command: ");
    gets(strCommand);
    USART1_Write(strCommand);
    printf("\r\n");

    while (1);
}

// write data to the peripheral via USART1
void USART1_Write(char ch[])
{
    // wait while the tx buffer is empty
    while (!(USART1->ISR & 0x00000080));
    for (int i = 0; i < strlen(ch); i++)
    {
        USART1->TDR = (ch[i] & 0xFF);
    }
    USART1->TDR = 0x0000000D;
    USART1->TDR = 0x0000000A;
}

// read data from the peripheral via USART1
char USART1_Read(void)
{
    // wait while the rx buffer is empty
    while (USART1->ISR & 0x00000020);
    return USART1->RDR;
}

// write data to the PC via USART2
int USART2_Write(int ch)
{
    // wait while the tx buffer is empty
    while (!(USART2->ISR & 0x00000080));
    USART2->TDR = (ch & 0xFF);
    return ch;
}

// read data from the PC via USART2
int USART2_Read(void)
{
    // wait while the rx buffer is empty
    while (!(USART2->ISR & 0x00000020));
    return USART2->RDR;
}

// initialize USART1
void USART1_Init(void)
{
    RCC->APB2ENR |= 0x00004000;                 // enable USART1 clock

    GPIOA->AFR[1] |= 0x00000110;                // set AF1 to PA9, PA10

    GPIOA->MODER |= 0x00280000;                 // define GPIO modes to alternate function for PA9, PA10

    USART1->BRR = 0x00000341;                   // set the baud rate, 9600 @ 8MHz

    USART1->CR1 = 0x0000002C;                   // enable te, re, and rx interrupt
    USART1->CR1 |= 0x00000001;                  // enable ue
}

// initialize USART2
void USART2_Init(void)
{
    RCC->APB1ENR |= 0x00020000;                 // enable USART2 clock

    GPIOA->AFR[0] |= 0x00001100;                // set AF1 to PA2, PA3

    GPIOA->MODER |= 0x000000A0;                 // define GPIO modes to alternate function for PA2, PA3

    USART2->BRR = 0x00000341;                   // set the baud rate, 9600 @ 8MHz

    USART2->CR1 = 0x0000000C;                   // enable te and re
    USART2->CR1 |= 0x00000001;                  // enable ue
}

// handle the USART1 interrupt event
void USART1_IRQHandler(void)
{
    char c;
    if (USART1->ISR & 0x00000020)
    {
        c = USART1->RDR;
        //GPIOA->ODR ^= 0x00000020;             // toggle the PA5 state
        printf("%c", c);
    }
}

// implement stdin/stdout/stderr functionality
struct __FILE{int handle;};
FILE __stdin = {0};
FILE __stdout = {1};
FILE __stderr = {2};

int fgetc(FILE *f)
{
    int c;

    c = USART2_Read();

    if (c == '\r')
    {
        USART2_Write(c);
        c = '\n';
    }
    USART2_Write(c);

    return c;
}

int fputc(int c, FILE *f)
{
    return USART2_Write(c);
}

EDIT:

I've modified the code a bit and kept trying. When attempting to change the broadcasted network name/password (it didn't work) it now replies with the first two typed characters in the command consistently and after a moment put forth the gibberish at looks like it should have been summoned with an "AT+GMR" command. The following code is what was uploaded to the device. Any thoughts on how this could have happened? Thanks!

#include "stm32f0xx.h"
#include <stdio.h>
#include <string.h>

void USART1_Init(void);
void USART2_Init(void);
void USART1_Write(char ch[]);
char USART1_Read(void);

int main(void)
{
    // disable the interrupt detection
    __disable_irq();

    RCC->AHBENR |= 0x00020000;                      // enable port A clock
    GPIOA->MODER |= 0x00000400;                     // set mode for PA5

    USART1_Init();
    USART2_Init();

    char strCommand[50];

    NVIC_EnableIRQ(USART1_IRQn);
    __enable_irq();

    printf("\r\nInterface for ESP8266 AT commands.\r\n");
    printf("Please enter the AT command: ");
    gets(strCommand);
    USART1_Write(strCommand);
    printf("\r\n");

    while (1);
}

// write data to the peripheral via USART1
void USART1_Write(char ch[])
{
    // wait for the tx buffer to be empty
    while (!(USART1->ISR & 0x00000080));
    for (int i = 0; i < strlen(ch); i++)
    {
        USART1->TDR = (ch[i] & 0xFF);
    }
//  USART1->TDR = '\r';
//  USART1->TDR = '\n';
}

// read data from the peripheral via USART1
char USART1_Read(void)
{
    // wait while the rx buffer is empty
    while (USART1->ISR & 0x00000020);
    return USART1->RDR;
}

// write data to the PC via USART2
int USART2_Write(int ch)
{
    // wait while the tx buffer is empty
    while (!(USART2->ISR & 0x00000080));
    USART2->TDR = (ch & 0xFF);
    return ch;
}

// read data from the PC via USART2
int USART2_Read(void)
{
    // wait while the rx buffer is empty
    while (!(USART2->ISR & 0x00000020));
    return USART2->RDR;
}

// initialize USART1
void USART1_Init(void)
{
    RCC->APB2ENR |= 0x00004000;                 // enable USART1 clock

    GPIOA->AFR[1] |= 0x00000110;                // set AF1 to PA9, PA10

    GPIOA->MODER |= 0x00280000;                 // define GPIO modes to alternate function for PA9, PA10

    USART1->BRR = 0x00000341;                       // set the baud rate, 9600 @ 8MHz

    USART1->CR1 = 0x0000002C;                       // enable te, re, and rx interrupt
    USART1->CR1 |= 0x00000001;                  // enable ue
}

// initialize USART2
void USART2_Init(void)
{
    RCC->APB1ENR |= 0x00020000;                 // enable USART2 clock

    GPIOA->AFR[0] |= 0x00001100;                // set AF1 to PA2, PA3

    GPIOA->MODER |= 0x000000A0;                 // define GPIO modes to alternate function for PA2, PA3

    USART2->BRR = 0x00000341;                       // set the baud rate, 9600 @ 8MHz

    USART2->CR1 = 0x0000000C;                       // enable te and re
    USART2->CR1 |= 0x00000001;                  // enable ue
}

// handle the USART1 interrupt event
void USART1_IRQHandler(void)
{
    char c;
    while (1)
    {
        if (USART1->ISR & 0x00000020)
        {
            c = USART1->RDR;
        }
        else
        {
            break;
        }
        printf("%c", c);
    }
}

// implement stdin/stdout/stderr functionality
struct __FILE{int handle;};
FILE __stdin = {0};
FILE __stdout = {1};
FILE __stderr = {2};

int fgetc(FILE *f)
{
    int c;

    c = USART2_Read();

    if (c == '\r')
    {
        USART2_Write(c);
        c = '\n';
    }
    USART2_Write(c);

    return c;
}

int fputc(int c, FILE *f)
{
    return USART2_Write(c);
}

I was able to get the ESP to respond to the AT commands with the following code. There are sections commented out as I was simply frankensteining my way to 'working' code. I was able to change the SSID and password via a hard coded string. I simply sent it by pressing 'Enter' to get the code to proceed.

As it turns out the issue laid in sending data to the ESP (rather than receiving, which was my initial theory). Now I need to get the code to receive an uint8_t[] from the terminal, but that is a separate issue from the original question so I'll mark this as answered.

Thank you @hamboy75, @Juraj, and @KamilCuk for your help!

#include "stm32f0xx.h"
#include <stdio.h>
#include <string.h>

void USART1_Init(void);
void USART2_Init(void);
void USART1_Write(char ch[]);
char USART1_Read(void);
void USART1_Get(unsigned char *string);

void USART1_PutChar(uint8_t ch);
void USART1_Write2(uint8_t *str);

int main(void)
{
    // disable the interrupt detection
    __disable_irq();

    RCC->AHBENR |= 0x00020000;                      // enable port A clock
    GPIOA->MODER |= 0x00000400;                     // set mode for PA5

    USART1_Init();
    USART2_Init();

    char strCommand[50];
    uint8_t str[] = "AT+CWSAP_CUR=\"tempNetwork\",\"tempPassword\",1,2,1,0\r\n";

    NVIC_EnableIRQ(USART1_IRQn);
    __enable_irq();

    printf("\r\nInterface for ESP8266 AT commands.\r\n");
    printf("Please enter the AT command: ");
    gets(strCommand);
    //USART1_Write(strCommand);
    USART1_Write2(str);
    printf("\r\n");

    while (1);
}

// write data to the peripheral via USART1
void USART1_Write(char ch[])
{
    // wait for the tx buffer to be empty
    while (!(USART1->ISR & 0x00000080));
    for (int i = 0; i < strlen(ch); i++)
    {
        //USART1->TDR = (ch[i] & 0xFF);
    }
    //USART1->TDR = '\r';
    //USART1->TDR = '\n';

    USART1->TDR = ('T' & 0xFF);
    USART1->TDR = ('T' & 0xFF);
    USART1->TDR = '\r';
    USART1->TDR = '\n';
}

// write a string via USART1
void USART1_Write2(uint8_t *str)
{
    while (*str != 0)
    {
        USART1_PutChar(*str);
        str++;
    }
}

// write one character via USART1
void USART1_PutChar(uint8_t ch)
{
    while (!(USART1->ISR & 0x00000080));
    USART1->TDR = ch;
}

// read data from the peripheral via USART1
char USART1_Read(void)
{
    // wait while the rx buffer is empty
    while (USART1->ISR & 0x00000020);
    return USART1->RDR;
}

// write data to the PC via USART2
int USART2_Write(int ch)
{
    // wait while the tx buffer is empty
    while (!(USART2->ISR & 0x00000080));
    USART2->TDR = (ch & 0xFF);
    return ch;
}

// read data from the PC via USART2
int USART2_Read(void)
{
    // wait while the rx buffer is empty
    while (!(USART2->ISR & 0x00000020));
    return USART2->RDR;
}

// initialize USART1
void USART1_Init(void)
{
    RCC->APB2ENR |= 0x00004000;                 // enable USART1 clock

    GPIOA->AFR[1] |= 0x00000110;                // set AF1 to PA9, PA10

    GPIOA->MODER |= 0x00280000;                 // define GPIO modes to alternate function for PA9, PA10

    USART1->BRR = 0x00000341;                       // set the baud rate, 9600 @ 8MHz

    USART1->CR1 = 0x0000002C;                       // enable te, re, and rx interrupt
    USART1->CR1 |= 0x00000001;                  // enable ue
}

// initialize USART2
void USART2_Init(void)
{
    RCC->APB1ENR |= 0x00020000;                 // enable USART2 clock

    GPIOA->AFR[0] |= 0x00001100;                // set AF1 to PA2, PA3

    GPIOA->MODER |= 0x000000A0;                 // define GPIO modes to alternate function for PA2, PA3

    USART2->BRR = 0x00000341;                       // set the baud rate, 9600 @ 8MHz

    USART2->CR1 = 0x0000000C;                       // enable te and re
    USART2->CR1 |= 0x00000001;                  // enable ue
}

// handle the USART1 interrupt event
void USART1_IRQHandler(void)
{
    char c;
    while (1)
    {
        if (USART1->ISR & 0x00000020)
        {
            c = USART1->RDR;
            printf("%c", c);
        }
        else
        {
            break;
        }
    }
}

// implement stdin/stdout/stderr functionality
struct __FILE{int handle;};
FILE __stdin = {0};
FILE __stdout = {1};
FILE __stderr = {2};

int fgetc(FILE *f)
{
    int c;

    c = USART2_Read();

    if (c == '\r')
    {
        USART2_Write(c);
        c = '\n';
    }
    USART2_Write(c);

    return c;
}

int fputc(int c, FILE *f)
{
    return USART2_Write(c);
}