-
Thread
Schalter PORTC 1-5 C
neu gecodet aber nützt nichts hoffe auf hilfe. Hab Atmega8-16 inter. 1 Mhz 2 LED: PC0 PB6 [c] #include <avr/io.h> #include <avr/pgmspace.h> #include <util/delay.h> #include <stdio.h> #include <string.h> //#include "pcd8544.h" #include "main.h" bool PC_LCD = 0; bool PC_END =
_delay_ms(100); LcdContrast(0x00); LcdUpdate(); _delay_ms(100); //display string LcdClear(); LcdPixel ( 10, 10, 1); LcdUpdate();// Auf Display */ while(1) { } //Hauptprogramm return 0; } void PC_Down() { PC_END = 0; } [/c]
-
Thread
Probleme mit fgets() und write() - RS232
#include <stdio.h> #include <stdlib.h> #include <termios.h> #include <fcntl.h> #include <string.h> int main(void){ int laenge; char c[100]; const char *port = "/dev/ttyS0"; unsigned int fd = open(port, O_RDWR | O_NOCTTY); if(fd == -1){ printf("Falscher Port(name)\n"); return 1; } printf("\e[1;31mBitte String eingeben: \n\e[0m"); fgets(c, 99, stdin); laenge = strlen(c); c[laenge - 1] = c[laenge]; // \n durch \0 ersetzen printf("\e[1;34m%d\n%d\n\e[0m", laenge, c[laenge]); printf("Daten werden
-
Thread
reference operator in C?
Ich würde gerne folgendes machen: [c] structure f; structure &ff=f; [/c] In C++ geht das, aber irgendwie will C (WinARM) es nicht akzeptieren. Was ich will ist eigentlich folgendes. Ich gehe mal davon aus, dass bei 8-Bit-Mikrocontrollern
0000036B: 8380 STD Z+0,R24 Store indirect with displacement 65: s->string[3]='a'; +0000036C: 81EC LDD R30,Y+4 Load indirect with displacement +0000036D: 81FD LDD R31,Y+5 Load indirect with displacement +0000036E: E681
-
Thread
[C#] Verständnishilfe bei Serieller Kommunikation
Du versuchst gerade zwei Dinge auf einmal zu lernen, einerseits die serielle Kommunikation mit C# und andererseits wie so eine Übertragung überhaupt grundsätzlich funktioniert. Wenn du letzteres einigermaßen verstanden hast wird der C# Teil leicht. Im einfachsten Sinne kannst du über RS232 Daten
keine Probleme bereiten wird (an beiden Fronten zu kämpfen wäre vielleicht zu viel). Edit: Die C#-Klassendoku durchzulesen ist zwar auch gut, schau aber auch mal allgemein Rs232/UART an zB hier im uC Wiki oder echtes Wiki: http://de.wikipedia.org/wiki/Universal_Asynchronous_Receiver_Transmitter
-
Thread
[C++] vector für Mikrocontroller
Beitrag #4641343: > welche Alternativen > existieren? Um Exceptions loszuwerden kannst du auch mit [c]-fno-exceptions[/c] kompilieren - mit allem was daraus folgt: https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_exceptions.html
Aber das geht mit std::array nicht: [c]struct Foo { Foo(int) { } }; int main() { std::array<Foo, 3> Test{}; /* Soll keine foo-Objekte enthalten */ }[/c]
-
Thread
SPI MISO Leitung funktioniert nicht (AT32UC3C)
(&C_SPI, 8, SPI_MODE_1); if (retval != SPI_OK) { LcdWriteString(LCD_LINE1, " "); LcdWriteString(LCD_LINE2, " Error SPI "); LcdWriteString(LCD_LINE3
= 3: 28000000 spi_status_t ret = spi_setupChipReg(&C_SPI, &spi_options, PBA_CLOCK); if (ret != SPI_OK) { LcdWriteString(LCD_LINE1, " "); LcdWriteString(LCD_LINE2, " Error SPI "); LcdWriteString(LCD_LINE3, "
-
Thread
Freitagsfrust - Pointer
** Die wichtigste Info fehlt: Was ist RCV_ERRORCME? ******* > const char RCV_ERRORCME[] = { '+', 'C', 'M', 'E', ' ', 'E', 'R', 'R', > 'O', 'R', ':', 0x0 }; Ernsthaft? Einen String aus einzelnen chars konstruiert? Noch nie was von String-Literals wie "+CME ERROR:" gehört? >> welchen mit memcmp() gefunden werden soll. memcmp() für Strings? > rc = MySearch(&RCV_ERRORCME[0]); Und die nächste C-Grundlage nicht verstanden :(. Der Name eines Arrays ist direkt ein Zeiger auf das Array, und damit ein Zeiger auf das erste Element. RCV_ERRORCME
-
Thread
Unerklärter Reset
; while (mode == 1) { OutputString(inputString, stringSz); } } return 0; } [/code] Port_Initialization_Function.c (Ports konfigurieren) [code] #include <avr/io.h> #include "Port_Initialization_Function_Prototypes.h
pInputString[*pStringSz] = '0'; break; case Num1: PORTB = 0x06; pInputString[*pStringSz] = '1'; break; case Num2: PORTB = 0x5B; pInputString[*pStringSz
-
Thread
avr-g++ mehrere .cpp Dateien -> Fehler(AVR freeze)
Aber noch ein paar Tipps. String String::operator= (char* s) { hat den falschen Returntyp. Der op= returniert eine Referenz String& String::operator= ( const char* s ) { Wenn du C++ arbeitest, gewöhn dir von Anfang an an, const korrekt zu arbeiten. Du willst einen konstanten String mittels op= an den String binden. Dazu sollte das Argment auch const sein (dein ein String Literal ist grundsätzlich const. Lediglich aus Abwärtskompatibilitätsgründen zu altem C, wird es ausnahmsweise
-
Thread
ADS1112 ADC Wert in Spannung rechnen
abschneiden" int nachKomma = Messwert % 1000; // zwei Nachkommastellen "isolieren" lcd_string("Solar "); itoa( vorKomma, ausgabe,10); lcd_string(ausgabe); lcd_string(","); itoa( nachKomma, ausgabe,10); lcd_string(ausgabe); lcd_string(" "); [/CODE] Danke für deine Unterstützung
// Anzahl der auszugebenden Stellen = 4 lcd_string (AdcValArray [++m]); // ADC Wert ausgeben if (m == 0) lcd_string ('.'); // Dezimalpunkt setzen } } [/c]
-
Thread
Bascom: 10 stellige Hexzahl in Dezimalzahl wandeln
vorher noch nie beschäftigt, denke aber (noch :), es ist einfacher die Ausgabe zu ändern, als alles in C neu zu programmieren. Die Umwandlung von einer hexadezimalen Zahl in einem String zu einer dezimalen Zahl geschieht mit Hilfe von Hexval (http://avrhelp.mcselec.com/hexval.htm). Leider funktioniert
. Aber dann wären die Strings nicht mehr so einfach zu lesen :-) [C] #include <stdio.h> #include <string.h> typedef char LongNum[14]; LongNum Bits[] = { "0000000000001", "0000000000002",
-
Thread
UART arbeitet bei Codeänderung nicht mehr, ATmega16
Fehlverhalten des Controllers auf das ich nicht nachvollziehen kann. Wenn ich folgenden Code verwende [c] int main(void){ u8Flag = 0; //Datei die auf SD Karte angelegt werden soll unsigned char file_name [] = "test.txt"; //String der in die Datei geschrieben werden soll unsigned char str
//write char into transmit buffer }[/c] [c] void gvUsartPutStringPolling(const char* u8String){ while(*u8String != '\0'){ gvUsartPutCharPolling((uint8_t)*u8String); u8String++; } } [/c] Wenn ich keine SD-Karte anschließe
-
Thread
Padauk MCU für 0.038 USD aus Taiwan
Hello, World!" das von SDCC auch bereits in recht brauchbaren Assemblercode übersetzt wird (ja, der String liegt jetzt im ROM): [c] #include <stdbool.h> #include <stdio.h> volatile unsigned char sendcounter; volatile unsigned int senddata; volatile bool sending; __sfr __at(0x04) inten; _
, "${workspaceFolder}/include/pdk", "${workspaceFolder}/include/pdk/device", "C:/Program Files (x86)/SDCC/include/", "." ], "C_Cpp.default.cStandard": "c99", "cSpell.allowCompoundWords": true, "cSpell.diagnosticLevel": "Hint", "cSpell.enabled": false
-
Thread
String in Variable speichern
http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Und demnächst wird jetzt mal ein C-Buch fällig! Du kannst eine Sprache wie C nicht ohne vernünftige Unterlagen lernen.
nicht von einer Falle in die Nächste zu tappen. Literaturstudium zum Thema "Stringverarbeitung in C" ist ein absolutes Muß! Wenn man das aber betrieben hat, dann stellt sich die Frage: 'Wie speichere ich einen String in einer Variablen' gar nicht mehr.
-
Thread
vom µC über Bluetooth ins Handy und von dort ins Internet
ohne großartiges rum gefrickel und zusätzliche Tools im Internet. Ggf kannst du dir auch dann den uC selbst sparen da der esp8266 ja auch ein uC ist
connection.getInputStream()); byte[] content = new byte[1024]; int bytesRead = 0; String strContent = ""; while((bytesRead = bis.read(content)) != -1){ strContent += new String(content,0,bytesRead); } returnString = strContent; [
-
Thread
UART Interrupts, Rückgabe der Variable
uint8_t uart_str_complete; volatile char uart_string[]; //... [/c] uart.h [c] #ifndef UART_H_ #define UART_H_ //.. // Diese beiden Varialben sollen auch ausserhalb verfuegbar sein extern volatile uint8_t uart_str_complete = 0; extern volatile char uart_string[UART_MAXSTRLEN + 1] = ""; //.. #endif /* UART_H_ */ [/c] main.h [c] #ifndef MAIN_H_ #define MAIN_H_ //.. #include "uart.h" //.. #endif /* MAIN_H_ */ [/c] main.c [c] #include
-
Thread
Frage zu Entprellungsprogramm
0xFF; //alle LEDs aus lcd_init(); lcd_setcursor(0,1); lcd_string("Hallo"); while(1) { if(entprellung(PD0)) { PORTB &= ~(1<<PB7); //LED7 an, wenn taster an PD0 gedrückt } } } [/c] Der Fehler
alles wie gewünscht: [c]#include <avr/io.h> #include <util/delay.h> #include "lcd-routines.h" #include <stdbool.h> char buffer[20]; void delay_ms(uint16_t ms) { while(ms>0) {lcd_setcursor(0,1); lcd_string
-
Thread
UART senden per interrupt mit atmega8
Es würde also auch folgendes gehen [c] unsigned char characerArr[9] [/c] Im aufruf dann zb: [c] SendStringByInt("test"); Für SendStringByInt(chararray temparr){ Characterarr temparr; Udsra | (1<< txc); } ISR (TXC_vector
keinen atmega 8 zur stelle da ich längere zeit bei meiner freundin bin wie sieht das hiermit aus?? [c] #define MaxTxLen 12; char globalArr[MaxTxLen]; SendStringByInt("test"); unsigned int i=0; SendStringByInt(char temp[]){ unsigned int cnt; for(cnt = 0;cnt < sizeof(temp) ; cnt++)
-
Thread
PWM per UART verändern in C
. Beispiel aus deinem Code: main.c:39: warning: passing argument 1 of 'eeprom_read_byte' from incompatible pointer type [c] volatile int16_t eeFooWord EEMEM = 0x64; ... test_byte = eeprom_read_byte(&eeFooWord); [/c] Na, fällt
Kleines Erfolgserlebnis: habe mich in die get_string() geklemmt und lasse mir dann den über atoi den uart_rx_buffer in eine int umwandeln. Sobald der int-Wert kleinergleich ICR1 ist, ändert er die Pulsbreite. [c]void get_string(char *daten) {
-
Thread
UART String wird immer wieder gesendet
} void uart_puts (char *s) { while (*s) { // so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" uart_putc(*s); s++; } } void uart_init() { UBRR0H = (BRC >> 8); UBRR0L = BRC; UCSR0B = (1 << TXEN0) | (1 << TXCIE0); UCSR0C =
} void uart_puts (char *s) { while (*s) { // so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" uart_putc(*s); s++; } } void uart_init() { UBRR0H = (BRC >> 8); UBRR0L = BRC; UCSR0B = (1 << TXEN0) | (1 << TXCIE0); UCSR0C =
-
Thread
Attiny13 spring t aus Hauptschleife
Change Interrupt 19 einschalten sei(); //Global alle Interrups einschalten } [/c] Der INT0 wird normal ausgelöst. Der PCINT19 löst zwar auch aus, restet aber den Controller. Ich sehe das daran, dass der String "Start" nochmal gesendet wird. Also zuerst "PCINT2" und danach "Start". Die etwas verkürzte Fassung des Code: [c] int main(void) //Hauptprogramm { initPorts(); //AVR-Ports initialisieren initUart(); //Uart initialsieren initInterrupt(); //Interrups initialisieren putString("Start\n");
-
Thread
Serieller Ausgabesalat
serielle Leitung nutzt und es tauchten keine Störzeichen auf. Hier ein Auszug aus meinem Code: [c]static void serialChar(uint8_t c) { while((UCSR0A & (1 << UDRE0)) == 0){;} UDR0 = c; } static void serialString_P(char* s) { while(pgm_read_byte(s)) { serialChar(pgm_read_byte(
Ein einfacher Aufruf zur Ausgabe von einem String mit Variablen sieht bei mir so aus: [c] serialString_P(PSTR("Steurungswert: ")); serialNumberDigits(parameter.a, 1); serialString_P(PSTR(";")); [/c] wie kann ich das den Prüfen und worin
-
Thread
Datentypen wie "uint8_t"
lästig). In C gibt es die Konvention, dass ein String immer mit einem '\0' Zeichen aufhört. Alle Funktionen die mit Strings arbeiten, wissen das, zb auch die UART-String-Ausgabe Funktion. d.h. der String "TEST"
array[] = "TEST"; Jetzt übernimmt der Compiler das abzaehlen. Das hat den Vorteil, wenn sich der String "TEST" ändert, zb. auf "NOCH EIN TEST", dann muss nicht ich die Array-Größe abzählen, sondern das erledigt der Compiler für mich. > Also ich bin gerade dabei, mir langsam aber sicher C-Kenntnisse
-
Thread
Wiefiel Platz ist in einem AVR Mega16?
[C] ..... if(Flags & DebugFlag){ // Schleife für Debugging durch Flag aktivieren uart_puts_p( PSTR("neuer String empfangen") ); ... // Variablenwert ausgeben } [/C] und
[C] uart_puts( "neuer String empfangen" ); [/C] den Funktionsaufruf ändern zu [C] uart_puts_P( "neuer String empfangen" ); [/C] und der String bleibt im Flash und wird auch von dort ausgegeben
-
Thread
5-Dollar-Entwicklerboard mit RISC-V: Sipeed Longan Nano
: 04 03 09 04 .... ------ String Descriptor 1 ------ bLength : 0x26 (38 bytes) bDescriptorType : 0x03 (String Descriptor) Language 0x0409 : "GDMicroelectronics"
"offiziellen" dfu-util, wo der Patch https://sourceforge.net/p/dfu-util/dfu-util/ci/f2b7d4b1113ef6c3ada31a0654c9aefebcdb1de5/ schon drin ist) Jetzt blinkts endlich wieder! Gibt wohl verschiedene Chip-Revisions mit und ohne den Bug :-(
-
Thread
STM32 - UART - Zeichen für Zeichen auswerten - Unmöglich? (Zeichenlängen pro char von 1-34.)
Wert 0 (\0) hat. Auf der anderen Seite ist außer in einem Einzelfall ein einzelnes char nie ein String. Der Einzallfall ist dann gegeben, wenn das char den Wert 0 (\0) hat. Dann ist es auch ein gültiger String der Länge 0. Ein (fast beliebiges) C-Buch oder ein grundlegender Text dazu sollten weiterhelfen
[c]if (data == '$') {[/c]
-
Thread
Variabelinhalt über UART senden
wird. Dazu benutze ich folgenden Syntax: [c] unsigned char senden; senden = recive_char(); send_string(senden); [/c] Leider wird so nichts zurückgesendet. Hier mal die Prozedur recive_char und die Variabeldeklenationen: [c] //Globale
a cast" oder so ähnlich). So was macht man einfach nicht. In C gibt es keinen Datentyp /string/ und deshalb ist das Murks.
-
Thread
GSM Modem über Atmega32 steuern
Coding in AVR Studio 4: #include <avr/io.h> #include <util/delay.h> int uart_putc(unsigned char c); void SendeString (char *szBuf); void long_delay(uint16_t ms); int main(void) { int c=0; UCSRA = 0x00; // MCU =ATMega32, F_CPU = 16Mhz, 9600 Baudrate UCSRB = 0x18; //8 Bit , kein Parity, 1 Stopbit, Asynchron UCSRC = 0x86; UBRRH = 0x00; UBRRL = 0x67; if(c==0) { SendeString("at+cpin=0000\r\n"); //AT-Befehl zur Pineingabe long_delay(2000); //2 sec warten //2 Sekunden Warteschleife SendeString("at+cmgf=1\r\n"); //SMS-Ein und Ausgabe erfolgt
-
Thread
führende Leerzeichen aus String entfernen
Hallo, gibt es in C eine _fertige_ Funktion führende Leerzeichen aus einem String zu entfernen?
Hier die Variante ohne Kopieren: [C] #include <ctypes.h> char * ltrimstr(char *s) { char c; while ((c = *s++) != 0 && isspace(c)) /* advance pointer */ ; return s; } [/C]
-
Thread
MSP430 - UART sendet Zeichen doppelt
genau das, was du willst! "warte, bis uart sendebereit!" erst dann sollte man den txbuffer füllen. [C] void SendUSART0c(char c) { while (!(IFG1 & UTXIFG0)); TXBUF0 = c; } [/C]
P2DIR |= 0x10; // P2.4 output direction - der Sendeaufruf: UART0sendString ( "ANGEKOMMEN !" ); - die SendString-Funktion: void UART0sendString ( UINT8* string ) { UINT8 zaehler = 0; while ( string[zaehler] != 0 ) { UART0sendChar( string[zaehler] )
-
Thread
Warum diese Warnung?
Hallo Leute, hab gerade nen kleines Problemchen mit der Übergabe von Char-Feldern, sprich Strings. Hier mal ein kleines Beispiel Programm welches das Verhalten hat: [c] #include <avr/io.h> void Versuch (unsigned char *Daten); int main(void){ unsigned char Test[5]; *Test="
Versuch mal, dir den theoretischen und praktischen Unterschied zwischen [c] char* test1 = "Hallo";[/c] und [c] char test2[] = "Hallo";[/c] klar zu machen. Oliver
-
Thread
Helpthread zum Wikiartikel AVR Eclipse
läuft unter gentoo. Hier zuerst einmal mein Testprogramm: [c]#include "RP6RobotBaseLib.h" int main(void) { initRobotBase(); //writeString("Hallo Welt!\n"); return 0; }[/c] So weit klappt das ganz gut. Die includes stehen im Projectexplorer
löschen } for(i=0; i<5; ++i) { itoa(irco_distance[i],irco_string[i],10); textout(i*21,8,irco_string[i],0); } delay(200); } while(1); return 0; } [/c] Beim Build-Prozess kommt folgende Fehlermeldung. make all
-
Thread
Error - could not find definition of symbol 'putrsXLCD_2' in file 'D:\LCD_2015\main.o'.
/* $Id: putrxlcd.c,v 1.1 2003/12/09 22:52:09 GrosbaJ Exp $ */ #include <p18cxxx.h> [c]#include "xlcd2.h" /******************************************************************** * Function Name: putrsXLCD * Return Value: void * Parameters: buffer: pointer to string * Description: This routine writes a string of bytes to the * Hitachi HD44780 LCD controller. The user * must check to see if the LCD controller
-
Thread
_|| in flash? eeprom_read_byte()
[c] char data; ... lcd_string(&data); [/c]Du hast ein *einzelnes Zeichen*, und übergibst dann die Adresse dieses Zeichens an eine Funktion, die unter der Adresse einen String erwartet. Mit dem EEPROM
[c] uint8_t myByte; .. lcd_string(&myByte); [/c] Was für ein "offizielles Beispiel" soll das denn sein? Du machst da exakt den gleichen Fehler wie oben. Nochmal: das Problem hat mit dem EEPROM
-
Thread
Zugriff string Konstante im PROGMEM eleganterer, einfacherer Weg?
strE[] PROGMEM = "unknown"; static char strings[] = { strA, strB, ... }; void get_id_name(uint8_t id, char *out) { strcpy_P(out, &(strings[id]); } [/c] Logischerweise kannst du auch diesen in den PROGMEM legen. Spart dir dann
[1] beschrieben. Ob ich das mit den Zeigern jemals verstehen werde??? :-( Gruß AVRli... [C] void get_id_name(uint8_t id, char *out) { char string_1[] PROGMEM = "String 1"; char string_2[] PROGMEM = "String 2"; char string_3[] PROGMEM = "String 3"; char string_4[] PROGMEM = "String 4
-
Thread
String aus Progmem lesen
Hallo ihr C-Gurus, ich hätte da mal ein Problem im Atmel Studio 6. Ich möchte einen mittels PSTR im Flash abgelegten String in eine Variable lesen um diesen zu bearbeiten und später anzuzeigen. Ich habe zur
2 mal aus dem Flash? Bruacht doch keiner [C] index = 0; while( ( c = pgm_read_byte(&t[index]) ) ) { // mach was mit c, zb in msg_str speichern msg_str[index++] = c; } msg_str[index] = '\0'; ... [/C]
-
Thread
Ideen und Konzepte für dynamisches Logging
Funktion Output noch einen 3. Parameter spendierst kannst, kannst du die Sache flexibler aufbauen. [c] void log_output(uint8_t ModulID, char* LogMessage, ...); [/c] jetzt kannst du deine Funktion den String 'LogMessage' Parsen lassen, wie in printf und weißt dann, was für Parameter in der Liste folgen. Ich habe diese Variante bei meinen Ereigniss-Loggern genutzt, auf dem AVR hatte ich meine Strings aber ins Flash gelegt und mir das Parsen mit einer MessageID gesparrt. [c] log_output(RS232Buffer, "Fehler: Buffer OVF %d Zeichen", toManyChars); [/c] nur als Idee :-) Stephan
-
Thread
Kommunikation Excel VBA --> µC / Stringterminator
Laufen bekommen - mit diesem Abschluss. (wenn ich als Abschluss auf irgendein anderes Zeichen warte im µC-Code, z.B. einfach mal "X" und im gesendeten String ein "X" vorkommt, dann funktioniert es einwandfrei. Der Terminator wird vom µC erkannt.) Ich kann aber scheinbar in Excel-VBA nicht einfach \0 (
könnte die sofort Ohne Schleife oder Konvertierung oder irgendeiner anderen "Auseinanderdröselei" des Strings mit meinem µC direkt verarbeiten. Nur wäre dann eben wenn Drehzahl 0 auch die Information = \0 und mein µC würde die Nachricht dort abhacken. Ich müsste dann also mit der UART-Routine direkt auf eine
-
Thread
Unsigned Integer Wert auf 100er Runden
Korrektur, man kommt natürlich auch mit nur einmal Modulo aus: [c] rest = wert % 100; wert -= rest; if (rest >= 50) wert += 100; [/c]
*/ } [/c] GRUß ;-)
-
Thread
Eigenbau-Ringbuffer: Holy oder Crap?
) c) Schreibe ein Zeichen in den Ringpuffer, das macht dann die ISR. --- Dein Code ist nicht vollständig, da [c]uart1_string[][/c] nirgendwo definiert ist! Ich würde ihn als [c] #define RINGBUFFER_SIZE
< MaxLen) String[Len++] = Char; } // Terminate string String[Len] = 0; } [/c]
-
Thread
Thermoducker - Density einstellen
Hermann Kokoschka schrieb im Beitrag #6923440: > Wurde hier eigentlich schon die String-Terminierung diskutiert? Wer redet denn von Strings? Wir sind bei einzelnen Bytes.
uint8_t density, uint8_t breakTime) { writeBytes(ASCII_DC2, '#', (density << 5) | breakTime); }[/c] und Aufruf: [c]setPrintDensity(uint8_t density=10, uint8_t breakTime=2)[/c] Verwirrend: density=10 --> 50% +(10 x 5%), soweit ok, aber dann schieben die einen uint8 mit Dezimalwert 10, b1010 um
-
Thread
strchr und ch32v003 mit riscv-none-elf-gcc
PC-Konsole) - sdcc 4.4 (auf einem STM8) erfolgt mit folgendem Code: [code] char string[120]; char *ptr; char c; c= 'z'; strcpy(string, "Dieses ist ein String"); ptr = strchr(string, c); if (ptr) { printf("\n\rDas Zeichen %c wurde
ist auch nicht richtig, denn nach der Beschreibung eines uralten Referncemanual aus 1987 zu Turbo C (das stammt von meinem ersten gekauften C-Compiler -verrückt wie lange ich schon mit C hantiere-) kann "strch()" auch das Zero-Zeichen am Ende eines Strings finden und würde so auch die Länge eines Strings
-
Thread
Z80 Single Board Computer
Harald N. schrieb im Beitrag #7677690: > Aber wenn ich simpel einen String in den Sendepuffer > schreibe, wird nur das letzte Zeichen übertragen, aber dafür Anzahl > Zeichen Mal oft. Hallo Harald, keine Ahnung, ob Dein Problem inzwischen gelöst ist, aber... circbuff.c
erwischt. Nur das dieser Fehler halt absolut nichts mit dem Problem oder dem Puffer zu tun hat. [c]const unsigned char* text = "Hello Zilog Z80";[/c] Ich hatte den * vergessen um den String als Char Pointer zu deklarieren. Natürlich hat der Code dann gebaut: [code]C:\Users\NaHa\Downloads\
-
Thread
PSTR() und String zusammensetzten?
Hallo, im C-Code für einen Atmel Mega328P muss ich einen String auf einen PSTR() und einen String zu einen String zusammensetzten. Gibt es dafür bereits eine elegante Prozedur? Bisher mache ich das so ...
Funktionen für C-Strings.
-
Thread
Library für Maturaprojekt
Translation = Serial.read(); } else if (Serial.available() == "true"){ Funktion = Serial.readString(); } [/c] Schritt 2: Lies dir die Dokumentation von Serial.available und Serial.read durch und vergleiche das Gelesene mit dem Ergebnis von Schritt 1. Tipp: Es gibt auch die Funktionen
} } [/c]
-
Thread
Compiler (C) für PIC 12/16
Du wohl eine andere Vorstellung von "Bibliothek" wie ich. Ich > verstehe sowas wie "stddef.h", "string.h" drunter. Das sind keine Bibliotheken. Das sind nur Headerfiles. Bibliotheken ("Libraries") heißen *.lib oder *.a (oder, wenn sie dynamisch gelinkt werden, *.dll bzw. *.so). In C++ gibt es
was bei C eine Library ist Wo steht die Definition nochmal im C-Standard?
-
Thread
Probleme mit GLCD von Powertip (T6963C)
wenn man das ding von Powertip so nennen darf) steht da nur "select number of columbs" ... laut T6963C kann man mit MD2,3 die Anzahl der Spalten festlegen. Jedoch geht MD2 nicht an den T6963C MD2 Pin ... aber eigentlich denke ich ist der Pin auch egal, der Display müsste trotzdem was anzeigen, wenn auch
LCD_CMD = 0xB2; // Auto Write Mode aus (Auto Inkrement) lcd_send_cmd(); } [/c]
-
Thread
Gabellichtschranke pulse zählen
Hatte dein Compiler dazu denn gar nichts zu sagen? [C] char Buffer [5]=("U/min: ") ; [/C] Wie quetscht du den einen String das aus 17 Zeichen besteht in ein Array mit leidiglich 5 Elementen? Lass doch den Compiler das Array für dich
counter = TCNT2; sprintf( buffer, "%3u", counter ); lcd_setcursor( 10, 2 ); lcd_string( Buffer ); } } [/C] und wenn das dann zählt, dann änderst du fürs erste [C] while(1) { TCNT2 = 0; _delay_ms( 100 ); // 0.1 Sekunden warten counter = TCNT2;
-
Thread
Menü (hängt)
(0,2); lcd_string (" XXXXXXXXX"); long_delay(1000); menue(); } [/c]
Thx, meine main sieht nun folgendermasen aus: [c] int main(void) { DDRD = 0xE0; DDRC = 0x30; PORTD = 0x1C; lcd_init(); set_cursor(0,0); lcd_string (" Guten Tag"); set_cursor(0,2); lcd_string (" XXXXXXXXX"); long_delay
-
Thread
Problem mit Delay und LCD Ausgabe.
{ char Buffer[20]; itoa( variable, Buffer, 10 ); lcd_string( Buffer ); } } return 0; } [/c] Für die Ausgabe des Schriftzuges habe ich zu Beginn der While Schleife noch vor dem dealy folgendes geschrieben: [c] set_cursor(0,1); lcd_string
Buffer[20]; itoa( variable, Buffer, 10 ); lcd_string( Buffer ); } } return 0; } [/c] Danke für die Hilfe! Gruß Michael