DEV Community: vietdt89

Setup Uart with STM32F411RE

vietdt89 — Sat, 26 Oct 2024 06:18:49 +0000

1. Open block diagram in Datasheet

We will use USART2 interface because it is connected to the same bus (APB1) with the power interface. That means we can communicate directly with the computer via USB without having a chip to convert from UART to USB.

2. Write UART send function to computer USB

Open Alternate function mapping in datasheet. We can see that creating UART TX involving PA2 and AF07 (will mention later)

First we need to setup PA2 port to alternate function type as table above

Enable clock to GPIOA

RCC->AHB1ENR |= GPIOAEN;

Set PA2 to alternate mode As the table, we need to set bit 5 and 4 of pin 2 to value 10 If we want to receive UART, as the alternate table, we need to set PA3 to alternate mode

GPIOA->MODER &=~(1U<<4);
GPIOA->MODER |= (1U<<5);

GPIOA->MODER &=~(1U<<6);
GPIOA->MODER |= (1U<<7);

Set PA2 alternate type to UART_TX As mentioned above, besides PA2, we need to modify AF07. AFRL is a low register for alternate function There are 2 alternate function registers, and we are dealing with PA2, so we use AFR[0] for low to locate to AFRL2, and we will modify bit 8, 9, 10, 11. To set to AF7, use value 0111

GPIOA->AFR[0] |= (1U<<8);
GPIOA->AFR[0] |= (1U<<9);
GPIOA->AFR[0] |= (1U<<10);
GPIOA->AFR[0] &= ~(1U<<11);

Set PA3

GPIOA->AFR[0] |= (1U<<12);
GPIOA->AFR[0] |= (1U<<13);
GPIOA->AFR[0] |= (1U<<14);
GPIOA->AFR[0] &= ~(1U<<15);

Set clock to USART2 port

#define UART2EN (1U<<17)
RCC->APB1ENR |= UART2EN;

Set direction of UART to sending We need to set TE mode

#define CR1_TE (1U<<3)
USART2->CR1 = CR1_TE;

Then we need to enable USART in bit 13
Remember that we only enable after we set up all the configuration.

#define CR1_UE (1U<<13)
USART2->CR1 |= CR1_UE;
USART2->CR1 = CR1_TE | CR1_RE; //if we want to receive UART

Set baudrate
We will set frequency as 16Mhz and baudrate as 115200.
And calculate as formula below

Then we need to set value to BRR register
Write data to pin
Before sending, we need to check if send status is ok or not

#define SR_TXE (1U<<7)
USART2->SR & SR_TXE

And we can only write one character per write

USART2->DR = (character & 0xFF);

Source code

#include "stm32f4xx.h"
#include <stdint.h>
#include <stdio.h>

#define GPIOAEN (1U<<0)
#define UART2EN (1U<<17)

#define CR1_TE (1U<<3)
#define CR1_UE (1U<<13)
#define SR_TXE (1U<<7)

#define SYS_FREQ 16000000
#define APB1_CLK SYS_FREQ
#define UART_BAUDRATE 115200

static void uart_set_baudrate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t BaudRate);
static uint16_t compute_uart_bd(uint32_t PeriphClk,uint32_t BaudRate);
void uart2_tx_init(void);
void uart2_write(int ch);

int __io_putchar(int ch){
    uart2_write(ch);
    return ch;
}
int main(void){
    uart2_tx_init();
    while(1){
        uart2_write('O');
        //printf("hello\n\r");
    }
    return 0;
}

void uart2_tx_init(void){
    //Enable GPIOA
    RCC->AHB1ENR |= GPIOAEN;

    //Set PA2 to alternate function mode
    GPIOA->MODER &=~(1U<<4);
    GPIOA->MODER |= (1U<<5);

    //Set PA2 alternate function type to UART_TX (AF07)
    GPIOA->AFR[0] |= (1U<<8);
    GPIOA->AFR[0] |= (1U<<9);
    GPIOA->AFR[0] |= (1U<<10);
    GPIOA->AFR[0] &= ~(1U<<11);
    //Enable clock access to uart2
    RCC->APB1ENR |= UART2EN;

    //Configure baudrate
    uart_set_baudrate(USART2, APB1_CLK, UART_BAUDRATE);
    //Configure transfer direct
    USART2->CR1 = CR1_TE;

    //Enable uart module
    USART2->CR1 |= CR1_UE;

}

void uart2_write(int ch){
    while( !(USART2->SR & SR_TXE)){}
    USART2->DR = (ch & 0xFF);
}

static void uart_set_baudrate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t BaudRate){
    USARTx->BRR |= compute_uart_bd(PeriphClk, BaudRate);
}

static uint16_t compute_uart_bd(uint32_t PeriphClk,uint32_t BaudRate){
    return ((PeriphClk + (BaudRate/2U))/BaudRate);
}

