ATNEL tech-forum

Re: STM32 WS2812 Pomoc

2018-04-09T21:52:41+01:00

Po długim czasie zapoznawania się doszedłem, że dalej miałem GPIO źle ustawione, ponieważ ustawiłem wszystkie sygnału jako wyjście, a nie jako funkcja alternatywna.
Teraz mam:
[syntax=c]//pinC 8 wyjscie
GPIOC->MODER |= GPIO_MODER_MODER0_0;

//pin wejścia timera(PA6 ??) podciąganie do dołu
GPIOA->ODR &= ~GPIO_ODR_6;

//PB1 alternatywne(Timer3_CH4)
GPIOB->MODER |= GPIO_MODER_MODER1_1;

//PA3 alternatywne(Timer2_CH4)
GPIOA->MODER |= GPIO_MODER_MODER3_1;

//PB13 alternatywne(SPI2_SCK)
GPIOB->MODER |= GPIO_MODER_MODER13_1;

//PB14 wejcie(SPI2_MISO)

GPIOB->ODR &= ~GPIO_ODR_14;

//PB15 alternatywne(SPI2_MOSI)
GPIOB->MODER |= GPIO_MODER_MODER15_1;[/syntax]

Teraz mam na wyjściu SCK sygnał o długości 1 bita 2000 ns.
Jednak nie wiem jak dalej mają działać te timery ?

Do tego poradnika https://ep.com.pl/files/11801.pdf niestety nie ma plików na ftp
Próbowałem przekopiować sam kody jednak w linijce
{&RCC->AHBENR, RCC_AHBENR_RSTVAL | RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN| RCC_AHBENR_GPIOCEN | RCC_AHBENR_DMAEN},
nie mam w bibliotece elementu RCC_AHBENR_RSTVAL, na podstawie dokumentacji także nie doszedłem co to jest.

Statystyki: Napisane przez lukas12 — 9 kwi 2018, o 21:52

Re: STM32 WS2812 Pomoc

2018-04-03T10:38:03+01:00

lukas12 napisał(a):

Dzięki za poradę niestety nic nie pomogło, czy dam przykładowo:
GPIOC->MODER |= (1 << 8*2);
czy GPIOC->MODER |= 1 << (8 << 1);
efekt jest dalej ten sam. Z Reference Manual korzystam.
Zmieniłem kod konfiguracji GPIO na twój niestety dalej brak sygnałów na SCK

Nie działa bo masz pewnie w dalszej części coś źle poustawiane, do ustawienia portów w F0 nie są potrzebne żadne dodatkowe funkcje - w F1 funkcja przydaje się bo tam jest to kilka % bardziej zawiłe

Tutaj masz od A do Z co i jak https://ep.com.pl/files/11801.pdf

Statystyki: Napisane przez ps19 — 3 kwi 2018, o 10:38

Re: STM32 WS2812 Pomoc

2018-04-03T08:37:54+01:00

lukas12 napisał(a):

Jak widzę powyżej to już jest loteria, strzelanie z działa we wszystkie strony, a nuż się trafi.
Stosujesz jakieś "podwójne" przesunięcia bitowe, ciężko cokolwiek z tego zrozumieć i pewnie dlatego nie możesz trafić, żeby zadziałało

Ustawianie portów to jak wiadomo podstawa podstaw. Należy na początek przygotować sobie funkcje do modyfikacji parametrów.
Najlepiej zacznij od poradnika:
https://www.elektroda.pl/rtvforum/topic3111562.html

W jednym z dodatków tego poradnika są przygotowane odpowiednie funkcje do modyfikacji portów.
Zrób sobie bibliotekę, pobaw się diodami:
Dla stm32f103 mam takie (zaczerpnięte z tego poradnika) funkcje:

[syntax=c]#ifndef LIB_SW_GPIO_GPIO_H_
#define LIB_SW_GPIO_GPIO_H_

#include "stm32f1xx.h"

#define PORTA GPIOA
#define PORTB GPIOB
#define PORTC GPIOC
#define PORTD GPIOD
#define PORTE GPIOE
#define PORTF GPIOF
#define PORTG GPIOG
#define PORTH GPIOH

#defineRTC_PORTA_ENABLED//Ustawione w HALu
#defineRTC_PORTB_ENABLED// Włączone w irmp
#defineRTC_PORTC_ENABLED
//#defineRTC_PORTD_ENABLED
//#defineRTC_PORTE_ENABLED
//#defineRTC_PORTF_ENABLED
//#defineRTC_PORTG_ENABLED

