-
Thread
Kommunikatin zwischen Treibern
Parameters.DeviceIoControl.IoControlCode = IOCTL_DRIVER_OUT; irpStack->Parameters.DeviceIoControl.OutputBufferLength = sizeof(IOCTL_RX_OUT); irpStack->Parameters.DeviceIoControl.InputBufferLength = sizeof(IOCTL_RX_IN); [/c] Nun würde ich gerne in der completion funktion die Daten aus den IOCTL_RX_OUT auslesen
-
Thread
Pointerübertragung wird nicht realisiert
printf ("\n\r in get_false"); return false; } printf ("\n\r Get: %d", *(buffer_ptr+(sizeof(uint16_t)*read)) ); *element = *(buffer_ptr+(sizeof(uint16_t)*read)); printf ("\n\r element in get: %d", *element); read = (read+1) & buffer_mask; return true; } [/c] Bekommer:
man nicht mehr einfach so rummachen kann. Das hier [c] printf ("\n\r Get: %d", *(buffer_ptr+(sizeof(uint16_t)*read)) ); [/c] ist das deutlichste Zeichen, dass dir viele Grundlagen fehlen. Das ist grundlegend falsch. Machs dir wenigstens nicht so kompliziert. Du kannst hier ruhig Array Syntax
-
Thread
Frage zur seriellen Eingabe (Buffer)
Zwischen string="Hallo\0" und strcpy steht doch eindeutig stringarray[0]=(char* )malloc(strlen(string)*sizeof(char)) :-D (langen Tag gehabt)
string="Hallo\0" und strcpy > steht doch eindeutig > stringarray[0]=(char* )malloc(strlen(string)*sizeof(char)) Und wenn man ganz genau schaut, dann fehlt da ein +1 (dafür ist da ein Cast, der in C besser nicht da wäre :-) > :-D (langen Tag gehabt) LOL,
-
Thread
Mehrdimensionale Arrays - Mehrere Werte aufeinmal zuweisen
Bequemlichkeitsmakros #define FILL_FLOAT_ARRAY1(array,...) memcpy(array, (float []){__VA_ARGS__}, sizeof (array)) #define FILL_FLOAT_ARRAY2(array,...) array = (floatarray33_t){{__VA_ARGS__}} int main(void) { static float avalues[33] = {1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3
memcpy(arry_1[0], (float []){1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3}, sizeof arry_1[0]); memcpy(arry_1[0], avalues, sizeof arry_1[0]); FILL_FLOAT_ARRAY1(arry_1[1], 1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3); // Drei Möglichkeiten, ein in ein
-
Thread
Altium Designer und Dateizugriffe mittels C
Image_name[10]="ABCDEFGH"; char c; int i=0; for (i=0; i<15;i++){ c=Image_name[i]; fwrite(&c, sizeof(c), 1, pfile); } fclose(pfile); } [/c] Warum zweimal Slash hinter dem C: ? ->der Compiler vermutet sonst eine "illegal escape sequence". Ich hab mir schon die tollsten Sachen ueberlegt ..
for (i=0;i=100;i++) {buffer[i]=a; if (i==100) {break;}} fwrite (buffer , 1 , sizeof(buffer) , pfile ); fclose (pfile); } [/c] Ja natuerliche pruefe ich spaeter noch brav den FILE Zeiger. Aber da komm ich gerade ja noch garnicht hin.
-
Thread
Bitfelder Byte-weise auslesen
uint8_t bit3 : 1; }; union CANFeld { struct CanBits BitField; uint8_t Bytes[ sizeof struct CanBits ]; }; struct CANFrame{ uint32_t ID; uint8_t DLC; uint8_t Byte0; uint8_t Byte1; uint8_t Byte2; uint8_t Byte3; uint8_t Byte4; uint8_t Byte5; uint8_t Byte6
uint8_t bit3 : 1; }; union CANFeld { struct CANBits BitFeld; uint8_t Bytes[sizeof(struct CANBits)]; }; int main(void) { union CANFeld test; test.BitFeld.bit1 = 0x2A; // 0010 1010 test.BitFeld.bit2 = 0x21; // 0010 0001 test.BitFeld.bit3 = 0; uint8_
-
Thread
C Struct - großes Problem
woher soll er es denn wissen? p_real++ macht zum schluss immer p_real + sizeof( p_real )
Peter wrote: > p_real++ > > macht zum schluss immer p_real + sizeof( p_real ) Nein, p_real + sizeof( *p_real )
-
Thread
PROGMEM und 2 dimensionaler array
Array1D [i] = Array2D[0][i]; > } Sowas? > #include <string.h> > memcpy (Array1D, Array2D[0], sizeof (Array1D)); und im Flash: > #include <avr/pgmspace.h> > memcpy_P (Array1D, Array2D[0], sizeof (Array1D)); Vorsuaasetzung ist natürlich, daß Array1D ein Array ist und nicht nur ein Zeiger. In letzerem Fall ist die Längenberechnung (sizeof) anzupassen.
-
Thread
Beliebige Daten über RS232 versenden
Datentyp erledigen: [c] union hilfsunion { meindatentyp Nutzdaten; char Alternative[sizeof (meindatentyp)]; }; hilfsunion x; x.Nutzdaten = 1234.567; for (i = 0; i < sizeof (meindatentyp); i++) sende_daten(hilfsunion.Alternative[i]); [/c] ... wenn /meindatentyp/ beispielsweise
auf die Struktur, den nach unsigned char casten und die Länge in Bytes der kompletten Struktur mit sizeof() holen.
-
Thread
C_Linux_PCI-Buskommunikation
Hardwload.c case . . case Hardw_SET_ADCOverRangeReset: { if(copy_from_user(&val64,(void*)arg,sizeof(u64))) { return -EFAULT; } PDEBUG("hardw(ioctl_Hardw): SET_ADCOverRangeReset0x%llx\n",val64); WRITE_ICSDEV_U32(board, STATUS_OFFSET, (u32)(0xFLL & val64)); break; } . .
> . > . > > case Hardw_SET_ADCOverRangeReset: > { > if(copy_from_user(&val64,(void*)arg,sizeof(u64))) { > return -EFAULT; > } > PDEBUG("hardw(ioctl_Hardw): SET_ADCOverRangeReset0x%llx\n",val64); > > WRITE_ICSDEV_U32(board, STATUS_OFFSET, (u32)(0xFLL & val64)); > break; >
-
Thread
C in Datei schreiben
, skalaren, Datentypen möglich sind, wie zb. Zuweisung. if (fd != NULL) { for( i = 0; i < sizeof(transfer)/sizeof(*transfer); ++i ) fprintf( fd, "%x", transfer[i] ); fclose( fd ); } (Die sizeof Geschichte geht natuerlich nur dann, wenn die Array-Deklaration für den Compiler an dieser
-
Thread
const char in Eeprom
für Zahlen zu verwenden : //eeprom_busy_wait(); //eeprom_write_block(&"Hallo",(uint8_t*)200, sizeof(standby_text_Z1)); //eeprom_busy_wait(); //eeprom_read_block(&standby_text_Z1,(uint8_t*)200, sizeof(standby_text_Z1)); Kann doch nicht wirklich sein das ich einen String bzw char in seine Einzelteile
und sizeof bringt nur die größe des datentyps ... bei strings nutzt man strlen um die menge der bytes im string auszulesen [c] const char text[] PROGMEM = {"Hallo Welt"}; char* p_text = pgm_read_word
-
Thread
Code funktioniert in main(), aber nicht über Funktion?
Dein Problem ist "sizeof(s)-1". Wenn Du das so in der Funktion benutzt kommt da 1 (EINS) raus! Der Datentype von s ist "char*"! Und in im avr-gcc sind nun mal alle Pointer 2 Byte groß.
Hallo Gast, das wars. Hab jetzt mal einen size parameter mit eingebaut und mit sizeof(s)/sizeof(s[0]) gefüllt. Danke für die Hilfe! Grüsse Axel
-
Thread
Name für variable
Info hast du von wo? [c] #include <stdio.h> static int tmp_n[3] = {1,2,3}; int *n = tmp_n + sizeof(tmp_n)/sizeof(*tmp_n) - 1; int main(){ printf("%d %d %d\n",n[0],n[-1],n[-2]); return 0; } [/c] [pre] daniel@Daniels-Surface-Pro-3:~$ gcc -std=c99 -Wall -Werror -pedantic main.c -o main
-
Thread
Frage zu Array
[c] memset(TEST, 0, sizeof(TEST)); [/c] Wenn Du aber nur möchtest, dass kein Text mehr darin ist, reicht auch [c] TEST[0] = 0; [/c] Das Nullbyte ist die Markierung für das Textende.
Ich bin eher fuer: [c] #define MY_STRING "HALLO" char *ptr = NULL; ptr = (char*)malloc(sizeof(char)*strlen(MY_STRING)+1); strncpy(ptr, "Hallo", strlen(MY_STRING)+1); if(ptr) free(ptr); ptr = NULL; [/c]
-
Thread
Funktion funktioniert nur einmal
ganzes String Array genullt ist dann solltest Du das immer mit einem memset machen (memset(string, 0, sizeof(string)) ... ist lesbarer als Deine for() Schleife. Achja, es gibt auch noch strncpy bei dem Du die zu schreibende Anzahl von Bytes mit angibst; hat den Vorteil dass Du beim Kopieren des Strings
Restliche speicher von string ist immer noch mit den original daten gefüllt. memset(string,0, sizeof(string)) dauert etwas länger und schreibt über die komplette länge ein 0 rein. Ein String in C ist nicht wie in Pascal definiert. In C endet der String wenn eine 0 kommt, in Pascal wird die länge
-
Thread
Libusb usb_bulk_read "echtzeitfähig"?
byte_empfangen; char buffer_in[BUF_IN_SIZE]; usb_bulk_read(dev, EP_IN, buffer_in, sizeof(buffer_in),20); if ((byte_empfangen)!= sizeof(buffer_in)) { printf(">> error: bulk read timeout\n Error: returned: %i\n",byte_empfangen);
usb_bulk_setup_async(this->fd_dev, &context0, EP_IN); usb_submit_async(context0, this->buf, sizeof(this->buf)); [/pre] [c]#include "allmyincludes_usb.h" struct usb_bus *bus; struct usb_device *dev; function open() { for(bus = usb_get_busses(); bus; bus = bus->next) {
-
Thread
RTTTL Player
Lautsprecher als Ausgang SPEAKER_DDR |= (1<<SPEAKER); while(1) { if (i >= (sizeof(ma)/sizeof(ma[0]))) i = 0; play(i); // Sleep-Mode set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_mode(); i++; } return 0; } [/c] Sorry, habe
song9,songA,songB,songC,songD,songE,songF}; PGM_P audio_start_titel_P(uint8_t nr){ if (nr >= (sizeof(songs)/sizeof(songs[0]))) nr =0; return (const char*)(pgm_read_word(&(songs[nr]))); } [/c]
-
Thread
Fehler gegen sendto() zu andere server, den mit UDP socket verbindet ist
),sizeof(server_address_hm)); // Bind socket to the particular addresses if (bind(socket_fd_ob,(struct sockaddr *)&server_address_ob, sizeof(struct sockaddr)) == -1) { error("bind()"); } if (bind(socket_fd_hm,(struct sockaddr *)&server_address_hm, sizeof(struct sockaddr)) == -1) { error("bind()"); } address_length = sizeof(struct sockaddr); address_length2 = sizeof(struct sockaddr); printf("\nMain server waiting for client
-
Thread
LWIP-Stack:Ist dieses Verhalten Normal?
sGlblArgCmdSetIP.iServerIP_3); udp_connect(conn, &ip, 333); ... buf = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct ServerData), PBUF_RAM); memcpy(buf->payload, (void*) &cmd, sizeof(struct ServerData)); udp_send(conn, buf); pbuf_free(buf); [/c] Dein Code sollte so aber auch funktionieren. Ich habe
-
Thread
Absturzproblem
Bootloader (auf dem tutorial zu c bootloadern basierend) folgendes: [c] memset(flash_data, 0xFF, sizeof(flash_data)); [/c] dieses commando bringt den uc sofort zum abstürzen und neustarten. Das witzige ist, dass ich das kommando schon immer drinn hab und es im tutorial auch drinn steht. definition
Hm, wenn ich den memset durch das ersetze: [c] for (uint16_t mm = 0; mm < sizeof(flash_data); mm++) { flash_data[mm] = 0xff; } [/c] tritt der fehler nicht auf! Ist das nicht genau das selbe?
-
Thread
Atmega644 - HP Variable in Eeprom speichern ?
=0; uint8_t i =0; float a; for (i=0;i<20;i++) { eeprom_read_block(&a,&schalt[i],sizeof(float)); if (a != sch[i]) { eeprom_write_block(&sch[i],&schalt[i],sizeof(float)); //eeprom_write_word(&schalt[i], i1); } } } [/c] ausgang: [c] void var_aus_eeprom
- eimaliger Aufruf in main.c { uint8_t i =0; float a; eeprom_read_block(&a,&schalt[19],sizeof(float)); if (a == sch[19]) { for (i=0;i<20;i++) { eeprom_read_block(&sch[i],&schalt[i],sizeof(float)); } }[/c] [c] uint8_t schaltautomatik = 0; sch[0] =
-
Thread
C-Programm pollt unendlich lange
sende_buffer[]="hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; int size = sizeof(sende_buffer); int bytes; bytes = write (port, sende_buffer, size); if (bytes != size) { printf("fehler\n"); } //sleep(1); //FUNKTIONIERT ABER UNSCHÖN //POLLEN////////
ENDLOS?? /////////////////////////////////////////// int bytes2; char empfangs_buffer[sizeof(sende_buffer)]; bytes2 = read (port, empfangs_buffer, sizeof(empfangs_buffer)); //AUSGABE int x; for(x=0; x<=sizeof(empfangs_buffer)-1; x++) { printf("%X\n", empfangs_buffer[
-
Thread
com schnittstelle mit c ansprechen
TEXT("\r\nERROR:\t %s"), HELP_STRING); return (1); // und tschüß ... } memset (&o, 0, sizeof (OVERLAPPED)); // Struktur mit 0en füllen o.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL); // einen Eventsetzten HANDLE hCom = CreateFile (szCOM, GENERIC_WRITE | GENERIC_READ, 0,NULL,
MB_ICONINFORMATION); LocalFree (lpMsgBuf); return (1); // und tschüß ... } dcb.DCBlength = sizeof(DCB); // Laenge des Blockes MUSS gesetztsein! GetCommState (hCom, &dcb); // COM-Einstellungen holen und aendern dcb.BaudRate = BD_RATE; // Baudrate dcb.ByteSize = 8;
-
Thread
Probleme bei UART Auswertung
uart_getc(); if(c & UART_NO_DATA) continue; if( (c=='\r') || (bufferzaehler==(sizeof(Befehlsbuffer)/sizeof(Befehlsbuffer[0]) )-1)) { Befehlsbuffer[bufferzaehler] = '\0'; break; } Befehlsbuffer[bufferzaehler++] = c; }
} if( c == '#' ) { inCommand = 1; return 0; } if( inCommand && lineLen < sizeof(lineBuff)-1 ) { lineBuff[lineLen] = c; lineLen++; #ifdef DEBUG // zum debuggen, damit der String immer // gültig ist. lineBuff[lineLen] = '\0'; uart_puts( '\n' );
-
Thread
printf verbiegen auf Port
Fehlerbehandlung empfiehlt sich dann sowas: [C] char buffer[50]; int foo; int bar; if(snprintf(buffer, sizeof(buffer)-1, "foo:%d bar:%d",foo,bar)<0) { buffer[sizeof(buffer)-1] = '\0'; } writeStringToLCD(buffer); [/C] Matthias
-
Thread
Initialisierung großer structs mit vielen Nullen
AVR-LibC. Das spart schon mal copydata. Den Array-Anfang kannst en bloc initialisieren; es sind 6*sizeof(tData) Bytes.
natürlich ein kleiner Jackpot ist. [c]uint8_t i; memcpy_P(&Data[0], &InitData[0], COUNT_INITDATA * sizeof(tData)); for (i = COUNT_INITDATA; i < COUNT_DATA; i++) memcpy_P(&Data[i], &InitData[COUNT_INITDATA-1], sizeof(tData));[/c] Vielleicht gibt's ja noch revolutionär andere Ideen zu dem Thema...
-
Thread
Frage zu "C" Array Aufteilung
Zeile1[256]; char Zeile2[256]; char Zeile3[256]; char Zeile4[256]; .... fgets( Zeile1, sizeof(Zeile1), fp ); fgets( Zeile2, sizeof(Zeile2), fp ); fgets( Zeile3, sizeof(Zeile3), fp ); fgets( Zeile4, sizeof(Zeile4), fp ); ... [/c] nicht schön, und auch nicht elegant, aber was
-
Thread
0x00 bei Dateiende
Ah habs gefunden. hatte Fwrite(buffer,(sizeof(buffer))); gemacht da die daten aber in wirklichkeit -1 waren hat der einen wert zu viel reingeschrieben. Unten noch mal das abgeänderte wie es nun richtig läuft. Danke an alle die sich dann so
>sizeof(buffer)-1 Das könnte gefährlich werden wenn du den Text in buffer mal änderst (kürzer machst). Für Text nimm lieber strlen(buffer). Dann wär das Problem gar nicht erst aufgetreten.
-
Thread
MPD steuern und auslesen mit libmpdclient
char Buffer[200]; FILE *f = popen("mpc", "r"); if (f != NULL) { while (fgets(Buffer, sizeof(Buffer), f) != NULL) printf("%s\n", Buffer); pclose(f); } int i = 0; while (Buffer[i] != '\n') { title[i] += Buffer[i]; i++; } title[i + 1] = '\0'; printf(":%s:\n", title
{ readLine(0, "mpc -f \"\%artist\%\""); strncpy(artist, buffer, MAX_BUFFER); artist[sizeof(artist) - 2] = ' '; readLine(0, "mpc -f \"\%title\%\""); strncpy(title, buffer, MAX_BUFFER); readLine(2, "mpc -f \" \""); // Platzhalter strncpy(line1, buffer, MAX_BUFFER); if (
-
Thread
UC3 SMC->SDRAM Datenbereich
bei 32-Bit Architektur aber eher unüblich, üblich sind 32 Bit. Versuche mal rauszubekommen, was sizeof(unsinged long) für einen Wert ergibt. Erwartungswert ist vier. > In meiner Implementierung verwende ich den Pointer als uint16_t [...] Dann schau mal ins Assembler Listing, welche Instruktionen
32-Bit Architektur aber eher unüblich, üblich sind 32 Bit. > Versuche mal rauszubekommen, was sizeof(unsinged long) für einen Wert > ergibt. Erwartungswert ist vier. Wie erwartet ergibt sizeof(unsigned long) vier für 32Bit. Das erklärt einiges. Vielen Dank fürs drauf aufmerksam machen. >
-
Thread
Probleme mit 2d-Matrix auf elemente zugreifen
} arr_##name arr_##name alloc_arr_##name(int len){ arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL}; return a; } arr_arr_integer Rotation2D(arr_arr_integer a) { } [/code] Die Aufgabe an sich habe ich schon verstanden, allerdings komme ich nicht klar auf die
ich an den Wert 1 ran? Wie funktioniert genau [code] arr_##name a = {len, len > 0 ? malloc(sizeof(type) * len) : NULL};[/code] Normalerweise kenne ich das mit dem Fragezeicheoperator nur mit einer Bedingung. Jetzt steht vor der Bedingung allerdings noch einmal len. Was bedeutet dies? Das ##
-
Thread
EEPROM lesen im Interrupt
Zeitraster von 10ms ausgelöst. ISR (TIMER2_OVF_vect) { eeprom_read_block(dev_info, &DevInfo, sizeof(TS_DEV_INFO)); }
Ahnungsloser schrieb im Beitrag #4037517: > eeprom_read_block(dev_info, &DevInfo, sizeof(TS_DEV_INFO)); Was soll diese Aufzählung von 3 Unbekannten? Damit kann keiner was anfangen.
-
Thread
Array löschen
Nicht gut. Mach lieber memset(a, 0, sizeof(a));
falsh, da du da ein String von ascii '0' (0x30) und nicht 0 reinschreibst. Besser ist memset(a,0,sizeof(a)); zu verwenden. Sollte tatsächlich '0' (0x30)(48) gemeint sein so benutzt du memset(a,'0',sizeof(a)); Olaf
-
Thread
Arduino Funkübertragung - NRF24L01
radio.stopListening(); char text[]="Hallo"; Serial.print("Senden:"); if (radio.write( &text,sizeof(text))) { Serial.println("..OK"); } else { Serial.println("..Fehler"); } radio.startListening(); delay(1000); } [/c] [c] //EMPFÄNGER #include <SPI.h> #include
} void loop() { radio.stopListening(); char text[]="Hallo"; if (radio.write( &text,sizeof(text))) { } else { } radio.startListening(); delay(1000); } [/c] Vielen Dank für eure Hilfe!!
-
Thread
Softwareschutz
to find the absolute value of v unsigned int r; // the result goes here int const mask = v >> sizeof(int) * CHAR_BIT - 1; r = (v ^ mask) - mask;[/c]
Tom schrieb im Beitrag #5580412: > v >> sizeof(int) * CHAR_BIT Rechts Shift von vorzeichenbehafteten Zahl ist undefined behaviour. Shift um eine Zahl die >= die Anzahl Bits ist, ebenfalls. Also keine besonders gute Idee, zumal es abs() gibt,
-
Thread
Spannungsteiler funktioniert nicht, was mache ich falsch?
} // Assign value if in bounds if (index >= 0 && index <= sizeof(message)) { message[index - 1] = buffer; } else { // TODO for now just complain Serial.print(F("Index is out of bounds: ")); Serial.println(index - 1); } // Message fully read, now print if (buffer == 0xAB && index - 1 == sizeof(message) - 1) { // Message length may either be 10 or 19, depending on the message int messageLength = index; Serial.print(F("Message received: ")); for
-
Thread
Bild auf SRAM speichern
[c] uint8_t pixels[352*288*3]; memcpy(pixels, bilddaten, sizeof(pixels)); [/c] ? Im SRAM ist nachher sogar noch Platz frei.
found: struct Bild auslesen. Check ob Name/Nummer/... passt. Wenn nein: Leseposition um sizeof(struct Bild) + binaerdatengroesse weiterverschieben.. done d.H. du hast im SRAM eine kette von Bild-Structs, dazwischen immer die Komprimierten Daten. Das Ende der Kette kannst du z.B. durch eine
-
Thread
ist das C++ oder was anderes? int var = Objekt->funktion()->obkektVatiable;
myObject1* myObject2_myFunction() { return obj1; } int main() { obj1 = (myObject1*) malloc( sizeof(myObject1) ); myObject2* obj2 = (myObject2*) malloc( sizeof(myObject2) ); obj2->myFunction = myObject2_myFunction; /* ... */ int var = obj2->myFunction()->objectVariable; }[/c]
-
Thread
effizienter C-Code zum Vergleichen von 6 Werten
Geht für Arrays der Länge 2(!)-255 byte i=sizeof(array)/sizeof(array[0])-1; //Länge des Arrays -1 max=array[0]; do { if (max<array[i] max=array[i]; } while (--i); //dekrement und anschließendes prüfen auf 0 //erzeugt am wenigsten
-
Thread
EEPROM schreiben&lesen
ROMCODE_A[8]; . ..ROMCODE_A[i]= tut irgendwas . . eeprom_write_block(&ee_ROMCODE_A,&ROMCODE_A,sizeof(ROMCODE_A));//speichern . . . eeprom_read_block(&ROMCODE_A,&ee_ROMCODE_A,sizeof(ee_ROMCODE_A));//laden . . . ..verwende ROMCODE_A Speichern tut er aber garnichts?
Variable im SRAM geschrieben werden. SRAM->EEPROM->SRAM eeprom_read_block(ROMCODE_A,ee_ROMCODE_A,sizeof(ee_ROMCODE_A)), führt auch zu keinem Ergebnis?
-
Thread
Daten shiften und umwandeln
meinem code auf bestimmte routinen zugreifen kann. [c] unsigned short *Adr_B; Adr_B = malloc(10*sizeof(*Adr_B)); unsigned short *Bank_Addr_B; Bank_Addr_B = malloc(16*sizeof(*Bank_Addr_B)); unsigned char *Bank_S_B = 0x02; Bank_S_B = malloc(10*sizeof(*Bank_S_B)); for (j=0;j < 10;j++){
-
Thread
char an Funktion übergeben
, die restlichen waren lehr. jetzt zeigt er mir komische symbole an. und mit [code]for (n=0; n<=sizeof(Tx); n++) [/code] werden nicht alle zeichen dargestellt. aber danke für die Hinweise
sollen, die restlichen waren lehr. jetzt zeigt er mir > komische symbole an. und mitfor (n=0; n<=sizeof(Tx); n++) werden nicht > alle zeichen dargestellt. > aber danke für die Hinweise sizeof(Tx) ist genauso falsch an diese stelle. Was wolltest du überhaupt mit '\'' erreichen? eigentlich macht
-
Thread
ARM7: Daten im Flash ablegen
jeder Zugriff führt zum Debugger-Crash. Aufruf mit GDisplay_Show_Bitmap((uint32_t*)data_vw,sizeof(data_vw)); void GDisplay_Show_Bitmap(uint32_t *ptr,uint32_t size) { volatile uint32_t i,j,k; for (i=0;i<size;i++) { k = (uint32_t)(*ptr)++; // Hier ist Debugger weg!
rprintf("\n"); } int main() { /* init... blah blupp */ printData(data, sizeof(data)/sizeof(uint8_t)); // 9/1 } [/c] Die Daten stehen dabei im Flash, wo sie mit 'const' auch hingehören.
-
Thread
wie uint32_t über SPI rausschicken
+) SPI_MasterTransmit (data [n]); } ... uint32_t foo = 0x1234567890; Transmit ((void*) &foo, sizeof (foo));[/c]
unsigned char*)data)[n] ); } [/C] [C] > uint32_t foo = 0x1234567890; > Transmit ((void*) &foo, sizeof (foo)); [/C] Da hingegen brauchts keinen cast [c] Transmit (&foo, sizeof (foo)); [/c]
-
Thread
Compilerprobleme Server
= htons(MY_PORT); my_addr.sin_addr.s_addr = INADDR_ANY; err = bind(sock_fd, &my_addr, sizeof(struct sockaddr_in)); if (err == -1) err_exit("webserver: bind() failed"); setuid(getuid()); err = listen(sock_fd, N_CONNECTIONS); if (err == -1) err_exit("webserver:
signal(SIGCHLD, SIG_IGN); printf("Type Ctrl-C to stop.\n"); while (1){ addr_size = sizeof(struct sockaddr_in); client_fd = accept(sock_fd, &client_addr, &addr_size); if (client_fd == -1) err_exit("webserver: accept() failded"); ... [/c] lg michael
-
Thread
Servomotor steuern - C Routine von dieser Seite
line[lineLength] = '\0'; haveLine = 1; lineLength = 0; } else if( lineLength < sizeof(line) ) { line[lineLength++] = c; uart_putc( c ); // eventuell Echo schicken, damit der Benutzer auch was sieht } } [/c]
received_data[lineLength] = '\0'; haveLine = 1; lineLength = 0; } else if( lineLength < sizeof(received_data) ) { received_data[lineLength++] = data; } return data; }/* uart_getc */ [/c]