ATNEL tech-forum 2015-02-05T08:34:29+01:00 https://forum.atnel.pl/feed.php?f=4&t=10508&mode 2015-02-05T08:34:29+01:00 2015-02-05T08:34:29+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117306#p117306 <![CDATA[Re: Nieblokująca obsługa DS18B20 z CRC]]> QuadMan napisał(a):

Witam,
Nie bardzo zrozumiałem, który w końcu kod działa Ci poprawnie ? Ten z delay-ami, czy ten na przerwaniach powyżej?


Kod z delay'ami w ogóle nie jest brany pod uwagę. Kod zamieszczony przeze mnie jest przerobioną wersją oryginalnego kodu, który wysyła 2 komendy w paczce 16 bitów. Chciałem aby mój wysyłał komendy po 8 bitów, ponieważ wydaje mi się, że prościej byłoby mi później odbierać 1 bajt scratchpada do elementu 0 tablicy, zmienić indeks i wpisać kolejny bajt, itd.
Ilość bitów jest ściśle uzależniona od liczników.
QuadMan napisał(a):

Jak często masz te przerwania, na których Ci zależy ? Bo 1Wire ma taką cechę, że pomiędzy poszczególnymi bitami ( nadawanymi czy odbieranymi ) może być czas dowolnie długi, co do Resetu to też nie jest tak, że musi być dokładnie 480 us - krytyczny jest tylko ten czas oczekiwania na "presence"

Przerwanie generowane jest z częstotliwością 8kHz czyli 125us, w inne funkcje wykonujące się w przerwaniu nie wnikam.


squeez napisał(a):

Jak koledzy wspomnieli, wykorzystanie UART mogło by pomóc ale skoro nie wchodzą żadne zmiany sprzętowe hmm ... ale może da się jedną przemycić :)

Niestety, żadnych tego typu zmian. Tylko operacje na kodzie. :(

Statystyki: Napisane przez xpower — 5 lut 2015, o 08:34

]]> 2015-02-05T01:34:30+01:00 2015-02-05T01:34:30+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117293#p117293 <![CDATA[Re: Nieblokująca obsługa DS18B20 z CRC]]> Nie bardzo zrozumiałem, który w końcu kod działa Ci poprawnie ? Ten z delay-ami, czy ten na przerwaniach powyżej?

Jak często masz te przerwania, na których Ci zależy ? Bo 1Wire ma taką cechę, że pomiędzy poszczególnymi bitami ( nadawanymi czy odbieranymi ) może być czas dowolnie długi, co do Resetu to też nie jest tak, że musi być dokładnie 480 us - krytyczny jest tylko ten czas oczekiwania na "presence" po zmianie stanu magistrali na High tu wystarczy cli () na środek tego czasu, czyli na 60us. Kiedyś robiłem taką sztukę, że musiałem obsługiwać dość krytyczne czasowo przerwania - nie mogłem sobie pozwolić nawet na te ok 60us delay-a, ale one występowały rzadko ( co kilka ms ), więc kolejne bajty 1Wire odbierałem dopiero po zakończeniu obsługi tego krytycznego przerwania.
Trochę to chaotycznie wyszło, nie wiem czy coś z tego ktoś zrozumiał :-(.

Pozdrawiam, QuadMan.

P.S. W AVR- ach i tak nie masz priorytetów przerwań, więc nawet rozwiązanie z "licznikiem programowym" nie będzie działało pewnie - no chyba, że obsługa tych istotnych przerwań jest przynajmniej nieco krótsza niż minimalny dopuszczalny błąd pomiaru czasu tym "licznikiem programowym".

Pozdrawiam serdecznie, QuadMan.

Statystyki: Napisane przez QuadMan — 5 lut 2015, o 01:34

]]> 2015-02-05T00:10:16+01:00 2015-02-05T00:10:16+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117289#p117289 <![CDATA[Re: Nieblokująca obsługa DS18B20 z CRC]]> Poza tym oryginalny kod, po zmianie typów zmiennych na bardziej przyjazne dla AVR, działa dobrze.

