ATNEL tech-forum

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-06-10T12:03:38+01:00

Wywołuję crc16_update(checksum, bajt[i]) w nadajniku, wysyłam razem z pakietem tę sumę kontrolną (wyliczoną dla 16 wysyłanych bajtów danych).
W odbiorniku na odebranych danych wywołuję crc16_update(checksum, bajt[i]) dla 16 bajtów danych. Porównuję wyliczoną sumę kontrolną z przechwyconą w pakiecie - jest różnica. Zawsze w 60. pakiecie.

Chyba będę musiał potestować i popatrzeć co do bitu jak te dwie sumy kontrolne wyglądają.

[syntax=c]void sendPacket(int seq)
{
uint8_t TxBytes[18]; //16B+CRC16
uint16_t checksum = 0; //CRC

//tworzenie danych
//2 bajty - numer pakietu
TxBytes[0] = seq/256; //HIGH
TxBytes[1] = seq%256; //LOW

//losowe dane = 14 bajtow
for(uint8_t i = 0; i < 14; i++)
TxBytes[i+2] = rand();

//2B CRC
for (uint8_t i = 0; i < 16; i++)
checksum = _crc16_update(checksum, TxBytes[i]);

TxBytes[16] = (checksum >> 8); //HIGH
TxBytes[17] = checksum; //LOW

_LEDOn;
synchronize();
startSequence();
for (uint8_t i = 0; i < 18; i++)
sendByte(TxBytes[i]);

_outputHigh;
_delay_us(_releaseDelay);
_LEDOff;
}[/syntax]
[syntax=c]volatile uint8_t _RxFlag;
uint8_t _RxBuffer[_bufferSize]; //18

static uint16_t correctCount;

void Listen(void)
{
if(_RxFlag)
{
uint16_t checksum = 0; //CRC

for (uint8_t i = 0; i < 16; i++)
checksum = _crc16_update(checksum, _RxBuffer[i]);

if (((checksum >> 8) & _RxBuffer[16]) && (checksum & _RxBuffer[17]))
correctCount++;

uint16_t lastRx = (_RxBuffer[0] << 8) | (_RxBuffer[1]);

...
_RxFlag = 0;
}
}[/syntax]

Kod umieszczamy w syntax=c - Zielony J.

Statystyki: Napisane przez BioZ — 10 cze 2013, o 12:03

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-06-10T11:59:51+01:00

Jeśli chodzi o to co piszesz z CRC to sorki ale w ogóle nie zrozumiałem co chciałeś przekazać

że crc źle działa ? czy jak ? .... przecież to niemożliwe - crc działa zawsze dobrze - no chyba że chodziło o coś innego

Statystyki: Napisane przez mirekk36 — 10 cze 2013, o 11:59

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-06-10T12:00:50+01:00

Hej,

wielkie dzięki za wskazówki. Udało się dojść do dobrej formy. FYI, czterobitowa preambuła okazała się być wystarczającą.
Widzę jeszcze jedną rzecz, już niezwiązaną z częścią opartą na książce, mianowicie z obliczaniem sumy kontrolnej.
Obserwując w odbiorniku stopę błędów oraz liczbę odebranych i poprawnie odebranych pakietów, widzę, że zawsze w tych samych momentach następuje błąd - ewidentnie nie jest on losowym wynikającym z przekłamań transmisji. Dla funkcji crc16_update() różne CRC jest wyliczone na przykład dla 60. pakietu (dalej nie analizuję). Dla crc_ccitt_update() dla około setnego. W teorii tak być nie powinno, wszak zgodnie z sygnaturą sumę kontrolną przechowuję w zmiennej 16b, a dane wejściowe są 8b...?

Pozdrawiam.

Statystyki: Napisane przez BioZ — 10 cze 2013, o 11:48

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-04-29T15:48:39+01:00

Ale posłuchaj - ja w książce pokazałem przykład. To nie oznacza, że każdy w każdym przypadku MUSI robić tak samo - jak piszesz o tej sekwencji startowej.....

Moim celem było to aby ktoś kto czyta zrozumiał jaką drogą do analizy problemu ja podszedłem i na tej podstawie spokojnie zrobił ze zrozumieniem i poradził sobie dalej ....

