• Witaj na Forum Arduino Polska! Zapraszamy do rejestracji!
  • Znajdziesz tutaj wiele informacji na temat hardware / software.
Witaj! Logowanie Rejestracja


Ocena wątku:
  • 0 głosów - średnia: 0
  • 1
  • 2
  • 3
  • 4
  • 5
Odbiornik do sygnalizatorów fischtronic (videotronic nova)
#21
To tak jestem uparty, z ta zmiana częstotliwości  nano nie ogarniam.(morze kiedyś znajdę dobry poradni )
Lecz po dwóch dniach użytkowania bateryjki nie dają rady szkoda zasięg spada do 1 metra( w zależności od piszczałki )
Ale ja jestem osioł uparty zakupiłem ATTINY85  i pomyślałem zrezygnować z biblioteki całkowicie.
No i rozkmina poszłem do przodu i znowu do tyłu....
Kod:
int code_vcr1[]={1,1,2,0,2,0,0,0,1};///////
int code_vcr2[]={1,1,2,0,2,0,0,1,0};//////ten uzywam testowo
int code_vcr3[]={1,1,2,0,2,0,1,0,0};/////Podac kody odbiornikow
int code_vcr4[]={1,1,2,0,2,1,0,0,0};///
int code_alar[]={1,1,2,0,2,0,0,0,0};//
/////////////////////////////////////
int code[]={0,0,0,0,0,0,0,0,0}; //// Wygenerowac to z 18 bitow i porownac z kodami odbiornikow
///////////////////////////////////
int binaryh[17];                 //18 bitow H do wygenerowania code
//////////////////////////////////
unsigned long staryczas = 0;   //
unsigned long nowyczas  = 0;  /////micros do synchronizacji
unsigned long czassynch = 14500;//
/////////////////////////////////
unsigned long czas_hig = 0; // Odczytane czasy twania wysokiego stanu
/////////////////////////////
void setup() {
Serial.begin(9600);
pinMode(2, INPUT);
}
void loop() {
 
synchronizacja();
odczyt();
}
////////////////////////////////////////////////////
void synchronizacja(void){
if (digitalRead(2)==HIGH) {
staryczas = micros();
}
if (digitalRead(2)==LOW) { 
nowyczas = micros();
}
}
//////////////////////////////////////////////////
void odczyt (void) {
if (nowyczas>=staryczas+czassynch){
for (int B=0;B<=17;B++){
czas_hig=pulseIn(2,LOW);
Serial.print(czas_hig);
Serial.print(",");
}
Serial.println("");
}
}
 
Przy odczycie kiedy jest :
  czas_hig=pulseIn(2,LOW);
jest prawie zajebiście wygląda to tak:


Kod:
279,282,283,276,279,1861,1868,1861,280,1861,1859,1861,1859,1858,284,285,1861,14507,
278,280,281,275,278,1858,1859,1861,280,1858,1859,1857,1858,1855,284,285,1865,14506,
280,281,283,271,275,1864,1863,1863,287,1860,1860,1859,1859,1864,284,282,1860,14504,
278,280,275,270,270,1859,1859,1857,283,1858,1857,1862,1862,1857,275,280,1857,14499,
276,278,279,278,279,1861,1861,1860,286,1861,1867,1864,1858,1859,279,285,1859,14493,
271,275,281,275,277,1857,1857,1857,283,1865,1858,1856,1855,1855,280,283,1857,14489,
281,282,284,277,280,1859,1858,1863,284,1860,1859,1857,1856,1856,282,283,1858,14487,
278,281,282,276,276,1857,1864,1863,277,1857,1857,1855,1856,1857,281,287,1859,14493,
279,281,283,276,280,1866,1862,1858,279,1859,1857,1856,1856,1856,283,285,1863,14491,
279,281,281,277,276,1861,1857,1857,278,1856,1856,1856,1855,1855,281,283,1863,14489,
279,283,283,275,281,1857,1858,1857,283,1859,1856,1857,1854,1855,283,283,1858,14489,
278,279,280,277,272,1858,1858,1855,282,1857,1856,1858,1854,1855,283,283,1855,14488,
279,280,284,269,270,1858,1858,1855,284,1860,1856,1855,1855,1861,283,279,1858,14487,
gdy odczytuje czasy stanów  niskich ostatni czas jest długi a ja bym chciał go mieć w zakresie 1855 no można by skopiować 17 czas do 18 bo ostatnie 8 czasów  /2 = 4 bity są 2 stanowe
no ale wolał bym  lepiej.......

   

