Projekte
BirgerT
nibo2_fork#01
bt_lib_uart.h
Projekte
Forum
Doku
Öffentliche Projekte
Startseite
Beispielprogramme
Projekte von anderen
Welcome
Username
Passwort
Eingeloggt bleiben
Zugangsdaten vergessen?
Registrieren
Projektverwaltung
⇨ Please choose! ⇦
——————————————————
✎ Create new project...
★ Browse existing projects...
——————————————————
⚬ MotorTest#1
⚬ C Tutorial 8#1
⚬ NIBO2 C Project#1
⚙ C Tutorial 15#1
⚬ 2010_11_18_el_test001#1
nibo2_fork#01
BSD_license.h
bt_lib_debugutil.c
bt_lib_debugutil.h
bt_lib_glcd.c
bt_lib_glcd.h
bt_lib_grafix.c
bt_lib_grafix.h
bt_lib_terminal.c
bt_lib_terminal.h
bt_lib_uart.c
bt_lib_uart.h
bt_lib_utils.h
lumpylumpy.h
main.c
nibo2_audio.c
nibo2_audio.h
nibo2_copro.c
nibo2_copro.h
nibo2_copro_cmd.h
nibo2_font.h
nibo2_global.h
nibo2_main_menu.h
nibo2_pwm_leds.c
nibo2_pwm_leds.h
nibo2_register.c
nibo2_register.h
nibo2_sensors.c
nibo2_sensors.h
test_debugutil.h
test_gfx_draw.h
xmas1.h
Project details
Compiler settings
Nachrichten
Sie sind nicht eingeloggt.
Neuigkeiten
★
NiboRoboLib 3.6
2017-01-17: Neue Version 3.6
★
NiboRoboLib 3.4.1
2016-04-16: Neue Version 3.4.1
★
Coding Tutorial
2015-11-22: Jetzt auch für den NIBO burger!
Site-Statistic
7426 private projects
385 public projects
16180353 lines compiled
58212 builds
NIBO
@
nibo2_fork_01/bt_lib_uart.h [read only]
////////////////////////////////////////////////////////////////////////// // // BT LIB UART serielle Kommunikation mit FIFO über UART0 und UART1 // // (c) Birger Töpelmann toepelmann(A)web.de Version 141018a !! Mode 1 noch nicht fertig // // INIT UART0 bzw. UART1 // Die Schnittstellen Parameter sind variabel, eine Änderung der // Einstellungen kann z.Bsp. über ein Terminalprogramm eingegeben // werden, ohne dass neu geflasht werden muss. // Es stehen mehrere Baudraten zur Wahl. // // SENDEN und EMPFANGEN // Über FIFO Ringbuffer, deren Größen einer 2er-Potenz // entsprechen müssen. // // STRINGs SENDEN // Ist die letzte Stringausgabe abgeschlossen, wird die übergebene // Stringadresse übernommen. Die Ausgabe erfolgt über einen zyklischen // Aufruf der Funktion mit Stringadresse 0. // So sollen Bufferüberläufe vermieden werden; // das Ausgabetempo wird durch die Buffergrößen beeinflußt. // // Zyklischer Aufruf der Printfunktion in der Mainloop: // // uart_txd_strP(UART0,0); // Stringausgabe testen/fortsetzen // uart_txd_str(UART0,0); // Stringausgabe testen/fortsetzen // // Starten der Stringausgabe (auch zyklischer Aufruf angenommen): // // if(state == SOLL_SENDEN){ // if(uart_txd_strP(UART0, str_seite1) == str_seite1){ // state = SEITE1_WIRD_GESENDET; // } // } // else if(state == SEITE1_WIRD_GESENDET) { // if(uart_txd_str(UART0, 0) == 0){ // state = SEITE1_WURDE_GESENDET; // } // } // // // TODO?! Testen // // if(uart_txd_strP(UART0, PSTR("Fertig")) != 0){ // state = SOLL_SENDEN; // } // } // // Der Aufruf -->> uart_txd_str(UART0,"Blödsinn"); << wird nicht unterstützt // stattdessen uart_txd_str(UART0, PSTR("sinnvoll"); verwenden // // TODO // - Mode Jobliste, Echo, -- XON/XOFF, XMODEM? // - wenn alle UART0 Funktionen stehen, diese auch für UART1 realisieren // - UART Disable für normale Port-/Pin Funktionen EXT3 evtl. in uart_init // - #define USE_UART1 0/1 oder mit Abfrage #if (BUFFER == 0) // ////////////////////////////////////////////////////////////////////////// // // #ifndef _BTLIB_UART_H_ #define _BTLIB_UART_H_ // // BSD License see "license.h" // #include "BSD_license.h" // #include "bt_lib_utils.h" // Sammlung von Makros und Typedefs // ////////////////////////////////////////////////////////////////////////// // // UART FIFO Empfangs- und Sendebuffergrößen in Bytes // // nur Zweierpotenz 4, 8, 16, 32, 64 oder max. 128 erlaubt // RXD = Empfänger (Receiver), TXD = Sender (Transmitter) // ////////////////////////////////////////////////////////////////////////// // #define UART0_RXDLEN 16 #define UART0_TXDLEN 16 #define UART1_RXDLEN 16 #define UART1_TXDLEN 16 // #define UART0 0x01 #define UART1 0x02 // ////////////////////////////////////////////////////////////////////////// // // PROTOTYPEN // ////////////////////////////////////////////////////////////////////////// // // Die USART UART_INIT // void uart0_init(uint16_t setup); void uart1_init(uint16_t setup); // // -> setup = Parameter BCD kodiert 0xabcd // a = Baudratenindex 0..9 (siehe unten) // b = Anzahl DatenBits 5,6,7,8 o.(9), // c = Parity 0 = no, 1 = odd, 2 = even // d = Stoppbits 1 oder 2 // // Baudratenindex in Baudratentabelle: // // 0 = 600 Baud 0.0% error // 1 = 1200 " 0,0% " // 2 = 2400 " 0,0% " // 3 = 4800 " 0,0% " // 4 = 9600 " 0,2% " // 5 = 14400 " 0,0% " // 6 = 19200 " 0,2% " // 7 = 28800 " 0,6% " // 8 = 38400 " 0,2% " // 9 = 57600 " 0,8% " !! Nibo2 Senden geht, Empfangen nicht // 10 = 76800 " 0,2% " // 11 = 250000 " 0,0% " // // Die Baudratentabelle enthält die die berechneten UBBR-Werte // von WormFood's AVR Baud Rate Calculator für F_CPU 16Mhz // und mit U2X enabled, für bessere Genauigkeit bei höheren Baudraten // // ANWENDUNGSBEISPIELE // // // UART 0 = 9600,8,n,1 // uart0_init(0x4801); // // UART 1 = 19200,8,e,1 // uart1_init(0x6821); // // // Vordefinierter String für Testausgabe, ob die eingestellten // Schnittstellenparameter am Terminalprogramm stimmen // extern const char uart_info_str[] PROGMEM; // // ////////////////////////////////////////////////////////////////////////// // // Akt. UART Parameter als Text in String schreiben: "19200,8,n,1\n\0" // char* uart0_info(char* str); char* uart1_info(char* str); // // -> str = Adresse Stringbuffer ( ! str[>=13] ) // <- char* = hinter den String ( *str == 0) // ////////////////////////////////////////////////////////////////////////// // // UART Modus setzen // 0 = Standard: Senden und Empfangen über FIFO // 1 = TxD Jobliste: Die UDRE ISR holt sich selber das zu sendende Byte // aus einem Buffer, oder PGM String // 2 = TxD Grafikbuffer 128x64 in Semigrafik ausgeben // 8 = TxD Echo von RxD // // // void uart0_set_mode(uint8_t mode); void uart1_set_mode(uint8_t mode); // ////////////////////////////////////////////////////////////////////////// // // Error Flags lesen und rücksetzen / quittiern // uint8_t uart0_error(); uint8_t uart1_error(); // // <- Errorflags: // #define UART_RXBUFF_OR 0x80 // Empfangsbuffer Overrun #define UART_TXBUFF_OR 0x40 // Sendebuffer Overrun #define UART_RX_NOCHAR 0x20 // Leseversuch auf leeren Buffer #define UART_FRAME_ERR (1<<FE) // 0x10 USART Frame Error #define UART_DATA_OR (1<<DOR) // 0x08 USART Data Overrun #define UART_PARITYERR (1<<UPE) // 0x04 USART Parity Error // ////////////////////////////////////////////////////////////////////////// // // Empfangsbuffer auf empfangene Zeichen abfragen // uint8_t uart0_rxd_avail(); uint8_t uart1_rxd_avail(); // // <- Anzahl der empfangenen Zeichen im Buffer // ////////////////////////////////////////////////////////////////////////// // // Zeichen einzeln aus dem Empfangsbuffer (RXD FIFO) lesen // char uart0_rxd_char(); char uart1_rxd_char(); // // <- das Älteste noch nicht gelesene Zeichen // ////////////////////////////////////////////////////////////////////////// // // Anzahl freie Zeichen im Sendebuffer (RXD FIFO) ermitteln // uint8_t uart0_txd_avail(); uint8_t uart1_txd_avail(); // // <- Anzahl der Zeichen, die noch in den Sendebuffer passen // ////////////////////////////////////////////////////////////////////////// // // Zeichen einzeln in den Sendebuffer (TXD FIFO) schreiben // uint8_t uart0_txd_char(char ch); uint8_t uart1_txd_char(char ch); // // -> ch = zu sendendes Zeichen // <- == 0 = Zeichen wurde in Buffer geschrieben // != 0 = Fehlercode Bufferüberlauf // ////////////////////////////////////////////////////////////////////////// // // Zeichenkette aus RAM oder FLASH in den Sende-FIFO schreiben // // mit dem Aufruf "uartx_txd_str(stringadresse);" // wird zunächst nur die Stringadresse an die Funktion übergeben, // // die Ausgabe selber zum UART FIFO erfolgt erst // mit dem Aufruf "uartx_txd_str(0);" // // Die Stringausgabe ist blockierend möglich.. // // if(uartx_txd_str(text_ptr) == text_ptr) { // while(uartx_txd_str(0) != 0) { ; } // Senden und Warten // state = UART_SENDEN_FERTIG; // } else { // state = UART_IST_BUSY; // } // // ..oder für Kooperatives Multitasking empfohlen.. // // ..Zyklischer Aufruf (z.Bsp. Timer ISR oder Mainloop).. // uart_state = uart_txd_str(0); // // ..und irgendwo in der Programmschleife dann.. // if(uart_state == 0) { // uartx_txd_str(text_ptr); // state = SENDEN // } // char* uart0_txd_str(char * str); char* uart1_txd_str(char * str); PGM_P uart0_txd_strP(PGM_P str); PGM_P uart1_txd_strP(PGM_P str); // // -> str = Adresse der zu sendenden Zeichenkette // oder 0, um Stringausgabe fortzusetzen // // <- == str = neue Zeichenkette wird ausgegeben // == 0 = wenn str = 0, dann Ausgabe fertig // != str = Zeichenkette wurde nicht übernommen (BUSY) // ////////////////////////////////////////////////////////////////////////// // // Zeichenkette mit formatierten Werten in den Sendebuffer schreiben // // Nur für Debugging gedacht // // BLOCKIEREND und LANGSAM: // - Funktion wartet bis Buffer leer ist. // - vsprintf() verwendet den FIFO direkt als Ausgabebuffer. // // Formatzeichen: // %d %i Decimal signed integer. // %o Octal integer. // %x %X Hex integer. // %u Unsigned integer. // %c Character. // %s String // %f double // %e %E double // %g %G double // %p Zeiger // %n Number of characters written by this printf. // %% %. No argument expected. // // Flags (müssen direkt nach dem '%' stehen: // // - linksbündig. // 0 Felder mit 0 ausfüllen (an Stelle von Leerzeichen). // + Vorzeichen einer Zahl immer ausgeben. // blank positive Zahlen mit Leerzeichen beginnen. // // %10i Integer mit 10 Stellen ausgeben Leerzeichen vorweg // %010i Integer mit 10 Stellen ausgeben Nullen vorweg // // # verschiedene Bedeutung: // // %#o (Oktal) 0 Präfix wird eingefügt. // %#x %#X (Hex) 0x Präfix wird bei Werten ungl. Null eingefügt. // %#e %#E Dezimalpunkt immer anzeigen. // %#f Dezimalpunkt immer anzeigen. // %#g %#G Dezimalpunkt immer anzeigen. Nullen nach dem // Dezimalpunkt werden nicht beseitigt. // //int16_t uart0_txd_strF(const char* str, ...); // // -> String mit Formatierungszeichen (stringf) // <- Länge des erzeugten Strings // // // ======================================= Gültigkeitsprüfung Buffergrößen // #if (UART0_RXDLEN > 128) #error bt_lib_uart.c = USART0 RXD BUFFER LEN maximal 128 erlaubt #endif #define UART0_RXMASK (UART0_RXDLEN -1) #if (UART0_RXDLEN & UART0_RXMASK) #error bt_lib_uart.c = USART0 RXD BUFFER LEN ist keine 2er Potenz #endif #if (UART0_TXDLEN > 128) #error bt_lib_uart.c = USART0 TXD BUFFER LEN maximal 128 erlaubt #endif #define UART0_TXMASK (UART0_TXDLEN -1) #if (UART0_TXDLEN & UART0_TXMASK) #error bt_lib_uart.c = USART0 TXD BUFFER LEN ist keine 2er Potenz #endif // #if (UART1_RXDLEN > 128) #error bt_lib_uart.c = USART1 RXD BUFFER LEN maximal 128 erlaubt #endif #define UART1_RXMASK (UART1_RXDLEN -1) #if (UART1_RXDLEN & UART1_RXMASK) #error bt_lib_uart.c = USART1 RXD BUFFER LEN ist keine 2er Potenz #endif #if (UART1_TXDLEN > 128) #error bt_lib_uart.c = USART1 TXD BUFFER LEN maximal 128 erlaubt #endif #define UART1_TXMASK (UART1_TXDLEN -1) #if (UART1_TXDLEN & UART1_TXMASK) #error bt_lib_uart.c = USART1 TXD BUFFER LEN ist keine 2er Potenz #endif #endif //_BTLIB__H_
Compiler results:
Werbung
Online
mattielangston028888
warrenhinder6456