Statystyki: Napisane przez xpower — 5 lut 2015, o 00:10

]]> 2015-02-04T23:57:44+01:00 2015-02-04T23:57:44+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117288#p117288 <![CDATA[Re: Nieblokująca obsługa DS18B20 z CRC]]> opoznienie jako zmieniana w przerwaniu powinna być volatile, a skoro jest 2 bajtowa, a procesor 8-bitowy to może się zdarzyć, że podczas, gdy jeden bajt jest sprawdzany to drugi się zmieni. Operacje na tej zmiennej w pętli głównej programu należy umieścić pomiędzy ATOMIC_BLOCK(ATOMIC_FORCEON)

Statystyki: Napisane przez Krauser — 4 lut 2015, o 23:57

]]> 2015-02-04T23:51:47+01:00 2015-02-04T23:51:47+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117287#p117287 <![CDATA[Re: Nieblokująca obsługa DS18B20 z CRC]]>
Dokładnie, wszystkie biblioteki jakie widziałem opierają się na delay'ach, o których tu nie może być mowy. Według datasheeta, sama operacja resetu to już w tym wypadku prawie czas 4 przerwań.
W przerwaniu wykonywane są też inne funkcje i prawdopodobnie to powoduje błędy - jakieś minimalne rozjazdy czasowe, przez które 1wire głupieje. Pomiar temp. nie jest priorytetem, temp musi być poprawna ale uaktualnienie może następować co np. 2-5 sekund.