Push button and led blink with STM32F411RE

vietdt89 — Fri, 25 Oct 2024 08:43:08 +0000

Write a driver to listen to button push event then blink led

Tool Board STm32F411RE Cube IDE Datasheet Reference manual User manual

1. Open User manual to locate led and button pin

To confirm the port and pin, we check the board selector in CubeIDE

Now we know that LED is on PA15 (port A pin 5), button is on PC 13 (Port C pin 13). We go to block diagram to check the bus that connect to that port. We need to enable clock to the bus before communicating with the ports
To check the bus, go to Datasheet-> block diagram

Both ports are on bus AHB1

2. Download header file

Now go to ST website and download the STM32CubeF4. This contains the header for controlling the register so that we don't need to calculate the bit location manually.
Get the latest here

We will keep these folders and delete all the remaining
\STM32Cube_FW_F4_V1.28.0\Drivers\CMSIS\Include \STM32Cube_FW_F4_V1.28.0\Drivers\CMSIS\Device\ST\STM32F4xx

3. Create new project

Create new project with STM32F411 component
Then import the header folder to Cube project

4. Source code

If we do not have stm32f4xx header, we will have to define the register location manually
In the code, we wil use structs provided by the header.

/*
#define PERIPH_BASE             (0x40000000UL)
#define AHB1PERIPH_OFFSET               (0x00020000UL)
#define AHB1PERIPH_BASE                 (PERIPH_BASE + AHB1PERIPH_OFFSET)

#define GPIOA_OFFSET                    (0x0000UL)
#define GPIOA_BASE              (AHB1PERIPH_BASE + GPIOA_OFFSET)

#define RCC_OFFSET              (0x3800UL)
#define RCC_BASE                (AHB1PERIPH_BASE + RCC_OFFSET)

#define AHB1EN_R_OFFSET                 (0x30UL)
#define RCC_AHB1EN_R                    (*(volatile unsigned int*)(RCC_BASE + AHB1EN_R_OFFSET))

#define MODE_R_OFFSET                    (0x00UL)
#define GPIOA_MODE_R                     (*(volatile unsigned int*)(GPIOA_BASE + MODE_R_OFFSET))

#define OD_R_OFFSET              (0x14UL)
#define GPIOA_OD_R               (*(volatile unsigned int*)(GPIOA_BASE + OD_R_OFFSET))
*/

Using header

#include "stm32f4xx.h"
#define GPIOAEN                  (1U<<0)
#define GPIOCEN                  (1U<<2)

#define PIN5                     (1U<<5)
#define PIN13                    (1U<<13)

#define LED_PIN                  PIN5
#define BTN_PIN                  PIN13

int main(void){
        // set clock for bus
    RCC->AHB1ENR |= GPIOAEN;
    RCC->AHB1ENR |= GPIOCEN;
        //set mode register for port A and port C
    GPIOA->MODER |= (1U<<10);
    GPIOA->MODER&=~(1U<<11);

    GPIOC->MODER &=~(1U<<26);
    GPIOC->MODER &=~(1U<<27);
        // reset led into off state
    //GPIOA->ODR &= ~LED_PIN;
    GPIOA->BSRR = (1U<<21);
        // blink loop
    while(1){
        if(GPIOC->IDR & BTN_PIN){//if 
            GPIOA->BSRR |= (1U<<21);
        }
        else{
            while (1){
                                //GPIOA->ODR|= LED_PIN;
                GPIOA->BSRR |= LED_PIN;
                for(int i = 0; i < 100000; i++){}//delay
                                //GPIOA->ODR &= ~LED_PIN;
                GPIOA->BSRR |= (1U<<21);
                for(int i = 0; i < 100000; i++){}//delay
                if(GPIOC->IDR & BTN_PIN){
                    break;
                }
            }
        }
    }
}

Explain
1. Go to memory mapping in datasheet

We can see that AHB1 bus register starts at 0x4002 0000 and the root address of all registers starts at 0x4000 0000. From this, we will define all register that we need to control the ports.
2. Register needed

All information is in Reference manual document

RCC AHB1: provide clock to AHB1 bus

Port A is at pin 0, port C is at pin 2.

Mode register: to set operation mode for each port.

We use port A to set led, port C to receive button event so port A will be output mode, port C will be input mode
Set led at Port A pin 5, so bit 11 and 10 of mode register should be 01.
Receive button event at Port C pin 13 so bit 27 26 of mode register should be 00.

3. Set led

We have 2 ways to set led. One is to set data pin, the other is to set reset pin.

Set data pin Find data register

Since led pin is in pin 5. We set led on off by setting bit 5 with 1 or 0

GPIOA->ODR|= LED_PIN;
GPIOA->ODR &= ~LED_PIN;

