ATNEL tech-forum 2014-02-19T20:41:47+01:00 https://forum.atnel.pl/feed.php?f=4&t=5773&mode 2014-02-19T20:41:47+01:00 2014-02-19T20:41:47+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=71172#p71172 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]>
w pętli while dałem

[syntax=c]int8_t signed_cel = atoi(strtok(buffer, "."));
lcd_locate(0,11);
lcd_int(signed_cel); //wyświetlenie liczby int[/syntax]

No i wyświetla mi się temperatura ładnie (tylko cześć całkowita- tyle wystarczy)

stworzyłem funkcje
[syntax=c]void alarm ();[/syntax]

[syntax=c]void alarm ()
{

T1=T_zad+HIS;
T2=T_zad-HIS;

if(signed_cel<T1)
{
BUZ_ON;
_delay_ms(1000);
BUZ_OFF;
}
if(signed_cel>T2)
{
BUZ_ON;
_delay_ms(1000);
BUZ_OFF;
}
}[/syntax]

Statystyki: Napisane przez Morcinek92 — 19 lut 2014, o 20:41

]]> 2014-02-15T13:42:02+01:00 2014-02-15T13:42:02+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70548#p70548 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> [syntax=c]char temp[] = "-21.3 C "; //łańcuch znaków z temperaturą
int8_t signed_cel = atoi(strtok(temp, "."));//cześć całkowita temperatury ze znakiem (-21)
//funkcja atoi zamienia łańcuch znaków na liczbę int
//funkcja strtok dzieli łańcuch na części powyższe wywołanie rozdziela tam gdzie .
lcd_int(signed_cel); //wyświetlenie liczby int
lcd_str("*");//jakiś tekst
uint8_t cel_fract = atoi(strtok(NULL, " ")); //cześć ułamkowa temperatury (3)
//kolejne wywołanie odnosi się do tej części łańcuch, która jest za .
//i dodatkowo zostaje obcięta część za spacją
lcd_int(cel_fract); //wyświetlenie liczby int
int16_t temp_int; //temperatura bez przecinka (-213)
if(signed_cel < 0)
temp_int = signed_cel*10 - cel_fract; //od ujemnych odejmij
else
temp_int = signed_cel*10 + cel_fract; //do dodatnich dodaj
lcd_str(" ");//jakiś tekst
lcd_int(temp_int);[/syntax]
Opis funkcji atoi w języku angielskim znajdziesz tutaj, a funkcji strtok tu. Po polsku jest w książkach Mirka przy okazji omawiania LCD albo parsowania stringów do sterowania komendami AT.

Statystyki: Napisane przez Krauser — 15 lut 2014, o 13:42

]]> 2014-02-15T11:19:54+01:00 2014-02-15T11:19:54+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70537#p70537 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Odległość wynosi około 5 m . W sumie czasami działa dobrze czasami nie, jutro wezmę się za wytrawienie płytek i mam nadzieje że nie będzie takich problemów. :D

Mam takie pytanie, bo chce zrobić do tego jeszcze termostat. Już mam prawie skończony tylko problem pojawił się kiedy chce żeby temperatura zadana była porównywana z temperatura rzeczywistą.

[syntax=c]uint8_t ACTIVE_HEAT = 0;[/syntax]

[syntax=c]if(ACTIVE_HEAT)
{
T1=T_zad+HIS;
T2=T_zad-HIS;

if(buffer<T2)
{
BUZZER_ON;
}
if(buffer>T1)
{
BUZZER_OFF;

}
}[/syntax]

No i właśnie nie wiem jak to zrobić..
Przy normalnym odczycie mógłbym wpisać "cel".

Statystyki: Napisane przez Morcinek92 — 15 lut 2014, o 11:19

]]> 2014-02-15T01:16:06+01:00 2014-02-15T01:16:06+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70524#p70524 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Ja sobie testuje w odległości 8m i jest OK (100 kolejnych ramek doszło), a mam w pobliżu router WiFi, mysz Bluetooth i ATB-BTM-222 przez który wysyłam pomiary do kompa lub na telefon.
Na schemacie od producenta są 2 kondensatory 100nF i 1uF. Takie kondensatory powinny być blisko modułu, a sam moduł również ma filtrowane zasilanie.
Dobrze dobrana antena oczywiście zwiększy zasięg, a że moduły są tanie to można bez obaw eksperymentować.

Statystyki: Napisane przez Krauser — 15 lut 2014, o 01:16

]]> 2014-02-14T09:28:56+01:00 2014-02-14T09:28:56+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70398#p70398 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]>

