Arduino schéma - arduino.sk

Komunikácia s RFM12B

Programovanie arduina
Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 8:50:40

Nejako som vycítil, že je tu dosť veľa komunikáciechtivých "Arduínčanov". Preto som "spáchal" knižnicu
a také malé demo na ukážku komunikácie pomocou modulov RFM12b.
Stručný popis: Sú to moduly na komunikáciu v pásmach 434, 868 a 915 MHz. Používajú moduláciu
FSK (Frequency Shift Keying) je to niečo podobné ako FM. Oproti modulácii OOK (On Off Keying) pri
rovnakom výkone dosiahneme väčší dosah a je vyššia odolnosť voči rušeniu. Výrobca udáva pri rýchlosti 1,2kbps
dosah na voľnom priestranstve 300m. Platí pravidlo: vyššia rýchlosť=menší dosah. Na jednom čipe RFM je
tranciever (vysielač aj prijímač) s radičom. Radičom nastavujeme mód TX/RX, výkon vysielača, citlivosť
prijímača, možno prelaďovať frekvenciu, rýchlosť komunikácie a veľa ďalších vecí. Komunikácia s CPU
je cez SPI. Toto je snáď jediná nevýhoda týchto modulov, pretože v minimálnej konfigurácii zožerie 5 pinov
Arduina. Malá nevýhoda je tá, že max. pracovné napätie je 3,8V. 5V ich síce nezabije, ale nepracujú.
Preto používam Arduino Pro Mini @3,3V. Pre 5V Arduino toto ľahko obídeme odporovými deličmi na pinoch ktorými
Arduino pristupuje k modulu t.j. nSEL, SCK, SDI. Opačným smerom nie je potrebná žiadna úprava, pretože Arduino
s napájaním 5V vyhodnotí 3,3V ako HIGH (vyskúšané, funguje). Samozrejme, že modul napájame 3,3V!
Arduino má síce HW implementáciu komunikácie SPI, ale ja som použil softwareovú. Výhoda? Každý môže požiť ľubovolné
piny ktorými bude Arduino komunikovať s RFM. Na nete sa dajú stiahnuť viaceré knižnice pre RFM, ja som použil vlastnú.
Možno niekto povie, že vymýšľam koleso no nie celkom. Tie knižnice sú síce premakané, dá sa nastaviť veľa parametrov
a rôzne konfigurácie, sú teda robustné a spotrebujú dosť systémových prostriedkov. Snažil som sa aby po inicializácii
a drobných nastaveniach mohla ihneď prebiehať komunikácia. Skúsený používateľ si potom môže "vytuningovať" nastavenie
modulu jednoduchým príkazom: rfm12b.cmd(0xabcd), kde 0xabcd je "tuningovací" príkaz (môže ich byť aj viac).
Všetky možnosti konfigurácie sa dajú vyčítať v datasheete, je ich skutočne dosť.
Koleso teda zostalo zachované, dezén si každý dopiluje sám (pozor na defekt!) a puklice - podľa vlastnej fantázie.
Komunikácia v tomto deme je typu master/slave, t.j. slave si robí svoje ("meria" teploty) pričom ticho počúva v éteri.
Master každých 10sek. požiada o poslanie nameraných údajov. Ak ale príde k zmene stavu tlačidla na strane mastra
master okamžite túto zmenu vyšle a slave zopne príslušný výstup. To znamená, že demo sa dá použiť na bezdrôtovú
telemetriu, ale aj na diaľkové ovládanie nejakého robota, či iného zariadenia (počet výstupov možno ľahko zvýšiť).
IMG_5239.JPG
IMG_5234.JPG