typedef enum {
/* Push-Pull */
gpio_mode_output_PP_2MHz = 2,
gpio_mode_output_PP_10MHz = 1,
gpio_mode_output_PP_50MHz = 3,
/* Open-Drain */
gpio_mode_output_OD_2MHz = 6,
gpio_mode_output_OD_10MHz = 5,
gpio_mode_output_OD_50MHz = 7,
/* Push-Pull */
gpio_mode_alternate_PP_2MHz = 10,
gpio_mode_alternate_PP_10MHz = 9,
gpio_mode_alternate_PP_50MHz = 11,
/* Open-Drain */
gpio_mode_alternate_OD_2MHz = 14,
gpio_mode_alternate_OD_10MHz = 13,
gpio_mode_alternate_OD_50MHz = 15,
/* Analog input (ADC) */
gpio_mode_input_analog = 0,
/* Floating digital input. */
gpio_mode_input_floating = 4,
/* Digital input with pull-up/down (depending on the ODR reg.). */
gpio_mode_input_pull = 8
} T_GPIO_MODE;

typedef enum {
PA0 = 0x00000001,
PA1 = 0x00000002,
PA2 = 0x00000004,
PA3 = 0x00000008,
PA4 = 0x00000010,
PA5 = 0x00000020,
PA6 = 0x00000040,
PA7 = 0x00000080,
PA8 = 0x00000100,
PA9 = 0x00000200,
PA10 = 0x00000400,
PA11 = 0x00000800,
PA12 = 0x00001000,
PA13 = 0x00002000,
PA14 = 0x00004000,
PA15 = 0x00008000,

PB0 = 0x00000001,
PB1 = 0x00000002,
PB2 = 0x00000004,
PB3 = 0x00000008,
PB4 = 0x00000010,
PB5 = 0x00000020,
PB6 = 0x00000040,
PB7 = 0x00000080,
PB8 = 0x00000100,
PB9 = 0x00000200,
PB10 = 0x00000400,
PB11 = 0x00000800,
PB12 = 0x00001000,
PB13 = 0x00002000,
PB14 = 0x00004000,
PB15 = 0x00008000,

PC0 = 0x00000001,
PC1 = 0x00000002,
PC2 = 0x00000004,
PC3 = 0x00000008,
PC4 = 0x00000010,
PC5 = 0x00000020,
PC6 = 0x00000040,
PC7 = 0x00000080,
PC8 = 0x00000100,
PC9 = 0x00000200,
PC10 = 0x00000400,
PC11 = 0x00000800,
PC12 = 0x00001000,
PC13 = 0x00002000,
PC14 = 0x00004000,
PC15 = 0x00008000,

} T_GPIO_PIN;

static inline uint8_t gpio_pin_READ( GPIO_TypeDef * const port, T_GPIO_PIN pin ) {
if ( !(port->IDR & pin) ) return 1;
else return 0;
}

extern void gpio_pin_cfg( GPIO_TypeDef * const port, T_GPIO_PIN pin, T_GPIO_MODE mode );

extern void gpio_pin_LO( GPIO_TypeDef * const port, T_GPIO_PIN pin );
extern void gpio_pin_HI( GPIO_TypeDef * const port, T_GPIO_PIN pin );
extern void gpio_pin_XOR( GPIO_TypeDef * const port, T_GPIO_PIN pin );
extern void RCC_gpio_init( void );

#endif /* LIB_SW_GPIO_GPIO_H_ */[/syntax]

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

void gpio_pin_cfg(GPIO_TypeDef * const port, T_GPIO_PIN pin, T_GPIO_MODE mode) {
pin = __builtin_ctz(pin) * 4;
uint32_t volatile * cr_reg;
uint32_t cr_val;
cr_reg = &port->CRL;
if (pin > 28) {
pin -= 32;
cr_reg = &port->CRH;
}
cr_val = *cr_reg;
cr_val &= ~((uint32_t) (0x0f << pin));
cr_val |= (uint32_t) (mode << pin);
*cr_reg = cr_val;
}

#ifdef NUCLEO_STM32F303RE
void RCC_gpio_init(void) {
// Sprawdź plik nagłówkowy, by odblokowac porty.

#ifdef RTC_PORTA_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOAEN;
#endif
#ifdef RTC_PORTB_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
#endif
#ifdef RTC_PORTC_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOCEN;
#endif
#ifdef RTC_PORTD_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIODEN;
#endif
#ifdef RTC_PORTE_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOEEN;
#endif
#ifdef RTC_PORTF_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOFEN;
#endif
#ifdef RTC_PORTG_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOGEN;
#endif
#ifdef RTC_PORTH_ENABLED
RCC->AHBENR |= RCC_AHBENR_GPIOHEN;
#endif
}
inline void gpio_pin_LO(GPIO_TypeDef * const port, T_GPIO_PIN pin) {
port->BRR = pin;
}
#endif