edit:

Dziwna sytuacja..
Ustawiam czujnik pod pin np. PD6 (zmieniałem piny) , wpinam przewód połączeniowy pod pin, ale nie podłączam - dioda miga- pojedynczo i wyświetla "0,0 C", dotknę ręką przewodu miga dwukrotnie i wyświetla mi ERROR ... zmieniałem przewody, nic to nie dało..


Okej, już działa, choć przyznam, że nie wiem dlaczego się tak działo..
Dziękuję bardzo Krauser


Mam takie pytanie odnośnie zasięgu między tymi modułami...
Zauważyłem, że kiedy dotknę palcem antenę od nadajnika, w tedy elegancko dane dochodza do odbiornika z równa częstotliwośćią , kiedy wezmę palec przychodzą strasznie nieregularnie... czym to możę być spowodowane? długościa kabli?? dodałem w module kondensator filtrujący 100nf no ale dużej różnicy nie ma.. myślałem o dodaniu anteny..

Statystyki: Napisane przez Morcinek92 — 14 lut 2014, o 09:28

]]> 2014-02-13T22:58:09+01:00 2014-02-13T22:58:09+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70375#p70375 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Jutro z samego rano sprawdzę :D

Statystyki: Napisane przez Morcinek92 — 13 lut 2014, o 22:58

]]> 2014-02-13T20:58:53+01:00 2014-02-13T20:58:53+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=70354#p70354 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Nadajnik:
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include "MK_RFM70/rfm70.h" //z zielonej książki Mirka
#include "1Wire/ds18x20.h" //z niebieskiej książki Mirka
#include <string.h>

char* format_string(char * str);

#define LED_PIN (1<<PB0)
#define LED_ON PORTB &= ~LED_PIN
#define LED_OFF PORTB |= LED_PIN

uint8_t sensor_cnt; //liczba czujników
uint8_t subzero, cel, cel_fract_bits; //zmienne przechowujące temperaturę: znak, część całkowita, część ułamkowa
char temp[20]; //łańcuch znaków wysyłany przez radio

int main(void)
{
RFM70_Init();
SetChannelNum(41);

DDRB |= LED_PIN; //dioda sygnalizacyjna
LED_OFF;

sensor_cnt = search_sensors();

while (1)//prymitywna obsługa termometru ;)
{
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL ); //rozpocznij pomiar
_delay_ms(1000); //czekaj 1s na zakończenie pomiaru
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) )//odczytaj wynik i jak OK to
{
//wyślij łańcuch znaków z temperaturą
Send_Packet(W_TX_PAYLOAD_NOACK_CMD, format_string(temp), strlen(format_string(temp)));
LED_ON; //mignij raz
_delay_ms(100);
LED_OFF;
}
else
{
//wyślij błąd
Send_Packet(W_TX_PAYLOAD_NOACK_CMD, "ERROR!", strlen("ERROR!"));
LED_ON; //mignij 2 razy
_delay_ms(100);
LED_OFF;
_delay_ms(100);
LED_ON;
_delay_ms(100);
LED_OFF;
}
}
}

//funkcja konwertująca zmienne przechowujące temperaturę na łańcuch znaków
char* format_string(char * str)
{
char buf[5];
str[0] = '\0'; //wyczyść łańcuch znaków
if(subzero)
strcat(str,"-"); //jeśli subzero==1 dopisz znak minus (temp. ujemna)
else
strcat(str," "); //jeśli subzero==0 dopisz spację zamiast znaku minus (temp. dodatnia)
strcat(str, itoa(cel, buf,10));//dopisz dziesiętne części temperatury
strcat(str,"."); //dopisz kropkę
strcat(str, itoa(cel_fract_bits, buf,10)); //dopisz dziesiętne części stopnia
strcat(str," C "); //dopisz znak jednostek (C - stopnie Celsiusza)
return str;
}[/syntax]

Odbiornik:
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include "MK_RFM70/rfm70.h" //z zielonej książki Mirka
#include "MKUART/mkuart.h" //z niebieskiej książki Mirka
#include "LCD/lcd44780.h" //z niebieskiej książki Mirka

#define LED_PIN (1<<PB0)
#define LED_DDR DDRB
#define LED_PORT PORTB
#define LED_ON LED_PORT &= ~LED_PIN
#define LED_OFF LED_PORT |= LED_PIN

#define LCD_BL (1<<PA7)
#define LCD_BL_DDR DDRA
#define LCD_BL_PORT PORTA

