ATNEL tech-forum

Re: Odmierzanie czasu STM32

2020-05-01T18:08:14+01:00

Zauważyłem że dane nie wysyłane są w całości. Nie wiem dlaczego wysyłanych jest tak mało danych. Poniżej zmiana stanów na D4 i D5 przy poleceniu LCD_init(). Znalazłem trochę błędów i poprawiłem:
[syntax=c]#include "stm32f4xx.h"
#include "44780_display.h"

extern void delay_ms( uint16_t ms );

void SendHalf( uint8_t data ){ //wysyłanie połowy bajtu

LCD_E_SET;

if( data & ( 0x01 )) LCD_D4_SET;
else LCD_D4_RESET;
if( data & ( 0x02 )) LCD_D5_SET;
else LCD_D5_RESET;
if( data & ( 0x04 )) LCD_D6_SET;
else LCD_D6_RESET;
if( data & ( 0x08 )) LCD_D7_SET;
else LCD_D7_RESET;

LCD_E_RESET;

}

void SendAll( uint8_t data ){ //wysyłanie całego bajtu

SendHalf( data >> 4 );
SendHalf( data );
delay_ms( 1 ); // delay_10us( 6 );

}

void RS_write_command( uint8_t command ){ //wysyłanie komendy

LCD_RS_COMMAND;
SendAll( command );

}

void RS_write_data( char data ){ //wysyłanie danej na wyświetlacz

LCD_RS_DATA;
SendAll( data );

}

void LCD_init( void ){ //inicjalizacja LCD

delay_ms( 25 );// _delay_10us( 1500 );
LCD_E_RESET;
LCD_RS_COMMAND;
SendHalf( 0x03 );
delay_ms( 5 );//_delay_10us( 410 );
SendHalf( 0x03 );
delay_ms( 1 );//_delay_10us( 100 );
SendHalf( 0x03 );
delay_ms( 1 );//_delay_10us( 100 );
SendHalf( 0x02 );
delay_ms( 1 );// _delay_10us( 100 );

RS_write_command( LCD_FUNC | LCD_4_BIT | LCDC_TWO_LINE | LCDC_FONT_5x7);
RS_write_command( LCD_ONOFF | LCD_DISP_ON );
RS_write_command( LCD_CLEAR );
delay_ms( 5 );// _delay_10us( 500 );
RS_write_command( LCDC_ENTRY_MODE | LCD_EM_SHIFT_CURSOR | LCD_EM_RIGHT );

//////////////////////////////////////////////////////////////////////////////

}

void LCD_clear_display( void ){ //czyszczenie ekranu

RS_write_command(LCD_CLEAR);
delay_ms( 5 );// _delay_10us( 5 );

}

void LCD_number_line( uint8_t x, uint8_t y ){

switch(y){

case 0:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE1 + x ) );
break;

case 1:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE2 + x ) );
break;

}
}

void LCD_write( char *text ){

while(*text) RS_write_data( *text++ );

}

void LCD_x_y_write( uint8_t x, uint8_t y, char *text ){

LCD_number_line( x, y );
RS_write_data( *text );

}[/syntax]

Żółtym D4, Niebieskim D5

Żółtym Enable, Niebieskim D4

Więcej sygnałów nie zauważyłem. Wygląda to tak jakby SendHalf() działał raz, a potem nie reagował na polecenia.

Statystyki: Napisane przez matteo9999111 — 1 maja 2020, o 18:08

Re: Odmierzanie czasu STM32

2020-05-01T14:08:04+01:00

Zealota napisał(a):

Widzę tu jeszcze jednego babola. Zamiast operatora sumy bitowej używasz operatora sumy logicznej, "||" zamiast "|".

I właśnie przez to porty C nie działały teraz jest na nich napięcie. Tylko wyświetlacz dalej nie chce furgać. Ciekawe bo po zmierzeniu oscyloskopem jest nadawany sygnał. Wyswietlacz działa na 100%, bo sprawdzałem go już gdzieś indziej.

Statystyki: Napisane przez matteo9999111 — 1 maja 2020, o 14:08

Re: Odmierzanie czasu STM32

2020-05-01T00:33:05+01:00

