ATNEL tech-forum

Re: 1-wire sterowane sprzętowo przez USART

2018-01-03T00:27:22+01:00

StaryAnoda napisał(a):

Ok to tak nie wiem czy powinienem się chwalić tym programem ale macie
Wiadomo ta pętla (for(volatile uint32_t I = 0; I != 1000000; I++){}
) zastępuję opóźnienie około 750 ms.

Domyślnie w większości przykładów czy bibliotek do STM Systick sobie tyka sobie co 1 ms.
Proste kopiuj wklej z Bluebooka obsługi soft timerów i problem rozwiązany, choćby tak:
[syntax=c]void HAL_SYSTICK_Callback( void ) {
sk_encoder_proc(); // Funkcja od Sylwka

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

n = softTimer2;
if (n) softTimer2 = --n;
}

int main (void) {
if (softTimer1 == 0) {
softTimer1 = 750;
}[/syntax]

Piszę to głównie po to by wskazać jak łatwo można łączyć światy AVR z STM.
Jak czerpać wiedzę z KolorBooków i bezpośrednio używać jej do np STM32.
Do takiego kodu dorzucamy jeszcze obsługę enkodera od Sylwka i już połowa projektu załatwiona.
To takie noworoczne przemyślenia, poza tematem ale czasami warto zatrzymać się przy refleksji...
Wszystkiego najlepszego w Nowym Roku

Statystyki: Napisane przez Zealota — 3 sty 2018, o 00:27

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T16:40:16+01:00

Ok to tak nie wiem czy powinienem się chwalić tym programem ale macie
Wiadomo ta pętla (for(volatile uint32_t I = 0; I != 1000000; I++){}
) zastępuję opóźnienie około 750 ms. Wiadomo w wersji finalnej trzeba to zastąpić timerem

Kod do odczytu temperatury z DS18B20:

[syntax=c]/*
*
* StaryAnoda
*
*/
#include
#include

void Send_Data(uint8_t Byte);
uint8_t One_Wire_Reset(void);
void Send_Byte(uint8_t Value);
uint8_t Read_Byte(void);
uint8_t Read_Bit(void);

uint8_t Byte_0;
uint8_t Byte_1;
uint16_t Temp_Int;
float Temperature;

int main(void)
{
RCC -> AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
RCC -> APB1ENR |= RCC_APB1ENR_USART2EN;

__DSB();

// Config for TX
GPIOA -> MODER |= GPIO_MODER_MODER2_1;
GPIOA -> AFR[0] |= 0b011100000000;

// Config for RX
GPIOA -> MODER |= GPIO_MODER_MODER3_1;
GPIOA -> OTYPER |= GPIO_OTYPER_OT_3;
GPIOA -> AFR[0] |= 0b0111000000000000;
//
USART2->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE;

while(1)
{
if(One_Wire_Reset())
{
Send_Byte(0xCC);
Send_Byte(0x44);

for(volatile uint32_t I = 0; I != 1000000; I++){}

if(One_Wire_Reset())
{
Send_Byte(0xCC);
Send_Byte(0xBE);

Byte_0 = Read_Byte();
Byte_1 = Read_Byte();

Temp_Int = (uint16_t)(Byte_0 | (Byte_1 << 8));

if(Byte_1 & 0b11111000)
{
Temp_Int = ~Temp_Int;
Temp_Int = Temp_Int ++;
Temperature = (float)(Temp_Int * -0.0625);
}
else
{
Temperature = (float)(Temp_Int * 0.0625);
}
}
}
}
return EXIT_SUCCESS;
}

void Send_Data(uint8_t Byte)
{
while(!(USART2 -> SR & USART_SR_TXE));
USART2 -> DR = Byte;
}

uint8_t One_Wire_Reset(void)
{
uint8_t receive = 0, results = 0;
USART2 -> BRR = (16000000/9600);

Send_Data(0xF0);

while(!(USART2 -> SR & USART_SR_RXNE));

receive = USART2 -> DR;
if(receive != 0xF0)
{
results = 1;
}
else
{
results = 0;
}
USART2 -> BRR = (16000000/115200);
return results;
}

void Send_Byte(uint8_t Value)
{
uint16_t i,tmp, receive;
for (i = 0; i < 8; i++)
{
tmp = Value >> i;
tmp &= 0x01;
if(tmp)
{
Send_Data(0xFF);
}
else
{
Send_Data(0x00);
}
while(!(USART2 -> SR & USART_SR_RXNE));
receive = USART2 -> DR;
}
}

uint8_t Read_Byte(void)
{
uint8_t i,value=0;
for (i = 0; i < 8; i++)
{
if(Read_Bit())
value |= 0x01 << i;
}
return value;
}

uint8_t Read_Bit(void)
{
uint8_t receive = 0;
uint16_t data = 0;
Send_Data(0xFF);

while(!(USART2 -> SR & USART_SR_RXNE));
data = USART2 -> DR;

if(data == 255)
{
receive = 1;
}
else
{
receive = 0;
}
return receive;
}

//! @}
//! @}[/syntax]

W niedalekiej przyszłości zaprezentuję kod już bardziej strawny. Jednak wydaję mi się, że po tym co zamieścilem idea jest już zrozumiała

Wada jest taka że po odłączeniu i podłączeniu czujnika będzie ciągle wskazywał -0.0 do ponownego zresetowania programu

Statystyki: Napisane przez StaryAnoda — 2 sty 2018, o 16:40

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T15:06:31+01:00

StaryAnoda napisał(a):

Jeżeli jesteś chętny to mogę wrzucić przykład dla STM32F411CE jak uporządkuję kod.

Oczywiście jeśli będziesz miał możliwość, to chętnie

Nefarious19 napisał(a):

Ja zrobiłem na delayach biblioteke pod F103. Trzeba dożycia powołać timer co tyka co 5us i wywoływać w nim funkcje delaydecrement. Działa ok. Też chcę to przeportowac pod uart.

To również nie jest zła opcja. Będę próbował podobnie Dzięki!

Statystyki: Napisane przez mikandrzej — 2 sty 2018, o 15:06

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T10:48:48+01:00

Ja zrobiłem na delayach biblioteke pod F103. Trzeba dożycia powołać timer co tyka co 5us i wywoływać w nim funkcje delaydecrement. Działa ok. Też chcę to przeportowac pod uart.

Statystyki: Napisane przez Nefarious19 — 2 sty 2018, o 10:48

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T08:04:02+01:00

Jeżeli jesteś chętny to mogę wrzucić przykład dla STM32F411CE jak uporządkuję kod.

Statystyki: Napisane przez StaryAnoda — 2 sty 2018, o 08:04

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T01:15:42+01:00

anshar napisał(a):

https://cnnblike.com/post/stm32-OneWire/

Dziękuję! Wygląda to nieźle Jutro przetestuję.

Statystyki: Napisane przez mikandrzej — 2 sty 2018, o 01:15

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T00:50:46+01:00

https://cnnblike.com/post/stm32-OneWire/

Statystyki: Napisane przez anshar — 2 sty 2018, o 00:50

Re: 1-wire sterowane sprzętowo przez USART

2018-01-02T00:33:23+01:00

Z tego co widzę, to w tym artykule jest opisane jak używać timera do tego celu, nie UART. Też jest to jakaś opcja, ale wolałbym wersje z UARTEM

Dzięki

Wysłane z mojego Redmi Note 4 przy użyciu Tapatalka

Statystyki: Napisane przez mikandrzej — 2 sty 2018, o 00:33

1-wire sterowane sprzętowo przez USART

2018-01-01T22:50:02+01:00

Witam.

Natknąłem się na możliwość dogadywania się m.in. z czujnikami temperatury DS18B20 przez magistralę 1Wire sterowaną sprzętowo przez UART. Do poszukiwać natchnęła mnie wypowiedź z elektrody:

Freddie Chopin napisał(a):

Zrób 1-wire na UARTcie, robienie tego inaczej jest zupełnie bezsensowne.

4\/3!!

Do tego znalazłem poradę od producenta:

"TUTORIAL 214
Using a UART to Implement a 1-Wire Bus Master"
https://www.maximintegrated.com/en/app-notes/index.mvp/id/214

Czy ma ktoś z tym jakieś doświadczenie? Być może jakieś kody/przykłady?
Oczywiście jeśli nie, to sam będę odkrywał koło na nowo, aczkolwiek być może z Waszą pomocą nie będzie to konieczne:)

Statystyki: Napisane przez mikandrzej — 1 sty 2018, o 22:50