#ifdef KA_NUCLEO
void RCC_gpio_init( void ) {
// Sprawdź plik nagłówkowy, by odblokowac porty.

#ifdef RTC_PORTA_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
#endif
#ifdef RTC_PORTB_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN;
#endif
#ifdef RTC_PORTC_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN;
#endif
#ifdef RTC_PORTD_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;
#endif
#ifdef RTC_PORTE_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN;
#endif
#ifdef RTC_PORTF_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOFEN;
#endif
#ifdef RTC_PORTG_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOGEN;
#endif
#ifdef RTC_PORTH_ENABLED
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOHEN;
#endif
}
inline void gpio_pin_LO( GPIO_TypeDef * const port, T_GPIO_PIN pin ) {
port->BSRR = pin<<16;
}
#endif

#ifdef STM32F103C8Tx_mini

void RCC_gpio_init(void) {
#ifdef RTC_PORTA_ENABLED
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
#endif
#ifdef RTC_PORTB_ENABLED
RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
#endif
#ifdef RTC_PORTC_ENABLED
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
#endif
}

#endif

inline void gpio_pin_HI(GPIO_TypeDef * const port, T_GPIO_PIN pin) {
port->BSRR = pin;
}
inline void gpio_pin_XOR(GPIO_TypeDef * const port, T_GPIO_PIN pin) {
port->ODR ^= pin;
}[/syntax]

Statystyki: Napisane przez Zealota — 3 kwi 2018, o 08:37

Re: STM32 WS2812 Pomoc

2018-04-02T15:49:26+01:00

Statystyki: Napisane przez lukas12 — 2 kwi 2018, o 15:49

Re: STM32 WS2812 Pomoc

2018-04-02T12:29:00+01:00

Tutaj miałeś namiesane, dalej jeszcze nie sprawdzałem. Dodałem kilka przydatnych definicji.
Przeczytaj str 158 http://www.st.com/content/ccc/resource/ ... 031936.pdf

To masz napisane dlaczego dla m.in MODER masz numer portu*2 (Bits 2y+1:2y)

[syntax=c]//http://www.st.com/content/ccc/resource/technical/document/reference_manual/c2/f8/8a/f2/18/e6/43/96/DM00031936.pdf/files/DM00031936.pdf/jcr:content/translations/en.DM00031936.pdf
#define GPIO_MODER_INPUT 0 //str 158 reference manual
#define GPIO_MODER_OUTPUT 1 //
#define GPIO_MODER_ALTERNATE 2
#define GPIO_MODER_ANALOG 3

#define GPIO_TYPER_PUSHPULL 0 //Nie mnożyć razy 2 !!!
#define GPIO_TYPER_OPEN_DRAIN 1

#define GPIO_OSPEEDR_LOW 0
#define GPIO_OSPEEDR_MEDIUM 1
#define GPIO_OSPEEDR_HIGH 3

#define GPIO_PIN_PULLUP 1// (binarnie (01) ;)
#define GPIO_PIN_PULLDOWN 2 //(binarnie 10)

GPIOC->MODER |= (1 << 8*2); //pin 8 wyjscie

//pin wejścia timera(PA6 ??) podciąganie do dołu
GPIOA->ODR &= ~(1<<6);
GPIOA->PUPDR |= (GPIO_PIN_PULLDOWN << 6*2);

//PB1 wyjscie(Timer3_CH4)
GPIOB->MODER |= (1 << 1*2);

//PA3 wyjscie(Timer2_CH4)
GPIOA->MODER |= (1 << 3*2);

//PB13 wyjscie(SPI2_SCK)
GPIOB->MODER |= (1 << 13*2);

//PB14 wyjscie(SPI2_MISO)
GPIOB->MODER |= (1 << 14*2);
GPIOB->PUPDR |= (GPIO_PIN_PULLDOWN << 14*2);
GPIOB->ODR &= ~(1<<14);

//PB15 wyjscie(SPI2_MOSI)
GPIOB->MODER |= (1 << 15*2);[/syntax]

Statystyki: Napisane przez ps19 — 2 kwi 2018, o 12:29

Re: STM32 WS2812 Pomoc

2018-04-01T22:26:53+01:00

Postanowiłem wykorzystać STM32F072 oraz dopasować kod odpowiednio z elektrody, niestety na żadnym z wyjść nic się nie generuje
[syntax=c]#include "stm32f0xx.h"
#include "stm32f0xx_nucleo.h"