Moja myśl lepiej zapisać czasy wierzchołków ( coś nie do końca wypala)
Po zmianie linii z low na high:
czas_hig=pulseIn(2,HIGH); 
Kod:
1826,1824,1823,1820,1821,1819,243,1821,251,251,1829,252,1831,1824,1822,1821,241,241,
239,248,252,1819,1828,1825,1822,1818,1816,246,1825,241,241,1823,246,1820,1826,1833,
1830,249,247,249,245,245,1825,1830,1830,1834,1832,1825,251,1820,250,245,1819,244,
1832,1822,1821,1821,247,247,249,249,235,1815,244,1820,1817,1816,1816,240,245,236,
239,1826,240,1822,1821,1819,1819,1817,241,241,248,250,1827,246,1824,1822,1821,1820,
1823,1821,1821,1819,1817,238,243,242,1832,247,248,249,247,248,1817,1818,247,1821,
1816,1819,1827,243,240,247,250,251,1817,1838,1830,1828,1828,1821,249,1820,245,251,
1838,1838,1820,1820,1817,249,250,251,243,242,245,1818,1821,1827,1822,1816,1816,246,
1821,1820,1827,1823,1818,247,248,242,1818,240,242,235,245,243,1831,247,1823,1821,
1820,1825,242,1819,249,249,1822,250,1825,1822,1823,1820,239,248,1824,250,247,1817,
1821,1821,1819,1817,1824,248,1823,246,250,1817,243,1821,1828,1827,1825,240,248,250,
250,1820,248,1830,1827,1829,1819,1819,244,1825,252,253,1820,241,1826,1821,1819,1819,
242,1818,249,240,1816,248,1827,1820,1817,1817,1816,247,231,240,242,1825,248,1829,
1827,1820,1819,241,1820,237,249,1834,250,1824,1829,1829,1821,1819,242,250,244,245,

