So I have been trying to do what I can without a scope. I wrote a simple C++ UART port term.
If I am not fooling myself I hope that the bits I am reading out is actually the right thing.
So here is my code that my STM board is running on. It simply sends 0b00000001 and then increments it until it reaches 127 and then restarts.
I see something interesting that I can't explain. It seems like I receive exactly these bytes as it increments but its still not a legitimate char?
Another weird thing is if I uncomment the additional USART_Write(); in the while loop it simply isn't sent over.
This is the output that you can actually see increment.
https://pastebin.com/52Wud7VT
/**
******************************************************************************
* @file main.c
* @author Auto-generated by STM32CubeIDE
* @version V1.0
* @brief Default main function.
******************************************************************************
*/
//APB1 : UART2
//UASRT Connected to PA2
#define STM32F401xx
#include "stm32f4xx.h"
void USART_write(int ch);
void delayMs(int delay);
void USART6_Init();
int main(void)
{
USART6_Init();
GPIOA->MODER |= 0x400;
//GPIOA->ODR |= 0x20;
char xx = 0b00000001;
char x[7] = {0};
x[0] = 0b1001000;
x[1] = 0b1000101;
x[2] = 0b1001100;
x[3] = 0b1001100;
x[4] = 0b1101111;
while(1){
USART_write(xx);
//USART_write(x[0]);
//USART_write(x[1]);
//USART_write(x[2]);
//USART_write(x[3]);
//USART_write(x[4]);
delayMs(1000);
xx++;
if (xx == 127) {
xx = 1;
}
GPIOA->ODR ^= 0x20;
}
}
void USART6_Init(){
//delayMs(1);
RCC->AHB1ENR |= 1;
RCC->APB2ENR |= (1 << 5);
GPIOA->AFR[1] |= (1<<15);
GPIOA->MODER |= ( 1 << 23 );
GPIOA->MODER |= ( 1 << 25 );
USART6->CR1 &= ~(1 << 12); // USART_WORDLENGTH_8B
USART6->CR1 &= ~(1 << 10); // USART_PARITY_NONE
USART6->CR1 |= (1 << 7); // USART_CR1_TXEIE
USART6->CR1 |= (1 << 5); // USART_CR1_RXNEIE
USART6->CR1 |= (1 << 3); // USART_MODE_TX
USART6->CR1 |= (1 << 2); // USART_MODE_RX
//USART6->BRR = 0x0683; //BAUDRATE 9600 @16Mhz//11010000011
USART6->BRR = 0b11010000011;
//USART6->BRR = 0x2D9;
//208.375
//104.1875
USART6->CR1 = 0x0008; //ENABLE Tx
USART6->CR1 |= 0x2000;
}
void USART_write(int ch){
//WHile the TX Buffer is empty
while((USART6->SR & 0x0080)){
USART6->DR = (ch & 0xFF);
}
}
void delayMs(int delay) {
int i;
for (; delay>0;delay--){
for (i = 0 ; i < 3195; i++);
}
}
This is a little snippit of whats in the pastebin
Leng: 1 rate :13 Char:
0x00000000000000000000000000000010
Leng: 1 rate :13 Char:
0x00000000000000000000000000000011
Leng: 1 rate :13 Char:
0x00000000000000000000000000000100
Leng: 1 rate :13 Char:
0x00000000000000000000000000000101
Leng: 1 rate :13 Char:
0x00000000000000000000000000000110
Leng: 1 rate :13 Char:
0x00000000000000000000000000000111
Leng: 1 rate :13 Char:
0x00000000000000000000000000001000
Leng: 1 rate :13 Char:
0x00000000000000000000000000001001
Leng: 1 rate :13 Char:
0x00000000000000000000000000001010
Leng: 1 rate :13 Char:
0x00000000000000000000000000001011
Leng: 1 rate :13 Char:
If anybody is interested in my C++ UART implementation here it is
#include <iostream>
#include <unistd.h> //Used for UART
#include <fcntl.h> //Used for UART
#include <termios.h> //Used for UART
#include <assert.h>
#include <string.h>
#include <vector>
#include <thread>
using namespace std;
void doUART(int BR, int i);
void printb(unsigned int v);
int main(int argc, char **argv)
{
std::vector<int> Baudrates;
for (int x= 1 ; x < 18 ; x++) {
Baudrates.push_back(x);
}
for (int x = 1; x < 18; x++) {
Baudrates.push_back(x + 10000);
}
/*
for (int x = 0 ; x < Baudrates.size(); x++) {
doUART(Baudrates[x]);
}*/
doUART(B9600, 0);
}
void printb(unsigned int v)
{
unsigned int i, s = 1 << ((sizeof(v) << 3) - 1); // s = only most significant bit at 1
printf("0x");
for (i = s; i; i >>= 1)
{
printf("%d", v & i || 0);
}
printf("\n");
}
void doUART(int BR, int i){
//-------------------------
//----- SETUP USART 0 -----
//-------------------------
//At bootup, pins 8 and 10 are already set to UART0_TXD, UART0_RXD (ie the alt0 function) respectively
int uart0_filestream = -1;
//OPEN THE UART
//The flags (defined in fcntl.h):
// Access modes (use 1 of these):
// O_RDONLY - Open for reading only.
// O_RDWR - Open for reading and writing.
// O_WRONLY - Open for writing only.
//
// O_NDELAY / O_NONBLOCK (same function) - Enables nonblocking mode. When set read requests on the file can return immediately with a failure status
// if there is no input immediately available (instead of blocking). Likewise, write requests can also return
// immediately with a failure status if the output can't be written immediately.
//
// O_NOCTTY - When set and path identifies a terminal device, open() shall not cause the terminal device to become the controlling terminal for the process.
uart0_filestream = open("/dev/ttyACM1", O_RDONLY | O_NOCTTY); //| O_NDELAY); //Open in non blocking read/write mode
if (uart0_filestream == -1)
{
//ERROR - CAN'T OPEN SERIAL PORT
printf("Error - Unable to open UART. Ensure it is not in use by another application\n");
}
//CONFIGURE THE UART
//The flags (defined in /usr/include/termios.h - see http://pubs.opengroup.org/onlinepubs/007908799/xsh/termios.h.html):
// Baud rate:- B1200, B2400, B4800, B9600, B19200, B38400, B57600, B115200, B230400, B460800, B500000, B576000, B921600, B1000000, B1152000, B1500000, B2000000, B2500000, B3000000, B3500000, B4000000
// CSIZE:- CS5, CS6, CS7, CS8
// CLOCAL - Ignore modem status lines
// CREAD - Enable receiver
// IGNPAR = Ignore characters with parity errors
// ICRNL - Map CR to NL on input (Use for ASCII comms where you want to auto correct end of line characters - don't use for bianry comms!)
// PARENB - Parity enable
// PARODD - Odd parity (else even)
struct termios options;
tcgetattr(uart0_filestream, &options);
//options.c_cflag = B9600 | CS8 | PARENB | CLOCAL | CREAD; //<Set baud rate
options.c_cflag = BR | CS8 | PARENB | CLOCAL | CREAD; //<Set baud rate
//options.c_iflag = INPCK;
//options.c_cflag |= CS8|PARENB; cfsetispeed(&options, B9600); cfsetospeed(&options, B9600);
//options.c_cflag &= ~(CRTSCTS|CSTOPB|CSIZE);
//options.c_oflag = 0;
//options.c_lflag = 0;
tcflush(uart0_filestream, TCIFLUSH);
tcsetattr(uart0_filestream, TCSANOW, &options);
// Read up to 255 characters from the port if they are there
unsigned char rx_buffer[256] = {0};
int rx_length;
unsigned int num_of_data_errors = 0;
rx_length = read(uart0_filestream, (void *)rx_buffer, 255);
rx_length = 0; // eliminate the first imcomplete received data message
auto begin = std::chrono::high_resolution_clock::now();
//std::cout << elapsed.count() << " ms elapsed.\n";
//----- CHECK FOR ANY RX BYTES -----
do
{
if (rx_length < 0)
{
perror("The following error occurred");
//cout << "An error occured (will occur if there are no bytes)" << endl;
}
else if (rx_length == 0)
{
perror("The following error occurred");
//cout << "No data waiting" << endl;
}
else
{
//Bytes received
//rx_buffer[rx_length] = '\0';
//cout << "rx_length = " << rx_length << "\trx_buffer = " << rx_buffer;
cout << "Leng: " << rx_length << " rate :" << BR << " Char: " << rx_buffer << std::endl;
printb(rx_buffer[0]);
// printb(rx_buffer[1]);
// printb(rx_buffer[2]);
// printb(rx_buffer[3]);
// printb(rx_buffer[4]);
// printb(rx_buffer[5]);
// printb(rx_buffer[6]);
// printb(rx_buffer[7]);
// printb(rx_buffer[8]);
// printb(rx_buffer[9]);
// printb(rx_buffer[10]);
// printb(rx_buffer[11]);
// printb(rx_buffer[12]);
// printb(rx_buffer[13]);
//assert(strcmp((const char*)rx_buffer, "HELLO_WORLD!! \r\n")==0);
}
if (i == 1) {
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> elapsed = end - begin;
//std::cout << "ELAPSED:" << elapsed.count() << std::endl;
if (elapsed.count() > 1000)
{
break;
}
}
} while (rx_length = read(uart0_filestream, (void *)rx_buffer, 255)); //Filestream, buffer to store in, number of bytes to read (max));
//----- CLOSE THE UART -----
close(uart0_filestream);
}