Statystyki: Napisane przez xpower — 4 lut 2015, o 23:51

]]> 2015-02-04T23:18:01+01:00 2015-02-04T23:18:01+01:00 https://forum.atnel.pl/viewtopic.php?t=10508&p=117280#p117280 <![CDATA[Nieblokująca obsługa DS18B20 z CRC]]>
Musze przerobić obsługę czujnika DS18B20 w taki sposób, aby zamiast 2 pierwszych bajtów z temp., otrzymywać pełen scratchpad oraz na jego bazie obliczać CRC. Wszystko byłoby fajnie... gdyby nie to, że obsługa czujnika musi być nieblokująca. :(
Oryginalny kod opiera się na wysyłaniu komend w formie 16-to bitowych instrukcji i w 90% działa (w 90% dlatego bo zdarzają się momenty, kiedy wartość temp skacze do losowej liczby np. 120, 300, itd. a za chwilę wszystko znowu jest ok).
Stąd pomysł na crc i obsługę w stylu "gdy pomiar się zgadza, przesyłam wartości temperatury do dalszej obróbki".
Swój kod chciałem oprzeć o oryginalny mechanizm działania, ale z instrukcjami 8-mio bitowymi. Czemu - chciałem zliczać tylko 8 bitów zarówno przy wysyłaniu jak i odbiorze, w tym drugim przypadku chyba szybciej upchnąłbym 9 bajtów w tablice, a później wywołał funkcję od CRC.
Stworzyłem kod zawarty poniżej... ale mówiąc krótko... nie działa i nie wiem dlaczego.

Co robię źle, ew. w jaki inny sposób się za to zabrać ?

PS. kod wersji mocno roboczej, komentarze mogą się nie zgadzać.
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#include "uart.h"
#include "MK_TERMINAL/mk_term.h"

#define OW_PIN PC4
#define OW_IN PINC
#define OW_OUT PORTC
#define OW_DDR DDRC

#define ONEWIRE_DIR_OUT ( OW_DDR |= (1 << OW_PIN) )
#defineONEWIRE_SET( OW_OUT |= (1<<OW_PIN) )
#define ONEWIRE_CLR( OW_OUT &= ~(1<<OW_PIN) )

#define ONEWIRE_DIR_IN ( OW_DDR &= (~(1 << OW_PIN )) )
#defineONEWIRE_READ( OW_IN & (1<<OW_PIN))


volatile uint16_t Timer1, Timer2;
uint8_t czujniki_cnt, subzero, cel, cel_fract_bits;//zmienne do obsługi komendy pomiaru z czujników
uint8_t temp, test_crc, error;//zmienne pomocnicze
uint32_t temp2;

uint16_t opoznienie;
uint8_t cykl, licz, cykl_parzysty = 0;
uint16_t dane, temperatura;
uint16_t i;
uint8_t tablica[9];//tablica scratchpad
uint8_t licznik = 0;

void obsluga_oneWire_1(void);
void obsluga_oneWire_2(void);
void obsluga_oneWire_3(void);

//==================================================================
//TABLICA Z WARTOŚCIAMI CRC
//==================================================================
const uint8_t crc8_table[256] = {
0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53
};


//==================================================================
//FUNKCJA MAIN
//==================================================================
int main(void)
{

/** USTAWIENIA TIMERA SPRZĘTOWEGO **/

TCCR0 |= (1<<WGM01); // tryb CTC
TCCR0 |= (1<<CS01); // preskaler = 8
OCR0 = 250; // dodatkowy podział przez 250 (rej. przepełnienia) 8kHz, 125us
TIMSK |= (1<<OCIE0); // zezwolenie na przerwanie CompareMatch


uart_init(__UBRR);//init uart i ustawienie prędkosci

_delay_ms(500);
tr_cls(0);
tr_cls(1);
//tr_cursor_hide(1);
tr_locate(0,10);
tr_attr(1,YELLOW,BLACK);
uart_sends("..:: TEST DS18B20 i OBLICZANIA CRC ::..");

sei();//odblokowanie przerwań
while(1)
{

// wyświetlanie wartości w terminalu
tr_locate(2,10);
tr_attr(1,YELLOW,BLACK);
uart_sends("Temp0: ");
uart_putint(tablica[0],10);
uart_sends("\u00B0C");

tr_locate(3,10);

tr_attr(1,YELLOW,BLACK);
uart_sends("Temp1: ");
uart_putint(tablica[1],10);
uart_sends("\u00B0C");

temperatura = ( tablica[0] + (tablica[1] >> 8 ) ) / 16;
tr_locate(4,10);
uart_putint(temperatura, 10);
uart_sends(" ");
}
}

ISR( TIMER0_COMP_vect )//przerwanie od timera0
{

i = opoznienie;
if (i) opoznienie = --i;

obsluga_oneWire_1();
obsluga_oneWire_2();
obsluga_oneWire_3();
}


//==================================================================
//FUNKCJA REALIZUJĄCA ALGORYTM SPRAWDZANIA CRC
//==================================================================
unsigned char get_crc(unsigned char *data, unsigned char count)
{
unsigned char result=0;

while(count--)
{
result = crc8_table[result ^ *data++];
}

return result;
}


//==================================================================
//FUNKCJE NIEBLOKUJĄCE OBSŁUGUJĄCE 1WIRE
//==================================================================
// obsluga_oneWire została podzielona na 3 fragmenty wywoływane w różnych momentach timer_interrupt
void obsluga_oneWire_1(void)// wywoływane na początku przerwania; co 125us; daje to czas trwania bitu = 250us
{

if (++cykl_parzysty & 1)
{
if ((cykl==2) || (cykl==5) )
{
ONEWIRE_DIR_OUT;
ONEWIRE_SET;// jezeli jeden z warunków spełniony, koniec trwania bitu
}
return;
}

switch (cykl)
{
case(0):// początek reset
{
if (!opoznienie) // czy minęło 500us czas trwania przerwy przed kolejnym resetem
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;
opoznienie = 1880;// czas trwania reset; 250ms
cykl=1;
}
} break;
// trwa reset
case(1):// koniec reset
{
if (!opoznienie) // czy minęło 250ms - czas trwania reset
{
ONEWIRE_DIR_OUT;
ONEWIRE_SET;
opoznienie = 4;// 500us czas trwania przerwy; w tym czasie po 32us DS18B20 wystawia impuls PRESENCE na 120us
cykl = 2;
licz = 0;
dane = 0xCC;//w wersji oryginalnej występuje tu komenda 0x44CC,
}
} break;


case(2):
{
if (!opoznienie) // czy minęło 250ms - czas trwania reset
{
if(licz < 8)
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;// początek nadawania bitu
}
else
{
cykl = 3;
licznik = 0;
dane = 0x44;//kolejna komenda do wysłania, w wersji oryginalnej tego nie ma
opoznienie = 4;// w oryginale 6000, co przy przerwaniu 125 us daje 750ms czasu oczekiwania na pomiar
}
}
}
break;

// przerwa po reset
case(3):// wysyłanie rozkazów
{
if (!opoznienie) // czy minęło 500us czas trwania przerwy
{
if(licznik < 8)
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;// początek nadawania bitu
}
else// wysłane wszystkie 16 bitów
{
cykl = 4;
licznik = 0;
opoznienie = 6000;// 750ms czas trwania pomiaru temperatury; to jest tez czas zgaszenia LED STATUS
}
}
} break;
// trwa pomiar temperatury
case(4):
{
if (!opoznienie) // czy minęło 750ms czas trwania pomiaru temperatury
{// początek reset
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;
opoznienie = 4;// 500us czas trwania reset
cykl=5;
}
} break;
// trwa reset
case(5):// koniec reset
{
if (!opoznienie) // czy minęło 500us - czas trwania reset
{
ONEWIRE_DIR_OUT;
ONEWIRE_SET;
opoznienie = 4;// 500us czas trwania przerwy
cykl = 6;
licznik = 0;
dane = 0xCC;// CC:Skip ROM, address all devices; BE:Read scratchpad
}
} break;
// przerwa po reset