Myślę, że kod nadajnika jest o wiele prostszy i tu pewnie nie masz najmniejszego kłopotu ze zrozumieniem. Za to powinieneś sobie jak już masz oscyl sprawdzić np ile bitów preambuły potrzebujesz - może mniej niż w przykładach z tymi kompletami która ja wykorzystywałem - może mniej ? ... przecież tu też pisałem że to wyraźnie zależy od sprzętu który się posiada.

Możesz zatem zacząć próby wprost od przesyłania jakichś krótkich sekwencji po kilka bitów aby tylko próbować je wyłapać w kodzie odbiornika ....

z drugiej zaś strony - jak widzę w kodzie:

#define F_CPU xxxxxx to już się domyślam że po pierwsze kompilujesz i piszesz kod być może w AVR Studio a jeśli jesteś początkujący (tego nie wiem ale tak tylko się domyślam po takich wpisach) ... to nawet nie wiesz ile jeszcze innych pułapek czeka na ciebie w tym AVR Studio. Więc jak najszybciej przejdź na Eclipse a z kodów WYWAL w diabły te definicje #define F_CPU ma ich w ogóle nie być w kodzie .... bo jak na końcu się okaże że masz jakiś czeski błąd np przez źle działające delaje to potem sam sobie w brodę będziesz pluł i może w końcu doczytasz i zrozumiesz że w kodzie się tego nie robi.

Można jednak być mądrzejszym PRZED szkodą, i posłuchać takiej porady i od razu tego nie wpisywać - a jeśli coś nie wychodzi to dopytać jak sobie poradzić.

Ale generalnie widok z oscyla napawa nadzieję, że już niedużo ci brakuje do odpalenia tego z powodzeniem

Dokładnie niedawno na tym forum ktoś na podstawie tej książki odpalał na jeszcze innych modułach komunikację i miał podobny kłopot na początku - i się załamywał - a później sam zobaczył, że bez wgryzienia się w szczegóły ciężko to odpalić ... tyle że te szczegóły nie są takie trudne ... dlatego polecam dobrze przeanalizować co ma się dziać w przerwaniu ICP

a podstawy tego masz także opisane dobrze i szczegółowo w pierwszej niebieskiej książce przy dekodowaniu RC5

Statystyki: Napisane przez mirekk36 — 29 kwi 2013, o 15:48

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-04-29T15:21:37+01:00

Hej,

dzisiaj dostałem się do oscyloskopu i niżej załączam zdjęcie (zmniejszyłem też liczbę sekwencji fazującej do 4, wystarczy dla tych modułów). Przebieg wygląda zgodnie z oczekiwaniami, tak samo przy nadajniku jak i przy odbiorniku.
Zauważyłem, że w "Pasji programowania" pierwszy bit sekwencji startowej jest 0. Teoretycznie sam mogę problem zignorować robiąc podobnie, choć jak zbiorę siły to jutro będę na nowo analizował. Chciałbym mieć jasno w głowie na temat tego, co się tam dzieje.

Pozdrawiam.

Statystyki: Napisane przez BioZ — 29 kwi 2013, o 15:21