Na obrázku je vľavo verzia DIP, vpravo SMD. Anténa je ?/4 (lambda-štvrť) pre 868MHz je to 86,4mm.
K vlastným programom: Na začiatku si zadefinujeme piny ktorými bude prebiehať komunikácia s CPU príkazom:
Rfm12b rfm12b(nIRQ, nSEL, SDO, SCK, SDI); Celkom jednoduché, podobné ako pri použití LCD!
Ďalej nasleduje samotná inicializácia modulu príkazom: rfm12b.init(net_id, my_id, pkt_size);
net_id - idendifikátor siete 0-255, pre expertov: je to vlastne nastavenie Sync. Pattern.
my_id - "moja" adresa - pod akým číslom sa bude hlásiť konkrétne CPU v sieti. Rozsah 1-255, v danej
sieti musí byť jedinečné! (t.j. jedno číslo sa v jednej sieti môže použiť len raz);
1-master, 2-254 adresy slave-ov, adresa 255 platí pre všetkých slave v sieti - "všeobecná výzva" napr. pri synchronizácii času 0-nepoužité.
pkt_size - množstvo prenášaných datových byte; podrobne vysvetlím ďalej.
Pri inicializácii sa nastaví nasledovné:
pásmo 868MHz;
frekvencia 868.0000 MHz;
rýchlosť komunikácie 4.8kbps
FIFO level8... a ďalšie veci, nebudem zdržovať. Po inicializácii prejde modul do módu RX (príjem).
Premenná pkt_size: Určuje koľko byte sa prenesie naraz (-1). V zdrojákoch vidieť, že sa vytvoria dve polia:
data_in[pkt_size] - sem sa uložia príjímané data a data_out[pkt_size] - tieto data sa budú vysielať.
data_in[0] a data_out[0] sú rezervované, preto (-1). V data_in[0] je adresa "odosielateľa" - kto data poslal,
do data_out[0] sa pri vyslaní paketu uloží adresa "príjemcu" - komu sú data určené. Čiže ak chcem prenášať
4byte (užitočných) dát nastavím pkt_size=5 a data vložím do data_out[1]...data_out[4]. Toto bude asi natvrdší orech určiť pkt_size.
Konkrétne v demo príklade prenášam 2 "teploty" (periodicky sa menia 2 premenné typu float). Premennú typu float zaokrúhlim na 1 des. miesto, vynásobím x10, prevediem na premennú typu int a na záver použitím funkcie highByte(x) a lowByte(x) "rozložím" na byty.
Na strane príjemcu je postup presne opačný až dostanem premennú typu float s 1 des.miestom. Jasné, že?
Týmto spôsobom môžeme prenášať rozsah od -3276,8 do +3276,7. Dolná hranica je hlboko pod teplotou absolútnej nuly a horná hranica
je nad rozsahom väčšiny teplotných snímačov. Môžeme samozrejme prenášať aj viac des. miest (pri dvoch je rozsah -327,68 až 327,67),
prípadne použiť aj iné algoritmy, alebo premennú float (albo iný typ) priamo "rozbiť" na byty. Toto už ponechám na fantázii každého tvorcu.
Všeobecne som sa snažil kód čo najviac "odľahčiť" a popísať čo najviac komentárov aby pochopil aj začiatočník.
Na záver stručný popis jednotlivých funkcií:
boolean rfm12b.irq() ak je TRUE nič sa nedeje, FALSE modul žiada "zásah" obsluhy, v hlavnej slučke signalizuje, že modul prijal data.
byte rfm12b.rx_data(data_in)
<250 modul prijal platný príkaz a data, data sú uložené v data_in[];
=250 data boli určené inému slave;
>250 nastala chyba v komunikácii (timeout, alebo nesedí CRC).
rfm12b.tx_data(target, cmd, data_out) modul sa prepne do režimu TX (vysielanie), na adresu "target" vyšle príkaz "cmd"
a data uložené v data_out[]. Po odoslaní dát modul prejde opäť do módu RX (príjem).
Celkove sa vysielajú aj prijímajú nasledovné data (premenné typu byte):
identifikátor siete (Sync. Pattern), adresát, príkaz, odosielateľ (data_out[0]), "užitočné" data (data_out[1]...data_out[pkt_size]),
na záver CRC. CRC sa vypočítava ako jednoduchý súčet.
Príkazov (funkcií) je viac, ak bude záujem vysvetlím.
Naposledy upravil xeram dňa Str 17. Júl 2013 10:59:29, celkovo upravené 2

Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Re: Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 9:09:31

Zdrojový kód MASTER. Uložíme ako .../projekty/rfm_master/rfm_master.ino
Ak niekto zistí nejakú chybu v ktoromkoľvek programe, nech mi to láskavo oznámi.
Kód: Vybrať všetko
/*----------------------------
demo RFM12b - MASTER, adr.1,
komunikuje so SLAVE s adr.2
-----------------------------*/
#include <Rfm12b.h>
#include "Timer.h"
#include <LiquidCrystal.h>

