Przesyłać mam próbkowany dźwięk drogą radiową i odtworzenie, puszczając go przez PWM. Teoretycznie wszystko działa. Ale nie mogę poradzić sobie z optymalizacją i dostrojenie tych modułów by działały jak najlepiej. Wiem że temat był poruszany w zielonej książce.
Problem polega na tym że jak sobie zrobię na jednym procesorze próbkowanie dźwięku i puszczę go od razu na PWM. To dźwięk wychodzi całkiem super mimo 8-bitowej rozdzielczości
A jak chcę to przesłać przez moduły to występuje metaliczny dźwięk, no słychać że jest gorsza jakość. Najpierw przedstawię konfiguracje rejestrów modułów:[syntax=c]const uint8_t PROGMEM RFM70_cmd_adrRX0[] = { (0x20|0x0A), 0x34,0x43,0x10,0x10,0x01};
const uint8_t PROGMEM RFM70_cmd_adrTX[] = { (0x20|0x10), 0x34,0x43,0x10,0x10,0x01};
const uint8_t PROGMEM RFM70_cmd_adrRX1[] = { (0x20|0x0B), 0x35,0x43,0x10,0x10,0x02};
const uint8_t PROGMEM RFM70_cmd_switch_cfg[] = { 0x50, 0x53 }; // zmiana rejestru
const uint8_t PROGMEM RFM70_cmd_flush_rx[] = { 0xe2, 0x00 }; // flush RX FIFO
const uint8_t PROGMEM RFM70_cmd_flush_tx[] = { 0xe1, 0x00 }; // flush TX FIFO
const uint8_t PROGMEM RFM70_cmd_activate[] = { 0x50, 0x73 }; // aktywacja
const uint8_t PROGMEM RFM70_cmd_tog1[]={ (0x20|0x04), 0xd9 | 0x06, 0x9e, 0x86, 0x0b };
const uint8_t PROGMEM RFM70_cmd_tog2[]={ (0x20|0x04), 0xd9 & ~0x06, 0x9e, 0x86, 0x0b}; //set1[4]
//Bank 0
const uint8_t PROGMEM RFM70_bank0Init[][2] = {
{ (0x20|0x00), 0x0F }, //Disable CRC ,CRC=1byte, POWER UP, TX
{ (0x20|0x01), 0x3F }, //Enable auto acknowledgement data pipe0-5
{ (0x20|0x02), 0x3F }, //Enable RX Addresses pipe0-5
{ (0x20|0x03), 0x03 }, //RX/TX address field width 5byte
{ (0x20|0x04), 0xff }, //x = 250 ms = 4000ms, y = 15 tries
{ (0x20|0x05), 0x17 }, //channel = 0x17
{ (0x20|0x06), 0x07 }, //air data rate-2M,out power 5dbm,setup LNA gain high (0dBM)
{ (0x20|0x07), 0x07 }, //
{ (0x20|0x08), 0x00 }, //
{ (0x20|0x09), 0x00 }, //
{ (0x20|0x0C), 0xc3 }, //LSB Addr pipe 2
{ (0x20|0x0D), 0xc4 }, //LSB Addr pipe 3
{ (0x20|0x0E), 0xc5 }, //LSB Addr pipe 4
{ (0x20|0x0F), 0xc6 }, //LSB Addr pipe 5
{ (0x20|0x11), 0x20 }, //Payload len pipe0
{ (0x20|0x12), 0x20 }, //Payload len pipe0
{ (0x20|0x13), 0x20 }, //Payload len pipe0
{ (0x20|0x14), 0x20 }, //Payload len pipe0
{ (0x20|0x15), 0x20 }, //Payload len pipe0
{ (0x20|0x16), 0x20 }, //Payload len pipe0
{ (0x20|0x17), 0x20 }, //Payload len pipe0
{ (0x20|0x1C), 0x3F }, //Enable dynamic payload legth data pipe0-5
{ (0x20|0x1D), 0x07 } //Enables Dynamic Payload Length,Enables Payload with ACK
};
//Bank 1
const uint8_t PROGMEM RFM70_bank1Init[][5] = {
// address data
{ (0x20|0x00), 0x40, 0x4B, 0x01, 0xE2 },
{ (0x20|0x01), 0xC0, 0x4B, 0x00, 0x00 },
{ (0x20|0x02), 0xD0, 0xFC, 0x8C, 0x02 },
{ (0x20|0x03), 0x99, 0x00, 0x39, 0x41 },
{ (0x20|0x04), 0xb9, 0x9E, 0x86, 0x0B },
{ (0x20|0x05), 0x24, 0x06, 0x7F, 0xA6 },
{ (0x20|0x06), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x07), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x08), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x09), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x0a), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x0b), 0x00, 0x00, 0x00, 0x00 },
{ (0x20|0x0C), 0x00, 0x12, 0x73, 0x00 },
{ (0x20|0x0D), 0x36, 0xb4, 0x80, 0x00 }
};
//Bank1
const uint8_t PROGMEM RFM70_bank1R0EInit[] = {
// address Data...
(0x20|0x0E), 0x41,0x20,0x08,0x04,0x81,0x20,0xCF,0xF7,0xFE,0xFF,0xFF
};[/syntax]
Bawiłem się nimi godzinami, googlowałem w poszukiwaniu działającej konfiguracji aż wreszcie zadziałało, ale czy to dobra konfiguracja? Chciałbym z tego wycisnąć maksimum.
W części nadawczej opierałem się na rozdziale o ADC pana Mirka. Inicjacja modułu oraz kod odpowiedzialny za wysyłanie wygląda tak:
[syntax=c]sei();//globalne odblokowanie przerwań
initRFM(); //inicjalizacja RFM73
setModeTX(); //tryb nadawania
setChannel(8); // kanał 8
setPower(3); // maksymalna moc (0: -10dBm | 1: -5dBm | 2: 0dBm | 3: 5dBm)
char ASCII[3];
while (1)
{
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));
itoa(ADCH, ASCII, 10);
sendPayload(&ASCII[0], 4, 0); //tablica, dlugosc, 0 - bez potwierdzenia | 1 - z potwierdzeniem
}[/syntax]
Miałem problemy z wysyłaniem wartości liczbowej, dlatego wysyłanie przez moduł rozwiązałem w ten sposób że konwertuje zmienną typu int na łańcuch znaków.
Strona odbiorcza to:
[syntax=c]DDRB |= (1<<PB1);
TCCR1A |= (1<<COM1A1) | (1<<COM1A0) | (1<<COM1B1) | (1<<COM1B0);
TCCR1A |= (1<<WGM12) | (1<<WGM10);
TCCR1B |= (1<<CS10);
sei();// globalne odblokowanie przerwań
uint8_t bufor[32];
initRFM(); //inicjalizacja RFM73
setModeRX(); //tryb odbioru
setChannel(8); // kanał 8
uint8_t a;
OCR1A = 0;
while (1)
{
if (receivePayload(bufor))
{
OCR1A = atoi((uint8_t*)bufor);
}
}[/syntax]
Tutaj konwersja odwrotna. Do rejestru OCR1A przypisuje odebraną wartość liczbową i wysyłam na PWM.
Taktowanie procesorów mam aktualnie ustawione na 20MHz, ale próbowałem też z 24MHz by osiągnąć jak najlepszą jakość dźwięku.
Obsługa modułów jest bez używania przerwań.
Czy da radę coś więcej z tego wycisnąć? Będę wdzięczny w naprowadzeniu co można było by zmienić.
Pozdrawiam
Statystyki: Napisane przez Dawid90 — 18 kwi 2014, o 00:37
]]>