W skrócie napisałem program który otrzymuje polecenia przez USART(przez bluetooth) i steruje odpowiednimi wyjściami.
Dodatkowo mam możliwość sprawdzenia stanu czujnika analogowego + jeśli osiągnie wartość minimalną wyłączy on układ.
Przy pisaniu programu podtrzymywałem się innym, jednak mam duże wątpliwości co do działania ukladu ADC i przesyłania jego danych do telefonu. Prosił bym o sprawdzenie, raczej jestem początkujący w tych sprawach.
Wyjścia binarne : PD2-7
Wejście adc : PC0
Zewnętrzny kwarc 8MHz
Cały kod:
[syntax=cpp]#define F_CPU 8000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <util/delay.h>
//=== Flagi ====================
//flaga globalna informująca main() o odebraniu komendy do dalszej analizy
volatile unsigned char odb_flaga = 0;
//=== Komendy AT ====================
#define AT_ILOSC_ZNAKOW10//maksymalna długość komendy wraz ze znakiem \n
//tablica wzorców komend AT
//UWAGA!!!
//1. Każda komenda w tablicy wzorców musi kończyć się znakiem null: \n
//2. Podczas wysyłania komend AT za pomocą Bluetooth komenda także powinna
//być kończona znakiem: \n
const char wzorce_komend[][AT_ILOSC_ZNAKOW] PROGMEM = {"AT+STAN\n",
"AT+POMPA\n",
"AT+SIEC\n",
"AT+PRZOD\n",
"AT+BOK\n",
"AT+TYL\n",
"AT+STOP\n"};
//Oblicz ilość wprowadzonych wzorców komend AT
#define AT_ILOSC_WZORCOW(sizeof(wzorce_komend)/AT_ILOSC_ZNAKOW)
//=== Bufor odebranych komend ====================
char bufor_odb[AT_ILOSC_ZNAKOW + 1];//bufor
volatile char at_odebrano_znakow = 0;//indeks znaku w tablicy bufora
//=== Bufor nadawczy (wysyłany tekst) ====================
#define BUFOR_NAD_IL_ZNAKOW 16
char bufor_nad[BUFOR_NAD_IL_ZNAKOW];
int i;
//--------------------------------------------------------------
void usart_inicjuj(void)
{
//Definiowanie parametrów transmisji za pomocą makr zawartych w pliku
//nagłówkowym setbaud.h. Jeżeli wybierzesz prędkość, która nie będzie
//możliwa do realizacji otrzymasz ostrzeżenie:
//#warning "Baud rate achieved is higher than allowed"
//Nie lekceważ go!!!
#define BAUD 9600 //9600bps standardowa prędkość transmisji modułu HC-05
#include <util/setbaud.h> //linkowanie tego pliku musi nastąpić
//po zdefiniowaniu BAUD
//ustaw obliczone przez makro wartości
UBRRH = UBRRH_VALUE;
UBRRL = UBRRL_VALUE;
#if USE_2X
UCSRA |= (1<<U2X);
#else
UCSRA &= ~(1<<U2X);
#endif
//Ustawiamy pozostałe parametry modułu USART
//U W A G A !!!
//W ATmega8, aby zapisać do rejestru UCSRC należy ustawiać bit URSEL
//zobacz także: http://mikrokontrolery.blogspot.com/2011/04/avr-czyhajace-pulapki.html#avr_pulapka_2
//standardowe parametry transmisji modułu HC-05
UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);//bitów danych: 8
//bity stopu: 1
//parzystość: brak
//włącz nadajnik i odbiornik oraz ich przerwania odbiornika
//przerwania nadajnika włączamy w funkcji wyslij_dane()
UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
}
//--------------------------------------------------------------
ISR(USART_RXC_vect)
{
//przerwanie generowane po odebraniu bajtu za pomocą USART
//indeks tablicy odbiorczej
static int bufor_odb_ind = 0;
//zapamiętaj odebraną liczbę
bufor_odb [bufor_odb_ind] = UDR;
//koniec komendy AT? (znak null, czyli \n, czyli zero)
if (bufor_odb [bufor_odb_ind] == 0x00) {
//tak, odebrano znak końca komendy
odb_flaga = 1; //ustaw flagę odbioru komendy - potrzebna dla main()
at_odebrano_znakow = bufor_odb_ind; //zapamiętaj ilość odebranych znaków
bufor_odb_ind = 0;//ustaw indeks na początek bufora odbiorczego
}else{
//nie, to nie jest ostatni bajt komendy
bufor_odb_ind++;//indeks bufora na następny wolny bajt
//czy przekroczono długość bufora?
if (bufor_odb_ind >= AT_ILOSC_ZNAKOW){
//tak przekroczono, czyli tekst odebrany nie jest komendą
//zaczynamy więc od początku
bufor_odb_ind = 0;
}
}
}
//--------------------------------------------------------------
ISR(USART_UDRE_vect){
//przerwanie generowane, gdy bufor nadawania jest już pusty,
//odpowiedzialne za wysłanie wszystkich znaków z tablicy bufor_nad[]
//indeks bufora nadawania
static int bufor_nad_ind = 0;
//sprawdzamy, czy bajt do wysłania nie jest znakiem końca tekstu (czyli zerem)
//i czy nie dotarliśmy już do końca tablicy bufora nadawania
if((bufor_nad[bufor_nad_ind] != 0) && (bufor_nad_ind < BUFOR_NAD_IL_ZNAKOW)){
//są jeszcze znaki do wysłania
//załaduj znak do rejestru wysyłki i ustaw indeks na następny znak
UDR = bufor_nad[bufor_nad_ind++];
}else{
//osiągnięto koniec napisu w tablicy bufor_nad[]
UCSRB &= ~(1<<UDRIE); //wyłącz przerwania pustego bufora nadawania
//co zakończy nadawanie
//zeruj indeks bufora nadawania
bufor_nad_ind = 0;
}
}
//--------------------------------------------------------------
void wyslij_dane(void){
//funkcja rozpoczyna inicjuje wysyłanie danych
//na wszelki wypadek upewnij się, że bufor nadawania USART jest pusty
while (!(UCSRA & (1<<UDRE)));
//bufor jest pusty można wysłać
//włącz przerwania pustego bufora UDR, co rozpocznie transmisję
//aktualnej zawartości bufora
UCSRB |= (1<<UDRIE);
//Wysyłką danych zajmie się funkcja przerwania ISR(USART_UDRE_vect)
}
int getADC(char number)
//number należy do <0, 7>, kod nie sprawdza szkoda pamięci FLASH
{
ADMUX &= 0xf0; //zerowanie 4 młodszych bitów
ADMUX |= number; //ustawianie numeru kanału
ADCSRA |= 1<<ADSC; //zaczyna konwersję
while(ADCSRA & (1 << ADIF)); //dopóki bit ADIF nie jest ustawiony nie jest gotowa konwersja
ADCSRA &= ~((1 << ADSC) | (1 << ADIF)); //zeruj flage konwersji i rozkaz rozpoczęcia
return ADC;
}
//--------------------------------------------------------------
void at_komenda_reakcja(unsigned char at_komenda_nr){
// Funkcja przełączająca reakcję na odebraną i rozpoznaną
// komendę AT wg kolejności w tablicy wzorcowej wzorce_komend[]
switch(at_komenda_nr){
case 0: //AT+STAN
wyslij_dane();
break;
case 1: //AT+POMPA
PORTD|= (1<<PD2);
PORTD&= ~(1<<PD3);
break;
case 2: //AT+SIEC
PORTD|= (1<<PD3);
PORTD&= ~(1<<PD2);
break;
case 3: //AT+PRZOD
PORTD|= (1<<PD4);
break;
case 4: // AT+BOK
PORTD|= (1<<PD5);
break;
case 5: //AT+TYL
PORTD|= (1<<PD6);
break;
case 6: //AT+STOP
PORTD&= ~( (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6) );
//a jednego portu łączyć je, by skrócić ilość operacji do jednej najpierw sumując poszczególne bity za pomocą | , a następnie negując je wszystkie razem za pomocą ~
break;
// i tak dalej
}
}
//--------------------------------------------------------------
void at_komenda_sprawdz(void){
//zmienna pomocnicza
unsigned int nr_rozpoznanej_komendy;
//zgaś flagę odebrania komendy
odb_flaga = 0;
//Pętla przeszukująca tablicę wzorców komend i porównująca wzorzec
//z odebraną komendą. Komenda spoza tablicy wzorców jest ignorowana.
//Funkcja strncasecmp_P() porównuje ciąg znaków ASCII zawarty w tablicy
//bufor_odb[] umieszczoną w pamięci SRAM z wybranym wzorcem z tablicy
//wzorce_komend[] która znajduje się w pamięci FLASH.
//Funkcja strncasecmp_P() nie rozróżnia dużych i małych liter,
//w związku z czym ich wielkość nie ma znaczenia przy wydawaniu komend
//przez USART (Bluetooth), czyli smartfona.
//rozpoczynamy od początku tablicy wzorców
nr_rozpoznanej_komendy = 0;
//dla kolejnych komend z tablicy wzorców
do{
//sprawdź, czy zgadza się ilość znaków odebranej komendy z badanym wzorcem
if(at_odebrano_znakow == (strlen_P(wzorce_komend[nr_rozpoznanej_komendy])-1)){//-1 ponieważ
//do porównania nie bierzemy znaku końca tekstu
//tak, ilość znaków zgodna
//sprawdź więc, czy rozpoznałeś właściwą komendę porównując znak po znaku
//odebrany tekst (umieszczony w buforze) z wybraną komendą wzorcową
if(!strncasecmp_P(bufor_odb, wzorce_komend[nr_rozpoznanej_komendy], at_odebrano_znakow)){
//rozpoznano komendę AT
at_komenda_reakcja(nr_rozpoznanej_komendy);//reaguj na odebraną komendę
//przerwij wykonywanie pętli while ponieważ już rozpoznaliśmy
// odebraną komendę
break;
}
}
//przejdź do następnej komendy w tabeli wzorców komend
nr_rozpoznanej_komendy++;
}while(nr_rozpoznanej_komendy < AT_ILOSC_WZORCOW);
}
void init() //procedura inicjalizacji podstawowych funkcji
{
/*INICJALIZACJA ADC */
ADCSRA = (1<<ADEN) |(1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2); //włączenie przetwornika adc oraz ustawienie prescalera na 128
ADMUX = (1<<REFS0) | (1<<MUX2) | (1<<MUX0); //napięcie zasilania AVcc, jako napięcie odniesienia Vref. i ADC0
DDRC &=~ (1<<PC0); //ADC0 jako wejście
//ustaw piny PD2-6 na wyjście
DDRD|= ( (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6) );
//--------------------------------------------------------------
}
int main(void)
{
init(); // inicjalizacja
//inicjuj moduł USART (RS-232)
usart_inicjuj();
//włącz przerwania globalne
sei();
while(1){
//Czekamy na informację o odebraniu danej nie blokując mikrokontrolera
//Jeżeli przerwanie poinformuje za pomocą ustawienia flago odb_flaga
//oznacza to, że odebrano komendę i należy ją rozpoznać
if(odb_flaga){ at_komenda_sprawdz()}
_delay_ms(500);
i = getADC(0);
itoa(i,bufor_nad,10);
if(i<100)//jeśli wynik ADC mniejszy od 100 wyłącza programy
{
PORTD&= ~( (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6) );
}
}
}
}[/syntax]
ADC:
Main
[syntax=cpp]int main(void)
{
init(); // inicjalizacja
//inicjuj moduł USART (RS-232)
usart_inicjuj();
//włącz przerwania globalne
sei();
while(1){
//Czekamy na informację o odebraniu danej nie blokując mikrokontrolera
//Jeżeli przerwanie poinformuje za pomocą ustawienia flago odb_flaga
//oznacza to, że odebrano komendę i należy ją rozpoznać
if(odb_flaga){ at_komenda_sprawdz()}
_delay_ms(500);
i = getADC(0);
itoa(i,bufor_nad,10);
if(i<100)//jeśli wynik ADC mniejszy od 100 wyłącza programy
{
PORTD&= ~( (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5) | (1<<PD6) );
}
}
}
}[/syntax]
reszta adc
[syntax=cpp]ISR(USART_UDRE_vect){
//przerwanie generowane, gdy bufor nadawania jest już pusty,
//odpowiedzialne za wysłanie wszystkich znaków z tablicy bufor_nad[]
//indeks bufora nadawania
static int bufor_nad_ind = 0;
//sprawdzamy, czy bajt do wysłania nie jest znakiem końca tekstu (czyli zerem)
//i czy nie dotarliśmy już do końca tablicy bufora nadawania
if((bufor_nad[bufor_nad_ind] != 0) && (bufor_nad_ind < BUFOR_NAD_IL_ZNAKOW)){
//są jeszcze znaki do wysłania
//załaduj znak do rejestru wysyłki i ustaw indeks na następny znak
UDR = bufor_nad[bufor_nad_ind++];
}else{
//osiągnięto koniec napisu w tablicy bufor_nad[]
UCSRB &= ~(1<<UDRIE); //wyłącz przerwania pustego bufora nadawania
//co zakończy nadawanie
//zeruj indeks bufora nadawania
bufor_nad_ind = 0;
}
}
//--------------------------------------------------------------
void wyslij_dane(void){
//funkcja rozpoczyna inicjuje wysyłanie danych
//na wszelki wypadek upewnij się, że bufor nadawania USART jest pusty
while (!(UCSRA & (1<<UDRE)));
//bufor jest pusty można wysłać
//włącz przerwania pustego bufora UDR, co rozpocznie transmisję
//aktualnej zawartości bufora
UCSRB |= (1<<UDRIE);
//Wysyłką danych zajmie się funkcja przerwania ISR(USART_UDRE_vect)
}
int getADC(char number)
//number należy do <0, 7>, kod nie sprawdza szkoda pamięci FLASH
{
ADMUX &= 0xf0; //zerowanie 4 młodszych bitów
ADMUX |= number; //ustawianie numeru kanału
ADCSRA |= 1<<ADSC; //zaczyna konwersję
while(ADCSRA & (1 << ADIF)); //dopóki bit ADIF nie jest ustawiony nie jest gotowa konwersja
ADCSRA &= ~((1 << ADSC) | (1 << ADIF)); //zeruj flage konwersji i rozkaz rozpoczęcia
return ADC;
}[/syntax]Statystyki: Napisane przez macko333 — 15 lut 2015, o 15:54
]]>