char rx_tmp[20];
uint8_t len = 0;

int main(void)
{
char buffer[17] = "TEMPERATURA";
LCD_BL_DDR |= LCD_BL;
LCD_BL_PORT |= LCD_BL;
RFM70_Init();
SetChannelNum(41);

LED_DDR |= LED_PIN;
LED_OFF;

lcd_init();
lcd_cls();
lcd_locate(0,0);
lcd_str(buffer);

USART_Init(__UBRR);
sei();
uart_puts(buffer);

while (1)
{
len = Receive_Packet(rx_tmp);
if (len > 0)//jeśli odebrano jakieś dane
{
LED_ON; //mignij raz
_delay_ms(100);
LED_OFF;
_delay_ms(100);
uart_puts(rx_tmp); //wyślij na port szeregowy
strlcpy(buffer, rx_tmp, 17);
lcd_locate(1,0);
lcd_str(buffer); //i wyświetl
lcd_str(" ");
}
}
}[/syntax]

Statystyki: Napisane przez Krauser — 13 lut 2014, o 20:58

]]> 2014-02-10T00:43:32+01:00 2014-02-10T00:43:32+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=69603#p69603 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Dopiero potem wysyłać temperaturę :)

Statystyki: Napisane przez mikandrzej — 10 lut 2014, o 00:43

]]> 2014-02-05T15:58:07+01:00 2014-02-05T15:58:07+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68537#p68537 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Funkcja wysyłąnia:

[syntax=c]void display_temp(uint16_t TTemp);
uint8_t TabTemp[2];[/syntax]

[syntax=c]void display_temp(uint16_t TTemp){
TTemp = display_temp;
TabTemp[0]= (uint8_t)TTemp; //młodszy bajt
TabTemp[1]= (uint8_t)(TTemp>>8); //starszy bajt
uint16_t wynik;
char ASCII[5];
wynik = TabTemp;
itoa(wynik, ASCII, 10 );

Send_Packet( W_TX_PAYLOAD_NOACK_CMD, ASCII, 4);
_delay_ms(100);
}[/syntax]


Odbiornik:

[syntax=c]void my_receive_packet( void * pBuf, uint8_t len );[/syntax]

[syntax=c]void my_receive_packet( void * pBuf, uint8_t len ) {
lcd_locate(1,2);
lcd_str( &pBuf[0] );
}[/syntax]




Nadal nie dziala tak jak powinno:((

Statystyki: Napisane przez Morcinek92 — 5 lut 2014, o 15:58

]]> 2014-02-04T20:07:10+01:00 2014-02-04T20:07:10+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68390#p68390 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> czy do funkcji wyświetlającej przesyłasz
liczby przekonwertowane na string ?

Statystyki: Napisane przez Zaba — 4 lut 2014, o 20:07

]]> 2014-02-04T13:14:22+01:00 2014-02-04T13:14:22+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68363#p68363 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> #include <avr/interrupt.h>
#include <util/delay.h>
#include <string.h>
#include <stdio.h>

#include "MK_RFM70/rfm70.h"
#include "1Wire/ds18x20.h"

void display_temp(uint16_t TTemp);
uint8_t TabTemp[2];


uint8_t czujniki_cnt;/* ilość czujników na magistrali */
volatile uint8_t s1_flag;/* flaga tyknięcia timera co 1 sekundę */
volatile uint8_t sekundy;/* licznik sekund 0-59 */
uint8_t subzero, cel, cel_fract_bits;


int main(void){

/* ustawienie TIMER0 dla F_CPU=11,0592MHz */
TCCR2 |= (1<<WGM21);/* tryb CTC */
TCCR2 |= (1<<CS20)|(1<<CS21)|(1<<CS22);/* preskaler = 1024 */
OCR2 = 108;/* dodatkowy podział przez 108 (rej. przepełnienia) */
TIMSK |= (1<<OCIE2);/* zezwolenie na przerwanie CompareMatch */
/* przerwanie wykonywane z częstotliwością ok 10ms (100 razy na sekundę) */
/* do naszych celów nie musi być to bardzo dokładne 10ms */

RFM70_Init();
SetChannelNum(41);

czujniki_cnt = search_sensors();
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
_delay_ms(750);

if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);

sei();

while(1)
{

if(s1_flag) {

if( 0 == (sekundy%3) ) czujniki_cnt = search_sensors();
if( 1 == (sekundy%3) ) DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
if( 2 == (sekundy%3) ) {
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
}

s1_flag=0;
}
}
}