#define LED_NO 10
#define SHIFT_SPEED200

const uint8_t led_buffer[LED_NO * 3 * 2] = {

0x00, 0x20, 0x00, 0x20, 0x0, 0x0, 0x0, 0x0, 0x20, 0x20, 0x05, 0x05, 0x05, 0x20,
0x05, 0x05, 0x05, 0x20, 0x08, 0x05, 0x01, 0x05, 0x08, 0x01, 0x01, 0x0c,
0x06, 0x02, 0x0b, 0x07,

0x03, 0x0a, 0x08, 0x04, 0x09, 0x09, 0x05, 0x08, 0x0a, 0x06, 0x07, 0x0b,
0x07, 0x06, 0x0c, 0x08, 0x05, 0x01, 0x09, 0x01, 0x02, 0x0a, 0x03, 0x03,
0x0b, 0x02, 0x04, 0x0c, 0x04, 0x05 };

int main(void) {

uint16_t counter = SHIFT_SPEED;
uint8_t index = 0;//indeks pierwszego elementu do przetransferowania

RCC->AHBENR |= RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN | RCC_AHBENR_GPIOCEN;//wlaczenie zegara portu A B C

RCC->APB1ENR |= RCC_APB1ENR_TIM3EN | RCC_APB1ENR_TIM2EN;//wlaczenie zegara dla timera 3 i 2

GPIOC->MODER |= 1 << (8 << 1);//pin 8 wyjscie

//pin wejścia timera(PA6 ??) podciąganie do dołu
GPIOA->ODR &= ~GPIO_ODR_6;

//PB1 wyjscie(Timer3_CH4)
GPIOB->MODER |= 1 << (1 << 1);

//PA3 wyjscie(Timer2_CH4)
GPIOA->MODER |= 1 << (3 << 1);

//PB13 wyjscie(SPI2_SCK)
GPIOB->MODER |= 1 << (13 << 1);

//PB14 wyjscie(SPI2_MISO)
GPIOB->MODER |= 1 << (14 << 1);
GPIOB->ODR &= ~GPIO_ODR_14;

//PB15 wyjscie(SPI2_MOSI)
GPIOB->MODER |= 1 << (15 << 1);

// TIM3 jest masterem dla TIM2
TIM3->CR1 = 0;
//CNT_EN jako TRGO
TIM3->CR2 = TIM_CR2_MMS_0;
//Trigger mode, wyzwalanie przez T1FP1
TIM3->SMCR =
TIM_SMCR_TS_0 | TIM_SMCR_TS_2 | TIM_SMCR_SMS_2 | TIM_SMCR_SMS_1;
//Włączenie synchronizacji z timerem podległym
TIM3->SMCR |= TIM_SMCR_MSM;
TIM3->PSC = 17;//jeden tick==375ns
TIM3->ARR = 1;
TIM3->CCR4 = 0;
//Kanał 1 jest wejściem
TIM3->CCMR1 = TIM_CCMR1_CC1S_0;
//PWM 1 na kanale 4
TIM3->CCMR2 = TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4M_1;
//Aktywowanie wejścia (kanał 1) i wyjścia (kanał 4)
TIM3->CCER = TIM_CCER_CC1E | TIM_CCER_CC4E;
//One pulse mode, downcounting
TIM3->CR1 = TIM_CR1_OPM | TIM_CR1_DIR;

//timer 2
TIM2->CR1 = 0;
//Trigger mode z wyzwalaniem przez ITR2 (TIM3)
TIM2->SMCR = TIM_SMCR_TS_1;
TIM2->SMCR |= TIM_SMCR_SMS_2 | TIM_SMCR_SMS_1;
//jeden tick timera 375ns
TIM2->PSC = 17;
TIM2->ARR = 2;
TIM2->CCR4 = 1;
//PWM 1 na kanale 4
TIM2->CCMR2 = TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4M_1;
//Aktywowanie wyjścia kanału 4
TIM2->CCER = TIM_CCER_CC4E;
//One pulse mode, downcounting
TIM2->CR1 = TIM_CR1_OPM | TIM_CR1_DIR;

//DMA dla TX SPI2
RCC->AHBENR |= RCC_AHBENR_DMA1EN;
DMA1_Channel5->CCR = 0;
DMA1_Channel5->CNDTR = LED_NO * 3;
DMA1_Channel5->CPAR = (uint32_t) &SPI2->DR;
DMA1_Channel5->CMAR = (uint32_t) led_buffer;
DMA1_Channel5->CCR = DMA_CCR_DIR | DMA_CCR_MINC | DMA_CCR_EN;
//skasowanie flagi transmision complete
DMA1->IFCR = DMA_IFCR_CTCIF5;

RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;
//preskaler 32: 812.5kHz, próbkowanie na drugim zboczu
SPI2->CR1 = SPI_CR1_MSTR | SPI_CR1_BR_2 | SPI_CR1_CPHA;
SPI2->CR2 = SPI_CR2_SSOE;
SPI2->CR1 |= SPI_CR1_SPE;

volatile uint32_t delay;

while (1) {
SPI2->CR2 |= SPI_CR2_TXDMAEN;

//czekaj na przetransferowanie wszystkich danych...
while (!(DMA1->ISR & DMA_ISR_TCIF5))
;
//...skasuj flagę transmision complete...
DMA1->IFCR = DMA_IFCR_CTCIF5;
//...i wyłącz generowanie żądań DMA od SPI
SPI2->CR2 &= ~SPI_CR2_TXDMAEN;

//przygotuj DMA do następnej transmisji
DMA1_Channel5->CCR &= ~DMA_CCR_EN;
DMA1_Channel5->CNDTR = LED_NO * 3;
DMA1_Channel5->CMAR = (uint32_t) &led_buffer[index];
DMA1_Channel5->CCR |= DMA_CCR_EN;

//czekaj na opróżnienie rejestru DR
while (!(SPI2->SR & SPI_SR_TXE))
;
//czekaj na zakończenie transmisji przez SPI
while ((SPI2->SR & SPI_SR_BSY))
;

//poczekaj na reset ledów ws2812
//DWT_Delay_us(50);
for (delay = 34; delay; delay--) {
};

//prostacka animacja
if (!--counter) {
if (index < ((LED_NO - 1) * 3))
index += 3;
else
index = 0;

counter = SHIFT_SPEED;
}
//GPIOC->ODR |= GPIO_ODR_8;
//for(delay = 100000; delay; delay--){};
//GPIOC->ODR &= ~GPIO_ODR_8;
//for(delay = 100000; delay; delay--){};
} /* while(1) */

}[/syntax]

