Projekte
BirgerT
nibo2_fork#01
bt_lib_debugutil.c
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_debugutil.c [read only]
////////////////////////////////////////////////////////////////////////// // // BT LIB DEBUGUTIL == AVR MCU UART Terminal Debugger // // (c) Birger Töpelmann toepelmann(A)web.de Version 141008a // // Zum Testen der Funktionen, Programme, Speicherinhalte und Timings // von AT-Mega MCU im Zielsystem über die serielle Schnittstelle und // mit einem (VT100/ANSI) Terminalprogramm auf dem PC. // // // In DEBUG() wird zunächst gewartet, bis 2x Leerzeichen empfangen // wurden, // ////////////////////////////////////////////////////////////////////////// // // BSD License see "BSD_license.h" // #include "BSD_license.h" // // // #include "nibo2_global.h" // //#include "bt_lib_utils.h" // Sammlung von Makros und Typedefs //#include "bt_lib_uart.h" // UART Kommunikation mit FIFOs //#include "bt_lib_terminal.h" // Mensch Mikrocontroller Kommunikation #include "bt_lib_debugutil.h" // Memory Dump, Laufzeitmessung // //////////////////////////////////////////////////////////////////////////// // // DEBUG AUSGABE mit testing_printf("Wert xyz = %d\n", wert_xyz); // // BLOCKIEREND und LANGSAM: // - Funktion wartet bis Buffer ausgegeben ist. // // 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. // // # 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. // // void testing_printf(char* str, ...); // Formatstring ausgeben // // void debug_printfintP(PGM_P str); // Fixtext ausgeben // ////////////////////////////////////////////////////////////////////////// // // e n u m {NIX,BYTES,WORDS,PGM,RAM,EEP}; // // adress_new= testing_memory_dump(BYTES, RAM, &memory, 16); // !! buffer[BUFF_SIZE]; ist buffer bereits die Adresse // adress_new= testing_memory_dump(BYTES, RAM, buffer, BUFF_SIZE); // // void* testing_memory_dump(uint8_t size, uint8_t source, void* adresse, uint8_t anzahl); // // while(testing_wait_for_terminal() == 0) { delay_ms(100); } // uint8_t testing_wait_for_terminal(); // while((zeichen = testing_wait_for_char(\n)) == 0) { delay_ms(100); } // char testing_wait_for_char(char ch); // // Laufzeitmessung in ms.. // void debug_ms_stoppuhr(uint8_t startstopp); // debug_ms_stoppuhr(START); // Stoppuhr starten // Testroutine(); // debug_ms_stoppuhr(STOPP); // Anzeige der Laufzeit // und Laufzeitmessung bis 32ms in us über Timer 3 // void debug_us_stoppuhr(uint8_t startstopp); // debug_us_stoppuhr(START); // Stoppuhr starten // Testroutine(); // debug_us_stoppuhr(STOPP); // Anzeige der Laufzeit // // ////////////////////////////////////////////////////////////////////////// // // DEBUG LOOP // ////////////////////////////////////////////////////////////////////////// // #if 0 void debug_loop(fn_Pointer_t debug_this){ char ch; if (debug_this == 0) return; if (SW3_DOWN) return; uart0_init(0x8801); // Terminal UART0 = 38400,8,n,1 // uart0_init(0x6801); // Terminal UART0 = 19200,8,n,1 debug_wait_for_char(' '); debug_wait_for_char(' '); debug_printP(PSTR("\nAVR MCU DEBUGGER gestartet..")); debug_printP(PSTR("\nVerlassen mit [x], Wiederholen mit [LEER]\n")); while(1==1){ debug_this(); do { ch = debug_wait_for_char(0); if (SW3_DOWN) ch='x'; if ( ch == 'x') { debug_printP(PSTR("\n\nDEBUGGER BEENDET..\n")); return; } else if ( ch == 't') { // testing_printP(term_scrtest); } delay_ms(10); } while (ch != ' '); } //while(1==1) } // debugloop #endif // ////////////////////////////////////////////////////////////////////////// // char debug_wait_for_char(const char ch){ while(1==1){ char temp = 0; if(uart0_rxd_avail()!=0) { // Zeichen empfangen ? temp = uart0_rxd_char(); // Zeichen abholen } if (SW3_DOWN) { return 'x'; } if ((temp == ch)||(ch == 0)) { // Vorgabe erfüllt? return temp; // Zeichen weitergeben } delay_ms(10); } // return 0; // kein Zeichen, oder Zeichen != Vorgabe } // ////////////////////////////////////////////////////////////////////////// // // Ausgabebuffer für debug_printf() // char debug_stringbuffer[80]; const char debug_prferr_1[] PROGMEM = {"\n\n\7* !! * printf Fehler\n"}; const char debug_prferr_2[] PROGMEM = {"* * B U F F E R - O V E R F L O W * * \n"}; // void debug_printf(char* str, ...){ // Zeiger auf Argumentenliste va_list parg; va_start(parg, str); // Ausgabestring im Textbuffer erzeugen int16_t result = vsprintf(debug_stringbuffer, str, parg); va_end(parg); if (result < 0) { debug_printP(debug_prferr_1); } if (result >= sizeof(debug_stringbuffer)) { debug_printP(debug_prferr_1); debug_printP(debug_prferr_2); } // Textbuffer Startadresse übergeben und.. uart0_txd_str(debug_stringbuffer); // ..warten, bis Ausgabe fertig ist while(uart0_txd_str(0) != 0) { NOP; } if (result >= sizeof(debug_stringbuffer)) { debug_printP(debug_prferr_2); } } // ////////////////////////////////////////////////////////////////////////// // void debug_prints(char* str) { // Text Startadresse übergeben und.. uart0_txd_str(str); // ..warten, bis Ausgabe fertig ist while(uart0_txd_str(0) != 0) { NOP; } } // // ////////////////////////////////////////////////////////////////////////// // void debug_printP(PGM_P str) { // Text Startadresse übergeben und.. uart0_txd_strP(str); // ..warten, bis Ausgabe fertig ist while(uart0_txd_strP(0) != 0) { NOP; } } // ////////////////////////////////////////////////////////////////////////// // void* debug_memory_dump(const uint8_t size, const uint8_t source, \ void* adresse, uint8_t anzahl){ uint8_t* byte_adresse; uint16_t* word_adresse; uint8_t start, ende, spalten, merker, byte; uint16_t word; // debug_printP(PSTR("\nmemory_dump ")); // debug_printf("%i ", anzahl); if (size == BYTES){ byte_adresse = (uint8_t*)adresse; word_adresse = 0; spalten = 16; // debug_printP(PSTR("BYTES")); } else if (size == WORDS) { byte_adresse = 0; word_adresse = (uint16_t*)adresse; spalten = 8; // debug_printP(PSTR("WORDS")); } // das war wohl nix else { debug_printP(PSTR(" size unbekannt\07\n")); return adresse; } // debug_printP(PSTR(" from ")); debug_printP(PSTR("\n")); if (source == PGM) { debug_printP(PSTR("FLASH ")); } else if (source == EEP) { debug_printP(PSTR("EEPROM ")); } else if (source == RAM) { debug_printP(PSTR("RAM ")); } else { debug_printP(PSTR(" source unbekannt\07\n")); return adresse; } // debug_printP(PSTR("..\n")); if (anzahl >0) { // debug_printP(PSTR("adress ")); if (size == BYTES) { start = LOBYTE(adresse); for (uint8_t i=0; i<16; i++) { start &= 0x0f; debug_printf("_%x ",start++); if (i==7) debug_printP(PSTR("- ")); } } debug_printP(PSTR("\n")); do { if (anzahl < spalten) { ende = anzahl; } else { ende = spalten; } anzahl -= ende; merker = ende; debug_printf("0x%04x ",adresse); if (size == BYTES) { do { if (source == PGM) { byte = pgm_read_byte(byte_adresse++); } else if (source == EEP) { byte = eeprom_read_byte(byte_adresse++); } else { byte = (uint8_t)*byte_adresse++; } debug_printf("%02x ",byte); if (ende == 9) { debug_printP(PSTR("- ")); } } while (--ende > 0); ende = merker; while (ende++ < spalten) { debug_printP(PSTR(" ")); if (ende == 8) debug_printP(PSTR("- ")); } byte_adresse = adresse; ende = merker; debug_printP(PSTR(" \'")); do { if (source == PGM) { byte = pgm_read_byte(byte_adresse++); } else if (source == EEP) { byte = eeprom_read_byte(byte_adresse++); } else { byte = (uint8_t)*byte_adresse++; } if ((byte < ' ')||(byte > 126)) { byte = '.'; } debug_printf("%c",byte); if (ende == 9) { debug_printP(PSTR("\'-\'")); } } while (--ende > 0); debug_printP(PSTR("\'\n")); adresse = byte_adresse; } else { // if (size == WORDS) { debug_printP(PSTR("= ")); do { if (source == PGM) { word = pgm_read_word(word_adresse++); } else if (source == EEP) { word = eeprom_read_word(word_adresse++); } else { word = *word_adresse++; } debug_printf("%04x ",word); } while (--ende > 0); adresse = word_adresse; debug_printP(PSTR("\n")); } } while (anzahl > 0); debug_printP(PSTR("\n")); } // if anzahl >0 return adresse; } // /////////////////////////////////////////////////////////////// STOPPUHR // uint16_t stoppuhr_messwert; char scalechar; // Merker 'u' oder 'm' für us oder ms // void debug_stoppuhr_start(const char scale){ if ((scale & 0x20) == 0) { // 'M' oder 'U' debug_printP(PSTR("\nStarte Stoppuhr..")); } scalechar = scale; // // Der TimerCounter3 TCNT3 wird im Modus 0 betrieben: // Gestartet wird der Timer über den Prescaler (CS32..CS30)!= 0 // TCNT3 zählt fortlaufend zwischen 0 und 65535 hoch. // // Gestoppt wird der Timer über den Prescaler = 0; // der Wert in TCNT3 enthält die abgelaufene Zeit F_CPU/Prescaler // // Erreicht TCNT den Wert im ICR wird die Overflow ISR aufgerufen: // // TimerCounter Register TCNT3 = 0; // Output Compare Register // OCR3A = 0; // OC3A an PE3 = LED2 Rot // OCR3B = 0; // OC3B an PE4 = LED3 Rot // OCR3C = 0; // OC3C an PE5 = LED4 Rot // Input Compare Register // ICR3 = 1000; // // Controlregister (ATmega128 Datenblatt Seite 132 ff.) // // WGM33/WGM32/WGM31/WGM30 = Waveform Generation Mode // x 0 0 0 0 = Mode 0: Normalmode // 1 0 1 0 = Mode 10: PWM,Phase Correct, // TOP steht im ICR // // COM3n1/COM3n0 = OC3n PWM Ausgangs Pin Verhalten // x 0 0 = Normales Verhalten als In- oder Output // 0 1 = Beim Compare Match wird getoggelt // 1 0 = OC3A ist 1, wird 0 bei Compare Match // 1 1 = OC3A ist 0, wird 1 bei Compare Match // // CS32/CS31/CS30 = Clock Select (Taktquelle und Vorteiler) // 0 0 0 = Timer Stopp // 0 0 1 = Zähltakt F_CPU /1 16Mhz // x 0 1 0 = Zähltakt F_CPU /8 2MHz // 0 1 1 = Zähltakt F_CPU /64 250kHz // 1 0 0 = Zähltakt F_CPU /256 62,5kHz // // keine PWM Ausgabe COM3xx = 0, Normalmode 0 WGM3x=0 // TCCR3A = (1<<WGM31) | (1<<COM3A1) | (1<<COM3B1) | (1<<COM3C1); TCCR3A = 0; // // Clear Interrupt Flagregister ETIFR &= 0x3e; // // Prescaler if ((scalechar | 0x20) == 'u') { cli(); // F_CPU (16Mhz) / 8 = Zähltakte alle 0,5 us // oder 2 Takte pro us TCCR3B = (1<<CS31); // Zeit läuft } else { // cli(); // F_CPU (16Mhz) / 256 = Zähltakte alle 32 us // oder 62,5 Takte pro ms TCCR3B = (1<<CS32); // Zeit läuft } // // Timer 3 Interrupt Masken // ETIMSK |= (1<<TOIE3); // Overflow // ETIMSK |= (1<<OCIE3A); // Compare A Match // ETIMSK |= (1<<OCIE3B); // Compare B Match // ETIMSK |= (1<<OCIE3C); // Compare C Match // ////////////////////////////////////////////////////////////////////////// // } // stoppuhr_start void debug_stoppuhr_stop(){ TCCR3B = 0; // Timer Stopp sei(); stoppuhr_messwert = TCNT3; char kommawert = '0'; if ((scalechar & 0x20) == 0) { debug_printP(PSTR("Laufzeit ")); } scalechar |= (uint8_t)0x20; if (scalechar == 'u') { if (TSTBIT(ETIFR,TOV3)) { debug_printP(PSTR(">32ms!!\n")); return; } } else { if (TSTBIT(ETIFR,TOV3)) { debug_printP(PSTR(">1048ms!!\n")); return; } // pro ms sind 62,5 Takte gezählt // " 2ms " 125 " // " 4ms " 250 " // : : // 512ms = 32000 Takte in stoppuhr_messwert // 1024ms = 64000 Takte // // 65535 Takte max. = 1048,56 ms: // 64000 + 1000 + 500 + 35 = 65535 Takte // 1024 + 16 + 8 + 0,56 = 1048,56 ms // uint16_t plus = 2048; // = 2*1024 für Nachkommastelle uint16_t minus = 64000; uint16_t rest = stoppuhr_messwert; // debug_printf(" %5u Takte = ", stoppuhr_messwert); stoppuhr_messwert = 0; do { if (rest >= minus) { stoppuhr_messwert += plus; rest -= minus; } // plus und minus jeweils halbieren.. minus >>= 1; plus >>= 1; // bis nix mehr zum Addieren da ist } while (plus > 0); // Für die Nachkommastelle ;) if (rest > 31) { stoppuhr_messwert++; } } if ((stoppuhr_messwert & 1) != 0) { kommawert = '5'; } debug_printf("%5u,%c %cs", (stoppuhr_messwert >> 1), kommawert, scalechar); } // ////////////////////////////////////////////////////////////////////////// // //EOF
Compiler results:
Werbung
Online
candidaharrell99753
leonelb389687792836
nelsonleeson85120051
Rob98
ruebenmendes25697
warrenhinder6456
wilfredocastillo