case(6):// wysyłanie rozkazów
{
if (!opoznienie) // czy minęło 500us czas trwania przerwy
{
if(licznik < 8)
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;// początek nadawania bitu
}
else// wysłane wszystkie 16 bitów
{
cykl = 7;
licznik = 0;
dane = 0xBE;
opoznienie = 4;// 500us czas trwania przerwy przed odczytaniem danych; nadmiarowe
}
}
} break;

case(7):// wysyłanie rozkazów
{
if (!opoznienie) // czy minęło 500us czas trwania przerwy
{
if(licznik < 8)
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;// początek nadawania bitu
}
else// wysłane wszystkie 16 bitów
{
cykl = 8;
licznik = 0;
opoznienie = 4;// 500us czas trwania przerwy przed odczytaniem danych; nadmiarowe
dane = 0;// teraz tu będę odbierał dane
}
}
} break;


case(8):// odczytanie temperatury
{
if ((!opoznienie) && // czy minęło 500us czas trwania przerwy przed odczytaniem danych; nadmiarowe
(licznik < 8) )
{
ONEWIRE_DIR_OUT;
ONEWIRE_CLR;// początek odbierania bitu
}

} break;

}// switch

}





void obsluga_oneWire_2(void)// wywoływane po około 2us po obsluga_oneWire_1()
{

if (cykl_parzysty & 1) return;

if ( ( (cykl==2) || (cykl==3) || (cykl==6) || (cykl==7) ) &&// wysyłanie rozkazów
// @2: CC:Skip ROM, address all devices; 44:Start temperature conversion
// @5: CC:Skip ROM, address all devices; BE:Read scratchpad
(!opoznienie) &&// czy minęło 500us czas trwania przerwy
(licznik < 8))// czy wszystkie bity
{
if (dane & 1)
{
ONEWIRE_DIR_OUT;
ONEWIRE_SET;// wysyłaj bit=1
}

dane >>=1;
licznik++;

}

else if ((cykl==8) && (!opoznienie) && (licznik < 8))
{
ONEWIRE_DIR_OUT;
ONEWIRE_SET;// początek odbierania bitu - pozwalam aby DS18B20 nadawał
}

}



void obsluga_oneWire_3(void)// wywoływane po około 11us po obsluga_oneWire_2()
{

if (cykl_parzysty & 1) return;

if ((cykl==8) && (!opoznienie)) // czy minęło 500us czas trwania przerwy
{
if(licznik > 8)
{
ONEWIRE_DIR_IN;
tablica[1] >>= 1;
if (ONEWIRE_READ) tablica[1] |= 0x80;
licznik++;
}

if(licznik < 8)
{
ONEWIRE_DIR_IN;
tablica[0] >>= 1;
if (ONEWIRE_READ) tablica[0] |= 0x80;
licznik++;
}
else // odebrane wszystkie bityw
{
cykl = 0;
licz = 0;
opoznienie = 4;// 500us czas trwania przerwy przed kolejnym resetem
}
}
}[/syntax]

Statystyki: Napisane przez xpower — 4 lut 2015, o 23:18

]]>