mam problem z dokończeniem projektu i liczę, że ktoś bardziej doświadczony pomoże mi go rozwiązać.
Mam dwa układy ATmega32 (docelowo), do których podpiąłem tanie moduły radiowe 433 MHz FS1000A (nadajnik/odbiornik). Chcę zrealizować bardzo prostą komunikację: wciśnij przycisk → wyślij dane → odbiornik zapala diodę po odebraniu poprawnych danych.
Starałem się bazować na przykładach z zielonej książki Mirosława Kardasia, jednak nie mam takiej wiedzy programistycznej, żeby poprawnie to samemu poskładać. Niestety nie działa mi paczka od użytkownika ryba84 z tematu: „Pseudo OneWire i/lub biblioteka do obsługi tanich modułów RF” – nawet po moich poprawkach pod ATmega32 (o ile dobrze to zrobiłem). Nie chcę też inwestować w zestaw ATB, dlatego chcę zrobić to na samych gołych AVR-ach na płytce stykowej tak aby projekt był możliwie najmniej złożony ze zbędnych elementów.
Poniżej wklejam mój kod nadajnika (ATmega32 w C, z własnym Manchesterem):
[syntax=c]Nadajnik
#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#define RF_PIN PIND5
#define LED_PIN PIND5
#define BUTTON_PIN PIND0
uint8_t checksuma;
// półokres bitu (Manchester) = 500us
#define HALF_BIT_US 500
#define INPUT 0
#define OUTPUT 1
void setLedOn()
{
PORTB |= (1 << LED_PIN);
}
void setLedOff()
{
PORTB &= ~(1 << LED_PIN);
}
void pinMode(char port, uint8_t pin, uint8_t mode)
{
switch (port)
{
case 'B':
if (mode == OUTPUT)
DDRB |= (1 << pin);
else
DDRB &= ~(1 << pin);
break;
case 'C':
if (mode == OUTPUT)
DDRC |= (1 << pin);
else
DDRC &= ~(1 << pin);
break;
case 'D':
if (mode == OUTPUT)
DDRD |= (1 << pin); // wpisuje 1 w miejsce pin
else
DDRD &= ~(1 << pin);
break;
/*
case 'A':
if (mode == OUTPUT)
DDRA |= (1 << pin);
else
DDRA &= ~(1 << pin);
break;
*/
}
}
void enablePullup(char port, uint8_t pin)
{
switch (port)
{
case 'B':
PORTB |= (1 << pin);
break;
case 'C':
PORTC |= (1 << pin);
break;
case 'D':
PORTD |= (1 << pin);
break;
/*
case 'A':
PORTA |= (1 << pin);
break;
*/
}
}
uint8_t isButtonPressed()
{
return !(PIND & (1 << BUTTON_PIN));
}
// --- Funkcje pomocnicze ---
void manchester_send_bit(uint8_t bit)
{
if (bit)
{
// Manchester "1" = [LOW-HIGH]
PORTD &= ~(1 << RF_PIN);
_delay_us(HALF_BIT_US);
PORTD |= (1 << RF_PIN);
_delay_us(HALF_BIT_US);
}
else
{
// Manchester "0" = [HIGH-LOW]
PORTD |= (1 << RF_PIN);
_delay_us(HALF_BIT_US);
PORTD &= ~(1 << RF_PIN);
_delay_us(HALF_BIT_US);
}
}
void manchester_send_byte(uint8_t data)
{
for (uint8_t i = 0; i < 8; i++)
{
uint8_t bit = (data & 0x80) ? 1 : 0;
manchester_send_bit(bit);
data <<= 1;
}
}
uint8_t calculate_checksum(uint8_t checksuma) {
return checksuma ^ 0xAA;
}
void disableTransceiver()
{
PORTD &= ~(1 << RF_PIN);
}
void send_frame(void)
{
// Preambuła: 10 połówek (1010...)
//for (uint8_t i = 0; i < 5; i++)
for (uint8_t i = 0; i < 32; i++) //lub 16
{
manchester_send_bit(1);
manchester_send_bit(0);
}
// Wysyłamy bajt danych (np. 0b10100000)
manchester_send_byte(0b10100000);
manchester_send_byte(calculate_checksum(checksuma));
//___________________________________________________________________________________________________________________
// Wrazie gdzyby dalej zostawało w stanie wysokim należy pierwszy bit '1' po 0b zmienić na zero albo dać inne dane
//opcja 2 po wykonaniu programu wykonać reset atmegi poprzez pin reset lub pinem wymusić
//______________________________________________________________________________________________________________
disableTransceiver();
}
int main(void)
{
pinMode('D', RF_PIN, OUTPUT);
pinMode('D', LED_PIN, OUTPUT);
pinMode('D', BUTTON_PIN, INPUT);
enablePullup('D', BUTTON_PIN);
while (1)
{
// if (isButtonPressed())
// { // naciśnięto przycisk
setLedOn();
_delay_ms(2000);
send_frame();
setLedOff();
_delay_ms(500); // prosty debouncing
// }
}
}[/syntax]
Do testów użyłem Arduino UNO jako odbiornika (zamiast drugiej ATmegi) z powodu chwilowego braku drugiej atmegi. Odbiornik próbuje rozpoznać preambułę i odebrać bajt danych, ale coś nie działa stabilnie – Odbiera bity i wyświetla w serial port ale nie są one stabilne i nie zgodne z danymi które założyłem.
[syntax=c]#include <Arduino.h>
// Piny
#define PIN_ODBIORU 2
#define PIN_LED 13
// Czas półbitu w mikrosekundach (zgodnie z nadajnikiem)
#define POL_BITU_US 500
#define TIMEOUT_MS 1000
/*
int read_rf(void){
int bit = digitalRead(PIN_ODBIORU);
delayMicroseconds(40);
if(digitalRead(PIN_ODBIORU) == bit)
{delayMicroseconds(40);
if(digitalRead(PIN_ODBIORU) == bit)
{delayMicroseconds(40);
if(digitalRead(PIN_ODBIORU) == bit)
{
return bit;
}
}
}
}*/
int read_rf()
{
int read[5];
for (int i = 0; i < 5; i++)
{
read[i] = digitalRead(PIN_ODBIORU);
delayMicroseconds(20);
}
// Zlicz wystąpienia HIGH
int high_count = 0;
for (int i = 0; i < 5; i++)
{
if (read[i] == HIGH)
high_count++;
}
// Zwróć stan dominujący
return (high_count >= 3) ? HIGH : LOW;
}
// Czekaj na początek transmisji
bool wait_for_transmission_start()
{
unsigned long start_time = millis();
int state_changes = 0;
int last_state = read_rf();
while (millis() - start_time < TIMEOUT_MS)
{
int current_state = read_rf();
if (current_state != last_state)
{
state_changes++;
last_state = current_state;
// Jeśli wykryto kilka zmian stanu, prawdopodobnie zaczyna się transmisja
if (state_changes >= 4)
{
return true;
}
}
delayMicroseconds(POL_BITU_US / 4);
}
return false;
}
// Odbiór pojedynczego bitu Manchester
int odbierz_bit_manchester()
{
int pierwszy = read_rf();
// czeka na zmiane statusu timeout
unsigned long start = micros();
// Czekaj aż zmieni się stan lub minie czas połowy bitu * 2
while ((read_rf() == pierwszy))
{
if (micros() - start > POL_BITU_US * 2)
{
return -1; // timeout
}
delayMicroseconds(10);
}
// Poczekaj do środka drugiej połowy bitu
delayMicroseconds(POL_BITU_US / 2);
int drugi = read_rf();
// dekodowanie
if (pierwszy == LOW && drugi == HIGH)
return 1;
if (pierwszy == HIGH && drugi == LOW)
return 0;
return -1; // błąd w odczycie
}
bool reciver_preamble()
{
int correct_patterns = 0;
for (int i = 0; i < 32; i++)
{
int bit1 = odbierz_bit_manchester();
// if (bit != 1)
// return false; // błąd
int bit2 = odbierz_bit_manchester();
// if (bit != 0)
// return false; // błąd
if(bit1 == 1 && bit2 == 0) {
correct_patterns++;
} else if(correct_patterns < 2) {
// Pozwól na błędy na początku
continue;
} else {
return false;
}
}
return correct_patterns >= 3;
}
// Odbiór bajtu (8 bitów)
bool odbierz_bajt(uint8_t &bajt)
{
reciver_preamble();
bajt = 0;
for (int i = 0; i < 8; i++)
{
int bit = odbierz_bit_manchester();
if (bit == -1)
return false; // błąd
bajt = (bajt << 1) | bit;
}
return true; // OK
}
//suma kontrolna XOR
uint8_t licz_checksum(uint8_t data)
{
return data ^ 0xAA;
}
void setup()
{
pinMode(PIN_ODBIORU, INPUT);
pinMode(PIN_LED, OUTPUT);
Serial.begin(9600);
Serial.println("Odbiornik gotowy");
}
void loop()
{
uint8_t bajt;
if (odbierz_bajt(bajt))
{
Serial.print("ODEBRANO: 0b");
Serial.println(bajt, BIN);
// Jeśli odebrano konkretny bajt, włącz diodę LED
if (bajt == 0b10100000)
{
digitalWrite(PIN_LED, HIGH);
delay(300);
digitalWrite(PIN_LED, LOW);
}
}
}[/syntax]Statystyki: Napisane przez Aven154 — 11 wrz 2025, o 09:28
]]>
hlip hlip