Widzę tu jeszcze jednego babola. Zamiast operatora sumy bitowej używasz operatora sumy logicznej, "||" zamiast "|".
Rejestry BSSR i ODR można używać zamiennie, ale te pierwsze reagują tylko na bit 1, ustawienie odpowiednich pól ustawia lub kasuje właściwy pin i można robić to "atomowo".

Statystyki: Napisane przez Zealota — 1 maja 2020, o 00:33

Re: Odmierzanie czasu STM32

2020-04-30T22:49:07+01:00

To ciekawe że porty C nie reagują. Czy jest możliwe spalenie jakoś tych pinów (wszystkie mają oznaczenia FT) przez wyświetlacz HD44780 i normalne działanie innych? Nie używam większego napięcia niż 5V.

Statystyki: Napisane przez matteo9999111 — 30 kwi 2020, o 22:49

Re: Odmierzanie czasu STM32

2020-04-30T19:12:19+01:00

Pisząc o literaturze to miałem właśnie na myśli poradnik Szczywronka, bo pod względem pisania na rejestrach jest generalnie posucha Mam kilka ogólnie dostępnych książek, ale żadna z nich w tym temacie nie ma wiele do powiedzenia, natomiast "STM32 w systemach sterowania i regulacji" daje trochę wiedzy o asemblerze dla STM32, ale tylko dla F1.
Z drugiej strony poradnik jest na tyle kompleksowy, że po jego "'przerobieniu" można już iść własną drogą

Co do ustawień rejestrów GPIO to w poradniku jest zgrabna biiblioteka do ich obsługi co oczywiście nie zwalnia od zrozumienia konfiguracji rejestrów, nie mniej jednak zaglądam w tym temacie do RM sporadycznie i zwykle to wystarcza.
Dobrze jest tez mieć RM do serii F0, tam są przykłady do konfiguracji różnych peryferii właśnie na rejestrach, podobnie jak w notach Atmela.

Statystyki: Napisane przez Zealota — 30 kwi 2020, o 19:12

Re: Odmierzanie czasu STM32

2020-04-30T18:40:24+01:00

Zealota napisał(a):

Zacznij od dobrego poradnika - tzw "poradnika Szczywronka" - znajdziesz w google. Tam masz wszystko prawie na tacy. Jeśli chcesz bliżej się zapoznać z STM32 to jest to konieczne, żebyś korzystał również z literatury.
.

Polecasz jakąś konkretną książkę do nauki programowania na rejestrach? Odnośnie poradnika Szczywronka to jestem właśnie w trakcie jego przerabiania. Co ciekawe ustawiając 1 na wyjściu PA5 (NUCLEO) również poleceniem GPIOA->BSRR... dioda działa. Postanowiłem wyłączyć sygnał zegarowy dla GPIOA tak samo porty C nie reagują. Wg manuala powinno to działać.

Statystyki: Napisane przez matteo9999111 — 30 kwi 2020, o 18:40

Re: Odmierzanie czasu STM32

2020-04-30T13:28:25+01:00

Wg mnie błąd robisz przy włączeniu zegarów.
Zamiast "|=" dajesz "=" i dlatego w drugiej linii wyłączasz zegar dla portu C oraz inne zegary na tej szynie..

To pewnie jeszcze nie wszystko, ale nie zajrzę teraz do RM dla F4.
Zacznij od dobrego poradnika - tzw "poradnika Szczywronka" - znajdziesz w google. Tam masz wszystko prawie na tacy. Jeśli chcesz bliżej się zapoznać z STM32 to jest to konieczne, żebyś korzystał również z literatury.
Oczywiście jak masz problemy to pytaj na forum, ale wrzucaj nowe watki - to pomoże w przyszłości innym.

Statystyki: Napisane przez Zealota — 30 kwi 2020, o 13:28

Re: Odmierzanie czasu STM32

2020-04-30T11:03:48+01:00

Nie chce zakładać nowego tematu to tutaj zapytam. Wykonałem bibliotekę do wyświetlacza 2x16 (HD44780). Stm nie zmienia wg stanu na wyjściu (sprawdzone oscyloskopem). Wszystkie LCD_Dx_SET/RESET są w rzeczywistości poleceniem GPIOA->BSRR = GPIO_BSRR_BS(BR)x. Nie wiem dlaczego tak jest? Chyba ze polecenie ...BSRR... jest tutaj niepoprawne.