Set/reset bit reset register

Set pin 5 bit 5 in reset in bit 21. So the code is

GPIOA->BSRR |= LED_PIN;
GPIOA->BSRR |= (1U<<21);

To listen to button event, we will listen to pin 13 of input data register

GPIOC->IDR & BTN_PIN

if bit is 1, button is released, 0 button is pressed
Here we have pullup, pulldown transistor for button

We need pullup transistor so that when button is not pressed, the state will be pulled up to HIGH
We need pulldown transistor so that when button is pressed, the state will be pulled down to LOW

Delegation is the last thing managers should do

vietdt89 — Tue, 23 Apr 2024 00:55:48 +0000

Delegation is a vital skill of effective leadership. It involves entrusting tasks and responsibilities to team members based on their skills, capabilities, and expertise, thereby fostering a culture of empowerment and accountability.

Effective delegation not only enhances productivity and efficiency but also promotes professional growth and development within the team. Mastering the art of delegation enables managers to focus on strategic initiatives and decision-making while empowering their team to take ownership and contribute to the overall goals of the organization.

There are lots of things you can do. Here are the ones I believe have the most impact:.

Before delegation

Raise team's capabilities According to Blanchard, different people in different situations need different styles of leadership. High competence and a good attitude are the first criteria to consider. Every member needs continuous improvement. Even the ones with high expertise who recently joined your team or the members who formed the team in the first place.

Giving your members training is an effective way to build trust and the foundation so that they can do the work with the least of our direction.

Communicate clearly There are important things that we need to clearly communicate to your directs

A SMART goal is a way for us to know when the work is done and how we can measure the progress. This is a critical tool so that they can manage themselves.
Capability dictionary: a list of what we have to obtain to do the work with best quality. Members who are eager to learn can refer to it to improve their competency.

After delegation
It is very difficult for everything to go the correct way from beginning. Now monitoring comes in handy

Provide feedback
woman in white long sleeve shirt sitting on red couch
For managers, 1:1 meetings are a familiar tool. We should use it to give instant feedback from various points of view so that members can correctly “turn the steering wheel.”.
Reflect on process
We can learn a lot from observing others working. Write it down and update the processes for future preparation of the next delegation as well as our own way of working.

Last words
Mastering the art of delegation is not just about distributing tasks; it's about empowering your team, fostering growth, and achieving collective success. By delegating effectively, managers can unlock the full potential of their team members, creating a dynamic and productive work environment where everyone thrives. So, embrace delegation as a strategic tool in your people management arsenal, and watch as your team flourishes and accomplishes more than you ever thought possible.

If you like my post, hit like button or comment if you want to add more ideas
Visit my site for more articles

Easy way to setup VSCode to learn Linux programming

vietdt89 — Sat, 13 Apr 2024 02:37:09 +0000

As an embedded engineer, I often need to practice Linux programming on my Windows laptop. I believe that installing a distro directly into the system is superfluous and somewhat complex.

I have since discovered WSL, which is more practical. Thus, I make a few notes about how to configure the system to run and build code.
This is for some one who knows how to do it but struggles to make it work
1. Use virtual machine
Firstly, I remind everyone about the old-school method with VM
You need Virtual machine with an Ubuntu distro. I choose Kubuntu because I think it is less prone to error than Ubuntu ( just my personal experience).

Install ssh to Ubuntu then enable it
The most important part is setting up Network in VM

The guess IP is the IP in Ubuntu you get from the ifconfig command.
You can test the connection in command window

Now open VSCode or Visual studio, install SSH extension and create new one, use the same command above and you are good to write code.

2. Use WSL

WSL stands for Windows Subsystem for Linux. In short, it works like below

This is the best tutorial on how to install WSL and connect it with VSCode. Just follow it.
Now you can access a Linux system like using VM, we come to the most important part, compile and run/debug source code.
You need to create a Hello world cpp file to test.
We need tasks.json file to compile the code in Linux and a launch.json file to debug.
tasks.json

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: g++ build active file",
            "command": "/usr/bin/g++",
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": "build",
            "detail": "compiler: /usr/bin/g++"
        }
    ]
}

Install gdb to Linux using command

sudo apt install gdb

Now check where gdb is

Config launch.json file and update miDebuggerPath with the path you get

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "debug",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}/${fileBasenameNoExtension}",
            "MIMode": "gdb",
            "cwd": "${fileDirname}",
            "miDebuggerPath": "/usr/bin/gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                },
                {
                    "description": "Set Disassembly Flavor to Intel",
                    "text": "-gdb-set disassembly-flavor intel",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "C/C++: g++ build active file"
        }
    ]
}

To compile code, use Ctrl Shift B

To debug, use Run -> Start Debugging

Everything should be ok now. Enjoy!