void display_temp(uint16_t TTemp){
TTemp = display_temp;
TabTemp[0]= (uint8_t)TTemp; //młodszy bajt
TabTemp[1]= (uint8_t)(TTemp>>8); //starszy bajt


Send_Packet( W_TX_PAYLOAD_NOACK_CMD, TabTemp, 3);
_delay_ms(100);
}


ISR(TIMER2_COMP_vect)
{
static uint8_t cnt=0;/* statyczna zmienna cnt do odliczania setnych ms */

if(++cnt>99) {/* gdy licznik ms > 99 (minęła 1 sekunda) */
s1_flag=1;/* ustaw flagę tyknięcia sekundy */
sekundy++;/* zwiększ licznik sekund */
if(sekundy>59) sekundy=0; /* jeśli ilość sekund > 59 - wyzeruj */
cnt=0;/* wyzeru licznik setnych ms */
}
}[/syntax]

Dotychczas tyle napisałem dla nadajnika.
Lecz na wyswietlaczu pojawiają mi się dziwne znaki, a nie liczby... (chińskie)

Statystyki: Napisane przez Morcinek92 — 4 lut 2014, o 13:14

]]> 2014-02-02T14:25:45+01:00 2014-02-02T14:25:45+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68038#p68038 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Morcinek92 napisał(a):

Czy jest ktoś w stanie mi pomóć??
a projekt ze str 395 niebieskiej książki przestudiowałeś?

Statystyki: Napisane przez wireless — 2 lut 2014, o 14:25

]]> 2014-02-02T13:55:45+01:00 2014-02-02T13:55:45+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68034#p68034 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> tylko przeczytałem o tym że nadajnik ATmega8 i rzuciło mi się w kodzie Timer0 CTC
taki alarmik mi zadzwonił w głowie :D

Statystyki: Napisane przez Zaba — 2 lut 2014, o 13:55

]]> 2014-02-02T12:29:40+01:00 2014-02-02T12:29:40+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68022#p68022 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Statystyki: Napisane przez Morcinek92 — 2 lut 2014, o 12:29

]]> 2014-02-02T11:32:57+01:00 2014-02-02T11:32:57+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=68003#p68003 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Nie chciałbym za bardzo mieszać Ci w projekcie ale
w nadajniku używasz ATmegi8 a jej Timer0 nie ma trybu CTC
i to
[syntax=c]/* ustawienie TIMER0 dla F_CPU=11,0592MHz */
TCCR0 |= (1<<WGM01); /* tryb CTC */
TCCR0 |= (1<<CS02)|(1<<CS00); /* preskaler = 1024 */
OCR0 = 108; /* dodatkowy podział przez 108 (rej. przepełnienia)[/syntax]

na pewno nie będzie działać tak jak zamierzasz :)
o ile dobrze pamiętam to tryb CTC w AT8 jest w 16-bitowym timerze

Statystyki: Napisane przez Zaba — 2 lut 2014, o 11:32

]]> 2014-02-02T08:22:04+01:00 2014-02-02T08:22:04+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=67982#p67982 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Statystyki: Napisane przez Morcinek92 — 2 lut 2014, o 08:22

]]> 2014-02-01T12:48:08+01:00 2014-02-01T12:48:08+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=67760#p67760 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> icer_cmg napisał(a):

RFM73 to nowsza wersja RFM70. Po drobnej zmianie inicjacji działa kod od starszej wersji - jest to opisane również na forum. Możesz więc szukać RFM70 i lekko zmodyfikować.


Dokładnie masz rację. Tą zmianę już dokonałem w bibliotekach. Komunikacja jest w porządku.
Szukałem właśnie projektów pod RFM70, lecz żadnych rezultatów.
Mscichu napisał(a):

Zaproponuję aby w nadajniku, który ma mieć zasilanie bateryjne korzystać z jak najniższej częstotliwości. Zobacz wykresy w datasheet, że mega8 przy 1MHz pobiera niecałe 2mA w stanie aktywnym, a przy 12MHz około 8mA. Oczywiście wydaje się, że to mało, ale dobrą praktyką jest aby nie uczyć się złych nawyków, a czterokrotne zmniejszenie zużycia energii to dobry pomysł. Dodatkowo usypianie RFM73 w nadajniku i wysyłanie danych co jakiś czas.


Bardzo dobra propozycja, postaram się do niej dostosować jest to bardzo duża różnica w poborze prądu przy zasilaniu bateryjnym.

Statystyki: Napisane przez Morcinek92 — 1 lut 2014, o 12:48

]]> 2014-02-01T11:51:16+01:00 2014-02-01T11:51:16+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=67751#p67751 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Statystyki: Napisane przez Mscichu — 1 lut 2014, o 11:51

]]> 2014-02-01T11:07:14+01:00 2014-02-01T11:07:14+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=67743#p67743 <![CDATA[Re: Pomiar temperatury = RFM73, DS18b20, LCD]]> Statystyki: Napisane przez icer_cmg — 1 lut 2014, o 11:07

]]> 2014-02-01T09:30:45+01:00 2014-02-01T09:30:45+01:00 https://forum.atnel.pl/viewtopic.php?t=5773&p=67735#p67735 <![CDATA[Pomiar temperatury = RFM73, DS18b20, LCD]]>
Pracuje nad projektem, którego zadaniem jest pomiar temperatury.

Założenia projektu:
Nadajnik:
Procesor: Atmega8 taktowana zew. 12Mhz.
Czujnik: Dallas DS18b20
Moduł radiowy: RFM73
Zasilanie: 3,3V (docelowo bateryjne)
Praca na zewnątrz- pomiar temperatury.

Odbiornik:
Procesor: Atmega8 taktowana zew. 12Mhz.
Wyświetlacz: LCD 16x2
Moduł radiowy: RFM73
Zasilanie: 3,3 dla modułu, oraz 5V dla wyświetlacza
Praca w domu

Odległość 60m. (mam nadzieje że dają rade, w razie czego wymienię na RFM12).

Głównie chodzi o sam pomiar temperatury w wędzarniku, a wynik przesyłany na wyświetlacz.

Układy mam poskładane na płytkach testowych:
Nadajnik:
Obrazek

Odbiornik:
Obrazek

Podstawową komunikacje wydaje mi się że mam już za sobą, typu: miganie diodą , wszystko działa.
Jeśli chodzi o pomiar temperatury z tym mam problem nie wiem jak się za to zabrać chodzi o przesyłanie wyniku pomiaru do odbiornika i pokazanie na LCD.

Kod:
Nadajnik:
[syntax=c]//Autor: Marcin Wójcik
//Data: 31.01.2014r.


#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "MK_RFM73/rfm70.h"
#include "1Wire/ds18x20.h"

void send_temp(uint8_t x);

uint8_t czujniki_cnt;/* ilość czujników na magistrali */
volatile uint8_t s1_flag;/* flaga tyknięcia timera co 1 sekundę */
volatile uint8_t sekundy;/* licznik sekund 0-59 */

