Nadajnik:
[syntax=c]#ifndef TRANSMITTER_H_
#define TRANSMITTER_H_
//*** Konfiguracja pinów
#define LED_PIN (1<<PC2)
// Pin sterujący włączaniem/wyłączaniem zasilania nadajnika
#define TRANSMITTER_PWR_PIN (1<<PB0)
#define TRANSMITTER_PWR_PORT PORTB
#define TRANSMITTER_PWR_DDR DDRB
#define TRANSMITTER_ON TRANSMITTER_PWR_PORT |= TRANSMITTER_PWR_PIN;_delay_ms(5);
#define TRANSMITTER_OFF TRANSMITTER_PWR_PORT &= ~TRANSMITTER_PWR_PIN;
// Pin podający sygnał na wejście nadajnika
#define TRANSMITTER_IN_PIN (1<<PD7)
#define TRANSMITTER_IN_PORT PORTD
#define TRANSMITTER_IN_DDR DDRD
#define TRANSMITTER_IN_HIGH TRANSMITTER_IN_PORT |= TRANSMITTER_IN_PIN
#define TRANSMITTER_IN_LOW TRANSMITTER_IN_PORT &= ~TRANSMITTER_IN_PIN
//*** Ustawienia parametrów transmisji
// Ilość bitów ramki synchronizacyjnej
#define SYNC_COUNT 20
// Czas trwania stanu wysokiego (impulsu) w bicie [us]
#define PULSE_HIGH_BIT 200
// Tolerancja dla czasów trwania stanu niskiego i wysokiego w biice [us]
#define TOLERANCE 50
// Czasy trwania poszczególnych stanów w bicie 0 oraz 1
#define MAX_PULSE_HIGH (PULSE_HIGH_BIT + TOLERANCE)
#define MIN_PULSE_HIGH (PULSE_HIGH_BIT - TOLERANCE)
#define MAX_PULSE_LOW (2*PULSE_HIGH_BIT + TOLERANCE)
#define MIN_PULSE_LOW (2*PULSE_HIGH_BIT - TOLERANCE)
// Deklaracje funkcji globalnych
void transmitter_init(void);
void send_start_bit(void);
void send_one(void);
void send_zero(void);
void send_sync_pack(void);
void wyslij_bajt(uint8_t data);
#endif /* TRANSMITTER_H_ */[/syntax]
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "transmitter.h"
// pomocnicze definicje pinów klawiszy
#define KL1 (1<<PC3)
#define KL2 (1<<PC4)
#define KL3 (1<<PC5)
int main(void)
{
DDRC |= KL1|KL2|KL3;// klawisze - wyjścia
PORTC |= KL1|KL2|KL3; // klawisze - podciąganie
DDRC |= LED_PIN;
PORTC |= LED_PIN;
uint8_t i;
transmitter_init();
_delay_ms(1000);
sei();// odblokowanie przerwań globalnych
while(1)
{
if( !(PINC & KL2) ) {
_delay_ms(30);
if( !(PINC & KL2) ) {
send_sync_pack();
wyslij_bajt(170);
TRANSMITTER_OFF;
_delay_ms(500);
}
}
}
}[/syntax]
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "transmitter.h"
// Funkcja inicjalizująca piny wychodzące z uC na NADAJNIK - pin IN i PWR
void transmitter_init(void)
{
TRANSMITTER_IN_DDR |= TRANSMITTER_IN_PIN;
TRANSMITTER_IN_HIGH;
TRANSMITTER_PWR_DDR |= TRANSMITTER_PWR_PIN;
TRANSMITTER_OFF;
}
//*** Kodowanie syganłu typu PULSE (stały czas trwania stanu wysokiego) - funkcje nadawcze
void send_one(void)
{
TRANSMITTER_IN_LOW;
_delay_us(2*PULSE_HIGH_BIT);
TRANSMITTER_IN_HIGH;
_delay_us(PULSE_HIGH_BIT);
}
void send_zero(void)
{
TRANSMITTER_IN_LOW;
_delay_us(PULSE_HIGH_BIT);
TRANSMITTER_IN_HIGH;
_delay_us(PULSE_HIGH_BIT);
}
void send_sync_pack(void)
{
uint8_t num, i;
num = SYNC_COUNT;
TRANSMITTER_ON; // włączenie nadajnika (po samej inicjalizacji domyślnie wyłączony)
TRANSMITTER_IN_LOW;
_delay_us(4*PULSE_HIGH_BIT);
// Nadawanie określonej liczby bitów synchronizacyjnych
for(i=0; i<num; i++)
{
send_zero();
}
TRANSMITTER_IN_HIGH;
_delay_us(3*PULSE_HIGH_BIT); // czas na odbiór dla odbiornika
}
// Funkcja testowa
void wyslij_bajt(uint8_t data)
{
uint8_t i;
uint8_t sreg;
// blokujemy przerwania na czas emisji danych
// aby zachować odpowiednie czasy trwania impulsów
sreg = SREG;
cli();
TRANSMITTER_IN_HIGH;
_delay_us(3*PULSE_HIGH_BIT);
// właściwy bajt danych
for( i=0; i<8; i++ ) {
if ( !(data & 0x80) ) send_zero();
else send_one();
data<<=1;
}
// zablokowanie nadajnika aby nie generował szumu
TRANSMITTER_IN_HIGH;
// odblokowujemy przerwania, jeśli były uprzednio włączone
SREG = sreg;
_delay_us(PULSE_HIGH_BIT*3);
}[/syntax]
Odbiornik:
[syntax=c]#ifndef RECEIVER_H_
#define RECEIVER_H_
//*** Konfiguracja pinów
#define LED_PIN (1<<PC5)
#define LED_PIN2 (1<<PC4)
#define RECEIVER_OUT_PIN (1<<PB0)
#define RECEIVER_OUT_DDR DDRB
#define RECEIVER_OUT_PORT PORTB
//*** Ustawienia parametrów transmisji
// Ilość bitów ramki synchronizacyjnej
#define SYNC_COUNT 16
// Czas trwania stanu wysokiego (impulsu) w bicie [us]
#define PULSE_HIGH_BIT 200
// Tolerancja dla czasów trwania stanu niskiego i wysokiego w biice [us]
#define TOLERANCE 50
// Czasy trwania poszczególnych stanów w bicie 0 oraz 1
#define MAX_PULSE_HIGH (PULSE_HIGH_BIT + TOLERANCE)
#define MIN_PULSE_HIGH (PULSE_HIGH_BIT - TOLERANCE)
#define MAX_PULSE_LOW (2*PULSE_HIGH_BIT + TOLERANCE)
#define MIN_PULSE_LOW (2*PULSE_HIGH_BIT - TOLERANCE)
#define MAX_PULSE_LOW_ZERO (PULSE_HIGH_BIT + TOLERANCE)
#define MIN_PULSE_LOW_ZERO (PULSE_HIGH_BIT - TOLERANCE)
// Deklaracje funkcji globalnych
void receiver_init(void);
void receive_event(void);
void register_binary_callback(void (*callback)(uint8_t received_byte, uint8_t repeat));
#endif /* RECEIVER_H_ */[/syntax]
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "receiver.h"
volatile uint8_t received_flag; // Flaga zakończenia odbioru - ustawiana pod koniec przerwania
volatile uint8_t received_byte; // 1 bajt danych z odebranej 24-biotwej ramki
volatile uint8_t repeat; // krotność przesłania tej samej ramki danych (gdy przycisk jest trzymany po wciśnięciu)
volatile uint8_t toggle_bit; // pozostaje niezmienny przy emisji tych samych ramek
// Funkcja inicjalizująca pin uC (ICP) oodbierający sygnał z odbiornika
void receiver_init(void)
{
RECEIVER_OUT_DDR &= ~RECEIVER_OUT_PIN; // pin odbierający sygnał jako wejście
// Konfiguracja i odblokowanie przerwania ICP
TCCR1B = (1<<CS11);// ustawienie preskalera dla Timer1 = 8
TCCR1B &= ~(1<<ICES1);// reakcja na zbocze opadające
TIMSK1 |= (1<<ICIE1);// odblokowanie przerwania ICP
}
// wskaźnik do funkcji callback
static void (*received_byte_callback)(uint8_t received_byte, uint8_t repeat);
// funkcja do rejestracji funkcji zwrotnej
void register_received_byte_callback(void (*callback)(uint8_t received_byte, uint8_t repeat)) {
received_byte_callback = callback;
}
// Zdarzenie odbioru danych
void receive_event(void)
{
if(received_flag)
{
received_flag = 0; // można odebrać kolejną ramkę danych
if(received_byte_callback) (*received_byte_callback)(received_byte, repeat);
}
//PORTC &= ~LED_PIN;
}
// Możliwe statusy odbieranej ramki
enum status { FRAME_START, FRAME_RESTART, FRAME_OK, FRAME_END};
// Procedura testowa przerwania
ISR(TIMER1_CAPT_vect)
{
static enum status frame_status;
static uint16_t ICP_last; // czas uchwycenie ostatniego zbocza
uint16_t Pulse_width, PulseLow_width, PulseHigh_width;
static uint8_t SlopeCount; // licznik zboczy
static uint8_t BitCount; // licznik bitów
static uint8_t FrameContent; // zawartość 16-bitowej ramki danych
static uint8_t StartSlope ;
static uint8_t zero_wait;
static uint8_t one_wait;
//uint8_t start_byte = 0;
//static uint8_t ktory;
Pulse_width = ICR1 - ICP_last;
ICP_last = ICR1;
PORTC ^= LED_PIN;
TCCR1B ^= (1<<ICES1); // zmiana sposobu wyzwolenia przerwania ICP
if(frame_status == FRAME_START)
{
frame_status = FRAME_OK;
SlopeCount = 1;
}
// gdy czas dłuższy niż 2T + tolerancja i StartSlope równe 0 - początek ramki danych
if((Pulse_width > MAX_PULSE_LOW) && (StartSlope != 1))
{
{
StartSlope = 1;
BitCount = 0;
SlopeCount = 0;
}
if(SlopeCount == 0 && StartSlope == 1)
{
FrameContent = 0;
TCCR1B |= (1<<ICES1);
frame_status = FRAME_START;
}
}
else
{
// jeśli zbocze parzyste, sprawdzamy PulseHigh_width, w przeciwnym razie PulseLow_width
if((SlopeCount > 0) && ((SlopeCount % 2) == 0))
{
PulseHigh_width = Pulse_width;
}
else if((SlopeCount > 0) && ((SlopeCount % 2) != 0))
{
PulseLow_width = Pulse_width;
}
}
// sprawdzamy, czy szerokość impulsu mieści się w granicznym przedziale
if((frame_status == FRAME_OK) && (SlopeCount > 0))
{
if(PulseHigh_width == Pulse_width && ((SlopeCount % 2) == 0))
{
if(PulseHigh_width > MAX_PULSE_HIGH)
{
frame_status = FRAME_RESTART;
}
if(PulseHigh_width < MIN_PULSE_HIGH)
{
frame_status = FRAME_RESTART;
}
}
else
{
if(PulseLow_width == Pulse_width && ((SlopeCount % 2) != 0))
{
if(PulseLow_width > MAX_PULSE_LOW)
{
frame_status = FRAME_RESTART;
}
if(PulseLow_width < MIN_PULSE_LOW)
{
frame_status = FRAME_RESTART;
}
}
}
}
// jeśli impulsy mieszczą się w przyjętych granicach, możemy je zdekodować
if(frame_status == FRAME_OK)
{
if(SlopeCount != 1) SlopeCount++;
// Określenie wartości bitu
if((SlopeCount > 0) && (SlopeCount % 2 == 0))
{
// sprawdzenie czy stan niski wynosi T - wtedy bit o wartości 0, gdy 2T - bit o wartości 1
if((PulseLow_width > MIN_PULSE_LOW) && (PulseLow_width < MAX_PULSE_LOW_ZERO))
{
zero_wait = 1; // czekamy na impuls wysoki kończący bit
}
if((PulseLow_width > MIN_PULSE_LOW) && (PulseLow_width < MAX_PULSE_LOW))
{
one_wait = 1; // czekamy na impuls wysoki kończący bit
}
}
else if((SlopeCount > 0) && (SlopeCount % 2 == 0))
{
if((PulseHigh_width > MIN_PULSE_HIGH) && (PulseHigh_width < MAX_PULSE_HIGH))
{
FrameContent = FrameContent << 1;
if(zero_wait)
{
FrameContent |= 0x00;
zero_wait = 0;
}
else
{
FrameContent |= 0x01;
one_wait = 0;
}
BitCount++;
if(BitCount == 8)
{
lcd_locate(1,0);
lcd_str("PELNA RAMKA");
// gdy odebrano poprzednią ramkę danych
if(received_flag == 0)
{
received_byte = FrameContent;
received_flag = 1;
}
frame_status = FRAME_RESTART;
}
}
}
}
if(frame_status == FRAME_RESTART)
{
TCCR1B &= ~(1<<ICES1);
StartSlope = 0;
}
}[/syntax]
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "receiver.h"
#include "lcd44780.h"
void moja_obsluga_binarna(uint8_t received_byte, uint8_t repeat);
int main(void)
{
DDRC |= LED_PIN | LED_PIN2;
PORTC |= LED_PIN | LED_PIN2;
//PORTC &= ~LED_PIN;
lcd_init();
lcd_cls();
lcd_locate(0,0);
lcd_str("START ");
receiver_init();
register_received_byte_callback(moja_obsluga_binarna);
_delay_ms(1000);
sei();// odblokowanie przerwań globalnych
while(1)
{
receive_event();
}
}
void moja_obsluga_binarna(uint8_t received_byte, uint8_t repeat) {
lcd_locate(0,0);
lcd_str("odbior binarny ");
lcd_locate(1,0);
lcd_str("bajt:");
lcd_int(received_byte);
lcd_str(" ");
}[/syntax]Statystyki: Napisane przez piotrek_194 — 30 gru 2014, o 15:39
]]>