#define pkt_size 5 //počet prenáš. byte, 1-255, v jednej sieti rovnaký počet, 0-tý byte rezervovaný!!!
#define net_id  1  //adresa siete 0 až 255
#define my_id   1  //adresa master zvyčajne 1, jedinečné v danej sieti!!!
#define slave_id 2
/*adresa slave: ľubovolné 2 až 254 opäť jedinečné! adresa 255 platí pre
všetkých slave v sieti "všeobecná výzva" napr. synchr. času */

#define tlac1  4  //tlačidlo 1
#define tlac2  5  //tlačidlo 2
#define tlac3  6  //tlačidlo 3

Rfm12b rfm12b(10,11,A0,13,12);  //poradie: nIRQ, nSEL, SDO, SCK, SDI
LiquidCrystal lcd(2,3,4,5,6,7);
Timer t;

byte data_in[pkt_size];  //pole dát pre príjem
byte data_out[pkt_size]; //pole dát pre vysielanie
byte buttons = 0;      //stav tlačidiel
byte rs_cmd;  //radio-send command
/*   rs_cmd = 2 pošli data
     rs_cmd = 3 posielam data
     rs_cmd = 10 setuj výstupy
     .
     .
     .   treba vymyslieť ďalšie až po 250
     rs_cmd = 250 data určené pre iného
     rs_cmd > 250 chyba pri príjme
*/
unsigned int pkt_snd = 0;  //odoslané pakety - nepovinné, len pre testovanie
unsigned int pkt_in = 0;  //prijaté pakety - nepovinné, len pre testovanie
unsigned int pkt_ok = 0;  //prijaté pakety OK - nepovinné, len pre testovanie
float temp1 = -99.9;
float temp2 = -99.9;

void setup(){
  lcd.begin(20,4);
  lcd.print("Start...");
  rfm12b.init(net_id, my_id, pkt_size);
  t.every(500, tmr05);
  t.every(1000, tmr1);
  t.every(10000, tmr10);
}

void loop(){
  t.update();
}

void tmr05(){  //kontrola tlačidiel 2x/s
  tlacidla();
}

void tmr1(){  //refresh display 1x/s
  zobraz();
}

void tmr10(){  //výzva pre slave "pošli data" každých 10s
  pkt_snd++;
  rfm12b.tx_data(slave_id, 2, data_out);
  unsigned long m_sek = millis()+100;  //čakáme max. 100ms na odpoveď
  rs_cmd = 0;
  while(m_sek > millis()){
    if(!rfm12b.irq()){
      prijem();
      break;
    }
  }
}

void prijem(){  //Príjem dialk. príkazu+data, alebo error
  pkt_in++;
  rs_cmd = rfm12b.rx_data(data_in);
  if(rs_cmd < 250){
    pkt_ok++;
    if(rs_cmd == 3)ext_data();
    //...zpracovanie ďalších príkazov
  }
}

void ext_data(){
/* zpracovanie prijatých dát; adresa "odosielatela"
   je v data_in[0] - vhodné pri viacerých slaveoch */
  int tmp_temp = word(data_in[1],data_in[2]);
  temp1 = (float)tmp_temp / 10.0;
  tmp_temp = word(data_in[3],data_in[4]);
  temp2 = (float)tmp_temp / 10.0;
}

void tlacidla(){
/*Načítanie tlačidiel - sú zdielané s LCD, piny treba vždy "prestaviť"
  ako vstupné, na konci ako výstupné */
  byte new_buttons = 0;
  pinMode(tlac1, INPUT_PULLUP);
  pinMode(tlac2, INPUT_PULLUP);
  pinMode(tlac3, INPUT_PULLUP);
  if(!digitalRead(tlac1)) bitSet(new_buttons,0);
  if(!digitalRead(tlac2)) bitSet(new_buttons,1);
  if(!digitalRead(tlac3)) bitSet(new_buttons,2);
  pinMode(tlac1,OUTPUT);
  pinMode(tlac2,OUTPUT);
  pinMode(tlac3,OUTPUT);
  if(new_buttons != buttons){  //je zmena stavu tlačidiel?
    buttons = new_buttons;
    data_out[1] = buttons;
    rfm12b.tx_data(slave_id, 10, data_out);//odošli stav tlačidiel
  }
}

