radio_sx127x.cpp

00001 #include "radio.h"
00002 #ifdef SX127x_H 
00003 
00004 const char* const Radio::chipNum_str = "SX127x";
00005 
00006 const RadioEvents_t* Radio::RadioEvents;
00007 LowPowerTimer Radio::lpt;
00008 uint8_t Radio::bw_idx;
00009 
00010 RegPaRamp_t Radio::RegPaRamp;
00011 
00012 const char* opModes[] = {
00013     "SLEEP    ", // 0
00014     "STANDBY  ", // 1
00015     "FS_TX    ", // 2
00016     "TX       ", // 3
00017     "FS_RX    ", // 4
00018     "RX       ", // 5
00019     "RX_SINGLE", // 6
00020     "CAD      "  // 7
00021 };
00022 
00023 const char* Radio::tx_ramp_strs[] = {
00024     "3400", // 0
00025     "2000", // 1
00026     "1000", // 2
00027     "500 ", // 3
00028     "250 ", // 4
00029     "125 ", // 5
00030     "100 ", // 6
00031     "62  ", // 7
00032     "50  ", // 8
00033     "40  ", // 9
00034     "31  ", // 10
00035     "25  ", // 11
00036     "20  ", // 12
00037     "15  ", // 13
00038     "12  ", // 14
00039     "10  ", // 15
00040     NULL
00041 };
00042 
00043 unsigned Radio::tx_ramp_read(bool fw)
00044 {
00045     RegPaRamp.octet = radio.read_reg(REG_PARAMP);
00046     return RegPaRamp.bits.PaRamp;
00047 }
00048 
00049 menuMode_e Radio::tx_ramp_write(unsigned val)
00050 {
00051     RegPaRamp.octet = radio.read_reg(REG_PARAMP);
00052 
00053     RegPaRamp.bits.PaRamp = val;
00054     radio.write_reg(REG_PARAMP, RegPaRamp.octet);
00055 
00056     return MENUMODE_REDRAW;
00057 }
00058 
00059 const char* const Radio::pktType_strs[] = {
00060     "FSK ", // 0
00061     "OOK ", // 1
00062     "LORA", // 2
00063     NULL
00064 };
00065 
00066 unsigned Radio::pktType_read(bool fw)
00067 {
00068     radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
00069     if (radio.RegOpMode.bits.LongRangeMode)
00070         return 2;
00071     else
00072         return radio.RegOpMode.bits.ModulationType;
00073 }
00074 
00075 menuMode_e Radio::pktType_write(unsigned idx)
00076 {
00077     if (idx == 2) {
00078         if (!radio.RegOpMode.bits.LongRangeMode) {
00079             /* to lora */
00080             radio.set_opmode(RF_OPMODE_SLEEP);
00081             radio.RegOpMode.bits.LongRangeMode = 1;
00082             wait_us(1000);
00083             radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
00084         }
00085     } else {
00086         if (radio.RegOpMode.bits.LongRangeMode) {
00087             /* from lora */
00088             radio.set_opmode(RF_OPMODE_SLEEP);
00089             radio.RegOpMode.bits.LongRangeMode = 0;
00090             wait_us(1000);
00091             radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
00092         }
00093 
00094         if (radio.RegOpMode.bits.ModulationType != idx) {
00095             radio.RegOpMode.bits.ModulationType = idx;
00096             radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
00097         }
00098     }
00099 
00100     return MENUMODE_REINIT_MENU;
00101 }
00102 
00103 void Radio::hw_reset()
00104 {
00105     radio.hw_reset();
00106 }
00107 
00108 void Radio::clearIrqFlags()
00109 {
00110     if (radio.RegOpMode.bits.LongRangeMode) {
00111         radio.write_reg(REG_LR_IRQFLAGS, 0xff); // clear flags in radio
00112     } else {
00113         radio.write_reg(REG_FSK_IRQFLAGS1, 0x0b);
00114         radio.write_reg(REG_FSK_IRQFLAGS2, 0x11);
00115     }
00116 }
00117 
00118 void Radio::readChip()
00119 {
00120 }
00121 
00122 uint8_t Radio::get_payload_length()
00123 {
00124     if (radio.RegOpMode.bits.LongRangeMode) {
00125         lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
00126         return lora.RegPayloadLength;
00127     } else {
00128         fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
00129         return fsk.RegPktConfig2.bits.PayloadLength;
00130     }
00131 }
00132 
00133 void Radio::set_payload_length(uint8_t len)
00134 {
00135     if (radio.RegOpMode.bits.LongRangeMode) {
00136         lora.RegPayloadLength = len;
00137         radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
00138     } else {
00139         fsk.RegPktConfig2.bits.PayloadLength = len;
00140         radio.write_u16(REG_FSK_PACKETCONFIG2, fsk.RegPktConfig2.word);
00141     }
00142 }
00143 
00144 void Radio::Rx()
00145 {
00146     if (radio.RegOpMode.bits.LongRangeMode)
00147         lora.start_rx(RF_OPMODE_RECEIVER);
00148     else
00149         fsk.start_rx();
00150 }
00151 
00152 void Radio::txPkt()
00153 {
00154     if (radio.RegOpMode.bits.LongRangeMode) {
00155         lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
00156         lora.start_tx(lora.RegPayloadLength);
00157     } else {
00158         fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
00159         //log_printf("fsk payLen %u\r\n", fsk.RegPktConfig2.bits.PayloadLength);
00160         fsk.start_tx(fsk.RegPktConfig2.bits.PayloadLength);
00161     }
00162 }
00163 
00164 void Radio::tx_carrier()
00165 {
00166     radio.set_opmode(RF_OPMODE_SLEEP);
00167     fsk.enable(false);
00168     radio.write_u16(REG_FSK_FDEVMSB, 0);
00169     radio.write_u16(REG_FSK_PREAMBLEMSB, 0xffff);
00170     fsk.start_tx(8);
00171 }
00172 
00173 void Radio::tx_preamble()
00174 {
00175     if (radio.RegOpMode.bits.LongRangeMode) {
00176         radio.write_u16(REG_LR_PREAMBLEMSB, 0xffff);
00177         lora.start_tx(8);
00178     } else {
00179         radio.write_u16(REG_FSK_PREAMBLEMSB, 0xffff);
00180         fsk.start_tx(8);
00181     }
00182 }
00183 
00184 void Radio::get_rssi()
00185 {
00186     //uint8_t buf[3];
00187     //radio.xfer(OPCODE_GET_RSSIINST, 0, 3, buf);
00188     //log_printf("-%0.1f dBm\r\n", buf[1]/2.0);
00189     if (radio.RegOpMode.bits.LongRangeMode) {
00190         log_printf("lora rssi %d dBm", lora.get_current_rssi());
00191         //REG_LR_RSSIVALUE
00192     } else {
00193         uint8_t v = radio.read_reg(REG_FSK_RSSIVALUE);
00194         log_printf("-%0.1f dBm\r\n", v/2.0);
00195     }
00196 }
00197 
00198 bool Radio::service(int8_t statusRow)
00199 {
00200     bool ret = false;
00201     static RegIrqFlags1_t prevRegIrqFlags1;
00202     static RegIrqFlags2_t prevRegIrqFlags2;
00203     static us_timestamp_t prev_now;
00204     us_timestamp_t now = lpt.read_us();
00205 
00206     if (radio.RegOpMode.bits.LongRangeMode) {
00207         const float bws[] = {7.8, 10.4, 15.6, 20.8, 31.25, 41.7, 62.5, 125, 250, 500};
00208         int32_t est_freq_error;
00209         int idx, hz;
00210         service_action_e act = lora.service();
00211         switch (act) {
00212             case SERVICE_READ_FIFO:
00213                 est_freq_error = radio.read_reg(REG_LR_TEST28);
00214                 est_freq_error <<= 8;
00215                 est_freq_error += radio.read_reg(REG_LR_TEST29);
00216                 est_freq_error <<= 8;
00217                 est_freq_error += radio.read_reg(REG_LR_TEST2A);
00218 
00219                 if (est_freq_error & 0x80000)
00220                     est_freq_error |= 0xfff00000;   // extend sign from 20bit to 32bit
00221 
00222                 //log_printf("est_freq_error:%08x\r\n", est_freq_error);
00223                 if (radio.type == SX1272)
00224                     idx = bw_idx + 7;
00225                 else
00226                     idx = bw_idx;
00227 
00228                 hz = est_freq_error * -0.524288 * bws[idx] / 500;
00229                 log_printf("hz:%d\r\n", hz);
00230 
00231                 RadioEvents->RxDone(lora.RegRxNbBytes, lora.get_pkt_rssi(), lora.RegPktSnrValue / 4.0);
00232                 break;
00233             case SERVICE_TX_DONE:
00234                 if (RadioEvents->TxDone_botHalf)
00235                     RadioEvents->TxDone_botHalf();
00236                 break;
00237             case SERVICE_ERROR:
00238             case SERVICE_NONE:
00239                 break;
00240         }
00241 
00242         if (radio.RegOpMode.bits.Mode == RF_OPMODE_CAD) {
00243             if (radio.dio1 || radio.dio0) {
00244                 RegIrqFlags_t irqFlags;
00245                 irqFlags.octet = 0;
00246                 log_printf("Cad: ");
00247                 if (radio.dio0) {
00248                     printf("Done ");
00249                     radio.RegOpMode.bits.Mode = RF_OPMODE_STANDBY;
00250                     irqFlags.bits.CadDone = 1;
00251                 }
00252                 if (radio.dio1)  {
00253                     printf("Detected");
00254                     irqFlags.bits.CadDetected = 1;
00255                 }
00256                 printf("\r\n");
00257                 radio.write_reg(REG_LR_IRQFLAGS, irqFlags.octet);
00258             }
00259         }
00260     } else {
00261         service_action_e act = fsk.service();
00262         switch (act) {
00263             case SERVICE_READ_FIFO:
00264                 /*if (fsk.RegRxConfig.bits.AfcAutoOn) {
00265                     printf("%dHz ", (int)(FREQ_STEP_HZ * fsk.RegAfcValue));
00266                     if (rssi != 0) {
00267                         printf("pkt:-%.1fdBm ", rssi / 2.0);
00268                         rssi = 0;
00269                     }
00270                 }*/
00271                 if (fsk.RegRxConfig.bits.AfcAutoOn)
00272                     log_printf("%dHz\r\n", (int)(FREQ_STEP_HZ * fsk.RegAfcValue));
00273 
00274                 RadioEvents->RxDone(fsk.rx_buf_length, /*TODO rssi*/0, 0);
00275                 break;
00276             case SERVICE_TX_DONE:
00277                 if (RadioEvents->TxDone_botHalf)
00278                     RadioEvents->TxDone_botHalf();
00279                 break;
00280             case SERVICE_ERROR:
00281             case SERVICE_NONE:
00282                 break;
00283         }
00284 
00285         if (statusRow > 0 && now-prev_now > 50000) {
00286             RegIrqFlags1_t RegIrqFlags1;
00287             RegIrqFlags2_t RegIrqFlags2;
00288 
00289             RegIrqFlags1.octet = radio.read_reg(REG_FSK_IRQFLAGS1);
00290             RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
00291             prev_now = now;
00292 
00293             if (RegIrqFlags1.octet != prevRegIrqFlags1.octet || RegIrqFlags2.octet != prevRegIrqFlags2.octet) {
00294 
00295                 printf("\e[%u;1f", statusRow);  // set (force) cursor to row;column
00296 
00297                 if (RegIrqFlags1.bits.ModeReady)
00298                     printf("ModeReady ");
00299                 if (RegIrqFlags1.bits.RxReady)
00300                     printf("RxReady ");
00301                 if (RegIrqFlags1.bits.TxReady)
00302                     printf("TxReady ");
00303                 if (RegIrqFlags1.bits.PllLock)
00304                     printf("PllLock ");
00305                 if (RegIrqFlags1.bits.Rssi)
00306                     printf("Rssi ");
00307                 if (RegIrqFlags1.bits.Timeout)
00308                     printf("Timeout ");
00309                 if (RegIrqFlags1.bits.PreambleDetect)
00310                     printf("PreambleDetect ");
00311                 if (RegIrqFlags1.bits.SyncAddressMatch)
00312                     printf("SyncAddressMatch ");
00313 
00314                 printf(" | ");
00315                 if (RegIrqFlags2.bits.FifoFull)
00316                     printf("FifoFull ");
00317                 if (RegIrqFlags2.bits.FifoEmpty)
00318                     printf("FifoEmpty ");
00319                 if (RegIrqFlags2.bits.FifoLevel)
00320                     printf("FifoLevel ");
00321                 if (RegIrqFlags2.bits.FifoOverrun)
00322                     printf("FifoOverrun ");
00323                 if (RegIrqFlags2.bits.PacketSent)
00324                     printf("PacketSent ");
00325                 if (RegIrqFlags2.bits.PayloadReady)
00326                     printf("PayloadReady ");
00327                 if (RegIrqFlags2.bits.CrcOk)
00328                     printf("CrcOk ");
00329                 if (RegIrqFlags2.bits.LowBat)
00330                     printf("LowBat ");
00331 
00332                 prevRegIrqFlags1.octet = RegIrqFlags1.octet;
00333                 prevRegIrqFlags2.octet = RegIrqFlags2.octet;
00334 
00335                 printf("\e[K");
00336                 ret = true;
00337             } // ..if irq flag changed
00338         } // ..if (++cnt > X)
00339     } // ..!radio.RegOpMode.bits.LongRangeMode
00340 
00341     return ret;
00342 }
00343 
00344 void Radio::setFS()
00345 {
00346     radio.set_opmode(RF_OPMODE_SYNTHESIZER_RX);
00347 }
00348 
00349 const menu_t* Radio::get_modem_sub_menu()
00350 {
00351     radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
00352     if (radio.RegOpMode.bits.LongRangeMode) {
00353         return NULL;
00354     } else {
00355         if (radio.RegOpMode.bits.ModulationType == 1) {
00356             fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
00357             if (fsk.RegOokPeak.bits.OokThreshType == 0) {
00358                 return ook_fixed_menu;
00359             } else if (fsk.RegOokPeak.bits.OokThreshType == 1) {
00360                 return ook_peak_menu;
00361             } else if (fsk.RegOokPeak.bits.OokThreshType == 2) {
00362                 return ook_average_menu;
00363             }
00364         } else
00365             return NULL;
00366     }
00367 
00368     return NULL;
00369 }
00370 
00371 const menu_t* Radio::get_modem_menu()
00372 {
00373     radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
00374 
00375     if (radio.RegOpMode.bits.LongRangeMode) {
00376         return lora_menu;
00377     } else {
00378         if (radio.RegOpMode.bits.ModulationType == 0)
00379             return fsk_menu;
00380         else {
00381             return ook_menu;
00382         }
00383     }
00384 }
00385 
00386 void Radio::tx_payload_length_print()
00387 {
00388     printf("%u", get_payload_length());
00389 }
00390 
00391 bool Radio::tx_payload_length_write(const char* txt)
00392 {
00393     unsigned len;
00394 
00395     sscanf(txt, "%u", &len);
00396     //log_printf("scanned %u from \"%s\"\r\n", len, txt);
00397 
00398     set_payload_length(len);
00399 
00400     return false;
00401 }
00402 
00403 const char* const Radio::opmode_status_strs[] = {
00404     "SLEEP    ", // 0
00405     "STANDBY  ", // 1
00406     "FS_TX    ", // 2
00407     "TX       ", // 3
00408     "FS_RX    ", // 4
00409     "RX       ", // 5
00410     "RX_SINGLE", // 6
00411     "CAD      ", // 7
00412     NULL
00413 };
00414 
00415 const char* const Radio::opmode_select_strs[] = {
00416     "SLEEP    ", // 0
00417     "STANDBY  ", // 1
00418     "FS_TX    ", // 2
00419     "TX       ", // 3
00420     "FS_RX    ", // 4
00421     "RX       ", // 5
00422     "RX_SINGLE", // 6
00423     "CAD      ", // 7
00424     NULL
00425 };
00426 
00427 unsigned Radio::opmode_read(bool forWriting)
00428 {
00429     radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
00430     return radio.RegOpMode.bits.Mode;
00431 }
00432 
00433 menuMode_e Radio::opmode_write(unsigned sel)
00434 {
00435     radio.RegOpMode.bits.Mode = sel;
00436     radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
00437 
00438     return MENUMODE_REDRAW;
00439 }
00440 
00441 void Radio::ocp_print(void)
00442 {
00443     unsigned i;
00444 
00445     radio.RegOcp.octet = radio.read_reg(REG_OCP);
00446     if (radio.RegOcp.bits.OcpTrim < 16)
00447         i = 45 + (5 * radio.RegOcp.bits.OcpTrim);
00448     else if (radio.RegOcp.bits.OcpTrim < 28)
00449         i = (10 * radio.RegOcp.bits.OcpTrim) - 30;
00450     else
00451         i = 240;
00452 
00453     printf("%u", i); 
00454 }
00455 
00456 bool Radio::ocp_write(const char* txt)
00457 {
00458     unsigned i;
00459 
00460     sscanf(txt, "%u", &i);
00461 
00462     if (i < 130)
00463         radio.RegOcp.bits.OcpTrim = (i - 45) / 5;
00464     else
00465         radio.RegOcp.bits.OcpTrim = (i + 30) / 10;
00466 
00467     radio.write_reg(REG_OCP, radio.RegOcp.octet);
00468 
00469     return false;
00470 }
00471 
00472 const value_item_t Radio::ocp_item = { _ITEM_VALUE, 4, ocp_print, ocp_write};
00473 
00474 static const char* const lora_bws_1276[] = {
00475     "  7.8KHz", // 0
00476     " 10.4KHz", // 1
00477     " 15.6KHz", // 2
00478     " 20.8KHz", // 3
00479     "31.25KHz", // 4
00480     " 41.7KHz", // 5
00481     " 62.5KHz", // 6
00482     "  125KHz", // 7
00483     "  250KHz", // 8
00484     "  500KHz", // 9
00485     NULL
00486 };
00487 static const char* const lora_bws_1272[] = {
00488     "125KHz", // 0
00489     "250KHz", // 1
00490     "500KHz", // 2
00491     NULL
00492 };
00493 
00494 unsigned Radio::lora_bw_read(bool fw)
00495 {
00496     bw_idx = lora.getBw();
00497     return bw_idx;
00498 }
00499 
00500 menuMode_e Radio::lora_bw_write(unsigned sidx)
00501 {
00502     lora.setBw(sidx);
00503     bw_idx = sidx;
00504 
00505     return MENUMODE_REDRAW;
00506 }
00507 
00508 dropdown_item_t Radio::lora_bw_item = { _ITEM_DROPDOWN, NULL, NULL, lora_bw_read, lora_bw_write};
00509 
00510 void Radio::lora_sf_print()
00511 {
00512     printf("%u", lora.getSf());
00513 }
00514 
00515 bool Radio::lora_sf_write(const char* txt)
00516 {
00517     unsigned sf;
00518 
00519     sscanf(txt, "%u", &sf);
00520     lora.setSf(sf);
00521 
00522     return false;
00523 }
00524 
00525 const value_item_t Radio::lora_sf_item = { _ITEM_VALUE, 3, lora_sf_print, lora_sf_write };
00526 
00527 const char* const lora_crs[] = {
00528     "4/5", // 0
00529     "4/6", // 1
00530     "4/7", // 2
00531     "4/8", // 3
00532     NULL
00533 };
00534 
00535 unsigned Radio::lora_cr_read(bool)
00536 {
00537     return lora.getCodingRate(false);
00538 }
00539 
00540 menuMode_e Radio::lora_cr_write(unsigned sidx)
00541 {
00542     lora.setCodingRate(sidx);
00543 
00544     return MENUMODE_REDRAW;
00545 }
00546 
00547 const dropdown_item_t Radio::lora_cr_item = { _ITEM_DROPDOWN, lora_crs, lora_crs, lora_cr_read, lora_cr_write};
00548 
00549 void Radio::lora_pblLen_print()
00550 {
00551     lora.RegPreamble = radio.read_u16(REG_LR_PREAMBLEMSB);
00552     printf("%u", lora.RegPreamble);
00553 }
00554 
00555 bool Radio::lora_pblLen_write(const char* str)
00556 {
00557     unsigned n;
00558 
00559     sscanf(str, "%u", &n);
00560 
00561     lora.RegPreamble = n;
00562     radio.write_u16(REG_LR_PREAMBLEMSB, lora.RegPreamble);
00563 
00564     return false;
00565 }
00566 
00567 const value_item_t Radio::lora_pblLen_item = { _ITEM_VALUE, 5, lora_pblLen_print, lora_pblLen_write};
00568 
00569 static const char* const lora_fixlen[] = {
00570     "EXPLICIT", // 0
00571     "IMPLICIT", // 1
00572     NULL
00573 };
00574 
00575 unsigned Radio::lora_fixlen_read(bool f)
00576 {
00577     if (lora.getHeaderMode())
00578         return 1;
00579     else
00580         return 0;
00581 }
00582 
00583 menuMode_e Radio::lora_fixlen_write(unsigned sidx)
00584 {
00585     lora.setHeaderMode(sidx == 1);   // true = implicit
00586 
00587     return MENUMODE_REDRAW;
00588 }
00589 
00590 const dropdown_item_t Radio::lora_fixlen_item = { _ITEM_DROPDOWN, lora_fixlen, lora_fixlen, lora_fixlen_read, lora_fixlen_write};
00591 
00592 bool Radio::lora_crcon_read()
00593 {
00594     return lora.getRxPayloadCrcOn();
00595 }
00596 
00597 bool Radio::lora_crcon_push()
00598 {
00599     lora.setRxPayloadCrcOn(!lora.getRxPayloadCrcOn());
00600     return lora.getRxPayloadCrcOn();
00601 }
00602 
00603 const toggle_item_t Radio::lora_crcon_item = { _ITEM_TOGGLE, "CrcOn", NULL, lora_crcon_read, lora_crcon_push};
00604 
00605 bool Radio::lora_iqinvTX_read()
00606 {
00607     lora.RegTest33.octet = radio.read_reg(REG_LR_TEST33);
00608     return !lora.RegTest33.bits.chirp_invert_tx;
00609 }
00610 
00611 bool Radio::lora_iqinvTX_push()
00612 {
00613     lora.invert_tx(lora.RegTest33.bits.chirp_invert_tx);
00614     return !lora.RegTest33.bits.chirp_invert_tx;
00615 }
00616 
00617 const toggle_item_t Radio::lora_iqinvTX_item = { _ITEM_TOGGLE, "iqInvTX", NULL, lora_iqinvTX_read, lora_iqinvTX_push};
00618 
00619 bool Radio::lora_iqinvRX_read()
00620 {
00621     lora.RegTest33.octet = radio.read_reg(REG_LR_TEST33);
00622     return lora.RegTest33.bits.invert_i_q;
00623 }
00624 
00625 bool Radio::lora_iqinvRX_push()
00626 {
00627     lora.invert_rx(!lora.RegTest33.bits.invert_i_q);
00628     lora.RegTest33.octet = radio.read_reg(REG_LR_TEST33);
00629     return lora.RegTest33.bits.invert_i_q;
00630 }
00631 
00632 const toggle_item_t Radio::lora_iqinvRX_item = { _ITEM_TOGGLE, "iqInvRX", NULL, lora_iqinvRX_read, lora_iqinvRX_push};
00633 
00634 void Radio::lora_ppg_print()
00635 {
00636     printf("%02x", radio.read_reg(REG_LR_SYNC_BYTE));
00637 }
00638 
00639 bool Radio::lora_ppg_write(const char* str)
00640 {
00641     unsigned ppg;
00642     sscanf(str, "%x", &ppg);
00643 
00644     radio.write_reg(REG_LR_SYNC_BYTE, ppg);
00645 
00646     return false;
00647 }
00648 
00649 const value_item_t Radio::lora_ppg_item = { _ITEM_VALUE, 4, lora_ppg_print, lora_ppg_write};
00650 
00651 void Radio::cadrx_push()
00652 {
00653     if (radio.RegDioMapping1.bits.Dio0Mapping != 2 || radio.RegDioMapping1.bits.Dio1Mapping != 2) {
00654         radio.RegDioMapping1.bits.Dio0Mapping = 2;    // DIO0 to CadDone
00655         radio.RegDioMapping1.bits.Dio1Mapping = 2;    // DIO1 to CadDetected
00656         radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
00657     }
00658 
00659     radio.set_opmode(RF_OPMODE_CAD);
00660 }
00661 
00662 const button_item_t Radio::lora_cadrx_item = { _ITEM_BUTTON, "CADRX", cadrx_push };
00663 
00664 bool Radio::lora_ppm_offset_read()
00665 {
00666     if (radio.type == SX1276) {
00667         lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
00668         return lora.RegModemConfig3.sx1276bits.LowDataRateOptimize;
00669     } else if (radio.type == SX1272) {
00670         lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
00671         return lora.RegModemConfig.sx1272bits.LowDataRateOptimize;
00672     } else
00673         return false;
00674 }
00675 
00676 bool Radio::lora_ppm_offset_push()
00677 {
00678     if (radio.type == SX1276) {
00679         lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
00680         lora.RegModemConfig3.sx1276bits.LowDataRateOptimize ^= 1;
00681         radio.write_reg(REG_LR_MODEMCONFIG3, lora.RegModemConfig3.octet);
00682         return lora.RegModemConfig3.sx1276bits.LowDataRateOptimize;
00683     } else if (radio.type == SX1272) {
00684         lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
00685         lora.RegModemConfig.sx1272bits.LowDataRateOptimize ^= 1;
00686         radio.write_reg(REG_LR_MODEMCONFIG, lora.RegModemConfig.octet);
00687         return lora.RegModemConfig.sx1272bits.LowDataRateOptimize;
00688     } else
00689         return false;
00690 }
00691 
00692 const toggle_item_t Radio::lora_ppm_offset_item = { _ITEM_TOGGLE, "LowDatarateOptimize", NULL, lora_ppm_offset_read, lora_ppm_offset_push};
00693 
00694 const menu_t Radio::lora_menu[] = {
00695     { {FIRST_CHIP_MENU_ROW, 22},     "bw:", &lora_bw_item, FLAG_MSGTYPE_ALL },
00696     { {FIRST_CHIP_MENU_ROW, 35},      "sf:",   &lora_sf_item, FLAG_MSGTYPE_ALL },
00697     { {FIRST_CHIP_MENU_ROW, 42},      "cr:",   &lora_cr_item, FLAG_MSGTYPE_ALL },
00698     { {FIRST_CHIP_MENU_ROW, 50}, "PreambleLength:", &lora_pblLen_item, FLAG_MSGTYPE_ALL },
00699 
00700     { {FIRST_CHIP_MENU_ROW+1, 1},    NULL, &lora_fixlen_item, FLAG_MSGTYPE_ALL },
00701     { {FIRST_CHIP_MENU_ROW+1, 10},   NULL, &lora_crcon_item, FLAG_MSGTYPE_ALL },
00702     { {FIRST_CHIP_MENU_ROW+1, 20},   NULL, &lora_iqinvTX_item, FLAG_MSGTYPE_ALL },
00703     { {FIRST_CHIP_MENU_ROW+1, 30},   NULL, &lora_iqinvRX_item, FLAG_MSGTYPE_ALL },
00704     { {FIRST_CHIP_MENU_ROW+1, 40}, "ppg:", &lora_ppg_item, FLAG_MSGTYPE_ALL },
00705     { {FIRST_CHIP_MENU_ROW+1, 48},   NULL, &lora_ppm_offset_item, FLAG_MSGTYPE_ALL },
00706 
00707     { {FIRST_CHIP_MENU_ROW+2, 1},    NULL, &lora_cadrx_item, FLAG_MSGTYPE_ALL },
00708 
00709     { {0, 0}, NULL, NULL }
00710 };
00711 
00712 void Radio::fsk_ook_bps_print(void)
00713 {
00714     printf("%u", fsk.get_bitrate());
00715 }
00716 
00717 bool Radio::fsk_ook_bps_write(const char* txt)
00718 {
00719     unsigned bps;
00720 
00721     sscanf(txt, "%u", &bps);
00722     fsk.set_bitrate(bps);
00723 
00724     return false;
00725 }
00726 
00727 const value_item_t Radio::fsk_ook_bitrate_item = { _ITEM_VALUE, 8, fsk_ook_bps_print, fsk_ook_bps_write };
00728 
00729 void Radio::gfsk_fdev_print(void)
00730 {
00731     printf("%u", fsk.get_tx_fdev_hz());
00732 
00733 }
00734 
00735 bool Radio::gfsk_fdev_write(const char* txt)
00736 {
00737     unsigned hz;
00738 
00739     sscanf(txt, "%u", &hz);
00740 
00741     fsk.set_tx_fdev_hz(hz);
00742 
00743     return false;
00744 }
00745 
00746 const value_item_t Radio::gfsk_fdev_item = { _ITEM_VALUE, 8, gfsk_fdev_print, gfsk_fdev_write};
00747 
00748 const char* const gfsk_bts[] = {
00749     "off", // 0
00750     "1.0", // 1
00751     "0.5", // 2
00752     "0.3", // 3
00753     NULL
00754 };
00755 
00756 const char* const ook_bts[] = {
00757     "off      ", // 0
00758     "bitRate  ", // 1
00759     "2*bitRate", // 2
00760     NULL
00761 };
00762 
00763 unsigned Radio::bt_read(bool forWriting)
00764 {
00765     if (radio.type == SX1276) {
00766         RegPaRamp.octet = radio.read_reg(REG_PARAMP);
00767         return RegPaRamp.bits.ModulationShaping;
00768     } else if (radio.type == SX1272) {
00769         radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
00770         return radio.RegOpMode.bits.ModulationShaping;
00771     }
00772     return 3;
00773 }
00774 
00775 menuMode_e Radio::bt_write(unsigned sel)
00776 {
00777     if (radio.type == SX1276) {
00778         RegPaRamp.bits.ModulationShaping = sel;
00779         radio.write_reg(REG_PARAMP, RegPaRamp.octet);
00780     } else if (radio.type == SX1272) {
00781         radio.RegOpMode.bits.ModulationShaping = sel;
00782         radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
00783     }
00784     return MENUMODE_REDRAW;
00785 } 
00786 
00787 const dropdown_item_t Radio::gfsk_bt_item = { _ITEM_DROPDOWN, gfsk_bts, gfsk_bts, bt_read, bt_write};
00788 const dropdown_item_t Radio::ook_bt_item = { _ITEM_DROPDOWN, ook_bts, ook_bts, bt_read, bt_write};
00789 
00790 bool Radio::paSelect_read()
00791 {
00792     radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
00793     return radio.RegPaConfig.bits.PaSelect;
00794 }
00795 
00796 bool Radio::paSelect_push()
00797 {
00798     radio.RegPaConfig.bits.PaSelect ^= 1; 
00799     radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
00800     return radio.RegPaConfig.bits.PaSelect;
00801 }
00802 
00803 const toggle_item_t Radio::paSelect_item = { _ITEM_TOGGLE,
00804     "RFO     ", // 0
00805     "PA_BOOST", // 1
00806     paSelect_read, paSelect_push
00807 };
00808 
00809 const char* const rxbws[] = {
00810     "  2.6", // 0
00811     "  3.1", // 1
00812     "  3.9", // 2
00813     "  5.2", // 3
00814     "  6.3", // 4
00815     "  7.8", // 5
00816     " 10.4", // 6
00817     " 12.5", // 7
00818     " 15.6", // 8
00819     " 20.8", // 9
00820     " 25.0", // 10
00821     " 31.3", // 11
00822     " 41.7", // 12
00823     " 50.0", // 13
00824     " 62.5", // 14
00825     " 83.3", // 15
00826     "100.0", // 16
00827     "125.0", // 17
00828     "166.7", // 18
00829     "200.0", // 19
00830     "250.0", // 20
00831     NULL
00832 };
00833 
00834 unsigned Radio::bw_read(uint8_t regAddr)
00835 {
00836     RegRxBw_t reg_bw;
00837 
00838     reg_bw.octet = radio.read_reg(regAddr);
00839 
00840     switch (reg_bw.bits.Exponent) {
00841         case 7:
00842             if (reg_bw.bits.Mantissa == 2)
00843                 return 0;
00844             if (reg_bw.bits.Mantissa == 1)
00845                 return 1;
00846             if (reg_bw.bits.Mantissa == 0)
00847                 return 2;
00848             break;
00849         case 6:
00850             if (reg_bw.bits.Mantissa == 2)
00851                 return 3;
00852             if (reg_bw.bits.Mantissa == 1)
00853                 return 4;
00854             if (reg_bw.bits.Mantissa == 0)
00855                 return 5;
00856             break;
00857         case 5:
00858             if (reg_bw.bits.Mantissa == 2)
00859                 return 6;
00860             if (reg_bw.bits.Mantissa == 1)
00861                 return 7;
00862             if (reg_bw.bits.Mantissa == 0)
00863                 return 8;
00864             break;
00865         case 4:
00866             if (reg_bw.bits.Mantissa == 2)
00867                 return 9;
00868             if (reg_bw.bits.Mantissa == 1)
00869                 return 10;
00870             if (reg_bw.bits.Mantissa == 0)
00871                 return 11;
00872             break;
00873         case 3:
00874             if (reg_bw.bits.Mantissa == 2)
00875                 return 12;
00876             if (reg_bw.bits.Mantissa == 1)
00877                 return 13;
00878             if (reg_bw.bits.Mantissa == 0)
00879                 return 14;
00880             break;
00881         case 2:
00882             if (reg_bw.bits.Mantissa == 2)
00883                 return 15;
00884             if (reg_bw.bits.Mantissa == 1)
00885                 return 16;
00886             if (reg_bw.bits.Mantissa == 0)
00887                 return 17;
00888             break;
00889         case 1:
00890             if (reg_bw.bits.Mantissa == 2)
00891                 return 18;
00892             if (reg_bw.bits.Mantissa == 1)
00893                 return 19;
00894             if (reg_bw.bits.Mantissa == 0)
00895                 return 20;
00896             break;
00897     }
00898 
00899     return 21;
00900 }
00901 
00902 unsigned Radio::rxbw_read(bool)
00903 {
00904     return bw_read(REG_FSK_RXBW);
00905 }
00906 
00907 unsigned Radio::afcbw_read(bool)
00908 {
00909     return bw_read(REG_FSK_AFCBW);
00910 }
00911 
00912 void Radio::bw_write(unsigned sidx, uint8_t regAddr)
00913 {
00914     RegRxBw_t reg_bw;
00915 
00916     reg_bw.octet = radio.read_reg(regAddr);
00917 
00918     switch (sidx) {
00919         case 0:
00920             reg_bw.bits.Mantissa = 2;
00921             reg_bw.bits.Exponent = 7;
00922             break;
00923         case 1:
00924             reg_bw.bits.Mantissa = 1;
00925             reg_bw.bits.Exponent = 7;
00926             break;
00927         case 2:
00928             reg_bw.bits.Mantissa = 0;
00929             reg_bw.bits.Exponent = 7;
00930             break;
00931         case 3:
00932             reg_bw.bits.Mantissa = 2;
00933             reg_bw.bits.Exponent = 6;
00934             break;
00935         case 4:
00936             reg_bw.bits.Mantissa = 1;
00937             reg_bw.bits.Exponent = 6;
00938             break;
00939         case 5:
00940             reg_bw.bits.Mantissa = 0;
00941             reg_bw.bits.Exponent = 6;
00942             break;
00943         case 6:
00944             reg_bw.bits.Mantissa = 2;
00945             reg_bw.bits.Exponent = 5;
00946             break;
00947         case 7:
00948             reg_bw.bits.Mantissa = 1;
00949             reg_bw.bits.Exponent = 5;
00950             break;
00951         case 8:
00952             reg_bw.bits.Mantissa = 0;
00953             reg_bw.bits.Exponent = 5;
00954             break;
00955         case 9:
00956             reg_bw.bits.Mantissa = 2;
00957             reg_bw.bits.Exponent = 4;
00958             break;
00959         case 10:
00960             reg_bw.bits.Mantissa = 1;
00961             reg_bw.bits.Exponent = 4;
00962             break;
00963         case 11:
00964             reg_bw.bits.Mantissa = 0;
00965             reg_bw.bits.Exponent = 4;
00966             break;
00967         case 12:
00968             reg_bw.bits.Mantissa = 2;
00969             reg_bw.bits.Exponent = 3;
00970             break;
00971         case 13:
00972             reg_bw.bits.Mantissa = 1;
00973             reg_bw.bits.Exponent = 3;
00974             break;
00975         case 14:
00976             reg_bw.bits.Mantissa = 0;
00977             reg_bw.bits.Exponent = 3;
00978             break;
00979         case 15:
00980             reg_bw.bits.Mantissa = 2;
00981             reg_bw.bits.Exponent = 2;
00982             break;
00983         case 16:
00984             reg_bw.bits.Mantissa = 1;
00985             reg_bw.bits.Exponent = 2;
00986             break;
00987         case 17:
00988             reg_bw.bits.Mantissa = 0;
00989             reg_bw.bits.Exponent = 2;
00990             break;
00991         case 18:
00992             reg_bw.bits.Mantissa = 2;
00993             reg_bw.bits.Exponent = 1;
00994             break;
00995         case 19:
00996             reg_bw.bits.Mantissa = 1;
00997             reg_bw.bits.Exponent = 1;
00998             break;
00999         case 20:
01000             reg_bw.bits.Mantissa = 0;
01001             reg_bw.bits.Exponent = 1;
01002             break;
01003     }
01004 
01005     radio.write_reg(regAddr, reg_bw.octet);
01006 }
01007 
01008 menuMode_e Radio::rxbw_write(unsigned sidx)
01009 {
01010     bw_write(sidx, REG_FSK_RXBW);
01011     return MENUMODE_REDRAW;
01012 }
01013 
01014 menuMode_e Radio::afcbw_write(unsigned sidx)
01015 {
01016     bw_write(sidx, REG_FSK_AFCBW);
01017     return MENUMODE_REDRAW;
01018 }
01019 
01020 const dropdown_item_t Radio::rxbw_item = { _ITEM_DROPDOWN, rxbws, rxbws, rxbw_read, rxbw_write};
01021 const dropdown_item_t Radio::afcbw_item = { _ITEM_DROPDOWN, rxbws, rxbws, afcbw_read, afcbw_write};
01022 
01023 void Radio::pblLen_print()
01024 {
01025     printf("%u", radio.read_u16(REG_FSK_PREAMBLEMSB));
01026 }
01027 
01028 bool Radio::pblLen_write(const char* txt)
01029 {
01030     unsigned n;
01031     sscanf(txt, "%u", &n);
01032     radio.write_u16(REG_FSK_PREAMBLEMSB, n);
01033     return false;
01034 }
01035 
01036 const value_item_t Radio::pblLen_item = { _ITEM_VALUE, 6, pblLen_print, pblLen_write};
01037 
01038 
01039 const char* const rxTriggers[] = {
01040     "off          ", // 0
01041     "RSSI         ", // 1
01042     "Preamble     ", // 2
01043     "RSSI+Preamble", // 3
01044     NULL
01045 };
01046 
01047 unsigned Radio::rxTrigger_read(bool fw)
01048 {
01049     fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
01050     return fsk.RegRxConfig.bits.RxTrigger;
01051 }
01052 
01053 menuMode_e Radio::rxTrigger_write(unsigned sidx)
01054 {
01055     fsk.RegRxConfig.bits.RxTrigger = sidx;
01056     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
01057     return MENUMODE_REDRAW;
01058 }
01059 
01060 const dropdown_item_t Radio::rxTrigger_item = { _ITEM_DROPDOWN, rxTriggers, rxTriggers, rxTrigger_read, rxTrigger_write};
01061 
01062 bool Radio::AgcAutoOn_read()
01063 {
01064     fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
01065     return fsk.RegRxConfig.bits.AgcAutoOn;
01066 }
01067 
01068 bool Radio::AgcAutoOn_push()
01069 {
01070     fsk.RegRxConfig.bits.AgcAutoOn ^= 1;
01071     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet); 
01072     return fsk.RegRxConfig.bits.AgcAutoOn;
01073 }
01074 
01075 bool Radio::AfcAutoOn_read()
01076 {
01077     fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
01078     return fsk.RegRxConfig.bits.AfcAutoOn;
01079 }
01080 
01081 bool Radio::AfcAutoOn_push()
01082 {
01083     fsk.RegRxConfig.bits.AfcAutoOn ^= 1;
01084     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet); 
01085     return fsk.RegRxConfig.bits.AfcAutoOn;
01086 }
01087 
01088 const toggle_item_t Radio::agcautoon_item = { _ITEM_TOGGLE, "AgcAutoOn", NULL, AgcAutoOn_read, AgcAutoOn_push};
01089 
01090 const toggle_item_t Radio::afcautoon_item = { _ITEM_TOGGLE, "AfcAutoOn", NULL, AfcAutoOn_read, AfcAutoOn_push};
01091 
01092 bool Radio::RestartRxOnCollision_read()
01093 {
01094     fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
01095     return fsk.RegRxConfig.bits.RestartRxOnCollision;
01096 }
01097 
01098 bool Radio::RestartRxOnCollision_push()
01099 {
01100     fsk.RegRxConfig.bits.RestartRxOnCollision ^= 1;
01101     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet); 
01102     return fsk.RegRxConfig.bits.RestartRxOnCollision;
01103 }
01104 
01105 const toggle_item_t Radio::RestartRxOnCollision_item = { _ITEM_TOGGLE,
01106     "RestartRxOnCollision", NULL,
01107     RestartRxOnCollision_read, RestartRxOnCollision_push
01108 };
01109 
01110 void Radio::RestartRxWithPllLock_push()
01111 {
01112     fsk.RegRxConfig.bits.RestartRxWithPllLock = 1;
01113     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
01114     fsk.RegRxConfig.bits.RestartRxWithPllLock = 0;
01115 }
01116 
01117 const button_item_t Radio::RestartRxWithPllLock_item = { _ITEM_BUTTON,
01118     "RestartRxWithPllLock",
01119     RestartRxWithPllLock_push
01120 };
01121 
01122 void Radio::RestartRxWithoutPllLock_push()
01123 {
01124     fsk.RegRxConfig.bits.RestartRxWithoutPllLock = 1;
01125     radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
01126     fsk.RegRxConfig.bits.RestartRxWithoutPllLock = 0;
01127 }
01128 
01129 const button_item_t Radio::RestartRxWithoutPllLock_item = { _ITEM_BUTTON,
01130     "RestartRxWithoutPllLock",
01131     RestartRxWithoutPllLock_push
01132 };
01133 
01134 bool Radio::AfcAutoClearOn_read(void)
01135 {
01136     fsk.RegAfcFei.octet = radio.read_reg(REG_FSK_AFCFEI);
01137     return fsk.RegAfcFei.bits.AfcAutoClearOn;
01138 }
01139 
01140 bool Radio::AfcAutoClearOn_push(void)
01141 {
01142     fsk.RegAfcFei.bits.AfcAutoClearOn ^= 1;
01143     radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
01144     return fsk.RegAfcFei.bits.AfcAutoClearOn;
01145 }
01146 
01147 const toggle_item_t Radio::AfcAutoClearOn_item = { _ITEM_TOGGLE, "AfcAutoClearOn", NULL, AfcAutoClearOn_read, AfcAutoClearOn_push};
01148 
01149 void Radio::AgcStart_push()
01150 {
01151     fsk.RegAfcFei.bits.AgcStart = 1;
01152     radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
01153     fsk.RegAfcFei.bits.AgcStart = 1;
01154 }
01155 
01156 const button_item_t Radio::AgcStart_item = { _ITEM_BUTTON, "AgcStart", AgcStart_push};
01157 
01158 void Radio::AfcClear_push()
01159 {
01160     fsk.RegAfcFei.bits.AfcClear = 1;
01161     radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
01162     fsk.RegAfcFei.bits.AfcClear = 0;
01163 }
01164 const button_item_t Radio::AfcClear_item = { _ITEM_BUTTON, "AfcClear", AfcClear_push};
01165 
01166 void Radio::syncWord_print(void)
01167 {
01168     unsigned n, stop;
01169 
01170     fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
01171 
01172     stop = fsk.RegSyncConfig.bits.SyncSize + 1;
01173     for (n = 0; n < stop; n++) {
01174         printf("%02x", radio.read_reg(REG_FSK_SYNCVALUE1+n));
01175     }
01176 }
01177 
01178 bool Radio::syncWord_write(const char* txt)
01179 {
01180     const char* ptr;
01181     const char* endPtr;
01182     unsigned o, n = 0;
01183 
01184     endPtr = txt + strlen(txt);
01185     for (ptr = txt; sscanf(ptr, "%02x", &o) == 1; ) {
01186         radio.write_reg(REG_FSK_SYNCVALUE1+n, o);
01187         n++;
01188         ptr += 2;
01189         if (ptr >= endPtr)
01190             break;
01191     }
01192 
01193     fsk.RegSyncConfig.bits.SyncSize = n - 1;
01194     radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
01195 
01196     return false;
01197 }
01198 
01199 const value_item_t Radio::syncWord_item = { _ITEM_VALUE, 17, syncWord_print, syncWord_write};
01200 
01201 void Radio::syncSize_print(void)
01202 {
01203     fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
01204 
01205     printf("%u", fsk.RegSyncConfig.bits.SyncSize + 1);
01206 }
01207 
01208 bool Radio::syncSize_write(const char* txt)
01209 {
01210     unsigned n;
01211     sscanf(txt, "%u", &n);
01212     if (n > 0) {
01213         fsk.RegSyncConfig.bits.SyncSize = n - 1;
01214         radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
01215     }
01216     return false;
01217 }
01218 
01219 const value_item_t Radio::syncSize_item = { _ITEM_VALUE, 2, syncSize_print, syncSize_write};
01220 
01221 bool Radio::SyncOn_read()
01222 {
01223     fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
01224     return fsk.RegSyncConfig.bits.SyncOn;
01225 }
01226 
01227 bool Radio::SyncOn_push()
01228 {
01229     fsk.RegSyncConfig.bits.SyncOn ^= 1;
01230     radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
01231     return fsk.RegSyncConfig.bits.SyncOn;
01232 }
01233 
01234 const toggle_item_t Radio::syncOn_item = { _ITEM_TOGGLE, "SyncOn", NULL, SyncOn_read, SyncOn_push};
01235 
01236 bool Radio::fsk_pktfmt_read()
01237 {
01238     fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
01239     return fsk.RegPktConfig1.bits.PacketFormatVariable;
01240 }
01241 
01242 bool Radio::fsk_pktfmt_push()
01243 {
01244     fsk.RegPktConfig1.bits.PacketFormatVariable ^= 1;
01245     radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
01246     return fsk.RegPktConfig1.bits.PacketFormatVariable;
01247 }
01248 
01249 const toggle_item_t Radio::fskook_pktfmt_item = { _ITEM_TOGGLE,
01250     "fixed   ",
01251     "variable",
01252     fsk_pktfmt_read, fsk_pktfmt_push
01253 };
01254 
01255 
01256 void Radio::rssiOffset_print(void)
01257 {
01258     int ro;
01259     fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
01260     ro = fsk.RegRssiConfig.bits.RssiOffset;
01261     printf("%d", ro);
01262 }
01263 
01264 bool Radio::rssiOffset_write(const char* txt)
01265 {
01266     int ro;
01267     sscanf(txt, "%d", &ro);
01268     fsk.RegRssiConfig.bits.RssiOffset = ro;
01269     radio.write_reg(REG_FSK_RSSICONFIG, fsk.RegRssiConfig.octet);
01270     return false;
01271 }
01272 
01273 const value_item_t Radio::rssiOffset_item = { _ITEM_VALUE, 2, rssiOffset_print, rssiOffset_write};
01274 
01275 const char* const rssiSmoothings[] = {
01276     "2  ", // 0
01277     "4  ", // 1
01278     "8  ", // 2
01279     "16 ", // 3
01280     "32 ", // 4
01281     "64 ", // 5
01282     "128", // 6
01283     "256", // 7
01284     NULL
01285 };
01286 
01287 unsigned Radio::rssiSmoothing_read(bool fw)
01288 {
01289     fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
01290     return fsk.RegRssiConfig.bits.RssiSmoothing;
01291 }
01292 
01293 menuMode_e Radio::rssiSmoothing_write(unsigned sidx)
01294 {
01295     radio.write_reg(REG_FSK_RSSICONFIG, fsk.RegRssiConfig.octet);
01296     fsk.RegRssiConfig.bits.RssiSmoothing = sidx;
01297     return MENUMODE_REDRAW;
01298 }
01299 
01300 const dropdown_item_t Radio::rssiSmoothing_item = { _ITEM_DROPDOWN, rssiSmoothings, rssiSmoothings, rssiSmoothing_read, rssiSmoothing_write};
01301 
01302 bool Radio::dataMode_read()
01303 {
01304     fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
01305     return fsk.RegPktConfig2.bits.DataModePacket;
01306 }
01307 
01308 bool Radio::dataMode_push()
01309 {
01310     fsk.RegPktConfig2.bits.DataModePacket ^= 1;
01311     radio.write_u16(REG_FSK_PACKETCONFIG2, fsk.RegPktConfig2.word);
01312     return fsk.RegPktConfig2.bits.DataModePacket;
01313 }
01314 
01315 const toggle_item_t Radio::dataMode_item = { _ITEM_TOGGLE,
01316     "continuous",
01317     "packet    ",
01318     dataMode_read, dataMode_push
01319 };
01320 
01321 bool Radio::bitSyncOn_read(void)
01322 {
01323     fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
01324     return fsk.RegOokPeak.bits.BitSyncOn;
01325 }
01326 
01327 bool Radio::bitSyncOn_push(void)
01328 {
01329     fsk.RegOokPeak.bits.BitSyncOn ^= 1;
01330     radio.write_reg(REG_FSK_OOKPEAK, fsk.RegOokPeak.octet);
01331     return fsk.RegOokPeak.bits.BitSyncOn;
01332 }
01333 
01334 const toggle_item_t Radio::bitSyncOn_item = { _ITEM_TOGGLE,
01335     "BitSyncOn", NULL,
01336     bitSyncOn_read, bitSyncOn_push
01337 };
01338 
01339 const button_item_t Radio::pdLabel_item = { _ITEM_BUTTON, "PreambleDetector", NULL};
01340 
01341 bool Radio::pdOn_read(void)
01342 {
01343     fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
01344     return fsk.RegPreambleDetect.bits.PreambleDetectorOn;
01345 }
01346 
01347 bool Radio::pdOn_push(void)
01348 {
01349     fsk.RegPreambleDetect.bits.PreambleDetectorOn ^= 1;
01350     radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
01351     return fsk.RegPreambleDetect.bits.PreambleDetectorOn;
01352 }
01353 
01354 const toggle_item_t Radio::pdOn_item = { _ITEM_TOGGLE,
01355     "On", NULL,
01356     pdOn_read, pdOn_push
01357 };
01358 
01359 const char* const pdsizes[] = {
01360     "1 byte ", // 0
01361     "2 bytes", // 1
01362     "3 bytes", // 2
01363     NULL
01364 };
01365 
01366 unsigned Radio::pdSize_read(bool)
01367 {
01368     fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
01369     return fsk.RegPreambleDetect.bits.PreambleDetectorSize;
01370 }
01371 
01372 menuMode_e Radio::pdSize_write(unsigned sidx)
01373 {
01374     fsk.RegPreambleDetect.bits.PreambleDetectorSize = sidx;
01375     radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
01376     return MENUMODE_REDRAW;
01377 }
01378 
01379 const dropdown_item_t Radio::pdSize_item = { _ITEM_DROPDOWN, pdsizes, pdsizes, pdSize_read, pdSize_write};
01380 
01381 void Radio::pdTol_print(void)
01382 {
01383     fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
01384     printf("%u", fsk.RegPreambleDetect.bits.PreambleDetectorTol);
01385 }
01386 
01387 bool Radio::pdTol_write(const char* txt)
01388 {
01389     unsigned n;
01390     sscanf(txt, "%u", &n);
01391     fsk.RegPreambleDetect.bits.PreambleDetectorTol = n;
01392     radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
01393     return false;
01394 }
01395 
01396 const value_item_t Radio::pdTol_item = { _ITEM_VALUE, 3, pdTol_print, pdTol_write};
01397 
01398 bool Radio::TxStartCondition_read()
01399 {
01400     fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
01401     return fsk.RegFifoThreshold.bits.TxStartCondition;
01402 }
01403 
01404 bool Radio::TxStartCondition_push()
01405 {
01406     fsk.RegFifoThreshold.bits.TxStartCondition ^= 1;
01407     radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
01408     return fsk.RegFifoThreshold.bits.TxStartCondition;
01409 }
01410 
01411 const toggle_item_t Radio::TxStartCondition_item = { _ITEM_TOGGLE,
01412     "FifoLevel   ", // 0
01413     "FifoNotEmpty", // 1
01414     TxStartCondition_read, TxStartCondition_push
01415 };
01416 
01417 void Radio::FifoThreshold_print(void)
01418 {
01419     fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
01420     printf("%u", fsk.RegFifoThreshold.bits.FifoThreshold);
01421 }
01422 
01423 bool Radio::FifoThreshold_write(const char* txt)
01424 {
01425     unsigned n;
01426     sscanf(txt, "%u", &n);
01427     fsk.RegFifoThreshold.bits.FifoThreshold = n;
01428     radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
01429     return false;
01430 }
01431 
01432 const value_item_t Radio::FifoThreshold_item = { _ITEM_VALUE, 3, FifoThreshold_print, FifoThreshold_write};
01433 
01434 const char* const dcFrees[] = {
01435     "none      ", // 0
01436     "manchester", // 1
01437     "whitening ", // 2
01438     NULL
01439 };
01440 
01441 unsigned Radio::dcFree_read(bool fw)
01442 {
01443     fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
01444     return fsk.RegPktConfig1.bits.DcFree;
01445 }
01446 
01447 menuMode_e Radio::dcFree_write(unsigned sidx)
01448 {
01449     fsk.RegPktConfig1.bits.DcFree = sidx;
01450     radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet); 
01451     return MENUMODE_REDRAW;
01452 }
01453 
01454 const dropdown_item_t Radio::dcFree_item = { _ITEM_DROPDOWN, dcFrees, dcFrees, dcFree_read, dcFree_write};
01455 
01456 bool Radio::fskook_crcon_read()
01457 {
01458     fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
01459     return fsk.RegPktConfig1.bits.CrcOn;
01460 }
01461 
01462 bool Radio::fskook_crcon_push()
01463 {
01464     fsk.RegPktConfig1.bits.CrcOn ^= 1;
01465     radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
01466 
01467     if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER)
01468         fsk.config_dio0_for_pktmode_rx();
01469 
01470     return fsk.RegPktConfig1.bits.CrcOn;
01471 }
01472 
01473 const toggle_item_t Radio::fskook_crcon_item = { _ITEM_TOGGLE,
01474     "CrcOn", NULL,
01475     fskook_crcon_read, fskook_crcon_push
01476 };
01477 
01478 void Radio::rssiThresh_print()
01479 {
01480     fsk.RegRssiThresh = radio.read_reg(REG_FSK_RSSITHRESH);
01481     printf("%.1f", fsk.RegRssiThresh / -2.0);
01482 }
01483 
01484 bool Radio::rssiThresh_write(const char* txt)
01485 {
01486     float dbm;
01487     sscanf(txt, "%f", &dbm);
01488     fsk.RegRssiThresh = dbm * -2.0;
01489     radio.write_reg(REG_FSK_RSSITHRESH, fsk.RegRssiThresh);
01490     return false;
01491 }
01492 
01493 const value_item_t Radio::rssiThresh_item = { _ITEM_VALUE, 3, rssiThresh_print, rssiThresh_write};
01494 
01495 bool Radio::pblPol_read()
01496 {
01497     fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
01498     return fsk.RegSyncConfig.bits.PreamblePolarity;
01499 }
01500 
01501 bool Radio::pblPol_push()
01502 {
01503     fsk.RegSyncConfig.bits.PreamblePolarity ^= 1;
01504     radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
01505     return fsk.RegSyncConfig.bits.PreamblePolarity;
01506 }
01507 
01508 const toggle_item_t Radio::pblPol_item = { _ITEM_TOGGLE,
01509     "0xaa",
01510     "0x55",
01511     pblPol_read, pblPol_push
01512 };
01513 
01514 const menu_t Radio::fsk_menu[] = {
01515     { {FIRST_CHIP_MENU_ROW, 22},    "bps:", &fsk_ook_bitrate_item, FLAG_MSGTYPE_ALL },
01516     { {FIRST_CHIP_MENU_ROW, 34},   "fdev:",       &gfsk_fdev_item, FLAG_MSGTYPE_ALL },
01517     { {FIRST_CHIP_MENU_ROW, 47},     "BT:",         &gfsk_bt_item, FLAG_MSGTYPE_ALL },
01518     { {FIRST_CHIP_MENU_ROW, 57}, "length:",     &fskook_pktfmt_item, FLAG_MSGTYPE_ALL },
01519 
01520     { {FIRST_CHIP_MENU_ROW+1, 1},         "rxbw:",      &rxbw_item, FLAG_MSGTYPE_ALL },
01521     { {FIRST_CHIP_MENU_ROW+1, 14},       "afcbw:",     &afcbw_item, FLAG_MSGTYPE_ALL },
01522     { {FIRST_CHIP_MENU_ROW+1, 27}, "preambleLen:",    &pblLen_item, FLAG_MSGTYPE_ALL },
01523     { {FIRST_CHIP_MENU_ROW+1, 47},   "RxTrigger:", &rxTrigger_item, FLAG_MSGTYPE_ALL },
01524     { {FIRST_CHIP_MENU_ROW+1, 72},           NULL, &pblPol_item, FLAG_MSGTYPE_ALL },
01525 
01526     { {FIRST_CHIP_MENU_ROW+2,  1},   "syncWord:", &syncWord_item, FLAG_MSGTYPE_ALL, &syncSize_item},
01527     { {FIRST_CHIP_MENU_ROW+2, 27},   "syncSize:", &syncSize_item, FLAG_MSGTYPE_ALL },
01528     { {FIRST_CHIP_MENU_ROW+2, 39},          NULL,   &syncOn_item, FLAG_MSGTYPE_ALL },
01529     { {FIRST_CHIP_MENU_ROW+2, 47},   "DataMode:",   &dataMode_item, FLAG_MSGTYPE_ALL },
01530     { {FIRST_CHIP_MENU_ROW+2, 69},   NULL,   &bitSyncOn_item, FLAG_MSGTYPE_ALL },
01531 
01532     { {FIRST_CHIP_MENU_ROW+3,  1},    NULL,   &pdLabel_item, FLAG_MSGTYPE_ALL },
01533     { {FIRST_CHIP_MENU_ROW+3, 18},    NULL,   &pdOn_item, FLAG_MSGTYPE_ALL },
01534     { {FIRST_CHIP_MENU_ROW+3, 23}, "size:",   &pdSize_item , FLAG_MSGTYPE_ALL },
01535     { {FIRST_CHIP_MENU_ROW+3, 36},  "tol:",   &pdTol_item , FLAG_MSGTYPE_ALL },
01536     { {FIRST_CHIP_MENU_ROW+3, 48},  "rssiThresh:",   &rssiThresh_item , FLAG_MSGTYPE_ALL },
01537 
01538     { {FIRST_CHIP_MENU_ROW+4,  1},           NULL, &agcautoon_item, FLAG_MSGTYPE_ALL },
01539     { {FIRST_CHIP_MENU_ROW+4, 11},           NULL, &afcautoon_item, FLAG_MSGTYPE_ALL },
01540     { {FIRST_CHIP_MENU_ROW+4, 22},           NULL, &RestartRxOnCollision_item, FLAG_MSGTYPE_ALL },
01541     { {FIRST_CHIP_MENU_ROW+4, 43},           NULL, &RestartRxWithPllLock_item, FLAG_MSGTYPE_ALL },
01542     { {FIRST_CHIP_MENU_ROW+4, 64},           NULL, &RestartRxWithoutPllLock_item, FLAG_MSGTYPE_ALL },
01543 
01544     { {FIRST_CHIP_MENU_ROW+5,  1},           NULL, &AfcAutoClearOn_item, FLAG_MSGTYPE_ALL },
01545     { {FIRST_CHIP_MENU_ROW+5, 17},           NULL,       &AgcStart_item, FLAG_MSGTYPE_ALL },
01546     { {FIRST_CHIP_MENU_ROW+5, 27},           NULL,       &AfcClear_item, FLAG_MSGTYPE_ALL },
01547     { {FIRST_CHIP_MENU_ROW+5, 37},   "rssiOffset:",    &rssiOffset_item, FLAG_MSGTYPE_ALL },
01548     { {FIRST_CHIP_MENU_ROW+5, 52}, "rssiSmoothing:", &rssiSmoothing_item, FLAG_MSGTYPE_ALL },
01549 
01550     { {FIRST_CHIP_MENU_ROW+6,  1}, "TxStartCondition:", &TxStartCondition_item, FLAG_MSGTYPE_ALL },
01551     { {FIRST_CHIP_MENU_ROW+6, 32},    "FifoThreshold:", &FifoThreshold_item, FLAG_MSGTYPE_ALL },
01552     { {FIRST_CHIP_MENU_ROW+6, 50},           "dcFree:", &dcFree_item, FLAG_MSGTYPE_ALL },
01553     { {FIRST_CHIP_MENU_ROW+6, 68},                NULL, &fskook_crcon_item, FLAG_MSGTYPE_ALL },
01554 
01555     { {0, 0}, NULL, NULL }
01556 };
01557 
01558 const button_item_t Radio::ookLabel_item = { _ITEM_BUTTON, "Ook", NULL};
01559 
01560 const menu_t Radio::common_menu[] = {
01561     { {FIRST_CHIP_MENU_ROW,  1},      NULL,        &paSelect_item, FLAG_MSGTYPE_ALL },
01562     { {FIRST_CHIP_MENU_ROW, 10}, "ocp mA:",             &ocp_item, FLAG_MSGTYPE_ALL },
01563     { {0, 0}, NULL, NULL }
01564 };
01565 
01566 const char* const ook_peak_steps[] = {
01567     "0.5", // 0
01568     "1.0", // 1
01569     "1.5", // 2
01570     "2.0", // 3
01571     "3.0", // 4
01572     "4.0", // 5
01573     "5.0", // 6
01574     "6.0", // 7
01575     NULL
01576 };
01577 
01578 unsigned Radio::ook_peak_step_read(bool fw)
01579 {
01580     fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
01581     return fsk.RegOokPeak.bits.OokPeakThreshStep;
01582 }
01583 
01584 menuMode_e Radio::ook_peak_step_write(unsigned sidx)
01585 {
01586     fsk.RegOokPeak.bits.OokPeakThreshStep = sidx;
01587     radio.write_reg(REG_FSK_OOKPEAK, fsk.RegOokPeak.octet);
01588     return MENUMODE_REDRAW;
01589 }
01590 
01591 const dropdown_item_t Radio::ook_peak_step_item = { _ITEM_DROPDOWN, ook_peak_steps, ook_peak_steps, ook_peak_step_read, ook_peak_step_write};
01592 
01593 const char* const ook_peak_decs[] = {
01594     "once per chip        ", // 0
01595     "once every 2 chips   ", // 1
01596     "once every 4 chips   ", // 2
01597     "once every 8 chips   ", // 3
01598     "twice in each chip   ", // 4
01599     "4 times in each chip ", // 5
01600     "8 times in each chip ", // 6
01601     "16 times in each chip", // 7
01602     NULL
01603 };
01604 
01605 unsigned Radio::ook_peak_dec_read(bool fw)
01606 {
01607     RegOokAvg_t RegOokAvg;
01608     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01609     return RegOokAvg.bits.OokPeakThreshDec;
01610 }
01611 
01612 menuMode_e Radio::ook_peak_dec_write(unsigned sidx)
01613 {
01614     RegOokAvg_t RegOokAvg;
01615     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01616     RegOokAvg.bits.OokPeakThreshDec = sidx;
01617     radio.write_reg(REG_FSK_OOKAVG, RegOokAvg.octet);
01618     return MENUMODE_REDRAW;
01619 }
01620 
01621 const dropdown_item_t Radio::ook_peak_dec_item = { _ITEM_DROPDOWN, ook_peak_decs, ook_peak_decs, ook_peak_dec_read, ook_peak_dec_write};
01622 
01623 void Radio::ookFixedThresh_print()
01624 {
01625     printf("%u", radio.read_reg(REG_FSK_OOKFIX));
01626 }
01627 
01628 bool Radio::ookFixedThresh_write(const char* txt)
01629 {
01630     unsigned n;
01631     sscanf(txt, "%u", &n);
01632     radio.write_reg(REG_FSK_OOKFIX, n);
01633     return false;
01634 }
01635 
01636 const value_item_t Radio::ookFixedThresh_item = { _ITEM_VALUE, 3, ookFixedThresh_print, ookFixedThresh_write};
01637 
01638 const char* const ook_avgOffsets[] = {
01639     "0.0dB", // 0
01640     "2.0dB", // 1
01641     "4.0dB", // 2
01642     "6.0dB", // 3
01643     NULL
01644 };
01645 
01646 unsigned Radio::ook_avgOffset_read(bool fw)
01647 {
01648     RegOokAvg_t RegOokAvg;
01649     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01650     return RegOokAvg.bits.OokAverageOffset;
01651 }
01652 
01653 menuMode_e Radio::ook_avgOffset_write(unsigned sidx)
01654 {
01655     RegOokAvg_t RegOokAvg;
01656     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01657     RegOokAvg.bits.OokAverageOffset = sidx;
01658     radio.write_reg(REG_FSK_OOKAVG, RegOokAvg.octet);
01659     return MENUMODE_REDRAW;
01660 }
01661 
01662 const dropdown_item_t Radio::ook_avgOffset_item = { _ITEM_DROPDOWN, ook_avgOffsets, ook_avgOffsets, ook_avgOffset_read, ook_avgOffset_write};
01663 
01664 const char* const ook_avgFilters[] = {
01665     "chip rate / 32.π", // 0
01666     "chip rate / 8.π ", // 1
01667     "chip rate / 4.π ", // 2
01668     "chip rate / 2.π ", // 3
01669     NULL
01670 };
01671 
01672 unsigned Radio::ook_avgFilter_read(bool fw)
01673 {
01674     RegOokAvg_t RegOokAvg;
01675     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01676     return RegOokAvg.bits.OokAverageThreshFilt;
01677 }
01678 
01679 menuMode_e Radio::ook_avgFilter_write(unsigned sidx)
01680 {
01681     RegOokAvg_t RegOokAvg;
01682     RegOokAvg.octet = radio.read_reg(REG_FSK_OOKAVG); 
01683     RegOokAvg.bits.OokAverageThreshFilt = sidx;
01684     radio.write_reg(REG_FSK_OOKAVG, RegOokAvg.octet);
01685     return MENUMODE_REDRAW;
01686 }
01687 
01688 const dropdown_item_t Radio::ook_avgFilter_item = { _ITEM_DROPDOWN, ook_avgFilters, ook_avgFilters, ook_avgFilter_read, ook_avgFilter_write};
01689 
01690 const char* const ookthreshs[] = {
01691     "fixed  ", // 0
01692     "peak   ", // 1
01693     "average", // 2
01694     NULL
01695 };
01696 
01697 
01698 unsigned Radio::ookthreshtype_read(bool)
01699 {
01700     fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
01701 
01702     return fsk.RegOokPeak.bits.OokThreshType;
01703 }
01704 
01705 menuMode_e Radio::ookthreshtype_write(unsigned sidx)
01706 {
01707     fsk.RegOokPeak.bits.OokThreshType = sidx;
01708     radio.write_reg(REG_FSK_OOKPEAK, fsk.RegOokPeak.octet);
01709 
01710     return MENUMODE_REINIT_MENU;
01711 }
01712 
01713 const dropdown_item_t Radio::ookthreshtype_item = { _ITEM_DROPDOWN, ookthreshs, ookthreshs, ookthreshtype_read, ookthreshtype_write};
01714 
01715 const menu_t Radio::ook_menu[] = {
01716     { {FIRST_CHIP_MENU_ROW, 22},   "bps:", &fsk_ook_bitrate_item, FLAG_MSGTYPE_ALL },
01717     { {FIRST_CHIP_MENU_ROW, 34},   "Fcutoff=",      &ook_bt_item, FLAG_MSGTYPE_ALL },
01718     { {FIRST_CHIP_MENU_ROW, 56}, "length:",     &fskook_pktfmt_item, FLAG_MSGTYPE_ALL },
01719 
01720     { {FIRST_CHIP_MENU_ROW+1,  1},  "rxbw:",      &rxbw_item, FLAG_MSGTYPE_ALL },
01721     { {FIRST_CHIP_MENU_ROW+1, 12}, "afcbw:",      &afcbw_item, FLAG_MSGTYPE_ALL },
01722     { {FIRST_CHIP_MENU_ROW+1, 25}, "preambleLen:",      &pblLen_item, FLAG_MSGTYPE_ALL },
01723     { {FIRST_CHIP_MENU_ROW+1, 47},   "RxTrigger:", &rxTrigger_item, FLAG_MSGTYPE_ALL },
01724 
01725     { {FIRST_CHIP_MENU_ROW+2,  1},   "syncWord:", &syncWord_item, FLAG_MSGTYPE_ALL, &syncSize_item},
01726     { {FIRST_CHIP_MENU_ROW+2, 27},   "syncSize:", &syncSize_item, FLAG_MSGTYPE_ALL },
01727     { {FIRST_CHIP_MENU_ROW+2, 39},          NULL,   &syncOn_item, FLAG_MSGTYPE_ALL },
01728     { {FIRST_CHIP_MENU_ROW+2, 47},   "DataMode:",   &dataMode_item, FLAG_MSGTYPE_ALL },
01729     { {FIRST_CHIP_MENU_ROW+2, 69},   NULL,   &bitSyncOn_item, FLAG_MSGTYPE_ALL },
01730 
01731     { {FIRST_CHIP_MENU_ROW+3,  1},    NULL,   &pdLabel_item, FLAG_MSGTYPE_ALL },
01732     { {FIRST_CHIP_MENU_ROW+3, 18},    NULL,   &pdOn_item, FLAG_MSGTYPE_ALL },
01733     { {FIRST_CHIP_MENU_ROW+3, 23}, "size:",   &pdSize_item , FLAG_MSGTYPE_ALL },
01734     { {FIRST_CHIP_MENU_ROW+3, 36},  "tol:",   &pdTol_item , FLAG_MSGTYPE_ALL },
01735     { {FIRST_CHIP_MENU_ROW+3, 48},  "rssiThresh:",   &rssiThresh_item , FLAG_MSGTYPE_ALL },
01736 
01737     { {FIRST_CHIP_MENU_ROW+4,  1}, "TxStartCondition:", &TxStartCondition_item, FLAG_MSGTYPE_ALL },
01738     { {FIRST_CHIP_MENU_ROW+4, 32},    "FifoThreshold:", &FifoThreshold_item, FLAG_MSGTYPE_ALL },
01739     { {FIRST_CHIP_MENU_ROW+4, 50},           "dcFree:", &dcFree_item, FLAG_MSGTYPE_ALL },
01740     { {FIRST_CHIP_MENU_ROW+4, 68},                NULL, &fskook_crcon_item, FLAG_MSGTYPE_ALL },
01741 
01742     { {FIRST_CHIP_MENU_ROW+5,  1},    NULL,   &ookLabel_item, FLAG_MSGTYPE_ALL },
01743     { {FIRST_CHIP_MENU_ROW+5,  5},    "threshType:",   &ookthreshtype_item, FLAG_MSGTYPE_ALL },
01744 
01745     { {0, 0}, NULL, NULL }
01746 };
01747 
01748 const menu_t Radio::ook_fixed_menu[] = {
01749     { {FIRST_CHIP_MENU_ROW+5, 25},    "threshold:",   &ookFixedThresh_item, FLAG_MSGTYPE_ALL },
01750     { {0, 0}, NULL, NULL }
01751 };
01752 
01753 const menu_t Radio::ook_peak_menu[] = {
01754     { {FIRST_CHIP_MENU_ROW+5, 25},    "step:",   &ook_peak_step_item, FLAG_MSGTYPE_ALL },
01755     { {FIRST_CHIP_MENU_ROW+5, 40},    "dec:",   &ook_peak_dec_item, FLAG_MSGTYPE_ALL },
01756     { {0, 0}, NULL, NULL }
01757 };
01758 
01759 const menu_t Radio::ook_average_menu[] = {
01760     { {FIRST_CHIP_MENU_ROW+5, 25},    "offset:",   &ook_avgOffset_item, FLAG_MSGTYPE_ALL },
01761     { {FIRST_CHIP_MENU_ROW+5, 45},    "filter:",   &ook_avgFilter_item, FLAG_MSGTYPE_ALL },
01762     { {0, 0}, NULL, NULL }
01763 };
01764 
01765 void Radio::boardInit(const RadioEvents_t* e)
01766 {
01767     targetInit();
01768 
01769     RadioEvents = e;
01770 
01771     RegPaRamp.octet = radio.read_reg(REG_PARAMP);
01772 
01773     if (radio.type == SX1276) {
01774         lora_bw_item.printed_strs = lora_bws_1276;
01775         lora_bw_item.selectable_strs = lora_bws_1276;
01776     } else if (radio.type == SX1272) {
01777         lora_bw_item.printed_strs = lora_bws_1272;
01778         lora_bw_item.selectable_strs = lora_bws_1272;
01779     }
01780 
01781     lpt.start();
01782 }
01783 
01784 unsigned Radio::read_register(unsigned addr)
01785 {
01786     return radio.read_reg(addr);
01787 }
01788 
01789 void Radio::write_register(unsigned addr, unsigned val)
01790 {
01791     radio.write_reg(addr, val);
01792 }
01793 
01794 void Radio::test() { }
01795 
01796 #endif /* ..SX127x_H */
01797