main.c

[syntax=c]#include "stm32f4xx.h"
#include "44780_display.h"
#include "delay_STM32.h"

int main(){

RCC->AHB1ENR = RCC_AHB1ENR_GPIOCEN;
RCC->AHB1ENR = RCC_AHB1ENR_GPIOAEN;
__DSB();

GPIOC->MODER |= GPIO_MODER_MODE2_0 || GPIO_MODER_MODE3_0 || GPIO_MODER_MODE10_0 || GPIO_MODER_MODE12_0; //linie danych 1,2,3,4
GPIOC->MODER |= GPIO_MODER_MODE13_0; //pin ENABLE
GPIOC->MODER |= GPIO_MODER_MODE14_0; //pin RS

GPIOA->MODER |= GPIO_MODER_MODE5_0;

SysTick_Config(16000000 / 1000);

LCD_init();
LCD_x_y_write(0,0,"C");

while(1){

}
}[/syntax]
plik biblioteczny:

[syntax=c]#include "stm32f4xx.h"
#include "44780_display.h"

extern void delay_ms( uint16_t ms );

static void SendHalf( uint8_t data ){ //wysyłanie połowy bajtu

LCD_E_SET;

if( data & ( 0x01 )) LCD_D4_SET;
else LCD_D4_RESET;
if( data & ( 0x02 )) LCD_D5_SET;
else LCD_D5_RESET;
if( data & ( 0x04 )) LCD_D6_SET;
else LCD_D6_RESET;
if( data & ( 0x08 )) LCD_D7_SET;
else LCD_D7_RESET;

LCD_E_RESET;

}

static void SendAll( uint8_t data ){ //wysyłanie całego bajtu

SendHalf( data >> 4 );
SendHalf( data );
delay_ms( 1 ); // delay_10us( 6 );

}

static void RS_write_command( uint8_t command ){ //wysyłanie komendy

LCD_RS_COMMAND;
SendAll( command );

}

static void RS_write_data( char data ){ //wysyłanie danej na wyświetlacz

LCD_RS_DATA;
SendAll( data );

}

void LCD_init( void ){ //inicjalizacja LCD

delay_ms( 15 );// _delay_10us( 1500 );
LCD_E_RESET;
LCD_RS_COMMAND;
SendHalf( 0x03 );
delay_ms( 4 );//_delay_10us( 410 );
SendHalf( 0x03 );
delay_ms( 1 );//_delay_10us( 100 );
SendHalf( 0x02 );
delay_ms( 1 );// _delay_10us( 10 );

//tutaj inicjalizujemy parametry techniczne wyświetlacza//////////////////////

RS_write_command( LCD_FUNC | LCD_4_BIT | LCDC_TWO_LINE | LCDC_FONT_5x7);
RS_write_command( LCD_ONOFF | LCD_DISP_ON );
RS_write_command( LCD_CLEAR );
delay_ms( 1 );// _delay_10us( 1 );
RS_write_command( LCDC_ENTRY_MODE | LCD_EM_SHIFT_CURSOR | LCD_EM_RIGHT );

//////////////////////////////////////////////////////////////////////////////

}

void LCD_clear( void ){ //czyszczenie ekranu

RS_write_command(LCD_CLEAR);
delay_ms( 1 );// _delay_10us( 5 );

}

void LCD_number_line( uint8_t x, uint8_t y ){

switch(y){

case 0:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE1 + x ) );
break;

case 1:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE2 + x ) );
break;

case 2:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE3 + x ) );
break;

case 3:
RS_write_command( LCDC_SET_DDRAM | ( LCD_GO_LINE4 + x ) );
break;

}
}

void LCD_write( char *text ){

while(*text) RS_write_data( *text++ );

}

void LCD_x_y_write( uint8_t x, uint8_t y, char *text ){

LCD_number_line( x, y );
RS_write_data( *text );

}[/syntax]

[syntax=c]#include "stm32f4xx.h"

//definicje wejść/wyjść/////////////////////////////////////////////

#define LCD_E_SET GPIOC->BSRR = GPIO_BSRR_BS13
#define LCD_E_RESET GPIOC->BSRR = GPIO_BSRR_BR13