void zobraz(){  //Nejaké dáta na LCD
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("t1 ");
  lcd.print(temp1,1);
  lcd.setCursor(0,1);
  lcd.print("t2 ");
  lcd.print(temp2,1);
  lcd.setCursor(0,2);
  lcd.print("rs_cmd");
  lcd.print(rs_cmd,DEC);
  lcd.setCursor(0,3);
  for(int i=1; i<5; i++){
    lcd.print(data_in[i]);lcd.print(",");
  }
  lcd.setCursor(9,0);
  lcd.print("pkt_snd");
  lcd.print(pkt_snd);
  lcd.setCursor(9,1);
  lcd.print("pkt_in");
  lcd.print(pkt_in);
  lcd.setCursor(9,2);
  lcd.print("pkt_ok");
  lcd.print(pkt_ok);
}
Naposledy upravil xeram dňa Pia 12. Júl 2013 8:34:27, celkovo upravené 2

Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Re: Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 9:12:29

Zdrojový kód SLAVE, uložíme ako .../projekty/rfm_slave/rfm_slave.ino
Kód: Vybrať všetko
/*----------------------------
demo RFM12b - SLAVE, adr. 2
-----------------------------*/

#include <Rfm12b.h>
#include "Timer.h"

#define net_id  1    //master aj slave musia byť v jednej sieti
#define my_id   2    //"moja" adresa (slave)
#define master_id 1  //adresa mastra
#define pkt_size 5  //počet prenáš. byte, 1-255, 0-tý rezervovaný
#define led1  4  //ledka 1
#define led2  5  //ledka 2
#define led3  6  //ledka 3
#define cled  13 //ledka inikujúca komunikáciu

Rfm12b rfm12b(9,8,7,6,5);
Timer t;

byte data_in[pkt_size];  //pole dát pre príjem
byte data_out[pkt_size]; //pole dát pre vyslanie
byte buttons = 0;
byte rs_cmd = 0;
float t_ext = 20.0;   //"teplota" exteréru
float t_int = 10.0;   //"teplota" interiéru

void setup(){
  rfm12b.init(net_id, my_id, pkt_size);
  t.every(2000, tmr2);
  pinMode(cled,OUTPUT);
  digitalWrite(cled,LOW);
}

void loop(){
  t.update();
  if(!rfm12b.irq()) prijem();
}

void tmr2(){
   t_int += 0.2;   //nové "meranie"
   if(t_int > 30.0)t_int = 20.0;
   float temp1 = (t_int + 0.5) * 10.0; //zaokrúhlenie na 1 des. miesto, *10
   int temp2 = (int)temp1;               //prevod na INTEGER
  data_out[1] = highByte(temp2);   //rozklad INTEGER na BYTE
  data_out[2] = lowByte(temp2);
   
  //to isté pre "teplotu" exteriéru
  t_ext -= 0.2;
  if(t_ext < -10.0)t_ext = 10.0;
  if(t_ext > 0.0){
    temp1 = t_ext + 0.5;      //zaokrúhlenie kladnej teploty
  } else {
    temp1 = t_ext - 0.5;      //zaokrúhlenie zápornej teploty
  }
  temp1 *= 10.0;
  temp2 = (int)temp1;
  data_out[3] = highByte(temp2);
  data_out[4] = lowByte(temp2);
}

void prijem(){
  digitalWrite(cled, HIGH);  //aby to pri komunikácii pekne blikalo :-)
  rs_cmd = rfm12b.rx_data(data_in);
  if(rs_cmd < 250 && data_in[0] == 1){//je rs_cmd od mastra?
    if(rs_cmd == 2)posli();        //príkaz na odoslanie dát
    if(rs_cmd == 10)vystupy();   //príkaz na nastavenie výstupov
    //...ďalšie a ďalšie príkazy...
  }
  digitalWrite(cled,LOW);
}

void posli(){  //odošle mastrovi príkaz "3" (posielam data)
  digitalWrite(cled,HIGH);
  rfm12b.tx_data(master_id, 3, data_out);
  digitalWrite(cled,LOW);
}

void vystupy(){  //riadenie výstupov
  boolean d_stat = bitRead(data_in[1],0);
  digitalWrite(led1, d_stat);
  d_stat = bitRead(data_in[1],1);
  digitalWrite(led2, d_stat);
  d_stat = bitRead(data_in[1],2);
  digitalWrite(led3, d_stat);
}

Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Re: Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 9:21:26