Re: [ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433

2013-04-29T06:52:04+01:00

Masz dostęp gdzieś do oscyloskopu ? Warto byłoby sprawdzić jak to się na nim przedstawia - czyli jak wygląda ramka nadawana i odebrana

Statystyki: Napisane przez mirekk36 — 29 kwi 2013, o 06:52

[ATmega128/C] HM-R i HM-T, transmisja bezprzewodowa (433MHz)

2013-04-29T00:28:16+01:00

Witam,

czy ma ktoś z Was doświadczenie w obsłudze układów HM-R i HM-T (433MHz) od HopeRF? Próbuję je zmusić do gadania, ale brak dokumentacji u producenta sprawy nie ułatwia...
W swojej aplikacji wykorzystałem przykład z "Pasji programowania" Mirosława Kardasia (rozdział 2.) jako bazę.
Wykorzystuję 2 płytki ZL8AVR z mikrokontrolerami ATmega128.

Jestem na etapie, w którym transmisja dwóch bajtów (sekwencja startowa i bit znaku) przebiega prawie całkowicie pomyślnie. Prawie, ponieważ pierwszy zarejestrowany bit jest zerem, podczas gdy powinien być jedynką. Od dłuższego czasu próbuję zlokalizować przyczynę tego stanu rzeczy.

Do nadawania wykorzystuję kodowanie Manchester, odbiór realizowany za pomocą przerwań i wyznaczania czasu trwania impulsów. Połówka bitu trwa 104us.
Na początku wysyłane są 64 jedynki dla celów fazowania. Następnie przerwa o długości całego bitu i dopiero potem dane właściwe.
Próbowałem różne warianty jeżeli chodzi o stan nóżki w czasie przerwy po fazowaniu, o długości czasów trwania przerw i bitów itp. i lepszej konfiguracji niż ta co teraz nie trafiłem.

Najpewniej problem jest w samym programie (źródła na końcu posta), ponieważ gdy łączę piny mikrokontrolerów przewodem pomijając moduły transmisji bezprzewodowej rezultat transmisji jest taki sam. Na razie jednak kilka godzin bezskutecznie błądzę w kodzie. Zapewne przez niedostateczną wiedzę i umiejętności z tematu, za jaki się zabrałem; również pierwszy raz korzystam na poważnie z języka C więc kod mógłby być zdecydowanie wyższej jakości, ale na razie skupiam się na samym problemie.

Też na inne dziwne zjawisko trafiłem przy okazji: gdy trzymam przycisk nadawania wciśnięty (powtarzanie transmisji co 100 milisekund), czasem co kilkanaście/kilkadziesiąt ramek odbiornik przestaje funkcjonować prawidłowo (tak, jak bym chciał); program wtedy w ogóle nie wchodzi w obsługę przerwania i dopiero po kilkunastu/kilkudziesięciu ramkach powraca do normalnej pracy (chyba, że wcześniej zwolnię klawisz, wtedy od razu się poprawia). Ten problem jest raczej związany z modułem samym w sobie, gdyż nie zdarzyło mi się tak przy połączeniu mikrokontrolerów samym przewodem.

Jeżeli jest ktoś z Was w stanie pomóc mi zlokalizować przyczynę problemu uprzejmie proszę o wskazówki.

Pozdrawiam serdecznie.

----------------
Kod źródłowy programu obsługującego nadawanie:
[syntax=c]#define _bitHalveDuration 104 //1000000us/4800bps = 208,(3)
#define _releaseDelay 208
#define _outputHigh PORTD |= (1 << PD3)
#define _outputLow PORTD &= ~(1 << PD3)
#define _syncPreambleLen 64
#define _LEDOn PORTC |= (1 << PC7)
#define _LEDOff PORTC &= ~(1 << PC7)

#define F_CPU 16000000UL
#include
#include
#include

void sendOne(void)
{
_outputHigh;
_delay_us(_bitHalveDuration);
_outputLow;
_delay_us(_bitHalveDuration);
}

void sendZero(void)
{
_outputLow;
_delay_us(_bitHalveDuration);
_outputHigh;
_delay_us(_bitHalveDuration);
}

void synchronize(void)
{
for (uint16_t i = 0; i < _syncPreambleLen; i++)
sendOne();

_outputHigh;
_delay_us(_releaseDelay);
}

void sendByte(uint8_t byte)
{
//start sequence
uint8_t ss = 0b11100011; //why so? just because

for (uint8_t i = 0; i < 8; i++)
{
if (!(ss & 0x80)) sendZero();
else sendOne();

ss <<= 1;
}

for (uint8_t i = 0; i < 8; i++)
{
if (!(byte & 0x80)) sendZero();
else sendOne();

byte <<= 1;
}

_outputHigh;
_delay_us(_releaseDelay);
}

void Initialize(void)
{
DDRC = 0xFF; //LED signalling
DDRD = 0x09; //HM-T output

LCD_Initalize(); //obvious
LCD_Clear(); //yup
}

int main(void)
{
Initialize();

while(1)
{
if (~PIND & 0x80) //ATTACK
{
char x = 'x';
_LEDOn;
synchronize();
sendByte(x);
_LEDOff;
}

_delay_ms(100);
}
}[/syntax]

Kod źródłowy programu obsługującego odbiór (diody użyte dla debugowania, brak wcięć celowo):
[syntax=c]#define F_CPU 16000000UL

#define _bitHalveDuration 104

#define _rxEnable PORTD |= (1 << PD0)
#define _rxDisable PORTD &= ~(1 << PD0)

#define _LEDOff PORTC &= 0

#define _micro_s(num) (((num)*((F_CPU/1000UL)/8))/1000)
#define _tolerance 20
#define _minBitHalveDuration _micro_s(_bitHalveDuration - _tolerance)
#define _maxBitHalveDuration _micro_s(_bitHalveDuration + _tolerance)
#define _maxBitDuration _micro_s((_bitHalveDuration*2) + (_tolerance*2))

#include
#include
#include
#include

uint8_t LEDs[8];

void Initialize(void)
{
DDRC = 0xFF; //LED signalling
DDRD = 0x01; //HM-R enable output (PD0) and data input (PD4)
_rxEnable; //enable HM-R

LCD_Initalize(); //obvious
LCD_Clear(); //yup

TCCR1B = (1 << CS11);
TCCR1B &= ~(1 << ICES1);
TIMSK |= (1 << TICIE1);

for (uint8_t i = 0; i < 8; i++) LEDs[i] = 1;

sei();
}

volatile uint8_t _RxByte;
volatile uint8_t _RxFlag;
enum _status {FRAME_RESTART, FRAME_OK};

void Listen(void)
{
if(_RxFlag)
{
_RxFlag=0;

LCD_Clear();
LCD_WriteData(_RxByte);
LCD_WriteData(' ');

for (uint8_t i = 0; i < 8; i++)
{
if (_RxByte & (1 << i)) LCD_WriteData('1');
else LCD_WriteData('0');
}
}
}

ISR(TIMER1_CAPT_vect)
{
static uint16_t LastCapture;
uint16_t PulseWidth;
static uint8_t PulseCount;
static uint32_t RxData;
static enum _status frame_status;
static uint8_t mancnt;
//static uint8_t bufferIndex = 0;
uint8_t startSeq = 0;

PulseWidth = ICR1 - LastCapture;
LastCapture = ICR1;

TCCR1B ^= (1 << ICES1);

//detect frame start
if (PulseWidth > _maxBitDuration) mancnt = 0;

if (mancnt == 0)
{
RxData = 0;
PulseCount = 0;
TCCR1B |= (1 << ICES1);
mancnt++;
frame_status = FRAME_OK;
}
else
if (frame_status == FRAME_OK)
{
LEDs[0] = 1;
if (PulseWidth < _minBitHalveDuration) frame_status = FRAME_RESTART;

if (PulseWidth > _maxBitDuration) frame_status = FRAME_RESTART;

if (frame_status == FRAME_OK)
{
LEDs[1] = 1;
if (PulseWidth > _maxBitHalveDuration) mancnt++;
if ((mancnt % 2) == 0)
{
LEDs[2] = 1;
RxData = RxData << 1;

if (TCCR1B & (1 << ICES1))
{
RxData |= 0x0001;
LEDs[3] = 1;
}
else
{
LEDs[4] = 1;
}

PulseCount++;
if (PulseCount == 15) //SS+char --> 16b
{
LEDs[5] = 1;
if (_RxFlag == 0)
{
LEDs[6] = 1;
_RxByte = RxData;
startSeq = RxData >> 8;
LCD_Clear();
for (uint32_t i = 0; i < 16; i++)
{
if (i == 8) LCD_GoTo(8,1);
if (RxData & (0x8000 >> i)) LCD_WriteData('1');
else LCD_WriteData('0');
}

if (startSeq == 0b11100011)
{
LEDs[7] = 1;
_RxFlag = 1;
}
}

frame_status = FRAME_RESTART;
}
}
mancnt++;
}
}

if (frame_status == FRAME_RESTART)
{
mancnt = 0;
TCCR1B &= ~(1<}
}

int main(void)
{
Initialize();

while (1)
{
Listen();

for (uint8_t i = 0; i < 8; i++)
{
if (LEDs[i] == 1)
{
PORTC |= (1 << i);
LEDs[i] = 0;
if (i == 7) _delay_ms(200); //swieto!!!
}
}
_delay_us(10);
_LEDOff;
}
}[/syntax]

Statystyki: Napisane przez BioZ — 29 kwi 2013, o 00:28