uint8_t subzero, cel, cel_fract_bits;

int main(void){

RFM70_Init();
SetChannelNum(41);

/* ustawienie TIMER0 dla F_CPU=11,0592MHz */
TCCR0 |= (1<<WGM01);/* tryb CTC */
TCCR0 |= (1<<CS02)|(1<<CS00);/* preskaler = 1024 */
OCR0 = 108;/* dodatkowy podział przez 108 (rej. przepełnienia) */
TIMSK |= (1<<OCIE0);/* zezwolenie na przerwanie CompareMatch */
/* przerwanie wykonywane z częstotliwością ok 10ms (100 razy na sekundę) */
/* do naszych celów nie musi być to bardzo dokładne 10ms */

/* sprawdzamy ile czujników DS18xxx widocznych jest na magistrali */
czujniki_cnt = search_sensors();

/* wysyłamy rozkaz wykonania pomiaru temperatury
* do wszystkich czujników na magistrali 1Wire
* zakładając, że zasilane są w trybie NORMAL,
* gdyby był to tryb Parasite, należałoby użyć
* jako pierwszego prarametru DS18X20_POWER_PARASITE */
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

/* czekamy 750ms na dokonanie konwersji przez podłączone czujniki */
_delay_ms(750);

/* dokonujemy odczytu temperatury z pierwszego czujnika o ile został wykryty */
/* wyświetlamy temperaturę gdy czujnik wykryty */
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) send_temp(0);
else {

//tutaj wyslyanie do odbiornika
Send_Packet( W_TX_PAYLOAD_NOACK_CMD, "Error!", 4);
}

sei();/* włączamy globalne przerwania */