Súbory knižnice uložíme ako:
.../libraries/Rfm12b/keywords.txt
.../libraries/Rfm12b/Rfm12b.cpp
.../libraries/Rfm12b/Rfm12b.h
najprv kľúčové slová...
Kód: Vybrať všetko
#######################################
# Syntax Coloring Map For Rfm12b
#######################################

#######################################
# Datatypes (KEYWORD1)
#######################################

Rfm12b   KEYWORD1

#######################################
# Methods and Functions (KEYWORD2)
#######################################

cmd   KEYWORD2
idle   KEYWORD2
init   KEYWORD2
irq   KEYWORD2
rcvr   KEYWORD2
read   KEYWORD2
rx_data   KEYWORD2
send   KEYWORD2
tx_data   KEYWORD2
trans   KEYWORD2

#######################################
# Constants (LITERAL1)
#######################################

Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Re: Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 9:22:13

Rfm12b.cpp
Kód: Vybrať všetko
/*
Copyright (c) xeram@azet.sk 2013
Knižnica RFM12b pre Arduino, ver.1.0
Toto je freeware, voľne šíriteľný program môžete ho distribuovať a/alebo modifikovať
podľa pravidiel GNU a vlastného uváženia.
Dúfam, že bude niekomu užitočný, ale nenesiem žiadne záruky.
*/

#include "Rfm12b.h"
#define time_out 50  //timeout=50ms

Rfm12b::Rfm12b(int nIRQ, int nSEL, int SDO, int SCK, int SDI){
   pinMode(nIRQ,INPUT);
   _nIRQ = nIRQ;
   pinMode(nSEL,OUTPUT);
   _nSEL = nSEL;
   digitalWrite(_nSEL,HIGH);
   pinMode(SDO,INPUT);
   _SDO = SDO;
   pinMode(SCK,OUTPUT);
   _SCK = SCK;
   digitalWrite(_SCK,LOW);
   pinMode(SDI,OUTPUT);
   _SDI = SDI;
   digitalWrite(_SDI,LOW);
}

// Zápis CMD do modulu + prečítanie dát
int Rfm12b::cmd(int cmd){
  int readd = 0;
  digitalWrite(_SCK, LOW);
  digitalWrite(_nSEL, LOW);
  for(byte i=0; i<16; i++) {
    if(cmd&0x8000) digitalWrite(_SDI, HIGH);// zapíš bit
      else digitalWrite(_SDI, LOW);
      delayMicroseconds(1);
    digitalWrite(_SCK, HIGH);
    readd <<= 1;
    delayMicroseconds(1);
    if(digitalRead(_SDO)) readd++;   //čítaj bit
    digitalWrite(_SCK, LOW);
    delayMicroseconds(1);
    cmd <<= 1;
  }
  digitalWrite(_nSEL, HIGH);
  return readd;
}

// Čítanie dát z RFM
//timeout: data_raw=0x8000, inak data_raw<= 0x00FF
int Rfm12b::read(){
  int data_raw = 0x8000;
  unsigned long m_sek = millis() + time_out;
  while((millis()) < m_sek){
    if(!digitalRead(_nIRQ)){
      data_raw = (cmd(0xB000) &0x00FF);
      break;
    }
  }
  return data_raw;
}

void Rfm12b::init(byte net_id, byte my_id, byte data_lng){
   delay(100);
  cmd(0x80E7); //EL,EF,868band,12.0pF
   cmd(0x8209); //X-tal osc, dis.out
  cmd(0xA640); //freq select
  cmd(0xC647); //4.8kbps
  cmd(0x94A1); //VDI,FAST,134kHz, Max,-97dBm
  cmd(0xC2AC); //AL,!ml,DIG,DQD4
  cmd(0xCA81); //FIFO8,SYNC,!ff,DR (FIFO level = 8)
  cmd(0xCE00 | net_id); //Sync Pattern
  cmd(0xC483); //@PWR,NO RSTRIC,!st,!fi,OE,EN
  cmd(0x9850); //!mp,90kHz, 0dB
  cmd(0xCC17); //FAST, 256kbps, DDIT,B W0
  cmd(0xE000);
  cmd(0xC800);
  cmd(0xC0C0); //5MHz,2.2V
  _net_id = net_id;
  _my_id = my_id;
  _data_lng = data_lng;
  rcvr();
}

// Mód RX - príjem
void Rfm12b::rcvr(){
   cmd(0x8209);
   cmd(0x82D9);
   cmd(0xCA80);   //FIFO reset
  cmd(0xCA83);
}

