-
Thread
variables Array in einer struct richtig initialisieren
dass du den eigentlichen Speicher dafür irgendwo in passender Größe per malloc() beschaffst. sizeof(struct) kannst du benutzen, um alles /außer/ dem flexible array zu bestimmen, d. h. wenn du 20 Elemente im Array hinter der eigentlichen struct haben willst, allozierst du [c]malloc(sizeof(struct xxx) + 20 * sizeof(array yy))[/c] Davon darfst du dann einen Typecast auf einen Zeiger auf die struct machen und nun auf den zusätzlichen Speicher am Ende typsicher zugreifen.
-
Thread
Arduino Text programmieren Gesperrt
different data pin on your microcontroller CHANGE THIS! #define DATA_PIN 6 #define arr_len( x ) ( sizeof( x ) / sizeof( *x ) ) // Matrix setup params Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(48, 16, DATA_PIN, NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_COLUMNS +NEO_MATRIX_ZIGZAG, NEO_GRB
-
Thread
Bauplan 512-Byte-Array
Irgendetwas von der struct musst du kennen und sei es nur die komplette Größe. memcpy( ziel, quelle, sizeof(quelle) ); oder mit einer klassischen for Schleife dazu castest du dir die Startadresse der struct um in einen Bytepointer und das wars dann schon. [C] void WriteToSD( uint8_t * Bytes, size_t
i] ); } int main() { struct irgendwas Daten; .... WriteToSD( (uint8_t*)&Daten, sizeof( Daten ) ); } [/C] Oder reden wir jetzt immer noch aneinander vorbei?
-
Thread
Feld Array Dynamisch Statisch Compiler C
voif function(void) { int x[DIMX][DIMY]; int **y; int i; y=(**int)malloc(DIMX*sizeof(*int)); for (i=0; i<DIMX; i++) { y[i] =(*int)malloc(DIMY*sizeof(int)); } } meine frage, wie bekommt der kompiler die umsetzung von : g=x[1][2]; und g=y[1][2]; auf die
du dieses problem gefunden hast, habe ich das übersehen!? zb. hier: y=(**int)malloc(DIMX*sizeof(*int)); (wenn wir mal von der falschen Pointer Syntax absehen) Den Return Wert von malloc _nie_ casten. In C ist der cast unnötig. malloc liefert einen void* und der ist in C zuweisungskompatibel
-
Thread
typeof-operator und non-static data members
etwas zuzugreifen, was gar nicht existiert. Einen Sonderfall stellen die Operatoren /typeof/ und /sizeof/ dar, da diese nicht das Element selbst, sondern nur dessen Eigenschaften (Typ bzw. Größe) kennen müssen. Aber nur für diese beiden Operatoren wollten die C++-Entwickler wohl kein eigenes Sprachkonstrukt
wird, ist das in Ordnung, wenn auch unschön: [c] typeof ((A *)0)->B [/c] bzw. [c] sizeof ((A *)0)->B [/c] Der Hack funktioniert aber nur außerhalb der Klassendeklaration von A. Versucht man, ihn innerhalb der Klassendeklaration anzuwenden, meckert der GCC schon wieder: [pre]
-
Thread
EEPROM beschreiben vorab und während des Betriebs
Funktion richtig? [c] uint8_t myByteBuffer[3]; eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer)); [/c] Wird dort der komplette Block geschrieben, also alle 4 Stellen (0,1,2,3)? Weil in C habe ich gelernt, dass man jede Stelle des arrays über eine Schleife beschreiben muss.
komplette Array umkopiert. Genauer: Alle Bytes die zu diesem Array gehören. und jetzt schaun wir mal: sizeof( myByteBuffer ) Aha. sizeof gibt die Anzahl der Bytes in seinem Argument zurück. IN deinem Fall das komplette Array. Also wird hier dem write_block mehr oder weniger gesagt: Kopiere soviele Bytes,
-
Thread
Char Array über USART Empfangen und vergleichen
Empfangen wenn was anliegt if ((UCSR0A & (1<<RXC0))) { uart_gets(ReceiveSerial, sizeof( ReceiveSerial)); USART_Transmit(); // Kontrolle zum Terminalprogramm if (!strcmp(ReceiveSerial,Lr99110101)) { stopbit = false; } } [/c] Das ist das uart_gets
und die benutzt du dann um dein ursprüngliches Array auszugeben [C] #define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x)) int main() { ..... usart_write_uint8Array( ARRAY_SIZE( Codetest2 ), Codetest2 ); } [/C] Das Geheimnis beim Programmieren besteht nicht darin, sich für jeden Pfurz
-
Thread
Gibt es listen in C wie in C++
NULL) { /* erstes Listenelement erzeugen */ ptr = (struct Menue *) malloc(sizeof(struct Menue)); *base = ptr; } else { /* weitere Listenelemente erzeugen */ /* Das Ende der Liste suchen */ while (ptr->next != NULL) ptr = ptr
next; /* neues Listenelement erzeugen */ ptr->next = (struct Menue *) malloc(sizeof(struct Menue)); ptr = ptr->next; } strcpy(ptr->Namemenue, name); strcpy(ptr->Menuepunkt1, menue1); strcpy(ptr->Menuepunkt1, menue2); strcpy(ptr->Menuepunkt1, menue3
-
Thread
integer for schleife in C
511 durchläufe (oder?) und ausserdem will ich gern später statt der 65535 (oder so) den wert mit sizeof ermitteln lassen.
ja, aber wollte den schleifenzähler ja vorher mit sizeof ermitteln, von daher nehm ich die do...while... von oben... klappt so jetz auch. thx!
-
Thread
Array kopieren / zuweisen
memcpy(arbeitsArray, code, sizeof arbeitsArray);
also prinzipiell gehts natürlich auch via: unsigned int i; for(i=0; i<sizeof(code);i++) { arbeitsArray[i] = code[i]; } aber gehts auch einfacher, also dass das Programm das nicht immer mühsam machen muss? Pointer? Prinzipiell gehts einfach darum, später mit dem ausgewählten
-
Thread
Struct nach Array casten: Risiko?
Bsp. ganz leicht überprüfen. Wenn sizeof(deine_struct) größer ist als die Summe der enthaltenen Variablen, wurde es durchgeführt, sonst nicht. AFAIK ist es unwahrscheinlich, dass der Compiler (bei gängigen structs) padding auf einem Mikrocontroller
dann lässt sich die Funktion legal mit allen Datentypen verwenden und beim Aufruf muss halt mit dem sizeof-Operator oder anderen geeigneten Mitteln die zu verwendende Größe bestimmt/festgelegt werden.
-
Thread
STM32 Timer PWM Periode dynamisch anpassen
100 }, }; int pwm_tx_finished = 0; int16_t pwm_tx_array_counter = 0; int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]); int16_t pwm_tx_period = 0; int16_t pwm_tx_pulse = 0; /* USER CODE END PV */ [/code] Im CallBack für den jeweils aktuellen Puls bereite ich den nächsten
100 }, }; int pwm_tx_finished = 0; int16_t pwm_tx_array_counter = 0; int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]); int16_t pwm_tx_period = 0; int16_t pwm_tx_pulse = 0; /* USER CODE END PV */ [/code] Der Main Loop ist leer und der µC erzeugt momentan nur diese PWM. Ich
-
Thread
c/c++ Array problem bitte hilfe
Allerdings spricht natürlich nichts dagegen, das Array mit [c] char *vec; vec = (char *) malloc(3*sizeof(char)); //oder auch vec = (char*) malloc(3); [/c] anzulegen und dann nach Deiner Methode in einer Zeile zu füllen. Das wäre dann eine weitere mögliche Lösung neben memcpy().
spricht natürlich nichts dagegen, das Array mit > > [c] char *vec; > > vec = (char *) malloc(3*sizeof(char)); //oder auch vec = (char*) > malloc(3); > > [/c] > > anzulegen und dann nach Deiner Methode in einer Zeile zu füllen. Dazu bräuchte man dann aber wieder memcpy()...
-
Thread
Aus einem Ergebnis heraus auf eine Rotine verweisen ?
f2( void ); u8_fp_v functions[] = { f0, f1, f2 }; u8 call_nr( u8 nr ) { if( nr >= sizeof(functions) / sizeof(u8_fp_v)) return 0xFF; // out of table return functions[nr](); // execute function } [/C] Die Funktionen f0..f2 geben hier eine Byte zurück
wird natürlich nichts ausgeführt, sondern 0xFF zurückgegeben. Ist auch ein schönes Beispiel für den sizeof Operator. Beim AVR-GCC gibt es noch einige Besonderheiten, wenn man die Tabelle in den Flash-Bereich legen will. Peter
-
Thread
Struktur in C
Ja, entweder etwas in der Art memset(myvar, 0, sizeof(myvar)); oder x myvar = { 0, { 0, 0, 0, 0, 0 } }; (In der zweiten Klammer dann 100 Werte...).
Noname schrieb im Beitrag #2720260: > Ja, entweder etwas in der Art > > memset(myvar, 0, sizeof(myvar)); > > oder > > x myvar = { 0, { 0, 0, 0, 0, 0 } }; > > (In der zweiten Klammer dann 100 Werte...). Komplett mit 0 initialisieren geht übrigends einfacher: x myvar = { 0 }; alle
-
Thread
incompatibler typ warum ?
Struct, die Funktion erwartet einen /char/ Pointer. Machs mit einem Cast: > enc_send_packet(sizeof(packet),(unsigned char*)packet); EDIT: Aber du solltest dir dann sicher sein, dass die Anordnung und Ausrichtung der Bytes im Struct passt. Und nichts irgendwie auf 16-Bit aligned wird....
, die Funktion erwartet einen /char/ Pointer. > > Machs mit einem Cast: >> enc_send_packet(sizeof(packet),(unsigned char*)packet); 'packet' ist damit aber immer noch kein Zeiger. [c](unsigned char *)&packet[/c]
-
Thread
Was ist mit diesen Warnhinweisen gemeint?
PWM's Modulieren kann. Unter anderem habe ich diese Case Anweisung: case '1': memset(Line,0,sizeof(Line)); uart_gets(Line, sizeof(Line)); proz = atoi(Line); //my_int = atoi(buffer); OCR1AL = proz*2.55; break; dabei bekomme ich aber diese Warnungen: main.c:117: warning
-
Thread
Parameter verschiedenen typs in eine tabelle einfügen
Man darf prinzipiell alles in void* casten. Ob's das überlebt, ist 'ne ganz andere Frage. Ist sizeof (void *) kleiner als sizeof (s32), dann gehen durch das Casting Informationen verloren.
-
Thread
Lampe jeden Sonntag einer geraden Woche leuchten lassen
= tstamp + 12 * 60 * 60; // damit die Lampe um 12 Uhr mittags am Vortag angeht int leng = sizeof(biomuell) / sizeof(biomuell[0]); int i; for (i = 0; i < leng; ++i) { if ( (restmuell[i] / 10000) == (tstamp / 10000)) { Serial.print ("RM:"); Serial.println (i); digitalWrite
-
Thread
C array über serielle schnittstelle emfangen
schon erledigt. Ist es ein Array eines anderen Datentyps, so musst Du mit eine Typecast und dem sizeof-Operator arbeiten. Sinnvoll ist in beiden Fällen die Verwendung eines Pointers auf Bytes, der auf die Arrayanfangsadresse gesetzt wird. Letztlich musst Du also eine definierte Anzahl von Bytes
int main () { char Line[40]; // String mit maximal 39 zeichen uart_gets( Line, sizeof( Line ) ); example[1][2] = Line; //empfangener String in das Array einsetzen } [/c]
-
Thread
Raspberry Pi C-Programmierung: RS232 Read Problem
sockfd < 0) { error("ERROR opening socket"); } bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(portno); if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof
serv_addr)) < 0) { error("ERROR on binding"); } listen(sockfd,5); clilen = sizeof(cli_addr); uart_filestream = uart_init(); //UART INIT while (1) { newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen
-
Thread
Linux: Dateizugriff von mehreren Prozessen
jedes Prozesses folgenden Code aus: [CODE] //try to get shared mem int shmid = shmget(SHM_ID, sizeof(pthread_mutex_t), 0666); if (shmid == -1) { //does not exist, we have to initialize shmid = shmget(SHM_ID, sizeof(pthread_mutex_t), 0666 | IPC_CREAT); cout << "SHM created, ID "
-
Thread
V-USB Keyboard LED
printf ("%s is not a vaild device.\n", device); //Print Device Name ioctl (fd, EVIOCGNAME (sizeof (name)), name); printf ("Reading From : %s (%s)\n", device, name); struct input_event ev; /* the event */ ev.type = EV_LED; ev.code = LED_CAPSL; /* turn off */ ev.value = 0; int retval = write(fd, &ev, sizeof(struct input_event)); /* turn on */ ev.value = 1; int retval = write(fd, &ev, sizeof(struct input_event)); [/c] Umsetzung: Es gibt schon: http://www.obdev.at/products/vusb/hidkeys.html
-
Thread
Länge eines im PROGMEM gespeicherten Arrays (C)
sizeof sollte auch funktionieren, schließlich sind die Arrays konstant.
Jabu schrieb im Beitrag #3106798: > Wie kann ich dies in C simpel realisieren? mit sizeof auf den Progmem variabel sollte es gehen, das setzt doch schon der compiler ein.
-
Thread
'sd_raw_write' makes pointer from integer without a cast
[c]uint32_t data; sd_raw_write(0,&data,sizeof(data)); [/c] Und deine Funktion oben zum Schreiben eines Strings sieht abenteuerlich aus. Da wäre mal etwas C-Lektüre lesen zum Thema Pointer und Strings angebracht. C lernt man nicht mal so eben
> Dann gib ihm doch genau das. Yep. [C] uint32_t data; sd_raw_write( 0, (uint8_t*)&data, sizeof(data) ); [/C]
-
Thread
MSP430 UART empfang nur letztes Byte
interrupt vector #pragma vector=UART0RX_VECTOR __interrupt void usart0_rx (void) { if(count<sizeof(string)) { switch(RXBUF0) { //...
Problem: [c] #pragma vector=UART0RX_VECTOR __interrupt void usart0_rx (void) { if(count<sizeof(string)) { switch(RXBUF0) { //... [/c] Du wertest im Interrupt RXBUF0 nur aus, wenn count (wie und wo definiert/initialisiert?) kleiner ist als sizeof(string) - (wie und wo definiert
-
Thread
.exe Datei stürtzt beim Aufruf ab
struct haeuser *head); void main() { struct haeuser *head; head=(struct haeuser*)malloc(sizeof(struct haeuser)); int Objekt=0,objektnr=0; char buchstabe; int flag=1; while(flag==1) { printf("Bitte geben Sie einen Buchstaben ein:\n"); fflush(stdin
).zg!=NULL) ... [/c] wo kommt head her? Von hier [c] head=(struct haeuser*)malloc(sizeof(struct haeuser)); ... hausanhaengen(head,Objekt++); [/c] tja. Aber nur weil du mittels malloc Speicher allokiert hast, bedeutet das nicht, dass da nur 0-en (und damit ein NULL
-
Thread
compiler fehler setzen daten 2d-array
Du könntest "memset(graphicData_s.data_au8, 0, sizeof(uint8_t[graphicData_s.rows_u32][graphicData_s.cols_u32]));" verwenden. Wenn es sowieso Variabel werden soll, würde ich da erst mal aus dem data_au8 einen Pointer machen. Unten noch ein Beispiel
support ist in einigen C Versionsstandards optional! void* mem = realloc(graphicData_s.data_au8, sizeof(gd_data_t)); // TODO: Prüfen, ob realloc fehlgeschlagen ist graphicData_s.data_au8 = mem; memset(graphicData_s.data_au8, 0, sizeof(gd_data_t)); // Als Beispiel, ein Rechteck in
-
Thread
nRF24L01 interrupt am Arduino
"); Serial.print(Empfangen[0]); Serial.print(" empfangen: "); for (int i = 1; i < sizeof(Empfangen); i++) { Serial.print(Empfangen[i]); Serial.print("\t"); } Serial.println(); neueNachrichtEmpfangen = false; } if (aktuelleMillis % 1000 == 1)
1); } void AnkommendeNachricht() { Serial.println("Interrupt"); radio.read(Empfangen, sizeof(Empfangen)); neueNachrichtEmpfangen = true; // Variable setzen, dass eine neue Nachricht zur Auswertung bereit steht } [/code] Das Programm läuft ca 5 Sekunden einwandfrei und dann kommt
-
Thread
Lm3s9b96 CAN controller initialisierung
= 0; g_sCANMsgObject1.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject1.ulMsgLen = sizeof(g_ucMsg1); g_sCANMsgObject1.pucMsgData = g_ucMsg1; // Initialize message object 2 to be able to send CAN message 2. This // message object is not shared so it only needs to
= 0; g_sCANMsgObject2.ulFlags = MSG_OBJ_TX_INT_ENABLE; g_sCANMsgObject2.ulMsgLen = sizeof(g_ucMsg2); g_sCANMsgObject2.pucMsgData = g_ucMsg2; for(;;) { // // Send message 1 using CAN controller message object 1. This is
-
Thread
string mit getchar auslesen
char txt[1000]; char *p=txt; while(p<txt + sizeof txt) statt while(1) *p++=c; statt direkter Ausgabe *p=0; am Ende Und wundern, warum es Abstürzt, wenn man nicht früh genug beendet.
strcpy(in_command, in_buff); // strcpy(in_buff,""); memset(&in_buff[0], 0, sizeof(in_buff)); chr_cnt = 0; } else // Falls kein Enter muss der Text gespeichert werden { if(isprint(c))
-
Thread
Eingabe auf Gültigkeit prüfen
char IsValid( char c ) { static char Valid[] = "@;ABGZ8/%"; for( unsigned char i = 0; i < sizeof( Valid ); ++i ) { if( Valid[i] == c ) return TRUE; } return FALSE; } .... if( IsValid( 'A' ) ) .... [/C] Da wird wohl mal etwas Literatur fällig. Ohne
abgeändert: [c] unsigned int valid(char signe ,char signes[]) { for (unsigned char i = 0; i < sizeof(signes); ++i) { if(signes[i] == signe) return 1; } return 0; } [/c] Allerdings funktioniert dies nicht. Die Zeichen werden doch in beiden Fällen als Array übergeben, sodass es
-
Thread
C: Int to String Funktion schlägt fehl.
net? und mit char_p[i] wird der Zeiger doch dereferenziert ??? (adresse = &(char_p[0]) + (i * sizeof(unsigned char)) *verwirrt bin* Oder habe ich da nen grundsätzlichen Denkfehler drin ???
snprintf(), um Zahlen in Strings umzuwandeln: [c]int zahl = 42; char string[123]; snprintf(&string, sizeof(string), "%d", zahl);[/c]
-
Thread
int richtig in char* konvertieren
Wert? im Internet lese ich immer wieder was von folgende Funktion. [c] char * itoa ( wert(sizeof(int)*8+1),10); [/c] Ich habs zuerst so probiert [c] char buf[8]; sprintf(buf,"%05u",wert); *data=buf; rf22_sendpacket((unsigned char*)buf,size); [/c] leider will das nicht so
Christoph B. schrieb im Beitrag #2551055: > [c] > char * itoa ( wert(sizeof(int)*8+1),10); > [/c] Hallo! Das versteh ich grad nicht. > [c] > char buf[8]; > sprintf(buf,"%05u",wert); > *data=buf; > rf22_sendpacket((unsigned char*)buf,size); > [/c]
-
Thread
CRC Prüfsumme rückwärts rechnen
message.c message.c - Definition der Funktion send_mes(), ruft mbx_data_send(mbx,message, (USHORT)(sizeof(S_header_mes)+l_mes)) auf qnxobj.c - Defintion der Funktion mbx_data_send() mit anschließendem Absenden des Pakets Vermutung: (USHORT)(sizeof(S_header_mes)+l_mes) bildet die gesuchte Summe
-
Thread
Nullelement eines struct
#3627540: > Laut C-Standard kann man structs ja nicht vergleichen. Doch, mit [c]memcmp(&obj1,&obj2,sizeof(obj_t))==0[/c]
#3627686: >> Laut C-Standard kann man structs ja nicht vergleichen. > > Doch, mitmemcmp(&obj1,&obj2,sizeof(obj_t))==0 Das aber liefert ... unerwartete Ergebnisse, wenn das /Alignment/ ins Spiel kommt. Sind nämlich die Strukturelemente nicht an Byte-, sondern an 16- oder 32-Bit-Adressen ausgerichtet
-
Thread
Variable in Variable
blue", &colors.blue } }; void set_color(char *name, int color) { for (size_t i = 0; i < sizeof(mapping) / sizeof(mapping[0]); i++) { if (strcmp(mapping[i].name, name) == 0) { *(mapping[i].color) = color; break; } } } [/c] Alternativ könnte man den Vektor auch
-
Thread
EEPROM, float und Array
multipliziert der Compiler automatisch das i mit der Größe des Basistyps, in deinem Fall eben der sizeof(float), wenn es dann darum geht auf Assemblerebene den Zugriff zu machen. Tatsächlich ist das erste, ws der Compiler macht, wenn du a[i] schreibst, das er das in die Form *(a+i) umwandelt und erst
damit weiter arbeitet. Dau kannst in C ja auch schreiben [c] double* p = malloc( 5 * sizeof(double) ); p[0] = 2.0; p[1] = 3.0; [/c] Genau hier kommt die Pointer Array Dualität zum tragen. Und genau das ist auch der Grund, warum der Name eines Arrays alleine als die Startadresse
-
Thread
NRZI Decoder Code gesucht
transitions at 1st, 4th, 5th positions) uint8_t nrzi_signal[] = {1, 0, 0, 0, 1, 1}; int length = sizeof(nrzi_signal) / sizeof(nrzi_signal[0]); uint8_t decoded_bits[32]; // Buffer for decoded data int decoded_length = nrzi_decode(nrzi_signal, length, decoded_bits); printf("NRZI Input
-
Thread
Displaymenue für normal LCD
reihenfolge beachten //siehe Beispiel!! LÖSUNG: unsigned char x = sizeof(mySUBM0)/sizeof(menueObject); so bekommst du z.B. die Länge deines ersten arrays raus. In x steht jetzt z.B. 4
-
Thread
2D Array an Funktion übergeben?!
Aufruf berücksichtigt, noch kann man sie innerhalb der Funktion wieder irgendwie zurückgewinnen (sizeof gibt dir nur die Größe eines Zeigers). Am Ende ist es also nur eine Art Doku für denjenigen, der diesen Funktionskopf liest.
uint8_t* myPointer; > myPointer[0] = myValue0; Wo zeigt denn myPointer hin? Wie sieht es mit sizeof aus? Kannst du das Array auf einen andere Speicheradresse zeigen lasse? Kannst du die Größe von dem Array ändern? Ähnlich ist nicht gleich. Bei beiden funktioniert Zeigerarithmetik und die
-
Thread
C Socketprogrammierung. Was könnte man weglassen?
newsockfd; struct sockaddr_in serv_addr; char buffer[BUF]; memset(buffer, 0, BUF * sizeof(*buffer)); sockfd = socket(AF_INET, SOCK_STREAM, 0); memset(&serv_addr, 0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(PORT); bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)); listen(sockfd, 5); newsockfd = accept(sockfd, 0, 0); [/c] Werden structs automatisch 0-initialisiert? Kann ich mir daher das zweite Memset sparen? - Weiters könnte ich ja
-
Thread
Entprellen von Schalter mit Interrupt und PinChange
(!rf12_canSend()) rf12_recvDone(); rf12_sendStart(RF12_HDR_ACK, &msgfile, sizeof msgfile); byte acked = waitForAck(); rf12_sleep(0); if (acked) { // Serial.print("ack1 \n"); d = RETRY_LIMIT;
(!rf12_canSend()) rf12_recvDone(); rf12_sendStart(RF12_HDR_ACK, &msgfile, sizeof msgfile); byte acked = waitForAck(); rf12_sleep(0); if (acked) { // Serial.print("ack2 \n"); i = RETRY_LIMIT; }