while(1){


if(s1_flag) {/* sprawdzanie flagi tyknięć timera programowego co 1 sekundę */

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 0 sprawdzaj ilość dostępnych czujników */
if( 0 == (sekundy%3) ) czujniki_cnt = search_sensors();

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 1 wysyłaj rozkaz pomiaru do czujników */
if( 1 == (sekundy%3) ) DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 2 czyli jedną sekundę po rozkazie konwersji
* dokonuj odczytu i wyświetlania temperatur z 2 czujników jeśli są podłączone, jeśli nie
* to pokaż komunikat o błędzie
*/
if( 2 == (sekundy%3) ) {
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) send_temp(0);
else {
//tutaj wyslyanie do odbiornika
Send_Packet( W_TX_PAYLOAD_NOACK_CMD, "Error!", 4);
}
}

/* zerujemy flagę aby tylko jeden raz w ciągu sekundy wykonać operacje */
s1_flag=0;
} /* koniec sprawdzania flagi */
} /* koniec pętli nieskończonej */
}

//No i tutaj !


/* wyświetlanie temperatury na pozycji X w drugiej linii LCD */
void send_temp(uint8_t x) {
//lcd_locate(1,x);
if(subzero) lcd_str("-");/* jeśli subzero==1 wyświetla znak minus (temp. ujemna) */
else lcd_str(" ");/* jeśli subzero==0 wyświetl spację zamiast znaku minus (temp. dodatnia) */
lcd_int(cel);/* wyświetl dziesiętne części temperatury */
lcd_str(".");/* wyświetl kropkę */
lcd_int(cel_fract_bits); /* wyświetl dziesiętne części stopnia */
lcd_str(" C "); /* wyświetl znak jednostek (C - stopnie Celsiusza) */
}

////////////

/* ================= PROCEDURA OBSŁUGI PRZERWANIA – COMPARE MATCH */
/* pełni funkcję timera programowego wyznaczającego podstawę czasu = 1s */
ISR(TIMER0_COMP_vect)
{
static uint8_t cnt=0;/* statyczna zmienna cnt do odliczania setnych ms */

if(++cnt>99) {/* gdy licznik ms > 99 (minęła 1 sekunda) */
s1_flag=1;/* ustaw flagę tyknięcia sekundy */
sekundy++;/* zwiększ licznik sekund */
if(sekundy>59) sekundy=0; /* jeśli ilość sekund > 59 - wyzeruj */
cnt=0;/* wyzeru licznik setnych ms */
}
}[/syntax]

Odbiornik:

[syntax=c]//Autor: Wójcik Marcin (Morcinek92)
//Data: 31,01,2014r.


#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include "MK_RFM73/rfm70.h"
#include "LCD/lcd44780.h"

#define LED_PIN_TEST (1<<PD1)
#define LED_ON_TEST PORTD &= ~LED_PIN_TEST
#define LED_OFF_TEST PORTD |= LED_PIN_TEST

volatile unsigned char rx_tmp[20];
volatile uint8_t len_moje = 0;

uint8_t znak_termo[] PROGMEM = {4,10,10,10,17,31,31,14};// wzór znaku termometru w pamięci FLASH
uint8_t znak_stopnia[] PROGMEM= {31,17,31,32,32,32,32,32}; //znak stopnia
uint8_t znak_celcjusza[] PROGMEM= {15,16,16,16,16,16,16,15}; //znak celcjusza

int main(void)
{
lcd_init();

// załadowanie znaków do pamięci CGRAM
lcd_defchar_P(0x83, znak_termo);
lcd_defchar_P(0x84, znak_stopnia);
lcd_defchar_P(0x85, znak_celcjusza);
// wyświetlenie własnych znaków na LCD
lcd_locate(1,5);
lcd_str("\x83");//znak termometru
lcd_locate(1,6);
lcd_str("20,0"); // W tym miejscu ma wysylać wartość aktualnej temperatury
lcd_locate(1,10);
lcd_str("\x84");//znak stopnia
lcd_locate(1,11);
lcd_str("\x85"); // znak celcjusza
lcd_locate(0,0);
lcd_str("Temp. Wedzarnik");

RFM70_Init();
SetChannelNum(41);

DDRD |= LED_PIN_TEST;
LED_OFF_TEST;






while(1)
{
len_moje = Receive_Packet(rx_tmp);
// jeśli odbiornik odebrał "test"
if (len_moje == 4)
{


LED_ON_TEST;
_delay_ms(1000);

LED_OFF_TEST;
_delay_ms(1000);


}
}
}[/syntax]


Szukałem w sieci jakiś wskazówek lecz nie znalazłem konkretnie takiego projektu, albo podobnych.. albo mało szukałem, albo to jest takie banalne że wszyscy sobie z tym radzą :D

Statystyki: Napisane przez Morcinek92 — 1 lut 2014, o 09:30

]]>