Nie odzwierciedla czasów wierzchołków (gdyby się to udało myślę ze nie było by problemu już zamienić na zera i jedynki .
jakaś różnica występuje przy dwóch podobnych  funkcjach(liczę na pomoc bo próbowałem blokować i analizować i lipa
plan zamontować  ATTINY85 +  Najprostsze zasilanie +( kolega ma drukarkę ma ogarnąć koszyk na akumulatory doklejany pod spód na nakrętka a miejsce na baterie pójdzie elektronika)
 
Odpowiedź
#22
Zainstalowanie core "mini CORE" jest proste , jest opisane na ich stronie github, jak nie znasz angielskiego to w CHROME klikasz na text prawym i z menu wybierasz przetłumacz. Potem w menu Arduino wybierasz Atmega328, Internal 8MHz, wgrywasz bootloader i masz Atmegę w NANO pracującą na 8MHz, albo na 4MHz, tak samo z ewentualnie z powrotem (to faktyczne działanie z daną czestotliwością lepiej zresztą tak z grubsza sprawdzić, czy led mający migać co 1s faktycznie miga co 1s, bo dla Atmega32 zauważyłem, że ustawienie na 4 lub 2 lub 1MHz ustawia na 1MHz - jest jakiś babol w Mightycore).
Attiny85 nie wnosi nic w zakresie oszczędności energii, a skoro umiałeś zainstalować dodatki core do obsługi tego MINICORE też dasz radę.
W PL Attiny kosztują 15-30zł, za tyle z Ali kupisz Atmegę 328P (145zł z wysyłką za 10szt), a jeszcze taniej nowszą Atmega328PB (120zł za 10szt.). Kiedyś na Ali z żalem kupiłem po kilka Attiny85/45/25, bo w tej samej cenie miałem paltkę Atmega88, teraz Atmega88 na ali jest za 10PLN przy zakupie 10szt, transport wliczony.
No ale wielkość Attiny może też ma zaletę, to wystarczy wpisać w Google "rc switch attiny85" i też są rozwiązania do przetestowania  https://www.youtube.com/watch?v=tg0PG128h6g.
Zakomentowałem to wyłączenie odbiornika dla Attiny, wykasowałem z receive demo wszystko o UART i szkic zajmuje 4k i 186B RAM, to już spokojnie zmieści się w Attiny, INT0 jest na pinie 7, PB2.
Czyli w pliku RCSwitch.h:
Kod:
// At least for the ATTiny X4/X5, receiving has to be disabled due to
// missing libm depencies (udivmodhi4)
#if defined( __AVR_ATtinyX5__ ) or defined ( __AVR_ATtinyX4__ )
//#define RCSwitchDisableReceiving
#endif
I poszło nawet w Attiny45 (AttinyCore bo jest jeszcze DIY Attiny CORE i tu nie kompiluje), zajmuje nawet mniej, testów działania nie robiłem, ale jak się mieści do 45 to w 85 powinno działać, tylko zamiast komunikatów na UART trzeba sobie ogarnąć komunikowanie zdarzeń np. ledami, by nie zwiększać już kodu. Przez brak UART Attiny jest kiepski do robienia prototypów, testowania, częstego wgrywania.
   
Miło być decenianym https://buycoffee.to/kaczakat
 
Odpowiedź
#23
Znalazłem sobie wymówkę by nie wychodzić z domu i zmontowałem to na Attiny85, znalazłem jakiś pilot do chińskiej zabawki na 433, odczytałem jego kody używając NANO, zrobiłem program i przetestowałem na NANO, wywaliłem UART, zmieniłem piny dla Attiny w programie i po wgraniu do Attiny85 wszystko działa OK.
Tylko jedna dziwna rzecz się wydarzyła, wgranie programatorem z Arduino jakiegokolwiek kodu, nawet blinka, nic nie robi u mnie, uC nie działa, nie realizuje programu. Wyeksportowanie tego programu do hex'a i wgranie zewnętrznym programem działa. Właśnie po to LED miga oprócz zmiany stanu przy wciśnięciu jednego z dwóch przycisków.
No właściwie zadziałało raz, czy dwa, potem znowu nie. Pin radia musi być odłączony do programowania, jest używany przez programator, a lecą na nim różne śmieci.
Kod:
#include <RCSwitch.h>
uint32_t ON  = 0x50550C;
uint32_t OFF = 0x505530;
uint8_t led=1;
RCSwitch mySwitch = RCSwitch();
uint32_t teraz, poprzednio;

void setup() {
//  Serial.begin(115200);
  mySwitch.enableReceive(0);  // Receiver on interrupt 0 => that is pin #2
  pinMode(led,OUTPUT);
 
}

void loop() {
  teraz=millis();
  if (mySwitch.available()) {
   
    uint32_t value = mySwitch.getReceivedValue();
   
//    if (value == 0) {
//      Serial.print("Unknown encoding");
//    } else {
//      Serial.print("Received ");
//      Serial.print( mySwitch.getReceivedValue(),16 );
//      Serial.print(" / ");
//      Serial.print( mySwitch.getReceivedBitlength() );
//      Serial.print("bit ");
//      Serial.print("Protocol: ");
//      Serial.println( mySwitch.getReceivedProtocol() );
//  }
if(value==ON) digitalWrite(led,1);
else if(value==OFF) digitalWrite(led,0);
    mySwitch.resetAvailable();
   
  }
if((teraz-poprzednio) >5000)
{
digitalWrite(led,! digitalRead(led)); 
poprzednio=teraz;
}
}
Miło być decenianym https://buycoffee.to/kaczakat
 
Odpowiedź
#24
Teraz takie pytanko bo się znowu cos udało:
-zrobiene synchronizacja
-odczyt czasu stanów wysokich
-zapisanie w kodzie 3 stanowym
Myslalem ze dwie tablice poruwnuje sie jak wszystko
If ( tablica1 ==tablica2){
Zapal lampke
}
I prubowalem z nawiasami kwadratowymi i po wpisaniu liczby w nawiasach.(wtedy poruwnuje tyko te liczby)
Zabardzo nie wiem jak je porownac .
 
Odpowiedź
#25
Idziesz w ślepą uliczkę. Te czasy coś znaczą wystarczy zdekodować..
Arduino zostało wymyślone po to, by robić dobrze jedną prostą rzecz – migać diodą. 
 
Odpowiedź
#26
Ja rozumiem ze te czasy znaczą jak długo utrzymuje sie stan wysoki lub niski na pinie .
Ja zapisałem je w 0.1.F akurat F to u mnie 2.
Synchronizacja jest na stanie dlugim niskim
Zaczyna sie odczyt 18 wierzchołków
Zapis do tablicy
Odczytanie zapisanie w systemie trzy stanowym.
Wystarczy tylko chyba porównać i zastanawiam sie jak....

Tam nie ma żadnych innych informacji
 
Odpowiedź
#27
Skoro już znalazłeś wzór na gotowy protokół do RcSwitch, a kod zajmuje mniej niż 1/2 uC Attiny85 po wywaleniu UART i da się użyć ten uC w tej bibliotece , to nie musisz wymyślać koła na nowo.

RcSwitch używając F wymusza zapisu sygnału do napisu albo tablicy char. A jak porównać dwa napisy czy są identyczne, to już znajdziesz gotowe funkcje i dla C i dla Arduino.
Miło być decenianym https://buycoffee.to/kaczakat
 
Odpowiedź
#28
Dlaczego nie rc switch .
Bo dobrze jest się czegoś nauczyć  ten kod juz rozpoznaje nadajniki i porównuje i zapala oświetlenie.
Kod:
int code_vcr1[]={1,1,2,0,2,0,0,0,1};//
int code_vcr2[]={1,1,2,0,2,0,0,1,0};//                                                   /
int code_vcr3[]={1,1,2,0,2,0,1,0,0};//Kody odbiornikow te są moje            
int code_vcr4[]={1,1,2,0,2,1,0,0,0};/////////////////////////////                 
int code_alar[]={1,1,2,0,2,0,0,0,0};// alarm czujnik pir zapalanie lampy lub lampy + alarm                          
int code_pilo[]={0,0,0,0,0,1,0,0,1};// Ostatnie 4 tryty nie zalacza buzera i led centralki videotronic (pomysl nad pilotem)                         
//////////////////////////////////////////////////// konfiguracja pinow ///////////////////////////////////////////////////                                  
int ledPin = 9;                    //  Piny Led 13 wbudowana (mozna uzyc kazy cyfrowy ktory jest wolny) ja mam  w nano 9                                                         
int odbiornikPin = 2;               //  Odbiornik                                                    
int potencjometrPin = A0;           //  Potencjometr                                               
////////////////////////////////////////////////////// czas synchronizacji ////////////////////////////////////////////////                                                  
unsigned long staryczas = 0;       // Zapamietany poczatekniskiego czasu (a własciwie koniec wysokiego)
unsigned long nowyczas  = 0;       // Odliczany czas podczas niskiego stanu
////////////////////////////////////////////////// sychronizacjia ////////////////////////////////////////////////////////             
unsigned long synchro_poczatek = 11000;    // Czas poczatku synchronizacji  
unsigned long synchro_koniec   = 11100;    // Czas konca synchronizacji     //cos nie działa przemyslec i poprawic
/////////////////////////////////////////////////// czasy trwania zera i jedynki /////////////////////////////////////////
unsigned long krutkie_zero = 150;       // czas krotkiego czasu zera
unsigned long dlugie_zero =  300;       // czas długiego czasu zera  // tu mozna filtrowac smieci regulacja czulosci
unsigned long krutka_jedynka = 1500;    // czas krotkiej jedynki     // to zalezy od bateri i odleglosci uczymy sie:)
unsigned long dluga_jedynka =  2000;    // czas dluhirj jedynki
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned long czasSwiecenia = 0;        // czas swiecenia lampy
///////////////////////////////////////////////////Przeliczenia czasu na bity potem na tryty/////////////////////////////
unsigned long czas_hig[17];      // Czasy trwania stanu High po synchronizacji
int binary[17];                  // Wygenerowane Bity  do wygenerowania codu
int code[8];                     // Wygenerowany kod trzy stanowy z Bitów
////////////////////////////////////////////////liczmiki porownania//////////////////////////////////////////////////////
int vcr1=9;
int vcr2=9;
int vcr3=9;
int vcr4=9;
int alar=9;
int pilo=9;
////////////////////////////////////////////////liczniki zamiany ow na tryty///////////////////////////////////////////
int p=0;
int d=1; 
////////////////////////////////////////////////Koniec zmiennych//////////////////////////////////////////////////////////
                                      //
void setup() {                        // Konfiguracja
pinMode(odbiornikPin, INPUT_PULLUP);  // Pin odbiornika podciagniety do plusa (testy ktory lebszy)
pinMode(ledPin, OUTPUT);              //  Pin zalaczenia LED                                                    
digitalWrite(ledPin, LOW);            // Ustaw Pin zalączenia LED na niski
}                                     //
////////////////////////////////////////
void loop() {                         // Program główny
/////////////////////////////////////// Synchronizcja długi czas miski i odczyt czasów stanu wyokiego i zapis do tablicy ///

if (digitalRead(odbiornikPin)==HIGH) {
staryczas = micros();
}
if (digitalRead(odbiornikPin)==LOW) { 
nowyczas = micros();
}
if ((nowyczas>=staryczas+synchro_poczatek)&&(nowyczas<=staryczas+synchro_koniec)){
for (int B=0;B<=17;B++){
oswietlenie_stale(); 
czas_hig[B]=pulseIn(odbiornikPin, HIGH);
}
czas_na_Bit();
Bit_na_tryt();
porownanie_kodu();
wykrycie_kodu();

}
oswietlenie_stale();
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////// Koniec programu ////////////////////////////////////////////////////////////////////
/////////////////// Odczyt z tablicy czasów i zamiana na 18 bitowy adres(jest tutaj mozliwosc odfiltrowania smieci)  ///////////////////////
void czas_na_Bit(void){
for (int B=0;B<=17;B++){

if(czas_hig[B]>dluga_jedynka){
binary[B]=2;}
  
if((czas_hig[B]>krutka_jedynka)&&(czas_hig[B]<dluga_jedynka)){
binary[B]=1;}

if((czas_hig[B]<dlugie_zero) && (czas_hig[B]>krutkie_zero)){
binary[B]=0;}

if(czas_hig[B]<krutkie_zero){
binary[B]=2;} 
}
}
////////////////////////////////////  Zamiana adresu 18 bitowego  na tryty  (protokuł MM)  /////////////////////////////////////////////////
void Bit_na_tryt(void){
p=0;
d=1; 
for (int B=0;B<=8;B++){
if ((binary[p]==1)&&(binary[d]==1)){
code[B] = 1; }

if ((binary[p]==0)&&(binary[d]==0)){
code[B] = 0; }

if ((binary[p]==1)&&(binary[d]==0)){
code[B] = 2; }

if ((binary[p]==2)||(binary[d]==2)){
code[B] = 3; }

p=p+2;
d=d+2;
}
}
/////////////////////////////////////////////////////////Porownanie kodu///////////////////////////////////////////////////////////////////
void porownanie_kodu(void){
vcr1=9;
vcr2=9;
vcr3=9;
vcr4=9;
alar=9;
pilo=9;
for (int B=0;B<=8;B++){
  if ((code[B])==(code_vcr1[B])){         
    vcr1=vcr1-1;}
  if ((code[B])==(code_vcr2[B])){
    vcr2=vcr2-1;}
  if ((code[B])==(code_vcr3[B])){
    vcr3=vcr3-1;}
  if ((code[B])==(code_vcr4[B])){
    vcr4=vcr4-1;}
  if ((code[B])==(code_alar[B])){
    alar=alar-1;}
  if ((code[B])==(code_pilo[B])){
    pilo=pilo-1;} 
  }
}
//////////////////////////////////////////////////////////// Wykrycie kodu ////////////////////////////////////////////////////////////////
void wykrycie_kodu(void){
czasSwiecenia = analogRead(potencjometrPin);
if ( (vcr1 == 0) || (vcr2 == 0) || (vcr3 == 0) || (vcr4 == 0) || (alar == 0) || (pilo == 0)){
  digitalWrite(ledPin, HIGH); 
  delay(czasSwiecenia*60*2);                               
  digitalWrite(ledPin, LOW); 

}
//////////////////////////////////////////////////// Podprogram swiecenia stalego /////////////////////////////////////////////////////////
void oswietlenie_stale(void){
czasSwiecenia = analogRead(potencjometrPin);
if (czasSwiecenia == 0){
digitalWrite(ledPin, HIGH);
}else{
digitalWrite(ledPin, LOW);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
I takie parę pytań i czy się myle .
W lopie jest 2 razy oświetlenie stale bo jak było raz to potencjometr mial straszne opóźnienia w zadzialaniu.zeby załączyć na stale to musiał być skręcony na zero i czekalem z 3 sekundy .( jaka jest różnica bo nie dostrzegam jedyne co widzę ze ta funkcja mogla się wykonać tyle co pętla) ......

Zaś przy wgrywaniu na atyniti85 za chiny nie mogłem wgrać po usb .sterowniki są nie wiem morze botloader nie ten . to linka bym prosił. ( pod win 7 64bity)
A na czysty układ atyniti85 przez uno się wgrywa......

 Następne jaka jest różnica
Delay(1000);
A..
Delay(czas*60) ;tu dziwnie sie zachowuje
A..
Czekaj=czas*60
Delay(czekaj); to jak by poprawiło działanie .

Jeszcze o zegary jak nastawiam 1 mhz to nie działa a 8 mhz juz tak chodzi o atuniti85o co chodzi z tymi zegarami proszę dużo info .

Na tym skeczu mialem 400 m okolo a ma drugi dzie 2 m. Pewnie prądu brakuje lub wilgoc chodz lakierowane bylo.a tak mierzylem odległość.
   
I tak jak na osobe co sie nie zna fajne wyszlo ....
 
Odpowiedź
#29
A jeszcze mam takie dwie różnice ze zmiennymi jak dam na sama gore gdzie reszta nie dziala .
A jak przed warunkiem niby dziala .
Tak samo z odczytem analogowym.
Nigdy nie bylem dobry w tlumaczeniu to pozaznaczam na szkicu ruznice i je opisze.
 
Odpowiedź
#30
Jak możesz zrobić jedną binarną liczbę 18 bitową, a faktycznie najprościej użyć 32 bitowej, bo takie są gotowe, to działania na nich będą znacznie szybsze niż na tablicy:
int code_vcr1[]={1,1,2,0,2,0,0,0,1};//
Bo co prościej porównać if (liczba==liczba), czyli porównać akurat ze sobą 32 bity, czy 9 x8 =72bity? A że nie ma do tego gotowca w funkcjach to jest 9-krotne porównanie 8 bitów, zapis, powrót, kolejne porównanie. A Arduino nie wie, że te liczby są trzybitowe i nie ma do nich specjalnej arytmetyki.
A sorry, ty tnie wstawiłeś w tablicę bajta, ty tu wstawiasz int, czyli 9x16 bitów.
Jak zmniejszasz prędkość z 8 na 1MHz to wszystko dzieje się tyle razy wolniej, i możliwe że pomiar czasu impulsów jest też 8x mniej dokładny, coś co mogło być zauważone w 120ns, teraz bęzie zauważone w 1us. Albo po prostu się uC nie wyrabia przy tej prędkości, tym bardziej jak nie szanujesz zasady, by wielkość zmiennych dobierać wg max potrzeb.
W moim przykładzie jest 5 poleceń w loop, sprawdź ile trwa ten loop (te od migania led co 5s to balast do wyrzucenia), dopisz funkcje by zbierały max'y i drukowały na serial (czas druku i zbierania tych info poza pomiarem), potem to samo w swoim kodzie.
Nauka nowych rzeczy jest ważna, ale jest ich i tak za dużo, nawet tylko tych ważnych, przydatnych w pisaniu programów.
Miło być decenianym https://buycoffee.to/kaczakat
 
Odpowiedź
  


Skocz do:


Przeglądający: 1 gości