//Mód TX - vysielanie
void Rfm12b::trans(){
   cmd(0x8229);
   cmd(0x8239);
}

// Idle
void Rfm12b::idle(){
  cmd(0x8209);
}

// Požiadavka na obsluhu
boolean Rfm12b::irq(){
  boolean int_req = (digitalRead(_nIRQ));
  return int_req;
}
// Vyslanie 1byte
void Rfm12b::send(byte data){
  while(digitalRead(_nIRQ)) continue;
  cmd(0xB800 + data);
}

void Rfm12b::tx_data(byte trgt, byte rccomm, byte sdata[]){
   trans();
   for(int i=0; i<8; i++){   //hlavička
      send(0xAA);
   }
   send(0x2D);
   send(_net_id);
   send(trgt);
   byte crcko = trgt;
   send(rccomm);
   crcko += rccomm;
   sdata[0] = _my_id;
   for(int i=0; i < _data_lng; i++){
      send(sdata[i]);
      crcko += sdata[i];
   }
   send(crcko);
   send(0xAA);   //koniec prenosu
   send(0xAA);
   send(0xAA);
   rcvr();
}

// Príjem dát:
byte Rfm12b::rx_data(byte rdata[]){
   int tmp_data;
   byte rmt_cmd = 0;
   byte sts_com = 250;
   byte crcko = 0;
   tmp_data = read();
   if(tmp_data == _my_id || tmp_data == 255){
      crcko += tmp_data;
      sts_com = 251;
   }
   if(sts_com == 251){
      rmt_cmd = read();
      crcko += rmt_cmd;
      for(int i=0; i < _data_lng; i++){
         tmp_data = read();
         if(tmp_data & 0x8000){
            sts_com = 252;      //timeout2
            break;
         }
      rdata[i] = tmp_data;
      crcko += tmp_data;
      }
   }
   if(sts_com == 251){
      sts_com = 253;
      tmp_data = read();
      if(tmp_data & 0x8000){
         sts_com = 254;   //timeout CRC
      } else {
         if(tmp_data == crcko){
            sts_com = rmt_cmd;
         }
      }
   }
   cmd(0xCA80);   //FIFO reset
  cmd(0xCA83);
   cmd(0x0000);
   return sts_com;
}

Príspevky: 41
Registrovaný: Štv 21. Feb 2013 10:59:11

Re: Komunikácia s RFM12B

Poslaťod xeram » Str 10. Júl 2013 9:25:55

...nakoniec Rfm12b.h. Všetko funguje, mám to na skúšobných doskách, teraz sa vrhám na praktické realizácie. :roll:
Kód: Vybrať všetko
#ifndef Rfm12b_h
#define Rfm12b_h

#if defined(ARDUINO) && ARDUINO >= 100
  #include "Arduino.h"
  #else
  #include "WProgram.h"
  #endif

class Rfm12b{
   public:
      Rfm12b(int nIRQ, int nSEL, int SDO, int SCK, int SDI);
      int cmd(int cmd);
      void idle();
      void init(byte net_id, byte my_id, byte data_lng);
      boolean irq();
      void rcvr();
      byte rx_data(byte rdata[]);
      int read();
      void tx_data(byte trgt, byte rccomm, byte sdata[]);
      void send(byte data);
      void trans();
   private:
      int _nIRQ, _nSEL, _SDO, _SCK, _SDI;
      byte _net_id, _my_id, _data_lng;
};
#endif

Príspevky: 1
Registrovaný: Pia 09. Aug 2013 11:22:15

Re: Komunikácia s RFM12B

Poslaťod mirecs » Pia 09. Aug 2013 11:34:10

Ahoj zbezne som prezrel tvoju RFM12B library a je asi treba pripomenut ze k spravnej funkcnosti je este treba pridat library Timer ktoru pouzivas a nieje uvedena v clanku.
Ked bude chvilu cas vyskusam, lebo nieco taketo potrebujem aj ja zatial vsak testujem RFM12B od lowpowerlab - http://lowpowerlab.com/blog/2012/12/28/ ... o-library/

Príspevky: 26
Registrovaný: Str 02. Máj 2012 8:32:44

Re: Komunikácia s RFM12B

Poslaťod lolo_671 » Pon 19. Aug 2013 22:00:44

Mne sa to začína páčiť ;)

Späť na Software