Statystyki: Napisane przez lukas12 — 1 kwi 2018, o 22:26

Re: STM32 WS2812 Pomoc

2018-03-31T20:43:24+01:00

topic18998.html#p193413
W tym miejscu znajdziesz dokumentację którą ściąga STM32Cube w czasie kompilacji Może w niej znajdziesz to czego szukasz. Polecam jeszcze kurs na FORBOT odnośnie STM32.

Statystyki: Napisane przez dario — 31 mar 2018, o 20:43

Re: STM32 WS2812 Pomoc

2018-03-31T20:01:09+01:00

https://www.elektroda.pl/rtvforum/viewt ... highlight=
Znajdziesz kompletne, nieblokujące sterowanie wykorzystujące SPI DMA oraz zewnętrzne bramki nand, które będą służyły m.in. jako dopasowanie poziomu napięć.

Statystyki: Napisane przez Zealota — 31 mar 2018, o 20:01

Re: STM32 WS2812 Pomoc

2018-03-31T17:24:58+01:00

W EP może coś znajdziesz:
https://ep.com.pl/artykuly/9736-_bity_jak_najprosciej_cz_STMF_plytka_eksperymentalna_z_mikrokontrolerem_STMFF.html

Statystyki: Napisane przez krish — 31 mar 2018, o 17:24

STM32 WS2812 Pomoc

2018-03-31T16:58:15+01:00

Witam, od dłuższego czasu próbuje bezskutecznie sterować diodami WS2812, przykłady na AVR zawszę sięgają ze wstawek Asemblera.
Posiadam STM32F070, moim problemem jest to że potrzebuję pomocy jak za pośrednictwem DMA sterować wyjściem na pinie. Przy pomiarze ADC użycie DMA jest proste, jednak jak to zrobić żebym miał na wyjściu przebiegi o długości 400 ns i 800 ns ?
Po skorzystaniu z biblioteki z http://www.martinhubacek.cz/arm/improve ... 2b-library udało mi się na taśmie zapalić jedną diodę. Jednak implementacja do zapalenia całości jest zbyt trudna.
Znalazłem jeszcze sposób z https://www.bitcraze.io/2014/04/neopixe ... ies-stm32/ - jednak bardzo trudno jest zaimplementować do aktualnej biblioteki HAL.

Czy ktoś może przerabiał temat i byłby w stanie mi w jakikolwiek sposób pomóc ?
Z góry dziękuję.

Statystyki: Napisane przez lukas12 — 31 mar 2018, o 16:58