Btree<T>::Btree(const char* filename)
//
// Purpose: initializes the instances of a B-tree. The
// constructor allocates dynamic memory for the array that tracks
// the deleted nodes.
//
// Parameters:
//
// input: filename - the name of the supporting file.
//
{
root = BTREE_NIL;
numData = 0;
numNodes = 0;
numDelNodes = 0;
// create the array that tracks the deleted nodes
countDelNodeArray = BTREE_MIN_DEL_ARRAY;
delNodeArray = new unsigned[countDelNodeArray];
if (!delNodeArray)
xAlloc();
// assign BTREE_NIL to the elements of the array delNodeArray
for (unsigned i = 0; i < countDelNodeArray; i++)
*(delNodeArray + i) = BTREE_NIL;
errMsg[0] = '\0';
nodeSize = sizeof(Bstruct<T>);
// open the stream for binary I/O
f.open(filename, ios::binary | ios::in | ios::out);
if (!f.good())
xFileOpen();
}
/* main ===================================================================== */
int
main (void) {
static volatile int i;
vLedInit();
FILE * tc = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
stdout = tc;
stderr = tc;
stdin = tc;
sei();
for (;;) {
test_count = 1;
printf_P (PSTR ("\nAvrIO Log test\n"
"Press any key to proceed...\n"));
while (getchar() == EOF)
;
vLogSetMask (LOG_UPTO (LOG_INFO));
i = iLogMask();
test (i == LOG_UPTO (LOG_INFO));
vLog_P (LOG_INFO, flashstr, ++test_count);
vLog (LOG_INFO, ramstr, ++test_count);
for (i = LOG_DEBUG; i >= LOG_EMERG; i--) {
fprintf_P (stderr, PSTR ("\nPriority up to %s\n"), sLogPriorityString(i));
vLogSetMask (LOG_UPTO (i));
vLedSet (LED_LED1);
PERROR ("Error %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PWARNING ("Warning %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PNOTICE ("Notice %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PINFO ("Info %d", test_count++);
vLedClear (LED_LED1);
PDEBUG ("Debug %d", test_count++);
PERROR ("Error %d", test_count++);
PWARNING ("Warning %d", test_count++);
PNOTICE ("Notice %d", test_count++);
PINFO ("Info %d", test_count++);
PDEBUG ("Debug %d", test_count++);
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
double dValue; // pour la valeur de l'humidité
xAdcSensor xSensor;
/*
* Repère d'étalonnage utilisé pour le test
*
* Le capteur est un modèle HIH4030 de Honeywell. Il est connecté à la
* broche ADC0. C'est un capteur linéaire.
* Le datasheet nous donne les valeurs de tension en sortie:
* V1 = Vout(0%) = 958mV
* V2 = Vout(75.3%) = 3268mV
* comme Vref=5V, le quantum de l'ADC vaut LSB=5/1024=4.88mV donc :
* V1 = Vout(0%) = 958mV et ADC = 196 LSB
* V2 = Vout(75.3%) = 3268mV et ADC = 670 LSB
* Ce qui donne le repère xSetting = (0, 75.3, 196, 670)
*/
xAdcSensorSetting xSetting = ADC_SENSOR_SETTING_LINEAR(0, 75.3, 196, 670);
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à mesure
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcVcc); // Tension de référence AVcc (5V pour Arduino UNO)
/*
* Le capteur est branché sur la voie 0 (ADC0)
* Moyennage sur 32 mesures
*/
vAdcSensorInit (&xSensor, &xSetting, ADC_SENSOR_LINEAR, 0, 32);
printf ("ADC0,Humidite\n");
for (;;) {
/*
* Lecture de la valeur brute en sortie de l'ADC :
* Si on n'a pas besoin de usAdc, on peut utiliser dAdcSensorGetValue()
* à la place de usAdcSensorGetRaw() et dAdcSensorRawToValue()
*/
usAdc = usAdcSensorGetRaw (&xSensor);
// Conversion de la valeur brute en grandeur mesurée.
dValue = dAdcSensorRawToValue (&xSensor, usAdc);
// Affichage des valeurs
printf ("%u,%.02f\n", usAdc, dValue);
vLedToggle (LED_LED1); // Bascule LED1 après chaque mesure
delay_ms (500);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
double dValue; // pour la valeur de la pression
xAdcSensor xSensor;
/*
* Repère d'étalonnage utilisé pour le test
*
* Le capteur est un modèle MPX4115AP de Freescale, sa tension de sortie est:
* Vout = Vcc*(.009*P-.095) avec P pression en kPa
* il s'agit bien d'un capteur linéaire.
* Le capteur mesure entre 150 hPa (15 kPa) et 1150 hPa (115 kPa).
* Pour Vcc=Vref=5V, le quantum de l'ADC vaut LSB=5/1024=4.88mV, ce qui donne:
* Vout(15) = 200mV = 41 LSB
* Vout(115) = 4700mV = 963 LSB
* Ce qui donne le repère xSetting = (150, 1150, 41, 963)
*/
xAdcSensorSetting xSetting = ADC_SENSOR_SETTING_LINEAR(150, 1150, 41, 963);
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à mesure
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcVcc); // Tension de référence AVcc (5V pour Arduino UNO)
/*
* Capteur branché sur la voie 0 (ADC0)
* Moyennage sur 32 mesures
*/
vAdcSensorInit (&xSensor, &xSetting, ADC_SENSOR_LINEAR, 0, 32);
printf ("ADC0,Pression\n");
for (;;) {
/*
* Lecture de la valeur brute en sortie de l'ADC :
* Si on n'a pas besoin de usAdc, on peut utiliser dAdcSensorGetValue()
* à la place de usAdcSensorGetRaw() et dAdcSensorRawToValue()
*/
usAdc = usAdcSensorGetRaw (&xSensor);
// Conversion de la valeur brute en grandeur mesurée.
dValue = dAdcSensorRawToValue (&xSensor, usAdc);
// Affichage des valeurs
printf ("%u,%.02f\n", usAdc, dValue);
vLedToggle (LED_LED1); // Bascule LED1 après chaque mesure
delay_ms (500);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
char sep = ','; // caractère de séparation entre valeurs
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à série de mesures
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcInternal); // Tension de référence interne (1.1V pour Arduino UNO)
// Affiche la ligne d'entête: ADC0,ADC1,...
for (int i = 0; i < ADC_CHAN_QUANTITY; i++) {
if (i == (ADC_CHAN_QUANTITY - 1)) {
// saut de ligne après dernière étiquette
sep = '\n';
}
printf ("ADC%u%c", i, sep);
}
for (;;) {
sep = ',';
// Affiche les valeurs ADC
for (int i = 0; i < ADC_CHAN_QUANTITY; i++) {
usAdc = usAdcReadAverage (i, 8); // lecture avec moyennage sur 8 valeurs
if (i == (ADC_CHAN_QUANTITY - 1)) {
// saut de ligne après dernière valeur
sep = '\n';
}
printf ("%u%c", usAdc, sep);
}
vLedToggle (LED_LED1); // Bascule LED1 après chaque série de mesure
delay_ms (1000);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int iError;
xHscSensor xSensor;
xHscRaw xRaw;
xHscValue xValue;
vLedInit();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
stderr = serial_port;
sei();
printf ("\nTest unitaire HSC I2C\n");
vTwiInit ();
iError = eTwiSetSpeed (100);
assert (iError == 0);
iError = iHscInitTwiSensor (&xSensor, 0, 1600, HSC_DEFAULT_TWIADDR);
assert (iError == 0);
for (;;) {
iError = iHscGetRaw (&xSensor, &xRaw);
if (iError) {
printf ("Sensor Error: %d\n", iError);
}
else {
vHscRawToValue (&xSensor, &xRaw, &xValue);
printf ("Press %.02f Temp %.02f\n", xValue.dPress, xValue.dTemp);
}
vLedToggle (LED_LED1);
delay_ms (500);
}
return 0;
}
/* internal public functions ================================================ */
int
main(void) {
int i;
vLedInit ();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
vTncInit (&tnc, serial_port, serial_port);
sei();
for (i = 0; i < TNC_RXBUFSIZE; i++)
msg[i] = i;
xScheduler = xTaskCreate (xTaskConvertMs (TRANSMIT_PERIOD), vScheduler);
vTaskStart (xScheduler);
for (;;) {
i = iTncPoll (&tnc);
vAssert (i >= 0);
if (i == TNC_EOT) {
for (i = 0; i < tnc.len; i++)
vAssert (tnc.rxbuf[i] == i);
vLedToggle (LED_LED1);
}
if (xMutexTryLock(&xMutexTx) == 0) {
i = iTncWrite (&tnc, msg, sizeof(msg));
vAssert (i == sizeof(msg));
}
}
return 0;
}
/* internal public functions ================================================ */
int
main(void) {
vLedInit ();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
sei();
vTncInit (&tnc, serial_port, serial_port);
sei();
for (;;) {
i = iTncPoll (&tnc);
vAssert (i >= 0);
if (i == TNC_EOT) {
uint16_t usLen = tnc.len;
i = iTncWrite (&tnc, &usLen, sizeof(usLen));
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int ret, c;
int src, target, level, net;
bool bPrintStat = true;
bool bTxOn = true;
bool bPromiscuous = true;
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
// FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
FILE * serial_port = xFileOpen (PORT, O_RDWR, &settings);
stdout = serial_port; // le port série est la sortie standard
stderr = serial_port; // le port série est la sortie d'erreur
stdin = serial_port; // le port série est l'entrée standard
// Affiche le menu
printf_P (PSTR ("\n\n** Test Ping RFM69 **\n"
"----------- Menu -----------\n"
"[space]: start/stop Tx\n"
" p: toggle promiscous\n"
" t: change target node\n"
" w: change power level\n"));
xRf69 * rf = xRf69New (0, 0, DIO0_IRQ);
assert (rf);
ret = iRf69Open (rf, eRf69Band868Mhz, MYNODE_ID, NET_ID);
assert (ret == 0);
src = iRf69NodeId (rf);
assert (src >= 0);
net = iRf69NetworkId (rf);
assert (net >= 0);
target = TARGET_ID;
for (;;) {
if (iFileDataAvailable (stdin)) {
c = getchar();
// Commandes utilisateur
switch (c) {
case ' ':
bTxOn = ! bTxOn;
printf_P (PSTR ("\nTx %s\n"), bTxOn ? "On" : "Off");
break;
case 'p':
bPromiscuous = ! bPromiscuous;
ret = iRf69SetPromiscuous (rf, bPromiscuous);
printf_P (PSTR ("\nPromiscuous %s\n"), bPromiscuous ? "On" : "Off");
break;
case 't':
ret = -1;
do {
printf_P (PSTR ("\nTarget ID (%d for broadcast)? "), RF69_BROADCAST_ADDR);
scanf ("%d", &ret);
}
while ( (ret < 1) || (ret > 255));
target = ret;
bPrintStat = true;
break;
case 'w':
ret = -1;
do {
printf_P (PSTR ("\nPower level [-18,13]? "));
scanf ("%d", &ret);
}
while ( (ret < -18) || (ret > 13));
level = ret + 18;
ret = iRf69SetPowerLevel (rf, level);
assert (ret == 0);
bPrintStat = true;
break;
default:
break;
}
}
if (bPrintStat) {
// Affiche les infos sur la liaison
long frf = lRf69Frequency (rf);
assert (frf >= 0);
level = iRf69PowerLevel (rf);
assert (level >= 0);
ret = bRf69isHighPower (rf);
assert (ret >= 0);
if (ret) {
level = level / 2 + 5;
}
else {
level -= 18;
}
bPromiscuous = bRf69isPromiscuous (rf);
printf_P (PSTR ("\nFrf: %lu kHz - Power Level: %d dBm - Promiscuous: %d\n"
"Own address: [%d]\n"
"Transmitting data on network %d to node [%d]...\n"),
frf / 1000, level, bPromiscuous, src, net, target);
bPrintStat = false;
}
if (bTxOn) {
// Transmission activée, on envoit...
ret = iRf69CanSend (rf);
assert (ret >= 0);
if (ret) {
static int count;
char msg[20];
snprintf_P (msg, sizeof (msg), PSTR ("Hello %d"), count++);
printf_P (PSTR ("\nT[%d]>[%d] '%s' > "), src, target, msg);
ret = iRf69Send (rf, target, msg, strlen (msg), target != RF69_BROADCAST_ADDR);
assert (ret == true);
if (target != RF69_BROADCAST_ADDR) {
int rssi;
ret = iRf69WaitAckReceived (rf, target, 1000);
rssi = iRf69Rssi (rf, false);
assert (rssi != INT_MAX);
switch (ret) {
case false:
printf_P (PSTR ("Timeout"));
break;
case true:
printf_P (PSTR ("Ack"));
break;
default:
printf_P (PSTR ("Error %d"), ret);
break;
}
printf_P (PSTR (" [RSSI = %d]"), rssi);
}
delay_ms (1000);
}
}
// Réception des paquets hors ACK
ret = iRf69ReceiveDone (rf);
assert (ret >= 0);
if (ret) {
if (iRf69DataLength (rf)) {
printf_P (PSTR ("R>%s\n"), sRf69Data (rf));
}
ret = iRf69AckRequested (rf);
assert (ret >= 0);
if (ret) {
ret = iRf69SendAck (rf, 0, 0);
assert (ret == true);
}
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int c, count;
uint8_t channel = DEFAULT_CHANNEL;
bool state = false;
bool loop = false;
bool txreq = false;
xBlyssFrame f;
xSerialIos xTermIos = SERIAL_SETTINGS (TERMINAL_BAUDRATE);
vLedInit();
FILE * tc = xFileOpen (TERMINAL_PORT, O_RDWR | O_NONBLOCK, &xTermIos);
stdout = tc;
stderr = tc;
stdin = tc;
sei();
printf_P (PSTR ("** Blyss Transmitter Test **\n"
"Channel: %u\n"
"Press 0 for OFF, 1 for ON, 2 for Loop...\n"), channel);
vBlyssInit ();
vBlyssFrameInit (&f, my_id);
vBlyssFrameSetChannel (&f, channel);
for (;;) {
if ( (c = getchar()) != EOF) {
switch (c) {
case '0':
state = false;
loop = false;
txreq = true;
printf_P (PSTR("\nLight OFF\n"));
break;
case '1':
state = true;
txreq = true;
loop = false;
printf_P (PSTR("\nLight ON\n"));
break;
case '2':
loop = true;
count = 0;
printf_P (PSTR("\nLoop ON/OFF\n"));
break;
default:
break;
}
}
if (txreq) {
vBlyssFrameSetState (&f, state);
vBlyssSend (&f, 4);
vBlyssPrintFrame (&f);
txreq = false;
}
if (loop) {
if (count-- == 0) {
state = !state;
txreq = true;
count = LOOP_TIME / 100;
}
delay_ms (100);
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int t = 1, ret;
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
stdout = serial_port; // le port série est la sortie standard
stderr = serial_port; // le port série est la sortie d'erreur
stdin = serial_port; // le port série est l'entrée standard
sei();
printf_P (PSTR ("\n\n*** RFM69 Common test ***\n\n"));
printf_P (PSTR ("Test %d - xRf69New(0,0,%d)\n"), t++, DIO0_IRQ);
xRf69 * rf = xRf69New (0, 0, DIO0_IRQ);
assert (rf);
printf_P (PSTR ("Success\n\n"));
printf_P (PSTR ("Test %d - iRf69Open (rf,eRf69Band868Mhz,%d,%d)\n"), t++,
NODE_ID, NET_ID);
ret = iRf69Open (rf, eRf69Band868Mhz, NODE_ID, NET_ID);
assert (ret == 0);
printf_P (PSTR ("Success\n\n"));
// NodeId
printf_P (PSTR ("Test %d - iRf69NodeId()\n"), t++);
ret = iRf69NodeId (rf);
printf_P (PSTR ("Node ID: 0x%02X\n"), ret);
assert (ret == NODE_ID);
printf_P (PSTR ("Success\n\n"));
// NetId
printf_P (PSTR ("Test %d - iRf69NetworkId()\n"), t++);
ret = iRf69NetworkId (rf);
printf_P (PSTR ("Network ID: 0x%02X\n"), ret);
assert (ret == NET_ID);
printf_P (PSTR ("Success\n\n"));
// temperature
printf_P (PSTR ("Test %d - iRf69Temperature()\n"), t++);
ret = iRf69Temperature (rf, 0);
printf_P (PSTR ("Temperature: %d oC\n"), ret);
assert (ret != INT_MAX);
printf_P (PSTR ("Success\n\n"));
// frequency
printf_P (PSTR ("Test %d - lRf69Frequency()\n"), t++);
double f = (double) lRf69Frequency (rf);
printf_P (PSTR ("Frequency: %.0f Hz (%.3f MHz)\n"), f, f / 1E6);
assert (ret >= 0);
printf_P (PSTR ("Success\n\n"));
// powerlevel/highpower
printf_P (PSTR ("Test %d - iRf69PowerLevel() & bRf69isHighPower()\n"), t++);
int level = iRf69PowerLevel (rf);
printf_P (PSTR ("Power Level: %d (raw)\n"), level);
assert (level >= 0);
ret = bRf69isHighPower (rf);
printf_P (PSTR ("High Power mode: %d\n"), ret);
assert (ret >= 0);
if (ret) {
level = level / 2 + 5;
}
else {
level -= 18;
}
printf_P (PSTR ("Power Level: %d dBm\n"), level);
printf_P (PSTR ("Success\n\n"));
// rssi
printf_P (PSTR ("Test %d - iRf69Rssi()\n"), t++);
ret = iRf69Rssi (rf, false);
printf_P (PSTR ("RSSI: %i dBm\n"), ret);
assert (ret != INT_MAX);
printf_P (PSTR ("Success\n\n"));
// bRf69isPromiscuous
printf_P (PSTR ("Test %d - Promiscuous\n"), t++);
ret = bRf69isPromiscuous (rf);
printf_P (PSTR ("Promiscuous: %d\n"), ret);
assert (ret == true);
ret = iRf69SetPromiscuous (rf, false);
assert (ret == 0);
ret = bRf69isPromiscuous (rf);
assert (ret == false);
ret = iRf69SetPromiscuous (rf, true);
assert (ret == 0);
ret = bRf69isPromiscuous (rf);
assert (ret == true);
printf_P (PSTR ("Success\n\n"));
// iRf69SetEncryptKey
printf_P (PSTR ("Test %d - AES Encrypt\n"), t++);
ret = iRf69isEncrypted (rf);
printf_P (PSTR ("AES Encrypt: %d\n"), ret);
assert (ret == false);
ret = iRf69SetEncryptKey (rf, "ABCDABCDABCDABCD");
assert (ret == 0);
ret = iRf69isEncrypted (rf);
assert (ret == true);
ret = iRf69SetEncryptKey (rf, 0);
assert (ret == 0);
ret = iRf69isEncrypted (rf);
assert (ret == false);
printf_P (PSTR ("Success\n\n"));
// iRf69SetEncryptKey
printf_P (PSTR ("Test %d - iRf69RcCalibration()\n"), t++);
ret = iRf69RcCalibration (rf);
assert (ret == 0);
printf_P (PSTR ("Success\n\n"));
// iRf69Sleep
printf_P (PSTR ("Test %d - iRf69Sleep()\n"), t++);
ret = iRf69Sleep (rf);
assert (ret == 0);
printf_P (PSTR ("Success\n\n"));
ret = iRf69ReceiveDone (rf);
assert (ret >= 0);
return 0;
}
/* main ===================================================================== */
int
main (void) {
int ret, c;
int src, level, net;
bool bPrintStat = true;
bool bRxOn = true;
bool bPromiscuous = true;
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
// FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
FILE * serial_port = xFileOpen (PORT, O_RDWR, &settings);
stdout = serial_port; // le port série est la sortie standard
stderr = serial_port; // le port série est la sortie d'erreur
stdin = serial_port; // le port série est l'entrée standard
// Affiche le menu
printf_P (PSTR ("\n\n** Test Gateway RFM69 **\n"
"----------- Menu -----------\n"
"[space]: start/stop Rx\n"
" p: toggle promiscous\n"
" w: change power level\n"));
xRf69 * rf = xRf69New (0, 0, DIO0_IRQ);
assert (rf);
ret = iRf69Open (rf, eRf69Band868Mhz, MYNODE_ID, NET_ID);
assert (ret == 0);
src = iRf69NodeId (rf);
assert (src >= 0);
net = iRf69NetworkId (rf);
assert (net >= 0);
for (;;) {
if (iFileDataAvailable (stdin)) {
c = getchar();
// Commandes utilisateur
switch (c) {
case ' ':
bRxOn = ! bRxOn;
printf_P (PSTR ("\nTx %s\n"), bRxOn ? "On" : "Off");
break;
case 'p':
bPromiscuous = ! bPromiscuous;
ret = iRf69SetPromiscuous (rf, bPromiscuous);
printf_P (PSTR ("\nPromiscuous %s\n"), bPromiscuous ? "On" : "Off");
break;
case 'w':
ret = -1;
do {
printf_P (PSTR ("\nPower level [-18,13]? "), RF69_BROADCAST_ADDR);
scanf ("%d", &ret);
}
while ( (ret < -18) || (ret > 13));
level = ret + 18;
ret = iRf69SetPowerLevel (rf, level);
assert (ret == 0);
bPrintStat = true;
break;
default:
break;
}
}
if (bPrintStat) {
// Affiche les infos sur la liaison
long frf = lRf69Frequency (rf);
assert (frf >= 0);
level = iRf69PowerLevel (rf);
assert (level >= 0);
ret = bRf69isHighPower (rf);
assert (ret >= 0);
if (ret) {
level = level / 2 + 5;
}
else {
level -= 18;
}
bPromiscuous = bRf69isPromiscuous (rf);
printf_P (PSTR ("\nFrf: %lu kHz - Power Level: %d dBm - Promiscuous: %d\n"
"Own address: [%d]\n"
"Receiving data on network %d...\n"),
frf / 1000, level, bPromiscuous, src, net);
bPrintStat = false;
}
if (bRxOn) {
// Réception des paquets
ret = iRf69ReceiveDone (rf);
assert (ret >= 0);
if (ret) {
int rssi = iRf69Rssi (rf, false);
assert (rssi != INT_MAX);
printf_P (PSTR ("R[%d]<[%d] "), iRf69TargetId (rf), iRf69SenderId (rf));
if (iRf69DataLength (rf)) {
printf_P (PSTR ("'%s'"), sRf69Data (rf));
}
ret = iRf69AckRequested (rf);
assert (ret >= 0);
if (ret) {
ret = iRf69SendAck (rf, 0, 0);
assert (ret == true);
printf_P (PSTR (" > Ack")); // > Ack [RSSI = -28]
}
printf_P (PSTR (" [RSSI = %d]\n"), rssi);
}
}
}
return 0;
}