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; }