#define LCD_RS_DATA GPIOC->BSRR = GPIO_BSRR_BS14
#define LCD_RS_COMMAND GPIOC->BSRR = GPIO_BSRR_BR14

#define LCD_D4_SET GPIOC->BSRR = GPIO_BSRR_BS2
#define LCD_D5_SET GPIOC->BSRR = GPIO_BSRR_BS3
#define LCD_D6_SET GPIOC->BSRR = GPIO_BSRR_BS10
#define LCD_D7_SET GPIOC->BSRR = GPIO_BSRR_BS12
#define LCD_D4_RESET GPIOC->BSRR = GPIO_BSRR_BR2
#define LCD_D5_RESET GPIOC->BSRR = GPIO_BSRR_BR3
#define LCD_D6_RESET GPIOC->BSRR = GPIO_BSRR_BR10
#define LCD_D7_RESET GPIOC->BSRR = GPIO_BSRR_BR12

//definicje komend///////////////////////////////////////////////////

#define LCD_CLEAR 0x01
#define LCD_HOME 0x02

#define LCDC_ENTRY_MODE 0x04
#define LCD_EM_SHIFT_CURSOR 0x00
#define LCD_EM_SHIFT_DISPLAY 0x01
#define LCD_EM_LEFT 0x00
#define LCD_EM_RIGHT 0x02

#define LCD_ONOFF 0x08
#define LCD_DISP_ON 0x04
#define LCD_CURSOR_ON 0x02
#define LCDC_CURSOR_OFF 0x00
#define LCDC_BLINK_ON 0x01
#define LCDC_BLINK_OFF 0x00

#define LCD_SHIFT 0x10
#define LCDC_SHIFT_DISP 0x08
#define LCDC_SHIFT_CURSOR 0x00
#define LCDC_SHIFT_RIGHT 0x04
#define LCDC_SHIFT_LEFT 0x00

#define LCD_FUNC 0x20
#define LCD_8_BIT 0x10
#define LCD_4_BIT 0x00
#define LCDC_TWO_LINE 0x08
#define LCDC_FONT_5x10 0x04
#define LCDC_FONT_5x7 0x00

#define LCDC_SET_CGRAM 0x40
#define LCDC_SET_DDRAM 0x80

#define LCD_GO_LINE1 0x00
#define LCD_GO_LINE2 0x40
#define LCD_GO_LINE3 0x10
#define LCD_GO_LINE4 0x50

//znaki spoza tablicy ASCII///////////////////////////////////////////

//deklaracje funkcji
static void SendHalf( uint8_t data );
static void SendAll( uint8_t data );
static void RS_write_command( uint8_t command );
static void RS_write_data( char data );
void LCD_init( void );
void LCD_clear( void );
void LCD_number_line( uint8_t x, uint8_t y );
void LCD_write( char *text );
void LCD_x_y_write( uint8_t x, uint8_t y, char *text );[/syntax]

Statystyki: Napisane przez matteo9999111 — 30 kwi 2020, o 11:03

Re: Odmierzanie czasu STM32

2020-04-29T14:52:28+01:00

91suoirfeN napisał(a):

matteo9999111 napisał(a):

z czasami rzędu [ms] nie ma problemów, ale jakbym chciał zrobić 1[us] niestety nie działa. Czy trzeba już w takiej sytuacji użyć funkcji asemblerowych?

jeżeli potrzebujesz odmierzać czas w dziesiątkach mikrosekund to kod powyżej jak najbardziej się sprawdzi. Wystarczy bowiem pozwolić kompilatorowi się wykazać i użyć flagi optymalizacji, np. -O2. Należy pamiętać że Cortex-M0 nie należy do najszybszych rdzeni i czasem złomega będzie od niego szybsza w pewnych zastosowaniach. Jest on po prostu znacznie okrojony z instrukcji w porównaniu do M3 czy M4.

Jeżeli interesują Cie bardziej dokładne opóźnienia to wpisz w google STM32F0 microsecond delay i poczytaj wyniki

W tym momencie tworzę na rdzeniu Cortex M4 (dokładnie to na uC STM32F411RE ). Zgadza się przy dziesiątkach us daje radę nawet przy taktowaniu fabrycznym 16MHz. Tylko potrzebne są mi czasy np 2us.

