-
Thread
Datenbanken in Java
[c] public class d { /** * @param args */ public static void main(String[] args) { Class.forName("org.hsqldb.jdbcDriver"); Connection con = DriverManager.getConnection("jdbc.hsqldb
JDBC driver."); e.printStackTrace(); }[/c] Bei mir hat's erst funktioniert, als ich zuvor noch die statische Methode static Class<?> forName(String className) aufgerufen habe: [c]Connection connection = null; try { Class.forName
-
Thread
printf-Funktion geht nur ohne Variable.
Ich meine, das 2 Zeichen ankommen. Dezimal 1 und dezimal 19. Als ASCII-string natürlich nur symbole... Edit: Ok, das selbe Problem wie ursprünglich. entferne ich die Variable aus dem String, also: [C] sprintf(Buffer,"Wert: X\n"); [/C] dann sehe ich im Terminal
lokalisieren oder gar zu beheben. Was soll das hier heissen? >entferne ich die Variable aus dem String In dem String ist keine Variable. Das hier: [c] sprintf(Buffer,"Wert: X\n"); [/c] >dann sehe ich im Terminal "Wert: X" ist jedenfalls kein Fehler sondern völlig richtig. Genau so steht
-
Thread
ATmega1284P Beschreiben in falschen Speicherbereich?
(u8_Ausrichtung == RECHTSBUENDIG) u8_XCoordString -= u8_WidthInPixel; for ( j=0; j < l; j++ ) { // analog zu c=strarray[i][j] wenn alles im RAM c = (Tu8)( pgm_read_byte( pstrflash++ ) ); LCD_schreiben(u8_XCoordString, u8_YCoordString, u8_font, c); u8_ZeichenBreit = ZeichenBreiteBestimmen(c, u8_font); u8_XCoordString += u8_ZeichenBreit; } }[/c] Was ist, wenn TextArray im Speicher > 64kB liegt?
-
Thread
UART sendet Zeichen mehrmals ATMega1280
Hallo zusammen, ich möchte einen String an die µC senden und dieser soll dann wieder zurück gesendet werden. Das funktioniert soweit auch, wenn ich ein delay von 1sec einbaue. Nehme ich das delay weg, sendet die UART den String mehrmals
- 1 ) *Buffer++ = NextChar; StringLen++; } } } while( NextChar != '\n' ); *Buffer = '\0'; } [/C]
-
Thread
[AVR] Grammatik für AVR C (avr-gcc)
zu einem string literal expandiert? Nach dem Preprozessing kommt da also sowas raus wie: [c] sprintf(prompt, "[bt-cmd@""%u""]$ ", ...[/c] > Ist der Befehl nun nur in avr-gcc enthalten oder auch im reinen > GnuC? Es ist ISO-C90. Stichwort: string concatenation. Der AVR-GCC hat eigentlich keinerlei Syntaxerweiterungen gegenüber dem GCC ,,aus der Dose''. OK, eine hat(te) er: binäre Konstanten (mit 0b
-
Thread
Frage zum Aufteilen von C-Programm in mehrere Dateien
<string.h> #include <stdio.h> } [/C] .. Das mache ich ja schon in der main.c: [C] { #include <avr/io.h> #include <avr/interrupt.h> #include <avr/sleep.h> #include <string.h> #include <stdio.h>
<avr/sleep.h> #include <string.h> #include <stdio.h> //usw, was ich halt so brauche #include "a.h" #include "b.h" #endif [/c] main.c, a.c, b.c : [c] #include "includes.h" [/c] a.h, b.h: [c] //Keine Includes
-
Thread
Unterschiede zwischen ARM und ATmega in der Programmierung
Initialisierungs-Code in Gewicht. Mir ist noch ein ein angenehmer Vorteil von ARM versus AVR eingefallen: Bei Strings muss man als C Programmierer nicht mehr zwischen RAM und Flash unterscheiden, da beide Speicher im selben Adressraum liegen. Dadurch entfällt das bei AVR standardmäßige Kopieren aller Strings ins
Stefan U. schrieb im Beitrag #5319188: > Eine mögliche Erklärung: Weil Strings in C normalerweise veränderbar > sind. String Literale normalerweise nicht, es sei denn man initialisiert ein Array damit. Das Problem ist halt, dass man einem Pointer nicht ansieht ob er in
-
Thread
Fehler nach Einfügen einer Else-Anweisung
Wenn ich diese Funktion verwende: [c] lcd_stringCenter_P((PSTR)"ID unknown.", 1); [/c] Er schmeißt dann aber bei mir einen Feher raus: Error 6 too few arguments to function 'lcd_stringCenter_P'
Es muss heißen: [c]lcd_stringCenter_P(PSTR("ID unknown."), 1);[/c]
-
Thread
String besteht nur aus 0xFF - Linkerproblem? AVR Studio 7
und uart_puts verwendet. uart_putc (Char) funktioniert tadellos. uart_puts funktioniert nur für Strings mit einer Länge von 3-4 Zeichen. Bei längeren Strings werden nur 0xFF Bytes übertragen. Hier meine Main-Loop. [c] const char a[] PROGMEM = {'H','e','y',0}; const char b[] PROGMEM = {
definiere und die ASCII-Codes da nacheinder eintrage, dann klappt es. Weise ich dem char[] (RAM) einen String zu, klappt es nicht. Speichere ich einen String im FLASH und kopiere diesen in den char[] Buffer mittels strcpy_P, so hängt sich der µC weg. Beim Debugging in der Simulierung vom Atmel-Studio kann
-
Thread
PI-Axen mit C++ programmieren (Move Relative)
mit der funktion LAN_sendString("1MA66666");. Es wird ein string an den µc gesendet, der in diesem fall mit der "1" die Achse anspricht, danach MA (Move Absolut) und 66666 sind die Schritte. Damit bewegen sich die Achsen. Nun möchte
genau, was übergeben werden muss. Nachdem aber ein Pointer gefordert wird, sowohl für den Command-String als auch den Report-String würde ich es einfach ausprobieren. Ich meine mich zu erinnern, dass die Controller-Karte nach erreichen der Position eine Meldung zurückgegeben hat. Andernfalls würde
-
Thread
MAC-Adresse in C# auslesen
Funktion rechenintensiv? Gibt es eine andere Möglichkeit in C# eine MAC-Adresse auszulesen: [c] public string GetMacAddress(string ipAddress) { string macAddress = string.Empty; System.Diagnostics.Process pProcess = new System.Diagnostics.Process
return macAddress; } else { return string.Empty; } } [/c]
-
Thread
Enum zu char array mappen mit verschiedenen Datentypen
(array_string[sensor2]); } [/c]
foo(void) { int i; for(i = 0; i < sensormax ; i++) { print_char_string(array_string[i]); print_number(array_Data[i]); } } [/c]
-
Thread
C++: Funktionspointer auf "fremde" Methode einer Klasse
Hallo, folgende Situation: Ich habe einen kleinen Skript-Interpreter geschrieben (Visual C++ 2005), der Scriptdateien abarbeiten kann. Der funktioniert auch schon prima. Ich habe diesen Interpreter als Klasse implementiert und füttere diesen mit Strings die dann abgearbeitet werden. Nun benötige
Wurst wrote: > folgende Situation: > Ich habe einen kleinen Skript-Interpreter geschrieben (Visual C++ 2005), > der Scriptdateien abarbeiten kann. Was für Script Dateien? >Der funktioniert auch schon prima. > Ich habe diesen Interpreter als Klasse implementiert und füttere diesen > mit Strings
-
Thread
Parse JSON string with cJSON in embedded C
Device stellt auch noch kein Problem dar. Die ankommenden Daten fange ich erst mal in einem einfachen String auf, sodass dies meine Ausgangssituation darstellt: [c]char* json_string = "[{\"KEY1\" : \"VALUE1\",\"KEY2\" : \"VALUE2\",\"KEY3\" : \"VALUE3\",\"KEY4\" : \"VALUE4\"}]";[/c] Ich habe jetzt schon min. 5 verschiedene JSON Parser für C ausprobiert, aber irgendwie bekomme ich sie alle nicht zum laufen. Am besten hat mir noch der cJSON Parser gefallen. [[https://github.com/DaveGamble/cJSON]] Könnte mir jemand (ruhig auch mit einer
-
Thread
PV Stringspannung messen
aufgeteilt, als bei 2x 2 Strings?
hat, dann pass auf, daß Du die beiden 15-Panel-Strings an den gleichen MPP-Tracker anschließt und den 14-Panel-String an den zweiten MPP-Tracker. Also nicht einfach wild die Eingänge mischen.
-
Thread
serielle Schnittstelle in C
[c] #include <windows.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <sys/types.h> #include <sys/stat.h> /*------------------------------------------
instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. 1> c:\program files\microsoft visual studio 10.0\vc\include\string.h(105): Siehe Deklaration von 'strcpy' 3) schnittstelle.cpp(119): error C2664: 'WriteFile': Konvertierung des Parameters 4 von 'int *'
-
Thread
ISR und Stackgröße
Da scheint es noch einige Unklarheiten zu geben, was Stringverarbeitung angeht [C] strncpy(breitengrad, "Warte...",8); [/C] Dre String "Warte..." hat keine Länge von 8 Zeichen, sondern es sind 9 Zeichen (du hast auf das abschliessende \0 vergessen). Ausserdem solltest du dir
zweitens macht er die notwendige Anpassung von alleine, wenn sich mal die Arraygröße verändert. [C] strncpy(breitengrad, "Warte...", sizeof(breitengrad)); [/C] strncpy ist aber nur die halbe Miete, denn strncpy hat hier ein Designproblem: Wenn der String gerade noch ohne das obligatorische \0
-
Thread
Frage zu C++ Code
/c] jetzt so: [c] ... << int(dd.month()) << .. [/c] Und das "dd.month" die richtigen Werte bekommt stellt ja mein Konstruktor sicher. Ist das eine gute Lösung? Einfach ist sie ja, was nicht immer gut
auch beim c-style Cast passieren.
-
Thread
avr-gcc: __DATE__ formatieren / "initializer element is not constant"
, der den C-String __DATE__ parsed und in einen Tag (Julian Day) umwandelt. Das verbraucht weder RAM noch Flash und kostet auch zur Laufzeit nichts. Wenn Interesse besteht, stelle ich das auch gern zur Verfügung
String initialisieren darf – anders als in C.
-
Thread
Timer und Interrupts beim ATmega 128
;-) Ähm. Das ist Grundlagen - C Programmierung - Strings. In jedem C Buch irgendwo im ersten Drittel des Buches in einem eigenen Kapitel über Strings lang und breit und 25 Variationen ausgewälzt. [[String-Verarbeitung in C]]
;-) > > Ähm. > Das ist Grundlagen - C Programmierung - Strings. > In jedem C Buch irgendwo im ersten Drittel des Buches in einem eigenen > Kapitel über Strings lang und breit und 25 Variationen ausgewälzt. > > [[String-Verarbeitung
-
Thread
C# Eingabe von Buchstaben verhindern
Ok, bei VS C# gibt es anscheinend das Event onChange nicht. Mist.
http://lmgtfy.com/?q=c%23+textbox+nur+zahlen+zulassen
-
Thread
Sammelbestellung AR488 kompatibler USB-GPIB Adapter. Interesse?
[c] #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> #define maxbuf 50 int main(int argc, char** argv) { char buf[maxbuf]; int n;
[c] #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <fcntl.h> #define maxbuf 50 int main(int argc, char** argv) { char buf[maxbuf]; int n;
-
Thread
Seriellen String mit C empfangen
Hallo zusammen! Ich bin gerade dabei ein kleines Programm in C zu schreiben um einen String, der an der seriellen Schnittstelle ankommt zu empfangen. Der String ist maximal 160 Bytes lang. Das Öffnen des Ports und initialisieren funktioniert soweit, jedoch komme ich beim String nicht weiter. Hier mal ein Ausschnitt, wie es bis jetzt läuft (allerdings werden hier nur einzelne Bytes empfangen): [c] void readdata(int iFd){ char buf[160]; int res=0; res = read
-
Thread
C Problem, String vergleich
Hi, hab versuch ein C Prgramm zu schreiben für ein Atmega8 mit 8Mhz. Es sollte einen ankommenden String von der RS232 mit einem im MC abgelegten String vergleichen. So sieht es bis jetzt aus: #include <avr/io.h
USART_I (); sei(); //Interrputs EIN sschalten for (;;) {} } also wenn der string richtig ist wird die LED leuchten PORTB2! FEHLER: Wenn ich jetzt denn richtig sende, leuchtet sie auch, aber wenn ich einen falschen string senden und dannach wieder den richtigen. Leuchtet nix
-
Thread
Zuweisung von Strings an ein Array
uart_putc(32); } } } int main(void) { foo(1); . . foo(4) } [/c] Auf meinem Terminal kommt da nur noch Murx raus. Ist es ein Problem, dass ich mehrere Strings in die Arrays schreibe, oder besser gesagt so wie ich sie da reinschreibe? Vielleicht sitze ich einfach
mich jetzt noch mal in Ruhe rangesetzt. Oben war ein Fehler von mir: Ich rufe natürlich nicht: [c] foo(1); . . foo(4): [/c] sondern: [c] foo(0); . . foo(3): [/c] auf. Nochmal zu dem 2D-Adressierten, ich dachte immer das waere genau anders herum, also: 0-0 1-0 2-0 .... 3-4 4-4
-
Thread
RS485 empfang und senden
TXC); // clear txc flag PORT_UART_OUT &= ~( 1 << PIN_UART_OUT ); } uint8_t c; uint8_t c1; //mainloop: for (;;) { if (uart_str_complete == 1) { uart_str_complete = 0; c = uart_string[0]; //Hole Daten vom UART ab if (c==0xA4) { c1=uart_string[1]; setTransmitMode(); //Sende-Pin auf HIGH schalten uart_puts("TEST OK" ); setReceiveMode(); /
-
Thread
WPF C#: listView
ich nichts finden. Wie hast du das geschafft? Direkt (ohne Data Binding und mit einfachen Strings): --- lv.Items.Add("Dies"); lv.Items.Add("ist"); lv.Items.Add("eine"); lv.Items.Add("Pfeife"); --- string s = lv.Items[3] as string; MessageBox.Show(s); lv.Items[2] = "keine"; --- Mit
Wow... [c] myListView.Items[myListView.SelectedIndex] = "Einfach mal was ausprobieren???"; [/c] merciless
-
Thread
In welcher Bibliothek(R8C) steck itoa Gesperrt
Hallo Ich programmiere in C den R8C. Ich müsste einen Longint ein einen Hex umwandeln. Dazu müsste man doch in C den Befehl "itoa" verwenden? Kann mir einer sagen in welcher Bibliothek der steckt? Und wo man dies nachlesen
http://www.goblack.de/desy/sc12chip/c/bibliothek/itoa.html
-
Thread
MISRA C / ISO 62262 in der Praxis?
sie keine > 0 findet. Genau dafür wurde mal strnlen_s eingeführt: https://en.cppreference.com/w/c/string/byte/strlen A. S. schrieb im Beitrag #6039358: > Printf oder strcpy sind halt fragile. Und auch hier gibt es Nachfolgefunktionen die diese entschärfen: strcpy_s: https://en.cppreference.com/w/c/string/byte/strcpy printf_s: https://en.cppreference.com/w/c/io/fprintf strcat_s, strncpy_s, sprintf_s, memcpy_s und noch einige weitere... Man müsste diese neueren Varianten nur auch verwenden
-
Thread
Text in 2D Arrays, stm32f4xx
Strings aus? Ich hab da einen Knopf in der Leitung. [c] for(x = 0;x <= 15; x++) { LCD_wr_Data(setup.txt_run_RunOpen[0][x]); } [/c] [c] void LCD_wr_Data(uint8_t data) { LCD_wr(true, data
im Text.h [c] typedef struct { char startup_Text_line1[STRING_LENGTH]; char operation_Text_line1[STRING_LENGTH]; char operation_Text_line2[STRING_LENGTH
-
Thread
Usart (XMega) gesendeten String mit empfagenem String vergleichen
*s) //zum Senden von Strings { while (*s) { USARTE0.DATA = *s ; while(!(USARTE0.STATUS & 0x40)); s++; _delay_ms(500); } } ISR(USARTE0_RXC_vect)//Empfangen mit Interrupt { int c = 0; c = USARTE0
= 0; /* 1= String vollständig */ ... ISR(USARTE0_RXC_vect)//Empfangen mit Interrupt { int c = 0; c = USARTE0.DATA; if (c=='\n') { c = 0x00; rxvalid = 1; rxbuffer[rxpos] = c;
-
Thread
String in äquivalente Nummer wandeln
nur für 3 Zeichen. Windows macht das mit Atoms, da wird eine Tabelle aller im System benutzen Strings aufgebaut und jedes bekommt eine Nummer. Man muss jeden String in diesem String-Pool eintragen und bekommt die 16 bit Nummer, bei demselben String dieselbe Nummer, aber daszu braucht man eine Zentrale die die Strings verwaltet, und löschen kann man die Strings nicht mehr weil keine Nummer doppelt vergeben werden darf (bis zum nächsten Reboot), es sei denn, man zählt mit wie viele die Strings verwendeun und informiert
-
Thread
string belegen
hallo, kann den unteren test-string nicht ausgeben auf dem lcd-display. oder ist der string für winavr-c nicht richtig? char test[8]; test[]='pebi'; mfg karlheinz
> test[]='pebi'; Was soll'n das sein? In C kann man keine Arrays als ganzes zuweisen. Genau das versuchst Du aber hier. strcpy( test, "pebi" );
-
Thread
Fehlerspeicher speichern in einer txt.Datei
if( NULL == .... ) Schreibweise, wäre es vernünftig, erst mal die Grundlagen von * C-Strings * Filebehandlung zu lernen (denn die 256-er for Schleife da am Anfang ist doch auch bescheuert)
: Du sollst den Returnwert von malloc nicht casten. Wenn du es tun musst, dann benutzt du keinen C Compiler sondern einen C++ Compiler. Und in dem Falle wäre dann sowieso die Benutzung der std::string Klasse angebracht.
-
Thread
Atmega 328p USART
#endif void uartSetup(uint16_t ubbrValue); void sendChar(unsigned char zeichen); void sendString(const char* charOfString); void sendString_p(const char* charOfString); void sendString_e(const char* charOfString); #endif /* uart_h */[/c] und die uart.c [c]// // uart.c // // Created
sendString_p(const char* charOfString){ //send string from flash register char c; /* while *charOfString != '\0 */ while ( (c = pgm_read_byte(charOfString++)) ) { sendChar(c);
-
Thread
Zeichenkette erstellen
[C] uart_puts("\x1B[2J\x1B[H"): [/c] Escape Sequenzen in Strings sollten sich eigentlich in jedem C-Lehrbuch finden. Wenn nicht: schmeiss es weg und kauf dir was ordentliches
nimmt einfach x und y als Text und fügt das ein, es ensteht also [C] "\33[x;yH" [/C] und daß dein Terminal mit diesem String nix anfangen kann, ist klar.
-
Thread
VB.net Darstellung von Daten RS232
Anstatt strings zu senden könntest du dir ein besser zu parsendes Protokoll ausdenken und die strings in deinem VB Programm selber zusammen setzen. Alternativ, wenn es wirklich strings seien müssen, alles in
man Polling), ist aber zumindest nicht elegant. Der SerialPort1_DataReceived kommt immer, wenn der µC was sendet (also eher in "Echtzeit"). Wenn der µC einen String raushaut, dann steht der auch komplett im SerialPort1.ReadExisting() und du bist fertig. Wenn der einzelne Bytes schickt solltest du doch
-
Thread
Array vom PROGMEM aufs Display
Adresse NULL. Das willst du sicher nicht. >lcd_string(buffer); Eher so. [c] const char mainmenu[] [8] PROGMEM = {"Menue 1","Menue 2","Menue 3"}; char buffer[8]; strcpy_P (buf, mainmenu[i], 8); lcd_string(buffer); [/c]
wie wär's mit PSTR ? [c] #include <avr/pgmspace.h> strcpy_P (buffer, PSTR("TestString")) [/c]
-
Thread
seriell char aus ringpuffer als zeichenkette speichern
>der ist in dewr uart.c enthalten. Tja, dann wollen wir das mal glauben. >mit welcher routine könnte ich das machen? mit einer selbstgeschriebenen... [c] char myString[5]; myString[4] = 0; myString[0] = ser_getc(); myString[1] = ser_getc(); myString[2] = ser_getc(); myString[3] = ser_getc(); [/c] und schon hast du einen String mit vier Zeichen. Oliver
-
Thread
c# werte in versch. klassen zur verfügung haben
die "Application.StartupPath" auf, das finde ich aber recht unschön da ich hier dann jedes mal dem string noch den Dateinamen anhängen muss. wenn sich der Dateiname ändert muss ich das an zig Stellen im code ändern! 2. ich speichere den filepath in der form1 und hole mir den string durch eine GetFilePath
aufruf der wert wieder gelöscht. Was mache ich falsch dass der Pfad nicht gespeichert wird? [c] namespace program { class Einstellungen { public string pathToSettingFile; ... } } [/c]
-
Thread
Atmega32 ADC
i=0; i<NumberofDigits; i++) Send_A_String(" "); Send_A_StringToMrLCDwithLocation(x, y, StringToDisplay); } [/C] solltest du nochmal nachdenken. Die ist ziemlicher Quatsch. Vor allen Dingen erreichst du nicht das was du willst: eine
); Send_A_StringToMrLCDwithLocation(x, y, StringToDisplay); } [/C]
-
Thread
call by reference will nicht , Atmega163, C
number > 9)) { i = 2; } char tmp[i]; itoa(number, tmp, 10); put_string_lcd(a, b, tmp); } [/c] Um einen String "23" zu bilden, benötigst du ein Array der Länge 3(!), und nicht 2. Denn der String besteht aus 3 Zeichen. '2', '3' und dem abschliessenden '\0' Zeichen
]; sprintf( buff, "%02d:%02d:%02d", std, min, sec ); put_string_lcd( TIMEPOSITION_Z, TIMEPOSITION_S, buff ); } [/c] aber so eine Zahlenausgabe an sich ist ja auch nützlich. Merke: du brauchst an solchen Stellen nicht kleckern. Ob du temporär ein Array der
-
Thread
Wie schreibt man eine *richtige* Testbench
sparen. Was genau willst du jetzt? Soll ich dir zeigen, wie die Syntax zum Öffnen von Dateien in c# (zum 2. mal kein C++ weder C) aussieht? Wie man strings parsed? Ich zeige eine horizontöffnende Sicht und du laberst nur rum. Gruß Jonas
sparen. Was genau willst du > jetzt? > Soll ich dir zeigen, wie die Syntax zum Öffnen von Dateien in c# (zum 2. > mal kein C++ weder C) aussieht? Wie man strings parsed? > > Ich zeige eine horizontöffnende Sicht und du laberst nur rum. > > Gruß Jonas Nee, er labert nicht rum! Das was da oben
-
Thread
mit Strings arbeiten
"unsigned int c" sollte, wie schon oben beschrieben "unsigned char c" sein. "strcat (buffer, (unsigned char) c)" ist auch falsch. strcat() verkettet strings und keine einzelnen Zeichen. Den ganzen strcpy() und strcat() sollte man weglassen. Hier verarbeitest Du ja nirgends wirklich Strings. Also: strcpy (buffer,""); -> weglassen und strcat (buffer, (unsigned char) c); -> unsigned char pos = 0; (oder int) buffer[pos] = c; pos++; buffer[pos] = '\0'; Und vor allem
-
Thread
Frage zu Pointern (Arduino)
Hallo, ich habe ein unsigned char* irdata. Das bekommt einen Pointer auf einen "string" wie "NEC 0xBE414DB2 32" zugewiesen. Diesen string teile ich auf mit [c] int i = 0; char* arg[3]; char* irString = strdup(irData); char* token = strtok(irString," "); while(token != NULL
, " "); i++; }[/c] arg[i] zeigt auf Strings innerhalb von /irString/. Solange /irString/ nicht durch free freigegeben wird (was irgendwann pasieren muss), sind auch die Zeiger von /arg/ gültig.
-
Thread
Auflösungswechsel
= 0; StateFlags = flags; DeviceName = new string((char)32, 32); DeviceString = new string((char)32, 128); DeviceID = new string((char)32, 128); DeviceKey = new string((char)32, 128);
{ return devMode.dmPelsWidth.ToString() + " x " + devMode.dmPelsHeight.ToString() + ", " + devMode.dmBitsPerPel.ToString() + " bits, " + devMode.dmDisplayFrequency.ToString
-
Thread
LCD zu langsam
set_cursor(5,4); sprintf(out,"%8.2fmm",(float)zVAL/stepsPerMmZ+frameZ[frame]); lcd_string(out); break; case 4: //update Frame set_cursor(13,1); sprintf(out,"G%d",frame+54); lcd_string(out); } } [/c] die lcd_string() methode looped halt über alle chars: [c] void lcd_string(char *data) { while(*data) { lcd_data(*data); data++; } } [/c] Hier hatte ich überlegt anstelle des loops alles in einen FIFO zu packen, der durch
-
Thread
Integer-Wert in ASCII-char
Ok, plausibel. Aber auch mit einem Speicherbereich sieht es so aus: Nach [c] char s2 [10]; sprintf(s2, "%i", j); [/c] ist der String leer, aber [c] char s2[10]; sprintf(s2, "Hallo"); [/c] gibt er aus.
wrote: > Ok, plausibel. Aber auch mit einem Speicherbereich sieht es so aus: > > Nach > > [c] > char s2 [10]; > sprintf(s2, "%i", j); > [/c] > > ist der String leer, aber > > [c] > char s2[10]; > sprintf(s2, "Hallo"); > [/c] > > gibt er aus. Dann musst du schon das komplette
-
Thread
Funktionen in C richtig Komentieren
iLength, iTime, iDate, iCmdShow (aus Win32-Code) pText (p = pointer) Also ich deklariere einen - String noch immer gerne als: strHlp - ein Zeichen als chKeybrd oder cKeybrd Olaf schrieb: >> bFlagPleite >> Kto_stand >> nTage_bis_Raeumung >> percentVal > die Verwendung deskriptiver Variablennamen
überhaupt nicht unterscheiden, nur im Typ und im ungarischen Präfix. > Also ich deklariere einen > - String noch immer gerne als: strHlp > - ein Zeichen als chKeybrd oder cKeybrd Vertretbar ist es, Typen unterschiedlicher Funktion zu differenzieren. Also Integers, Booleans, Strings voneinander zu unterscheiden
-
Thread
Laufschrift Denkanstöße
() [c] led.matrix[start_line + line][start_col + col] = CURRENT_STATE; [/c] liest, rufst Du stattdessen Deine Funktion [c] clear_pixel (start_line + line, start_col + col); [/c] auf. Im WordClock-Source
[/C]