ATNEL tech-forum

Re: Odp: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2013-01-02T15:12:17+01:00

Dziękuję za odpowiedz, nie mam aż takich ambicji i potrzeb to ma być po prostu system monitoringu temperatury w gospodarstwie, gdzie czasem trzeba dogrzac kurnik, psiarnie, itp. Dodatkowo jedynie chce jeszcze by była możliwość sprawdzenia temperatury na piecu i w domu

Statystyki: Napisane przez Gość — 2 sty 2013, o 15:12

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2013-01-02T15:04:48+01:00

Ja skończyłem swój projekt na 60 czujnikach bezprzewodowych do monitorowania różnych warunków środowiskowych (wilgotność, temperatura, wilgotność drewna, wykrywanie obecności wody, poziomu wody i kilku innych, monitorowanie siły sygnału, stanu baterii czujnika itd.). Do czego zmierzam... jak już zacząłem zabawę z RFM12B to i dalej tak szło bo dużo zrobiłem płytek i sprzętu... ale... natrafiłem na problem zasilania i poboru energii... o ile w kilku czujnikach to problemu nie stanowiło... to w późniejszym etapie okazało się, że są problemy z oszczędzaniem energii w sieci na bazie czujników. Uczulam na ten fakt.
Teraz jakbym miał przerabiać od początku taką sieć, bo nie powiem pomysł był fajny z automatycznym identyfikowaniem, z siecią rozproszoną i dynamiczną ramką... wszystko ok, ale te scalaki nie mają funkcji wake on radio!
Mając sieć rozproszoną (w moim przypadku mówiąc w uproszczeniu tablicą routingu zapisaną w stacji bazowej i posczególnych węzłach w czujnikach (lokalne tablice routingu) czujniki musiały działać cały czas. Nie trudno sobie wyobrazić, że musiały analizować sporo danych... uwzględniając nawet dynamiczne ustawianie siły sygnału nadawania (żeby zaoszczędzić energię) za szybko padały baterie .
Teraz zrobił bym to na RFM22B, RFM23B albo w ogóle na ZigBee.
Dlaczego od razu nie sięgnąłem po ZigBee wcześniej? proste: brakowało na to funduszy a wówczas to było masakrycznie drogie.

Jeżeli Twoim celem jest zrobienie inteligentnej sieci (taki był mój kiedyś cel- nie koniecznie słuszny, ale spełniający swoje zadanie) to fajnie by było zrobić to na nowszych układach. Jakby zaimplementować jeszcze automatyczną aktualizację oprogramowania w każdym z czujników (co w ZigBee jest stosunkowo proste a w RFM'ach hm... ciekawe do zrealizowania ) to ja bym był pod wrażeniem motywacji i chęci.

Pozdrawiam

Statystyki: Napisane przez rayden — 2 sty 2013, o 15:04

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2013-01-02T14:49:15+01:00

Praktycznie ostatnio nic nie ruszałem w nim bo nie bardzo miałem do tego czas i wenę.... pewnie w weekend posiedzę, ale ostatnio wyskoczył mi zarobkowy projekt regulatora na termoparze więc chwilowo ten jest zawieszony, ale na 100% do niego wrócę.

Chwilowo zresztą postanowiłem skupić się na uczeniu teorii, oglądaniu kursów Mirka i przetrawianiu (*void), (void*), wszelkich rzutowań, wskaźników na funkcję itp.

Parę koncepcji mi się wyklarowało, co zresztą już w kilku ostatnich tematach było przeze mnie pisane.

Statystyki: Napisane przez Gość — 2 sty 2013, o 14:49

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2013-01-02T14:19:55+01:00

Witam!
Na jakim etapie jest projekt w tej chwili?
Robiłem coś podobnego kilka lat temu może będę w stanie coś podpowiedzieć.

Statystyki: Napisane przez rayden — 2 sty 2013, o 14:19

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-17T09:17:12+01:00

Krauser napisał(a):

menu_sensors() to ślepy zaułek. W takich funkcjach to właśnie powinieneś ustawiać potrzebne flagi. Dobrze masz to że przyciski zmieniają swoją funkcję - to jedna flaga, ale cała realizacja wybranych procedur musi odbywać się w pętli głównej. Kolejna flaga ustawiana w funkcji menu_sensors() powinna odblokowywać warunek rysujący grafikę na potrzeby tej funkcji w pętli głównej. Dobrze zacząłeś, ale mam jeszcze uwagę do tamtego kodu:

[syntax=c]if( !Timer4 ) { //sprawdzenie Timer4
//tu Timer4 = 0
Timer4=100; //tu Timer4 = 100
//... tu Timer4 != 0
}
if(!flag_menu){ //w tym momencie Timer4 musi zostać wyzerowany inaczej powyższy kod go zmieni i już nie będzie 0
if( !Timer4 ) {[/syntax]

Coś mi nie pasowało właśnie, bo nie do końca "regularne" było miganie diodą czyli pomiar, użyję po prostu drugiego Timera programowego bo mam 4 przecież .
Powoli mi się klaruje z tym menu, ale zacząłem myśleć, w jaki sposób zmienić nazwy pomieszczeń a to dla mnie na razie czarna magia .

Statystyki: Napisane przez Gość — 17 gru 2012, o 09:17

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-14T14:29:32+01:00

Chwilowo się muszę uporać z widocznością zmiennych, itd. bo tak namieszałem po plikach, że mi co chwile wywala errory, albo multiplay definition

No odrobinę posprzątałem, ale łeb mi paruje ..... pół dnia siedzę by poprzesuwać deklaracje, definicje i tablice napisów by mi nie sypało multiplayami .

Statystyki: Napisane przez Gość — 14 gru 2012, o 14:29

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-14T14:16:04+01:00

Statystyki: Napisane przez Krauser — 14 gru 2012, o 14:16

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-14T13:11:50+01:00

menu.c

[syntax=c]
#include "menu.h"
#include "..\LCD\lcd44780.h"
#include "../1Wire/ds18x20.h"

#include
#include
#include

#define GET_ADDR(ptr, field) (void*)pgm_read_word(((uint8_t*)ptr)+offsetof(struct _menuitem, field))

const char PROGMEM txt_menu[] = "MENU";
const char PROGMEM txt_start[] = "Start Pomiaru";
const char PROGMEM txt_pomiar[] = "Pomiar";
const char PROGMEM txt_setings[] = "Ustawienia";
const char PROGMEM txt_alarms[] = "Alarmy";
const char PROGMEM txt_sensors[] = "Czujniki";
const char PROGMEM txt_rooms[] = "Pomieszczenia";
const char PROGMEM txt_set_id_rooms[] = "SetID2R";
const char PROGMEM txt_name_room[] = "Zmien nazwy";
const char PROGMEM txt_menu_set_alarm_temp[] = "Maks. Min.";
const char PROGMEM txt_tmpr[] = "Temp.";
const char PROGMEM txt_alarm[] = "Alarmy";
const char PROGMEM txt_on[] = "Włącz";
const char PROGMEM txt_off[] = "Wyłącz";
const char PROGMEM txt_param_trans[] = "Transmisja";
const char PROGMEM txt_test_trans[] = "Testuj Trans.";
const char PROGMEM txt_RS232[] = "RS232";
const char PROGMEM txt_RF[] = "RFM12B";
const char PROGMEM txt11[]="F: ";
const char PROGMEM txt_back[]="z powrotem";

static const struct _menuitem *currMenuPtr=&str_menu;
static int8_t menuindex;
static int8_t menufirstpos;

const struct _menuitem *GetMenuItem(uint8_t index)
{
const struct _menuitem *tmpmenuitem=currMenuPtr;

while((tmpmenuitem) && (index>0))
{
tmpmenuitem=GET_ADDR(tmpmenuitem, next);
index--;
}
return tmpmenuitem;
}

/*Funkcje Wyświetlające i obsługujące poszczególne pozycje MENU */
void menu_func(){// Menu Główne
lcd_cls();
lcd_str_P(txt11); lcd_str_P(txt_menu);
_delay_ms(2000);
}
void menu_alarm(){// Menu Alarm
lcd_cls();
lcd_str_P(txt11); lcd_str("alarm");
_delay_ms(2000);
}
void menu_setings(){// Menu Ustawienia

}
void menu_on_off(){// Menu ustawienia alarmu

}
void menu_param_trans(){// Menu Parametry Transmisji

}
void menu_test_trans(){// Menu Testuj Transmisje
lcd_cls();
lcd_str_P(txt11); lcd_str("test_transmisji");
_delay_ms(2000);
}
void menu_RS232(){// Menu transmisja RS232
lcd_cls();
lcd_locate(1,0);
lcd_str("Menu_RS");
_delay_ms(2000);
}
void menu_RF(){// Menu Transmisja RF12B
lcd_cls();
lcd_str_P(txt11); lcd_str("Menu_RF");
_delay_ms(2000);
}
void menu_sensors(){// Wyświetl znalezione czujniki
menu_func_flag=1;
lcd_cls();
lcd_locate(0,0);
lcd_str_P(txt11);
lcd_str("Menu_czujnik");
for(uint8_t i = 0;i < czujniki_cnt;i++){
display_id(i);
lcd_locate(i,0);
}
_delay_ms(5000);
menu_func_flag=0;
}
void menu_rooms(){// Menu Pomieszczeń
lcd_cls();
lcd_locate(1,0);
lcd_str("Menu_");
_delay_ms(2000);
}
void menu_set_id_to_room(){// Menu przypisania ID czujników do pomieszczeń
lcd_cls();
lcd_locate(1,0);
lcd_str("Przypisz czuj");
_delay_ms(2000);
}
void menu_name_room(){// Menu zmiany nazwy Pomieszczeń
lcd_cls();
lcd_locate(1,0);
lcd_str("Nazwy Pomiesz.");
_delay_ms(2000);
}
void menu_set_default(){// Ustaw domyślne nazwy pomieszczeń

}
void menu_set_alarm_temp(){// Ustaw Maksymalną temperaturę dla pomieszczenia
lcd_cls();
lcd_locate(1,0);
lcd_str("Ustaw Temp.");
_delay_ms(2000);
}

/*
* bool Menu_isSubmenu(struct _menuitem *mi)
{
struct _menuitem *parent=GET_ADDR(mi, parent);
if(Menu_isOnList(parent, mi)==true)
{
if(GET_ADDR(parent, parent)) return true;
} else return true;
return false;
}*/

void Menu_Show()
{

const struct _menuitem *tmpmenuitem=GetMenuItem(menufirstpos);

for(uint8_t i=0;i{
uint8_t charcnt=1;
lcd_locate(i,0);// Dla bibliotek Mirka lcd_locate(y,x)

if((i+menufirstpos)==menuindex) lcd_char('>'); else lcd_char(' ');
if(GET_ADDR(tmpmenuitem, text)&&tmpmenuitem) // Modyfikacja dzięki koledze Krauser
{
lcd_str_P(GET_ADDR(tmpmenuitem, text));
charcnt+=strlen_P(GET_ADDR(tmpmenuitem, text));
}
if(GET_ADDR(tmpmenuitem, submenu) && tmpmenuitem) // Modyfikacja dzięki koledze Krauser
{
lcd_char(0x7E);
charcnt++;
}
for(;charcnttmpmenuitem=GET_ADDR(tmpmenuitem, next);

}
}

void Menu_SelectNext()
{
if(GetMenuItem(menuindex+1)!=0)
{
menuindex++;
if((menuindex-menufirstpos)>=LCD_Y) menufirstpos++;
} else
{
menuindex=0;
menufirstpos=0;
}
Menu_Show();
}

void Menu_SelectPrev()
{
if(menuindex>0)
{
menuindex--;
if(menuindex }
else
{
const struct _menuitem *tmpmenuitem=currMenuPtr;
while(tmpmenuitem)
{
tmpmenuitem=GET_ADDR(tmpmenuitem,next);
if(tmpmenuitem) menuindex++;
}
menufirstpos=menuindex-(LCD_Y-1); //drobna modyfikacja
if(menufirstpos<0) menufirstpos=0;
}
Menu_Show();
}

void Menu_Back()
{
const struct _menuitem *tmpMenuPtr=GET_ADDR(currMenuPtr, parent);
menufirstpos=0;
menuindex=0;
currMenuPtr=tmpMenuPtr;
}

void Menu_Ok()
{
const struct _menuitem *tmpmenuitem=GetMenuItem(menuindex);
const struct _menuitem *submenu=GET_ADDR(tmpmenuitem, submenu);
menuitemfuncptr mfptr=GET_ADDR(tmpmenuitem, menuitemfunc);

if(mfptr) (*mfptr)(); //wywołuje funkcję jeśli dostępna (tu można opcjonalnie zablokować wyświetlanie menu po zakończeniu funkcji, ale wtedy po każdej funkcji)
if(submenu) //podmienia menu na submenu jeśli dostępne
{
currMenuPtr=submenu;
menuindex=0;
menufirstpos=0;
}
Menu_Show();
}
void KeyUp(void){

}
void KeyDown(void){

}
/* Koniec - Funkcje Wyświetlające i obsługujące poszczególne pozycje MENU */

const struct _menuitem str_menu_setings;
const struct _menuitem str_menu_sensors;
const struct _menuitem str_menu_param_trans;
const struct _menuitem str_menu_set_RS232;
/*struct _menu_item {napis menu, wsk na funkcje menu,wsk poprzed menu, wsk pod menu, wsk next menu} */
const struct _menuitem str_menu_start PROGMEM = {txt_start, start_pomiaru, 0, 0, 0};

const struct _menuitem str_menu_set_back PROGMEM = {txt_back, Menu_Back, &str_menu, 0, 0};
const struct _menuitem str_menu_set_RF PROGMEM = {txt_RF, menu_RF, &str_menu_set_RS232, 0, &str_menu_set_back};
const struct _menuitem str_menu_set_RS232 PROGMEM = {txt_RS232, menu_RS232, &str_menu_param_trans, 0, &str_menu_set_RF};

const struct _menuitem str_menu_back_sensor PROGMEM = {txt_back, Menu_Back, &str_menu_sensors, 0, 0};
const struct _menuitem str_menu_set_id_to_room PROGMEM = {txt_set_id_rooms, menu_set_id_to_room, &str_menu_sensors, 0, &str_menu_back_sensor};
const struct _menuitem str_menu_sensors PROGMEM = {txt_sensors, menu_sensors, &str_menu_setings, 0, &str_menu_set_id_to_room};

const struct _menuitem str_menu_back = {txt_back, Menu_Back, &str_menu, 0, 0};
const struct _menuitem str_menu_test_trans = {txt_test_trans, menu_test_trans, &str_menu, 0, &str_menu_back};
const struct _menuitem str_menu_param_trans = {txt_param_trans, menu_param_trans, &str_menu_setings, &str_menu_set_RS232, &str_menu_test_trans};
const struct _menuitem str_menu_setings PROGMEM = {txt_setings, menu_setings, &str_menu, &str_menu_sensors, &str_menu_param_trans};

const struct _menuitem str_menu_alarm PROGMEM = {txt_alarm, menu_set_alarm_temp, &str_menu, 0, &str_menu_start};
const struct _menuitem str_menu PROGMEM = {txt_menu, 0, &str_menu_start, &str_menu_setings, &str_menu_alarm};

[/syntax]

PS. zrozumiałem też, że przez sam zamysł obsługi menu, przez klawisze w tym wypadku muszę rozdzielić jakoś obsługę klawiszami Up i down menu od obsługi np. wyświetlania w danych podprogramach jakiś danych, zmiany nazw itp. czyli by naciskając klawisz Up by np. w procedurze zmiany nazwy, nie przeskoczyło mi menu w main wprowadziłem niewielką modyfikację, oraz zmieniłem zamysł flagi menu

main.c
[syntax=c]
SuperDebounce(&ok, &PINC, K_ok, 20, 500, Menu_Ok, Menu_Show);
if(!menu_func_flag){
SuperDebounce(&up, &PINC, K_up, 20, 500, Menu_SelectPrev, 0);
SuperDebounce(&down, &PINC, K_down, 20, 500, Menu_SelectNext, 0);
}
else{
SuperDebounce(&up, &PINC, K_up, 20, 500, KeyUp, 0);
SuperDebounce(&down, &PINC, K_down, 20, 500, KeyDown, 0);
}

[/syntax]

Statystyki: Napisane przez Gość — 14 gru 2012, o 13:11

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-14T12:49:24+01:00

rezasurmar napisał(a):

Dalej klikając w OK, wchodzimy do ostatnio odwiedzanego MENU, a dopiero po przytrzymaniu klawisza OK wchodzimy prawidłowo do MENU głównego......

Biorąc po uwagę 2 powyższe posty nie jest to możliwe. Jak wchodząc w menu uruchomisz funkcję start_pomiaru to zgodnie z jej kodem powinieneś mieć czysty ekran i dopiero wciśnięcie up/down spowoduje wyświetlenie menu z którego ta funkcja została wywołana. Natomiast wciśnięcie ok spowoduje ponowne wywołanie tej funkcji. Możesz jeszcze pokazać wszystkie zdefiniowane struktury _menuitem ?

Statystyki: Napisane przez Krauser — 14 gru 2012, o 12:49

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-14T11:59:56+01:00

Niestety dalej nie udało mi się zmusić menu, do tego by po odpaleniu podprogramu start_pomiaru, menu nie wyświetlało się ponownie, przez co cały zamysł menu_flag nie sprawdza się .

Dalej klikając w OK, wchodzimy do ostatnio odwiedzanego MENU, a dopiero po przytrzymaniu klawisza OK wchodzimy prawidłowo do MENU głównego......

Po 4secundach, zgodnie z ustawionym w Timerze = 400 czasem program wraca z powrotem do wyświetlania temperatur, niby to nie wada....hmmmm chyba to tak zostawię, bo już przynajmniej chwilowo nie mam siły z tym walczyć.

Teraz czas na dalsze pisanie, pamiętania pomiarów, przypisywania czujników do pomieszczeń etc. to ważniejsze .

Statystyki: Napisane przez Gość — 14 gru 2012, o 11:59

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-12T12:45:43+01:00

[syntax=c]void Menu_Ok()
{
const struct _menuitem *tmpmenuitem=GetMenuItem(menuindex);
const struct _menuitem *submenu=GetAddr(tmpmenuitem, submenu);

menuitemfuncptr mfptr=GetAddr(tmpmenuitem, menuitemfunc);
if(mfptr) (*mfptr)(); //wywołuje funkcję jeśli dostępna (tu można opcjonalnie zablokować wyświetlanie menu po zakończeniu funkcji, ale wtedy po każdej funkcji)
if(submenu) //podmienia menu na submenu jeśli dostępne
{
currMenuPtr=submenu;
menuindex=0;
menufirstpos=0;
}
if (flag_menu) Menu_Show(); //wyświetla menu lub submenu, blokada wyświetlania menu - zablokowane w funkcji np. start pomiaru
}[/syntax]

Statystyki: Napisane przez Krauser — 12 gru 2012, o 12:45

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-11T14:32:25+01:00

Chwilowo mam tak....
[syntax=c]
while(1) {

uint8_t ok, up, down;
//SuperDebounce(&menu, &PINC, K_menu, 20, 500, Menu_Show, 0);

SuperDebounce(&up, &PINC, K_up, 20, 500, Menu_SelectPrev, 0);
SuperDebounce(&down, &PINC, K_down, 20, 500, Menu_SelectNext, 0);
SuperDebounce(&ok, &PINC, K_ok, 20, 500, Menu_Ok, Menu_Show);

if( !Timer4 ) {
Timer4=100;
PORTD ^= (1<czujniki_cnt = search_sensors();
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
zapisz_tmpe(); // zapisuj pomiar do tablicy Tsens pod odpowiedni czujnik
}
if(!flag_menu){
if( !Timer4 ) {
Timer4=200;
display_tmpe(0,10,0); //display_temp(y,x,id_room)
lcd_locate(0,0);
display_id(0);
display_tmpe(1,10,1);
lcd_locate(1,0);
display_id(1);
display_tmpe(2,10,2);
lcd_locate(2,0);
display_id(2);
}
}

} /* koniec pętli nieskończonej */[/syntax]

Tylko nie wiem jak zmusić tą diabelska funkcję Menu_Show
[syntax=c]
void Menu_Show()
{
flag_menu=1;
const struct _menuitem *tmpmenuitem=GetMenuItem(menufirstpos);

for(uint8_t i=0;i{
uint8_t charcnt=1;
lcd_locate(i,0);// Dla bibliotek Mirka lcd_locate(y,x)
if((i+menufirstpos)==menuindex) lcd_char('>'); else lcd_char(' ');
if(GET_ADDR(tmpmenuitem, text)&&tmpmenuitem) // Modyfikacja dzięki koledze Krauser
{
lcd_str_P(GET_ADDR(tmpmenuitem, text));
charcnt+=strlen_P(GET_ADDR(tmpmenuitem, text));
}
if(GET_ADDR(tmpmenuitem, submenu) && tmpmenuitem) // Modyfikacja dzięki koledze Krauser
{
lcd_char(0x7E);
charcnt++;
}
for(;charcnttmpmenuitem=GET_ADDR(tmpmenuitem, next);
}
}
[/syntax]
By po wywołaniu funkcji start_pomiaru
[syntax=c]
void start_pomiaru(void){
lcd_cls();
lcd_locate(0,0);
lcd_str("zaczynamy.....");
_delay_ms(500);
flag_menu=0;
lcd_cls();
}
[/syntax]
Nie następowało ponowne wyświetlenie wywołanie Menu_Show...... nie rozumiem dlaczego program wraca, do Menu_Show?

Jedna flaga załatwiała by sprawę, gdy by nie to iż po skończeniu funkcji start_pomiaru znowu na chwile się wyświetla menu.....jak to pieroństwo zmusić by zostawało w głównej pętli programu?

Statystyki: Napisane przez Gość — 11 gru 2012, o 14:32

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-11T11:06:14+01:00

Docelowo chcę uzyskać efekt jak Mirek w projekcie wielozadaniowym, muszę się pobawić flagami, by jak raz wejdziemy w menu, klawisz menu był nieaktywny, albo miał inne zadanie, a najlepiej przerobię opcję działania klawisza K_ok, by przy dłuższym kliku, działał jako menu_show, ale po wejściu w menu_show powinna być ta funkcja zablokowana, podobnie będąc w menu, teoretycznie pomiar temperatury powinien odbywać się niezależnie, aczkolwiek nie ma parcia na to........ Bo chcę zrobić (tylko jeszcze nie wiem jak, nawet nie mam zarysu koncepcji) by po jakimś czasie bezczynności po wejściu w menu program sam z niego wychodził do wyświetlania pomiaru.....
Nie wiem, może co jakiś czas dodawać jakąś zmienną w menu........a w obsłudze klawisza ją kasować?

Statystyki: Napisane przez Gość — 11 gru 2012, o 11:06

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-10T16:12:13+01:00

Ja bym umieścił pomiar w pętli głównej poza warunkiem menu_show:

[syntax=c]if( !Timer4 ) {
Timer4=100;
PORTD ^= (1<czujniki_cnt = search_sensors();
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
zapisz_tmpe(); // zapisuj pomiar do tablicy Tsens pod odpowiedni czujnik
}[/syntax]

A z tego kawałka wywalił warunek z timerem, niech temperatura wyświetla się w każdym obiegu o ile nie jest wyświetlane menu

[syntax=c]if( !Timer4 ) {
Timer4=200;
display_tmpe(0,10,0); //display_temp(y,x,id_room)
lcd_locate(0,0);
display_id(0);
display_tmpe(1,10,1);
lcd_locate(1,0);
display_id(1);
display_tmpe(2,10,2);
lcd_locate(2,0);
display_id(2);
}[/syntax]

Statystyki: Napisane przez nixie — 10 gru 2012, o 16:12

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-12-10T15:37:41+01:00

Jak obiecałem tak zrobiłem, chwilowo to tylko menu i pomiar, oraz wyświetlanie danych z trzech czujników, cała reszta dopiero w fazie pisania (czyt. wymyślania jak to napisać). Zresztą całe to menu to jak to ładnie Mirek określa Koci program .
Na razie to mam problem, że po wywołaniu funkcji start pomiaru wyświetla się na chwile jeszcze menu, potem kawałek zostaje , oj szkoda gadać, głupi z tego jestem......
nie wiem, jak połączyć pseudo-wielowątkowość z obsługa menu i głównego programu.....

Zresztą oceńcie sami..... program w załączniku, oczywiście biblioteki 1wire i LCD w własnym zakresie należy sobie skopiować.

Statystyki: Napisane przez Gość — 10 gru 2012, o 15:37

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-27T14:12:36+01:00

Jeszcze nie, bo została mi obsługa klawiszy do przerobienia pod to, ale obsługę menu już wrzuciłem. Po wrzuceniu debounce od Mirka, będę powoli uruchamiał to .

PS. Mam nadzieje, że ruszy bez większych problemów, menu może być trochę chaotyczne, ale mam nadzieje, że będzie działać zgodnie z założeniami..... Jeszcze muszę pomyśleć o spowolnieniu przeskakiwania między menu, by nie było na _delayach. Zapewne wykorzystam ten sam mechanizm co Mirek przy debouncigu z softwerowym timerem.

PS2. Debouncig wrzucony, ale coś namieszałem w samych strukturach bo wyświetla się od razu menu RS232, można przejść do przodu do RFM12, odpalić program ale przypisany pod funkcję RS232, ale przy cofaniu menu idzie w maliny , program chyba też .
Chwilowo nic nowego nie wrzucam, przeanalizuję jeszcze raz struktury menu i jak będzie działać do dopiero wrzucę źródełka.

Statystyki: Napisane przez Gość — 27 lis 2012, o 14:12

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-27T14:05:51+01:00

Masz to juz wyswietlone na lcd ?

Statystyki: Napisane przez jachu — 27 lis 2012, o 14:05

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-27T13:35:24+01:00

Po kilku dniach walki, udało mi się w końcu stworzyć strukturę menu

[syntax=c]
menu.c

define GetAddr(ptr, field) (void*)pgm_read_word(((uint8_t*)ptr)+offsetof(struct _menu_item, field))

static const struct _menu_item *currMenuPtr=&menu;
//static uint8_t menuindex;
//static uint8_t menufirstpos;

const struct _menu_item *GetMenuItem(uint8_t index)
{
const struct _menu_item *tmpmenuitem=currMenuPtr;

while((tmpmenuitem) && (index>0))
{
tmpmenuitem=GetAddr(tmpmenuitem, next);
index--;
}
return tmpmenuitem;
}

/*Funkcje Obsługujące Poruszanie Po MENU */
void menu_show(){// Funkcja wyświetlająca MENU

}
void menu_select_next(){// Następny element MENU

}
void menu_select_prev(){// Poprzedni element MENU

}
void menu_back(){// Powróć do poprzedniego MENU

}
void menu_ok(){// Wejdź do MENU - czyli wykonuj, inaczej enter

}
/*Koniec - Funcji obsługujących MENU*/

/*Funkcje Wyświetlające i obsługujące poszczególne pozycje MENU */
void menu_func(){// Menu Główne
lcd_cls();
lcd_str_P(txt11); lcd_str_P(txt_menu);
_delay_ms(2000);
}
void menu_start(){// start pomiaru

}
void menu_alarm(){// Menu Alarm

}
void menu_setings(){// Menu Ustawienia

}
void menu_on_off(){// Menu ustawienia alarmu

}
void menu_param_trans(){// Menu Parametry Transmisji

}
void menu_RS232(){// Menu transmisja RS232

}
void menu_RF(){// Menu Transmisja RF12B

}
void menu_sensors(){// Wyświetl znalezione czujniki

}
void menu_rooms(){// Menu Pomieszczeń

}
void menu_set_id_rooms(){// Menu przypisania ID czujników do pomieszczeń

}
void menu_name_room(){// Menu zmiany nazwy Pomieszczeń

}
void menu_set_default(){// Ustaw domyślne nazwy pomieszczeń

}
void menu_set_alarm_temp(){// Ustaw Maksymalną temperaturę dla pomieszczenia

}
/* Koniec - Funkcje Wyświetlające i obsługujące poszczególne pozycje MENU */

/* Deklaracje głównych menu */
struct _menu_item menu; // Menu Główne
struct _menu_item str_menu_setings; // menu setings
struct _menu_item str_menu_sensors;
struct _menu_item str_menu_param_trans;
/*struct _menu_item {napis menu, wsk na funkcje menu,wsk poprzed menu, wsk pod menu, wsk next menu} */

struct _menu_item str_menu_set_RF = {txt_RF, menu_RF, &str_menu_param_trans, 0, 0};
struct _menu_item str_menu_set_RS232 = {txt_RS232, menu_RS232, &str_menu_param_trans, 0, &str_menu_set_RF};
struct _menu_item str_menu_param_trans = {txt_param_trans, menu_param_trans, &str_menu_setings, 0, &str_menu_set_RS232};

struct _menu_item str_menu_name_room = {txt_name_room, menu_name_room, &str_menu_sensors, 0,0};
struct _menu_item str_menu_set_id_rooms = {txt_set_id_rooms, menu_set_id_rooms, &str_menu_sensors, 0,0};
struct _menu_item str_menu_set_alarm_temp = {txt_menu_set_alarm_temp, menu_set_alarm_temp, &str_menu_setings, 0,0};
struct _menu_item str_menu_rooms = {txt_name_room, menu_name_room, &str_menu_setings, &str_menu_set_alarm_temp, &str_menu_name_room};
struct _menu_item str_menu_sensors = {txt_sensors, menu_sensors, &str_menu_setings, &str_menu_rooms, &str_menu_set_id_rooms};

struct _menu_item str_menu_alarm PROGMEM = {txt_alarm, menu_alarm, &menu, 0 ,0};
struct _menu_item str_menu_setings PROGMEM = {txt_setings, menu_setings, &menu, &str_menu_sensors, &str_menu_param_trans};
struct _menu_item menu PROGMEM = {txt_menu,menu_func, 0, &str_menu_alarm, &str_menu_setings};
[/syntax]

[syntax=c]
menu.h
/*
* menu.h
*
* Created on: 23-11-2012
* Author: Sylwester Taras
*/
#include
#include

#ifndef MENU_H_
#define MENU_H_

typedef void (*menu_item_func_ptr)();

struct PROGMEM _menu_item{
prog_char *text;
menu_item_func_ptr menu_item_func;
const struct _menu_item *parent;
const struct _menu_item *submenu;
const struct _menu_item *next;
};

void menu_show();// Funkcja wyświetlająca MENU
void menu_select_next();// Następny element MENU
void menu_select_prev();// Poprzedni element MENU
void menu_back();// Powróć do poprzedniego MENU
void menu_ok();// Wejdź do MENU - czyli wykonuj, inaczej enter

void menu_func();
void menu_setings();
void menu_alarm();
void menu_on_off();
void menu_param_trans();
void menu_RS232();
void menu_RF();
void menu_sensors();
void menu_rooms();
void menu_set_id_rooms();
void menu_name_room();
void menu_set_default();
void menu_set_alarm_temp();

extern struct _menu_item PROGMEM menu;

#endif /* MENU_H_ */
[/syntax]

[syntax=c]
napisy_menu.h
/*
* napisy_menu.h
*
* Created on: 23-11-2012
* Author: Sylwester Taras
*/

#ifndef NAPISY_MENU_H_
#define NAPISY_MENU_H_

prog_char txt_menu[] = "MENU";
prog_char txt_pomiar[] = "Pomiar";
prog_char txt_setings[] = "Ustawienia";
prog_char txt_alarms[] = "Alarmy";
prog_char txt_sensors[] = "Czujniki";
prog_char txt_rooms[] = "Pomieszczenia";
prog_char txt_set_id_rooms[] = "Ustaw czuniki";
prog_char txt_name_room[] = "Zmien nazwy pom.";
prog_char txt_menu_set_alarm_temp[] = "Maks. Min.";
prog_char txt_tmpr[] = "Temp.";
prog_char txt_alarm[] = "Alarmy";
prog_char txt_on[] = "Włącz";
prog_char txt_off[] = "Wyłącz";
prog_char txt_param_trans[] = "Transmisja";
prog_char txt_RS232[] = "RS232";
prog_char txt_RF[] = "RFM12B";
prog_char txt11[]="F: ";

#endif /* NAPISY_MENU_H_ */

[/syntax]

Teraz czeka mnie oprogramowanie poruszania się po menu, następnie wykonywanie działań właściwych w poszczególnych funkcjach menu . Ależ te struktury dają popalić .

Statystyki: Napisane przez Gość — 27 lis 2012, o 13:35

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-22T13:29:10+01:00

Hmmm co by tu dużo mówić, pierwszy krok za mną, działa, co prawda nie sprawdzałem jeszcze samego odczytu z eeprom, ale same "zarządzanie" czujnikami do struktur i z struktur działa bez zarzutu

[syntax=c]
/*
* main_tx.c
*
* Created on: 06-11-2012
* Author: Sylwester Taras na podstawie bibliotek ATNEL by Mirosław Kardaś
*
*/
#include
#include
#include
#include
#include "LCD/lcd44780.h"
#include "1Wire/ds18x20.h"
#include
#include "napisy.h"

uint8_t czujniki_cnt; // ilosc czujników na magistrali
volatile uint8_t s1_flag; // flaga tykniecia timera co 1 secunde
volatile uint8_t sekundy;// licznik sekund 0-99
uint8_t subzero, cel, cel_fract_bits; // definicja zmiennych do przechowywania pomiaru i znaku

// definicja struktury ID czujników
typedef struct {
uint8_t sens_max;// Pomiar max/h
uint8_t sens_min;// Pomiar min/h
uint8_t srednia;// Srednia temp/24h
uint8_t id_sens[OW_ROMCODE_SIZE]; // tablica z ID czujników
char id_room[10];// nazwa pomieszczenia przypisana
uint8_t mark;// znacznik pomieszczenia
}sens_id;// do konkretnego czujnika

// definicja struktury czujników pomiaru
typedef struct {
uint8_t subzero;// znak (temp. dodatnia==0 ujemna==1
uint8_t cel;// wartosc dziesietna temperatury
uint8_t cel_fract_bits;// wartosc po przecinku
sens_id id_sens;// przypisywanie struktury z id czujnika do struktury czujnika
} sens; // masło maslane ale nie wiem jak inaczej

void write_struct_to_eeprom(sens_id czujnik); // deklaracja funkcji zapisującej strukturę
// sens_id do EEPROM
void zapisz_id(void);// deklaracja funkcji zaspisującej ID czujnikow
// do tablicy ram_sens_id
sens Tsens [9]; // Tablica Tsens elementów struktur sens w ram
sens_id eem_sens_id[9] EEMEM; // definicja tablicy struktur sens_id w eeprom
sens_id ram_sens_id[9]; // definicja tablicy sens_id w ram, czyli nasza tablica sens_id
// na której pracujemy
//deklaracje funkcji obsługi czujnikow, wyswietlania itd
void zapisz_tmpe(void);
void display_tmpe(uint8_t y, uint8_t x, uint8_t id_room);
void display_id(uint8_t id);
//koniec deklaracji funkcji obsługi czujników itd.

int main(void){
DDRA |= (1<PORTA |= (1<DDRD |= (1<
/* Ustawienie Timera0 dla F_CPU=11,05920Mhz */
TCCR0 |= (1<TCCR0 |= (1<OCR0 = 108;// dodakowy podział przez 108 (rejestr przepełnienia)
TIMSK |= (1<
/*Przerywanie wygonywane jest z czestotliwoscia ok 10ms (100 razy na secunde)*/

lcd_init();
lcd_defchar(0x80,stopien); // definicja znaku stopnia w LCD

//sprawdzamy ile czujników DS18xxx jest widocznych na magistrali
czujniki_cnt = search_sensors();
lcd_locate(0,0);
lcd_str_P(PSTR("Znaleziono"));
lcd_locate(1,0);
lcd_int(czujniki_cnt);
lcd_str_P(PSTR(" sensor(y)"));// i wyswietlamy na wyswietlaczu
zapisz_id();// zapisz id czujnikow do tablicy struktur ram_sens_id
_delay_ms(2000); // czekamy by zauważyć ile nam wykryło czujników
lcd_cls(); // czyscimy wyświetlacz co by głupot nie pokazywał

//write_struct_to_eeprom(*ram_sens_id);
//Wysyłamy rozkaz wykonania pomiaru temperatury do wszystkich wykrytych czujników
//W przypadku zasilania w trybie NORMAL, gdy tryb Parasite, należy użyć jako pierwszego
//argumentu DS18X20_POWER_PARASITE
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL);
//Oczekiwanie na konwersję 750ms
_delay_ms(750); // wrzucamy jakąs ciekawa animacje

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

/* pętla nieskończona */
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 );
zapisz_tmpe(); // zapisuj pomiar do tablicy Tsens pod odpowiedni czujnik
}

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 2 czyli jedną sekundę po rozkazie konwersji
* dokonuj odczytu i wyświetlania temperatur z 4 czujników jeśli są podłączone, jeśli nie
* to pokaż komunikat o błędzie
*/
if( 2 == (sekundy%3) ) {

PORTD ^= (1<
display_tmpe(0,10,0); //display_temp(y,x,id_room)
lcd_locate(0,0);
display_id(0);
display_tmpe(1,10,1);
lcd_locate(1,0);
display_id(1);
display_tmpe(2,10,2);
lcd_locate(2,0);
display_id(2);

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

// wpisywanie ID czujników do tablicy Tsens struktury sens
//czujnniki_cnt==ilosc czujnikow na szynie 1wire
void zapisz_id(void){
for(uint8_t j=0; jfor(uint8_t i=0; i//zapisujemy ID czyjnika do tablicy struktur sens_id
//j==czujnik, i==rozmiar ID, czyli po prostu przepisujemy ID
//wykrytego czujnika do tablicy id_sens
ram_sens_id[j].id_sens[i] = gSensorIDs[j][i];
}
}
}// koniec procedury wpisywania ID czujników

// fukcja zapisujaca tablice ram_sens_id do eeprom
void write_struct_to_eeprom(sens_id czujnik){
eeprom_update_block(&czujnik, &eem_sens_id, sizeof(sens_id));
}
// zapisuj temperature, oraz ID czujnika do tablicy Tsens
void zapisz_tmpe(void){
for(uint8_t j=0; jDS18X20_read_meas(Tsens[j].id_sens.id_sens, &subzero, &cel, &cel_fract_bits);
Tsens[j].subzero=subzero;
Tsens[j].cel=cel;
Tsens[j].cel_fract_bits=cel_fract_bits;
for(uint8_t i=0; i//zapisujemy ID czyjnika do tablicy struktur sens_id
//j==czujnik, i==rozmiar ID, czyli po prostu przepisujemy ID
//wykrytego czujnika do tablicy id_sens
Tsens[j].id_sens.id_sens[i] = gSensorIDs[j][i];
}
}
}

void display_tmpe(uint8_t y, uint8_t x, uint8_t id_room){
lcd_locate(y,x);
if(Tsens[id_room].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(Tsens[id_room].cel);/* wyświetl dziesiętne części temperatury */
lcd_str(".");/* wyświetl kropkę */
lcd_int(Tsens[id_room].cel_fract_bits); /* wyświetl dziesiętne części stopnia */
lcd_str("\x80"); /* wyświetl znak jednostek (C - stopnie Celsiusza) */
}

void display_id(uint8_t nr_czujnika){
for(uint8_t i = 1; i < 5; i++ ){
if(Tsens[nr_czujnika].id_sens.id_sens[i] < 0x10) lcd_str("0");
lcd_hex(Tsens[nr_czujnika].id_sens.id_sens[i]);
}

}

/* ================= 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]

PS. Faktycznie 10elementowa tablica Tsens nie zajmuje aż tak wiele miejsca w eepromie, wrzucę ją całą do eeproma, uaktualniane będą ewentualnie tylko ID czujników w przypadku ich zmiany no i same id_room celem zadeklarowania własnych nazw pomieszczeń, na początku będą wrzucane standardowe napisy z flash, a potem można będzie ewentualnie edytować nazwy w eepromie.

PS. Teraz czas na kolejny etap, czyli stworzenie jakiegoś menu pod to , potem dalsze przygody .

Statystyki: Napisane przez Gość — 22 lis 2012, o 13:29

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-22T09:31:23+01:00

Masz rację, zresztą sam fakt rzutowania na typ pusty, niby jest zrozumiały, ale nie do końca i potem człowiek coś stosuje, a sam nie wie po co .
Chwilowo próbuję przetrawić te struktury bo to faktycznie fajna rzecz . Ale przykładów z tym biednie, a nic tak nie uczy jak "życiowy" przykład, a nie opisy samego zagadnienia. Dlatego męczę te zapisywania do eeprom by w końcu zatrybić o co w tym chodzi.
Tablice, wskaźniki fajna rzecz, ale struktury to jest to co tyrgryski lubią najbardziej, załatwiają wiele rzeczy, podobnie jak klasa vector, czyli kontenery itd.

Faktycznie, może nie będzie aż takiej nadmiarowości, bo nie wiem, czy znam na tyle wskaźniki by to wrzucić tym sposobem do eeproma, szczerze mówiąc nawet nie bardzo wiem jak to od tej strony ugryźć.

Statystyki: Napisane przez Gość — 22 lis 2012, o 09:31

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-22T09:20:34+01:00

A wiem wiem - ja już z SunRiverem kiedyś rozmawiałem o tym (void*) ... rzeczywiście - on miał na to jakieś uzasadnienie chyba z kompilatorów dla PIC (nie wiem czy dobrze pamiętam) ... no ale to człowiek omnibus jak wiesz i pisze w dziesiątkach różnych kompilatorów

dlatego tak jak ci mówiłem - stosowanie tego (void*) nie jest jakimś błędem okropnym bo jak widzisz działa poprawnie i nie ma warninga. Ale ja ze swojej strony to uzasadniłem podpowiadając o zagrożeniach szczególnie jak ktoś stawia pierwsze kroki - to pod tym kątem piszę. Sun to wiesz - sobie poradzi - jak on pisze (void*) przy tych argumentach to ja wiem że on sobie bardzo dobrze zdaje z tego sprawę.

A z drugiej strony ja zawsze jestem zwolennikiem ułatwiania sobie życia podczas pisania kodu, zatem jeśli teraz już dokładnie rozumiesz o co chodzi z tym (void*) w tym konkretnym przykładzie to też sam sobie wybierzesz sposób

ale dodam że - moim zdaniem akurat w konstrukcji AVR GCC, która jest na prawdę fajnie przemyślana jeśli chodzi o kompilator - to stosowanie rzutowania na typ wskaźnikowy void* zostawiłbym na tzw czarną godzinę, jeśli można w innych przypadkach się tego pozbyć i poprawić nawet czytelność kodu. Tak chyba też zakończyła się nawet może w tamtym temacie czy w mailu nasza konkluzja z Sunem

------------------------ [ Dodano po: 7 minutach ]

co do pytania twojego o te struktury, eeprom itp - to tak jak widzisz trzeba dobrze przemyśleć. Ale widzę, że piszesz i obawiasz się jakby że niepotrzebnie coś tam będziesz trzymał w eeprom. Z drugiej strony - czy planujesz wykorzystać cały eeprom po brzegi ? jeśli nie to w czym może przeszkadzać te parę bajtów nadmiaru ?

Innym rozwiązaniem problemu może być przygotowanie wskaźników na poszczególne miejsca w strukturze i to je zapakować do struktury w eepromie ... eeeh wiem że jak się tak o tym pisze z marszu to wygląda jak masło maślane z potrójnym saltem ... no ale postaraj się jeszcze pokombinować i ew pokazać efekty - w kodzie to może coś się uda podpowiedzieć dalej - naprowadzić

Statystyki: Napisane przez mirekk36 — 22 lis 2012, o 09:20

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-22T08:46:30+01:00

OK, już wczoraj to czytałem, ale byłem zbyt zmęczony by cokolwiek przetrawić . Dziękuję po pierwsze za pomoc.

Po drugie mogłem faktycznie namieszać z tymi danymi przekazywanymi do sizeof, bo zmieniałem to tyle razy, że mogło mi umknąć, po za tym po napisaniu posta wprowadziłem kilka zmian, bo po co mi cała tablica struktur Tsens, jak w eepromie potrzebuje mieć tylko ID czujnika, nazwę pomieszczenia, ewentualnie max, min, i średnią temperaturę z całej doby.

Po trzecie, sugerowałem się postem SurRivera (który chyba za bardzo jest skrzywiony C++, albo robi to z rozmysłem ), bo w książkach do C było właśnie opisane bez void* i już potem zgłupiałem kogo mam słuchać ;).
Zaraz będę walczył dalej ....(luz w pracy czasem się przydaje )

Tylko, nie wiem, jak to ugryźć (w tej chwili), bo tak, mając strukturę sens_id, która wchodzi w skład struktury sens z której to tworzona jest tablica Tsens[9], czyli dziesięć elementów typu struct sens.... i teraz wrzucając strukturę sens_id do eeprom, przecież będzie wrzucona tylko dla jednego czujnika, wrzucając zaś tablicę Tsens niepotrzebnie zajmuję w eeprom pamięć. Robić kolejną tablicę 10elementówą struktur sens_id która będzie wrzucona do EEPROM, czy jest na to jakiś inny sposób, bo nie bardzo wiem, jak zmusić eeprom by przyjmował 10 struktur sens_id, bez stworzenia tablicy by łatwo było na tym operować.

Statystyki: Napisane przez Gość — 22 lis 2012, o 08:46

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-21T16:36:49+01:00

to jest potworek

[syntax=c]eeprom_update_block((const void*)&czujnik, (void*)&eem_sens_id, sizeof(sens));[/syntax]

już tłumaczę dlaczego,

1. pozbądź się tego rzutowania - ono jest tu ZUPEŁNIE niepotrzebnie ponieważ argumenty funkcji są już void* i zresztą po to są void*, żebyś nie musiał rzutować nawet innych typów. To już jest wbudowana zaleta a ty próbujesz ją jeszcze dodatkowo niepotrzebnie obejść. Oczywiście to niczemu nie zaszkodzi w tym przypadku ale niestety robi się potworek i po tym rozpoznałem że tu jeszcze nie wiesz o co chodzi - dlatego tłumaczę

[syntax=c]eeprom_update_block( &czujnik, &eem_sens_id, sizeof(sens));[/syntax]

2. jak już będziesz robił rzutowanie to UWAŻAJ! rzutowanie na typ wskaźnikowy (void*) może być dla ciebie dosyć niebezpieczne, dokąd ostatecznie i dobrze nie zrozumiesz zasad rzutowania a widać, że jeszcze troszkę kiepsko. Nawet jak się rozumie rzutowanie dobrze to - rzutowanie na typ void* robi się w ostateczności, gdy już INACZEJ (normalnie) się nie da

3. patrz korzystasz ze struktury czujnik, korzystasz ze struktury eem_sens_id, tymczasem sizeof bierzesz z ??? sens ... a co to jest sens ... nawet dla oka ciężko później to analizować. nie lepiej dla oka jeśli byłoby tak?

[syntax=c]eeprom_update_block( &czujnik, &eem_sens_id, sizeof(czujnik) );[/syntax]

albo nawet jeśli struktury są równe i lecimy po całości to także

[syntax=c]eeprom_update_block( &czujnik, &eem_sens_id, sizeof(eem_sens_id) );[/syntax]

teraz to ja od razu widzę o jaki rozmiar chodzi do skopiowania/updejtowania

to tyle tak na gorąco

Statystyki: Napisane przez mirekk36 — 21 lis 2012, o 16:36

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-21T14:07:40+01:00

Zgodnie z tym postem topic1591.html#p15892 stworzyłem takiego potworka

[syntax=c]// wpisywanie ID czujników do tablicy Tsens struktury sens i wreszcie struktury id_sens i tablicy id_sens[]
void zapisz_id(void){
for(uint8_t j=0; jfor(uint8_t i=0; iTsens[j].id_sens.id_sens[i] = gSensorIDs[j][i];
}
}
}// koniec procedury wpisywania ID czujników

// fukcja zapisujaca tablice structur sens do eeprom
void write_struct_to_eeprom(sens czujnik){
eeprom_update_block((const void*)&czujnik, (void*)&eem_sens_id, sizeof(sens));
}
[/syntax]
mając zadeklarowane struktury

[syntax=c]
// definicja struktury ID czujników
typedef struct {
uint8_t sens_max;// Pomiar max/h
uint8_t sens_min;// Pomiar min/h
uint8_t srednia;// Srednia temp/24h
uint8_t id_sens[8]; // tablica z ID czujników
char id_room[9];// nazwa pomieszczenia przypisana
// do konkretnego czujnika
}sens_id;

sens_id eem_sens[9] EEMEM; // definicja tablicy struktur sens w eeprom // chwilowo pusta definicja wiem, że nie można
sens_id ram_sens_id; // definicja struktury id w ram

// definicja struktury czujników pomiaru
typedef struct {
uint8_t subzero;// znak (temp. dodatnia==0 ujemna==1
uint8_t cel;// wartosc dziesietna temperatury
uint8_t cel_fract_bits;// wartosc po przecinku
sens_id id_sens;// przypisywanie struktury z id czujnika do struktury czujnika
} sens; // masło maslane ale nie wiem jak inaczej
void write_struct_to_eeprom(sens czujnik); // deklaracja funkcji zapisującej strukturę
// sens do EEPROM
sens Tsens [9]; // Tablica Tsens elementów struktur sens w ram
[/syntax]

Tylko że [syntax=c]
void write_struct_to_eeprom(sens czujnik){
eeprom_update_block((const void*)&czujnik, (void*)&eem_sens_id, sizeof(sens));
}[/syntax]
Zapisuje tylko strukturę do EEPROM, czy zamiast sens czujnik, dać sens *czujnik i przekazywać wskaźnik do tablicy, czy coś nie do końca zrozumiałem, bo chcę eeprom_update_block.... załatwić przepisywanie całej tablicy Tsense do eeprom, dzięki temu po pierwsze mam wszystkie dane potrzebne w eeprom, które niepotrzebnie nie są za każdym razem zapisywane na nowo, bo eeprom_update_block najpierw sprawdzi czy dane już istnieją w eeprom, ewentualnie zmieni tylko to co się zmieniło .

Czy to jest prawidłowe wywołanie?
[syntax=c]write_struct_to_eeprom(*Tsens);[/syntax]
by całą tablicę struktur Tsens[] wrzucić do Tablicy struktur w eeprom?, w zasadzie potrzebuję mieć tylko tablicę struktry sens_id by była zachowana nazwa i ID czujnika, ale zaczyna mi wychodzić masło maślane.....

Statystyki: Napisane przez Gość — 21 lis 2012, o 14:07

Re: Pomiar temperatury DS18B20 ciąg dalszy...oraz RFM12

2012-11-20T13:58:23+01:00

Z racji iż istnieje już kilka podobnych tematów tj. topic1725.html oraz topic1784.html no i post17932.html?hilit=zapis%20eeprom#p17932

Po zapoznaniu się z w/w tematami doszedłem metodą wykluczeń (tj. wykluczania co wiem czego nie ) do tego iż najlepiej będzie stworzyć dwie struktury, a w zasadzie trzy.

[syntax=c]
// definicja struktury ID czujników w eeprom
typedef struct {
uint8_t id_sens_ee[8];
uint8_t sens_max;
uint8_t sens_min;
uint8_t srednia;
}sens_id;

sens_id eem_sens_id EEMEM; // definicja struktury id w eeprom
sens_id ram_sens_id; // definicja struktury id w ram

// definicja struktury czujników pomiaru
typedef struct {
uint8_t subzero;
uint8_t cel;
uint8_t cel_fract_bits;
char *id;// wskaźnik do tablicy z ID DS18x20
char id_room[9]; // tablica z nazwą pomieszczenia
sens_id id_sens;// przypisywanie struktury id do struktury czujnika
// masło maslane ale nie wiem jak inaczej
} sens;
[/syntax]

w przypadku struktury czujników sens, bedzie stworzona tablica
[syntax=c]sens Tsens [9]; // Tablica Tsens elementów struktur sens[/syntax]
gdzie będą lądować ID czujnika, aktualny pomiar temperatury itd. wszystko w RAM, do tego
w eeprom będzie tablica eem_sens_id EEMEM;, czyli tablica samych ID, z paroma dodatkowymi zmiennymi, bo po co mi aktualny pomiar w eepromie.

Czyli na początku robię funkcję (jeszcze przed main), która za pomocą bibliotek Mirka wykrywa czujniki na szynie 1wire, ich ID wrzuca do eeproma, następnie używając już tylko ID z eeprom wykonuję pomiary podobnie jak w temacie topic1725.html?hilit=zapis%20eeprom#p18348
Dzięki wykorzystaniu struktury struktur mogę przypisać dowolną nazwę do danego ID czujnika, nie tracąc przy okazji ID czujnika .
Dodatkowo (jeszcze nie wiem jak, ale w topic1591.html#p15892 SunRiver opisał dosyć dobrze odwoływanie się do eeproma struktury itp), będę mógł pobierać i zmieniać poszczególne parametry tablicy struktur w eepromie (tak mi się przynajmniej wydaje).

Docelowo będę miał 6 pomieszczeń do obczujnikowania, do tego jakieś alarmy max, min, temperatura na piecu z jakimś prostym sterowaniem, ale by było śmieszniej 2-3czujniki będą w bazie reszta po RFM12, albo nRF24L01, ale to później.

Mirek tak fajnie opowiadał o swoim 4kanałowym sterowniku, czuję się jak "krasnoludki" z kingsize, cyt. "bo z was dupy nie prowokatorzy..." koniec cytatu.

do tej pory miałem zrobione tak

[syntax=c]
/*
* main_tx.c
*/
#include
#include
#include
#include
#include "LCD/lcd44780.h"
#include "1Wire/ds18x20.h"
#include "sensory/sensory.h"
#include
#include "napisy.h"

// y kolumna, x wiersz, id_temp ID czujnika (pomieszczenie)
void display_temp(uint8_t y, uint8_t x, uint8_t id_room);
void zapisz_temp(void);
void zapisz_id_eeprom(void);
uint8_t t_co[OW_ROMCODE_SIZE];//zmienna z przypisanym ID czujnika
uint8_t ee_t_co[OW_ROMCODE_SIZE] EEMEM; //zmienna w eeprom z przypisanym ID czujnika
void show_id(uint8_t *id, uint8_t nr_czujnika);
//enum room {psy = 1, kurnik, kurnikII, koza, piec, garaz };

uint8_t czujniki_cnt; // ilosc czujników na magistrali
volatile uint8_t s1_flag; // flaga tykniecia timera co 1 secunde
volatile uint8_t sekundy;// licznik sekund 0-99

/*
* subzero-znak (temperatura dodatnia==0 lub ujemna==1
* cel-wartosc dziesietna temperatury
* cel_frac_bits-wartosc po przecinku
*/
uint8_t subzero, cel, cel_fract_bits;

int main(void){
DDRA |= (1<PORTA |= (1<DDRD |= (1<
/* Ustawienie Timera0 dla F_CPU=11,05920Mhz */
TCCR0 |= (1<TCCR0 |= (1<OCR0 = 108;// dodakowy podział przez 108 (rejestr przepełnienia)
TIMSK |= (1<
/*Przerywanie wygonywane jest z czestotliwoscia ok 10ms (100 razy na secunde)*/

lcd_init();
lcd_defchar(0x80,stopien); // definicja znaku stopnia w LCD

//sprawdzamy ile czujników DS18xxx jest widocznych na magistrali
czujniki_cnt = search_sensors();
lcd_locate(0,0);
lcd_str_P(PSTR("Znaleziono"));
lcd_locate(1,0);
lcd_int(czujniki_cnt);
lcd_str_P(PSTR(" sensor(y)"));// i wyswietlamy na wyswietlaczu
zapisz_id_eeprom();
lcd_cls();
//Wysyłamy rozkaz wykonania pomiaru temperatury do wszystkich wykrytych czujników
//W przypadku zasilania w trybie NORMAL, gdy tryb Parasite, należy użyć jako pierwszego
//argumentu DS18X20_POWER_PARASITE
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL);
//Oczekiwanie na konwersję 750ms
_delay_ms(750); // wrzucamy jakąs ciekawa animacje

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

/* pętla nieskończona */
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 );
zapisz_temp();
}

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 2 czyli jedną sekundę po rozkazie konwersji
* dokonuj odczytu i wyświetlania temperatur z 4 czujników jeśli są podłączone, jeśli nie
* to pokaż komunikat o błędzie
*/
if( 2 == (sekundy%3) ) {

PORTD ^= (1<
display_temp(0,10,0); //display_temp(y,x,id_room)
lcd_locate(0,0);
display_id(0);
display_temp(1,10,1);
lcd_locate(1,0);
display_id(1);
display_temp(2,10,2);
lcd_locate(2,0);
display_id(2);

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

void zapisz_id_eeprom(void){ // to jest jakaś genetyczna pomyłka
// wpisywanie ID czujników do EEPROM

for(uint8_t j=0; jfor(uint8_t i=0; iTsens[j].id_room[i] = gSensorIDs[j][i];
}
eeprom_write_block (Tsens[j].id_room, ee_t_co, OW_ROMCODE_SIZE);
}

// koniec procedury wpisywania ID czujników do EEPROM

}

/* ================= 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]
[syntax=c]
/*
* sensory.c
*
* Created on: 19-11-2012
* Author: sylwq
*/
#include
#include
#include
#include
#include "sensory.h"
#include
#include "..\LCD\lcd44780.h"
#include "..\1Wire\ds18x20.h"

// definicja struktury ID czujników w eeprom
typedef struct {
uint8_t id_sens_ee[8];
uint8_t sens_max;
uint8_t sens_min;
uint8_t srednia;
}sens_id;

sens_id eem_sens_id EEMEM; // definicja struktury id w eeprom
sens_id ram_sens_id; // definicja struktury id w ram

// definicja struktury czujników pomiaru
typedef struct {
uint8_t subzero;
uint8_t cel;
uint8_t cel_fract_bits;
char *id;// wskaźnik do tablicy z ID DS18x20
char id_room[9]; // tablica z nazwą pomieszczenia
sens_id id_sens;// przypisywanie struktury id do struktury czujnika
// masło maslane ale nie wiem jak inaczej
} sens;

sens Tsens [9]; // Tablica Tsens elementów struktur sens

void zapisz_temp(void){
for(uint8_t i=0; iDS18X20_read_meas(gSensorIDs[i], &subzero, &cel, &cel_fract_bits);
Tsens[i].subzero=subzero;
Tsens[i].cel=cel;
Tsens[i].cel_fract_bits=cel_fract_bits;
show_id(&gSensorIDs[i][0],i);
}
}

void display_temp(uint8_t y, uint8_t x, uint8_t id_room){
lcd_locate(y,x);
if(Tsens[id_room].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(Tsens[id_room].cel);/* wyświetl dziesiętne części temperatury */
lcd_str(".");/* wyświetl kropkę */
lcd_int(Tsens[id_room].cel_fract_bits); /* wyświetl dziesiętne części stopnia */
lcd_str("\x80"); /* wyświetl znak jednostek (C - stopnie Celsiusza) */
}

void show_id(uint8_t *id, uint8_t nr_czujnika){
for(uint8_t i = 1; i < 5; i++ ){
Tsens[nr_czujnika].id_room[i]=id[i];
}
}

/*
void display_id(uint8_t id){
for(uint8_t i = 1; i < 5; i++ ){
if(Tsens[id].id_room[i] < 0x10) lcd_str("0");
lcd_hex(Tsens[id].id_room[i]);
}

}
*/
[/syntax]

Chyba będę musiał wywalić to wszystko i pisać od początku, bo już sam nie wiem jak do tego podejść ...

Statystyki: Napisane przez Gość — 20 lis 2012, o 13:58