Statystyki: Napisane przez matteo9999111 — 29 kwi 2020, o 14:52

Re: Odmierzanie czasu STM32

2020-04-29T12:27:14+01:00

z czasami rzędu [ms] nie ma problemów, ale jakbym chciał zrobić 1[us] niestety nie działa. Czy trzeba już w takiej sytuacji użyć funkcji asemblerowych?

Statystyki: Napisane przez matteo9999111 — 29 kwi 2020, o 12:27

Re: Odmierzanie czasu STM32

2020-04-29T07:48:42+01:00

fofex napisał(a):

Zealota napisał(a):

...
register uint16_t n;
n = softTimer1; if (n) softTimer1 = --n;

Użycie zmiennej pośredniej jest w przypadku Cortexów niepotrzebne.
W przypadku AVR obecnie też.

Wystarczy
[syntax=c]void SysTick_Handler( void )
{
if(n) {
--n;
}
}[/syntax]

Albo bardziej cywilizowanie

[syntax=c]void SysTick_Handler( void )
{
tickThatSoftTimer();
}
...
static uint16_t thatTimerCounter;
void tickThatSoftTimer(void)
{
if(thatTimerCounter) {
--thatTimerCounter;
}
}[/syntax]

Zapomniałeś o volatile przy definicji thatTimerCounter

Statystyki: Napisane przez Jarecki — 29 kwi 2020, o 07:48

Re: Odmierzanie czasu STM32

2020-04-28T19:21:20+01:00

Zealota napisał(a):

...
register uint16_t n;
n = softTimer1; if (n) softTimer1 = --n;

Statystyki: Napisane przez fofex — 28 kwi 2020, o 19:21

Re: Odmierzanie czasu STM32

2020-04-28T18:04:42+01:00

Zealota napisał(a):

Dlaczego jak dzielisz 48Mhz / 1000 to wychodzi ci 1ms? Mi wychodzi co 1ms jak podzielisz 48MHz/48000. Jak coś źle napisałem to prosze mnie poprawić.

W jakim celu są te softtime. Jak one działają?

Statystyki: Napisane przez matteo9999111 — 28 kwi 2020, o 18:04

Re: Odmierzanie czasu STM32

2020-04-28T17:42:36+01:00

Robię to tak:
1. Ustawiam Systick na przerwanie co 1 ms:
[syntax=c]SysTick_Config( 48000000/1000 );[/syntax]
48000000 to oczywiście częstotliwość uK, a potrzebne są standardowe nagłówki z CMSIS.
Mam więc uruchomiony silnik timerów programowych, podobnie jak w bluebook.
W przerwaniu od Systicka może być np taki kod:
[syntax=c]volatile uint16_t softTimer1, softTimer2, delayTimer;

void SysTick_Handler( void ) {
register uint16_t n;
n = softTimer1; if (n) softTimer1 = --n;
n = softTimer2; if (n) softTimer2 = --n;
n = delayTimer; if (n) delayTimer = --n;
}
/*********************************************************/
void delay_ms( uint16_t ms ) {
delayTimer = ms;
while ( delayTimer ) {__NOP();}
}[/syntax]

Oczywiście trzba wyprowadzić funkcj na zewnątrz:
[syntax=c]extern uint16_t softTimer1;
extern uint16_t softTimer2;
extern uint16_t delayTimer ;

extern void delay_ms( uint16_t ms );[/syntax]

Po takim przygotowaniu mamy funkcję blokującą delay_ms() oraz dwie zmienne, softTimer1, softTimer2 do opóźnień nieblokujących.

Statystyki: Napisane przez Zealota — 28 kwi 2020, o 17:42

Odmierzanie czasu STM32

2020-04-28T16:41:56+01:00

Witam. Mam problem z odmierzaniem czasu w programie uC (STM32 rejestry). W jaki sposób wykonać prosty timer nierobiący nic poza czekaniem ten czas który mu zadam typu AVR - delay_ms(jakis_czas). Potrzebuje używać tego timera zarówno w main.c jak i bibliotekach. Myślałem nad SysTickiem tylko nwm jak mogę go wykożystać, aby działał mi we wszystkich bibliotekach.

Statystyki: Napisane przez matteo9999111 — 28 kwi 2020, o 16:41