| 0,0 → 1,765 |
|---|
| /***************************************************************************** |
| * Copyright (C) 2013 Oliver Gemesi * |
| * * |
| * This program is free software; you can redistribute it and/or modify * |
| * it under the terms of the GNU General Public License as published by * |
| * the Free Software Foundation; either version 2 of the License. * |
| * * |
| * This program is distributed in the hope that it will be useful, * |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
| * GNU General Public License for more details. * |
| * * |
| * You should have received a copy of the GNU General Public License * |
| * along with this program; if not, write to the * |
| * Free Software Foundation, Inc., * |
| * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * |
| *****************************************************************************/ |
| |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //+ xutils.c - erweiterte String-Funktionen, xprintf (Info nach History) |
| //+ und weitere Hilfsfunktionen wie z.B. UTCdatetime2local() |
| //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| //############################################################################ |
| //# HISTORY xutils.c |
| //# |
| //# 12.04.2014 OG |
| //# - chg: strncpyat(), strncpyat_P(), _strncpyat() erweitert um Parameter 'sepcharcount' |
| //# |
| //# 08.04.2014 OG |
| //# - add: strncpyat(), strncpyat_P(), _strncpyat() |
| //# |
| //# 28.02.2014 OG |
| //# - add: buffered_sprintf(), buffered_sprintf_P() |
| //# - add: buffer sprintf_buffer[] |
| //# - chg: PGMBUFF_SIZE und ARGBUFF_SIZE von 80 auf 40 geaendert |
| //# |
| //# 24.06.2013 OG |
| //# - add: strrtrim() entfernt Leerzeichen auf der rechten Seite |
| //# |
| //# 14.05.2013 OG |
| //# - chg: Kommentarkopf von UTCdatetime2local() aktualisiert |
| //# |
| //# 05.05.2013 OG |
| //# - chg: UTCdatetime2local() auf Config.timezone/summertime umgestellt |
| //# - add: include eeprom.h |
| //# |
| //# 04.05.2013 OG |
| //# - chg: umbenannt zu xutils.c |
| //# |
| //# 03.05.2013 OG |
| //# - add: UTCdatetime2local() |
| //# - fix: _xvsnprintf() Darstellung kleiner negativer Nachkommazahlen (-1<z<0) |
| //# |
| //# 29.04.2013 OG |
| //# - chg: Doku zu xprintf Ergaenzt bei 'bekannte Einschraenkungen' |
| //# - chg: includes reduziert auf das Notwendige |
| //# |
| //# 28.04.2013 OG - NEU |
| //############################################################################ |
| |
| |
| //############################################################################ |
| //# xprintf |
| //# |
| //# Diese Variante von printf ist angepasst auf das PKT: |
| //# |
| //# - Unterstuetzung von Festkomma-Integer Anzeige |
| //# - Overflow-Anzeige durch '*' wenn eine Zahl die Format-Maske sprengt |
| //# - progmen wird optional unterstuetz fuer den format-String als auch fuer |
| //# String Argumente |
| //# - strikte Einhaltung von Laengen einer Format-Maske |
| //# (ggf. wird die Ausgabe gekuerzt) |
| //# |
| //# In diesem Source sind nur die Basis-xprintf zum Erzeugen von formatierten |
| //# Strings. Die direkten Ausgabefunktionen auf den Screen sind in lcd.c |
| //# als lcdx_printf_at() und lcdx_printf_at_P(). |
| //# |
| //# FORMAT ANGABEN: |
| //# |
| //# %d: dezimal int signed (Rechtsbuendige Ausgabe) (Wandlung via itoa) |
| //# "%d" arg: 1234 -> "1234" |
| //# "%5d" arg: 1234 -> " 1234" |
| //# "%5.2d" arg: 1234 -> " 12.34" |
| //# "%05d" arg: 123 -> "00123" |
| //# "%3.2d" arg: -13 -> " -0.13" |
| //# |
| //# %u: dezimal int unsigned (Rechtsbuendige Ausgabe) (Wandlung via utoa) |
| //# wie %d jedoch mittels utoa |
| //# |
| //# %h: hex int unsigned -> Hex-Zahl Rechtsbuendig, Laenge wird unterstuetzt z.B. "%4h" |
| //# %o: octal int unsigned -> Octal-Zahl Rechtsbuendig, Laenge wird unterstuetzt z.B. "%2o" |
| //# %b: binary int unsigned -> Binaer-Zahl Rechtsbuendig, Laenge wird unterstuetzt z.B. "%8b" |
| //# |
| //# %ld, %lu, %lh, %lo, %lb: |
| //# wie die obigen jedoch fuer long-zahlen (via ltoa, ultoa) |
| //# nur wenn define USE_XPRINTF_LONG gesetzt ist! |
| //# Bespiele: "%ld", "%5.6ld" usw. |
| //# |
| //# %s: String aus RAM -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s") |
| //# %S: String aus progmem -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s") |
| //# |
| //# %c: einzelnes char -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s") |
| //# %%: Ausgabe von "%" |
| //# |
| //# |
| //# BEISPIELE: |
| //# |
| //# vorhanden in: osd/osdata.c, lcd/lcd.c |
| //# |
| //# |
| //# BEKANNTE EINSCHRAENKUNGEN: |
| //# |
| //# 1. padding '0' mit negativen Zahlen wenn padding aktiv ist ergibt z.B. "00-1.5" |
| //# 2. der Entwickler muss auf eine korrekte Format-Maske achten. Andernfalls |
| //# kommt es zu nicht vorhersehbaren Ausgaben. |
| //# 3. nicht in ISR's verwenden - dazu muss ggf. eine Anpassung durchgefuert werden |
| //# |
| //# KOMPILIER OPTIONEN |
| //# |
| //# define: USE_XPRINTF_LONG |
| //# Unterstuetzung von long int / unsigned long int ('l' Modifier in Maske) |
| // Wird in der main.h gesetzt |
| //############################################################################ |
| |
| #define USE_XPRINTF_LONG // Unterstuetzung von long integer - Achtung! Muss fuer PKT gesetzt sein |
| // da in Sourcen verwendet! |
| |
| |
| #include <avr/pgmspace.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| |
| #include "../main.h" |
| #include "../timer/timer.h" |
| #include "../eeprom/eeprom.h" |
| |
| |
| #define PGMBUFF_SIZE 40 // max. 40 chars bei format-String aus progmem |
| #define ARGBUFF_SIZE 40 // buffer fuer xprintf Parameter (strings, itoa, utoa) (fuer ltoa ggf. anpassen) |
| |
| |
| #define SPRINTF_BUFFER_SIZE 40 // max. 40 Chars fuer den Buffer fuer xsnprintf(), xsnprintf_P() |
| char sprintf_buffer[SPRINTF_BUFFER_SIZE]; |
| |
| |
| //---------------------- |
| // xprintf parser data |
| //---------------------- |
| typedef struct |
| { |
| uint8_t parse; // true / false |
| char cmd; // char: d u h o b s S c % |
| uint8_t prelen; // Vorkomma |
| uint8_t declen; // decimal (Nachkomma) |
| uint8_t point; // true / false |
| uint8_t uselong; // true / false |
| uint8_t mask; // true / false |
| char pad; // ' ' oder '0' |
| } xprintf_t; |
| |
| |
| //---------------------- |
| // Buffers |
| //---------------------- |
| char cmddigit[7]; |
| char argbuff[ARGBUFF_SIZE]; |
| char pgmbuff[PGMBUFF_SIZE]; |
| |
| |
| //#################################################################################### |
| |
| |
| //--------------------------------------------------------------------- |
| // Basisfunktion von xprintf |
| // Doku: siehe oben |
| //--------------------------------------------------------------------- |
| void _xvsnprintf( uint8_t useprogmem, char *buffer, uint8_t n, const char *format, va_list ap ) |
| { |
| const char *p_fmt; // pointer auf den format-String |
| char *p_dst; // pointer auf den destination buffer |
| const char *p_str; // pointer auf einen arg-String wenn ein String ausgegeben werden soll |
| char *p_cmddigit = 0; // pointer auf den Digit-Buffer fuer eine Maske (Laenge/Nachkommastellen) |
| const char *p_fmtbuff; // pointer auf den format-Buffer (fuer progmem) |
| const char *p_argbuff; // pointer auf den argbuffer |
| uint8_t fmtlen, arglen, overflow; |
| uint8_t i,j,dec; |
| uint8_t dstcnt; |
| uint8_t minus; |
| xprintf_t cmd; // parser Daten |
| |
| p_fmtbuff = format; |
| |
| if( useprogmem ) // format von progmem in's RAM kopieren |
| { |
| strncpy_P( pgmbuff, format, PGMBUFF_SIZE); |
| pgmbuff[PGMBUFF_SIZE-1] = 0; |
| p_fmtbuff = pgmbuff; |
| } |
| |
| cmd.parse = false; |
| p_fmt = p_fmtbuff-1; // -1 -> wird am Anfang der Schleife korrigiert |
| p_dst = buffer; |
| dstcnt = 0; |
| |
| do |
| { |
| if( dstcnt >= n ) // max. Anzahl von Zeichen fuer Ziel 'buffer' erreicht? |
| break; |
| |
| p_fmt++; // naechstes Zeichen von format |
| |
| //######################## |
| //# 1. PARSE |
| //######################## |
| |
| //------------------------ |
| // START: parse cmd |
| //------------------------ |
| if( cmd.parse == false && *p_fmt == '%' ) |
| { |
| memset( &cmd, 0, sizeof(xprintf_t) ); // init |
| cmd.parse = true; |
| cmd.pad = ' '; |
| p_cmddigit = cmddigit; |
| continue; |
| } |
| |
| //------------------------ |
| // NO parse: copy char |
| //------------------------ |
| if( cmd.parse == false ) |
| { |
| *p_dst = *p_fmt; |
| p_dst++; |
| dstcnt++; |
| continue; |
| } |
| |
| //------------------------ |
| // set: pad (eine '0' ganz am Anfang der Formatmaske) |
| //------------------------ |
| if( cmd.parse == true && *p_fmt == '0' && p_cmddigit == cmddigit ) |
| { |
| cmd.pad = '0'; |
| continue; |
| } |
| |
| //------------------------ |
| // set: vor/nach-kommastellen |
| //------------------------ |
| if( cmd.parse == true && *p_fmt >= '0' && *p_fmt <= '9' ) |
| { |
| *p_cmddigit = *p_fmt; |
| p_cmddigit++; |
| continue; |
| } |
| |
| //------------------------ |
| // set: point |
| //------------------------ |
| if( cmd.parse == true && *p_fmt == '.' && cmd.point == false ) |
| { |
| cmd.point = true; |
| *p_cmddigit = 0; |
| cmd.prelen = atoi( cmddigit ); |
| p_cmddigit = cmddigit; |
| continue; |
| } |
| |
| //------------------------ |
| // set: uselong |
| //------------------------ |
| #ifdef USE_XPRINTF_LONG |
| if( cmd.parse == true && *p_fmt == 'l' ) |
| { |
| cmd.uselong = true; |
| continue; |
| } |
| #endif |
| |
| //------------------------ |
| // END: parse cmd |
| //------------------------ |
| if( cmd.parse == true && (*p_fmt == 'd' || *p_fmt == 'u' || *p_fmt == 'x' || *p_fmt == 'b' || *p_fmt == 'o' || |
| *p_fmt == 's' || *p_fmt == 'S' || *p_fmt == 'c' || *p_fmt == '%') ) |
| { |
| cmd.cmd = *p_fmt; |
| cmd.parse = false; |
| |
| *p_cmddigit = 0; |
| if( cmd.point == false ) cmd.prelen = atoi(cmddigit); |
| else cmd.declen = atoi(cmddigit); |
| |
| if( cmd.point || cmd.prelen>0 ) |
| cmd.mask = true; |
| } |
| |
| |
| //######################## |
| //# 2. EXECUTE |
| //######################## |
| |
| //------------------------ |
| // exec cmd: "d,u,x,b,o" |
| //------------------------ |
| if( cmd.cmd == 'd' || cmd.cmd == 'u' || cmd.cmd == 'x' || cmd.cmd == 'b' || cmd.cmd == 'o' ) |
| { |
| if( cmd.uselong ) |
| { |
| #ifdef USE_XPRINTF_LONG |
| switch(cmd.cmd) |
| { |
| case 'd': ltoa ( va_arg(ap, long) , argbuff, 10); break; // LONG dezimal int signed |
| case 'u': ultoa( va_arg(ap, unsigned long), argbuff, 10); break; // LONG dezimal int unsigned |
| case 'x': ultoa( va_arg(ap, unsigned long), argbuff, 16); break; // LONG hex int unsigned |
| case 'b': ultoa( va_arg(ap, unsigned long), argbuff, 2); break; // LONG binary int unsigned |
| case 'o': ultoa( va_arg(ap, unsigned long), argbuff, 8); break; // LONG octal int unsigned |
| } |
| #endif |
| } |
| else |
| { |
| switch(cmd.cmd) |
| { |
| case 'd': itoa( va_arg(ap, int) , argbuff, 10); break; // dezimal int signed |
| case 'u': utoa( va_arg(ap, unsigned int), argbuff, 10); break; // dezimal int unsigned |
| case 'x': utoa( va_arg(ap, unsigned int), argbuff, 16); break; // hex int unsigned |
| case 'b': utoa( va_arg(ap, unsigned int), argbuff, 2); break; // binary int unsigned |
| case 'o': utoa( va_arg(ap, unsigned int), argbuff, 8); break; // octal int unsigned |
| } |
| } |
| |
| minus = (argbuff[0] == '-'); |
| arglen = strlen(argbuff); |
| |
| fmtlen = cmd.prelen + cmd.declen + (cmd.point ? 1 : 0); |
| arglen = strlen(argbuff); |
| |
| overflow = cmd.mask && // Zahl zu gross -> "*" anzeigen statt der Zahl |
| (arglen > cmd.prelen + cmd.declen || cmd.prelen < 1+minus); |
| |
| if( overflow ) // overflow: Zahl passt nicht in Maske |
| { // -> zeige '*.*' |
| for( i=0; (i < fmtlen) && (dstcnt < n); i++) |
| { |
| if( cmd.point && i==cmd.prelen ) *p_dst = '.'; |
| else *p_dst = '*'; |
| p_dst++; |
| dstcnt++; |
| } |
| } |
| else // else: if( overflow ) |
| { |
| if( !cmd.mask ) // keine Maske: alles von der Zahl ausgeben |
| fmtlen = arglen; |
| |
| p_argbuff = argbuff; |
| if( minus ) // wenn Zahl negativ: merken und auf dem argbuff nehmen |
| { |
| p_argbuff++; |
| arglen--; |
| } |
| |
| //----------------- |
| // die Zahl wird 'Rueckwaerts' uebertragen |
| //----------------- |
| dec = -1; // wird am Anfang der Schleife auf 0 gesetzt |
| j = 1; // zaehler fuer argbuff |
| for( i=1; i<=fmtlen; i++ ) |
| { |
| dec++; // Zaehler Dizmalstellen |
| |
| if( dstcnt+fmtlen-i <= n ) // wenn Zielbuffer nicht ueberschritten |
| { |
| if( cmd.point && (dec == cmd.declen) ) // Dezimalpunkt setzen |
| { |
| p_dst[fmtlen-i] = '.'; |
| continue; |
| } |
| |
| if( j <= arglen ) // Ziffer uebertragen aus argbuff |
| { |
| p_dst[fmtlen-i] = p_argbuff[arglen-j]; |
| j++; |
| continue; |
| } |
| |
| if( cmd.declen > 0 && // Nachkomma und 1. Vorkommastelle ggf. auf '0' |
| (dec < cmd.declen || dec == cmd.declen+1) ) // setzen wenn die Zahl zu klein ist |
| { |
| p_dst[fmtlen-i] = '0'; |
| continue; |
| } |
| |
| if( minus && ( (cmd.pad == ' ') || // ggf. Minuszeichen setzen |
| (cmd.pad != ' ' && i == fmtlen) ) ) // Minuszeichen bei '0'-padding an erster Stelle setzen |
| { |
| minus = false; |
| p_dst[fmtlen-i] = '-'; |
| continue; |
| } |
| |
| p_dst[fmtlen-i] = cmd.pad; // padding ' ' oder '0' |
| } // end: if( dstcnt+fmtlen-i <= n ) |
| } |
| p_dst += fmtlen; |
| dstcnt += fmtlen; |
| } |
| continue; |
| } |
| |
| //------------------------ |
| // exec cmd: "s", "S", "c" |
| //------------------------ |
| if( cmd.cmd == 's' || cmd.cmd == 'S' || cmd.cmd == 'c' ) |
| { |
| switch(cmd.cmd) |
| { |
| case 's': p_str = va_arg( ap, char *); // String aus dem RAM |
| break; |
| |
| case 'S': strncpy_P( argbuff, va_arg( ap, char *), ARGBUFF_SIZE); // String liegt im progmem -> in's RAM kopieren |
| argbuff[ARGBUFF_SIZE-1] = 0; |
| p_str = argbuff; |
| break; |
| |
| case 'c': argbuff[0] = va_arg( ap, int); // einzelnes char |
| argbuff[1] = 0; |
| p_str = argbuff; |
| break; |
| } |
| |
| fmtlen = cmd.prelen; |
| arglen = strlen(p_str); |
| |
| if( !cmd.mask ) // keine Maske: alles vom String ausgeben |
| fmtlen = arglen; |
| |
| for( i=0; i<fmtlen; i++) |
| { |
| if( dstcnt < n ) // wenn Zielbuffer nicht ueberschritten |
| { |
| if( *p_str ) // char uebertragen |
| { |
| *p_dst = *p_str; |
| p_str++; |
| } |
| else // padding |
| { |
| *p_dst = ' '; |
| } |
| p_dst++; |
| } |
| dstcnt++; |
| } |
| |
| continue; |
| } |
| |
| //------------------------ |
| // exec cmd: "%" |
| //------------------------ |
| if( cmd.cmd == '%' ) |
| { |
| *p_dst = '%'; |
| p_dst++; |
| dstcnt++; |
| continue; |
| } |
| |
| } while( (dstcnt < n) && *p_fmt ); |
| |
| *(p_dst + (dstcnt < n ? 0 : -1)) = 0; // terminierende 0 im Ausgabebuffer setzen |
| } |
| |
| |
| |
| //--------------------------------------------------------------------- |
| //--------------------------------------------------------------------- |
| void xsnprintf( char *buffer, uint8_t n, const char *format, ... ) |
| { |
| va_list ap; |
| |
| va_start(ap, format); |
| _xvsnprintf( false, buffer, n, format, ap); |
| va_end(ap); |
| } |
| |
| |
| //--------------------------------------------------------------------- |
| //--------------------------------------------------------------------- |
| void xsnprintf_P( char *buffer, uint8_t n, const char *format, ... ) |
| { |
| va_list ap; |
| |
| va_start(ap, format); |
| _xvsnprintf( true, buffer, n, format, ap); |
| va_end(ap); |
| } |
| |
| |
| |
| //----------------------------------------------------------- |
| // buffered_sprintf_P( format, ...) |
| // |
| // Ausgabe direkt in einen internen Buffer. |
| // Der Pointer auf den RAM-Buffer wird zurueckgegeben. |
| // Abgesichert bzgl. Buffer-Overflow. |
| // |
| // Groesse des Buffers: PRINTF_BUFFER_SIZE |
| // |
| // Parameter: |
| // format : String aus PROGMEM (siehe: xprintf in utils/xstring.h) |
| // ... : Parameter fuer 'format' |
| //----------------------------------------------------------- |
| char * buffered_sprintf( const char *format, ... ) |
| { |
| va_list ap; |
| |
| va_start( ap, format ); |
| _xvsnprintf( false, sprintf_buffer, SPRINTF_BUFFER_SIZE, format, ap ); |
| va_end(ap); |
| return sprintf_buffer; |
| } |
| |
| |
| |
| //----------------------------------------------------------- |
| // buffered_sprintf_P( format, ...) |
| // |
| // Ausgabe direkt in einen internen Buffer. |
| // Der Pointer auf den RAM-Buffer wird zurueckgegeben. |
| // Abgesichert bzgl. Buffer-Overflow. |
| // |
| // Groesse des Buffers: PRINTF_BUFFER_SIZE |
| // |
| // Parameter: |
| // format : String aus PROGMEM (siehe: xprintf in utils/xstring.h) |
| // ... : Parameter fuer 'format' |
| //----------------------------------------------------------- |
| char * buffered_sprintf_P( const char *format, ... ) |
| { |
| va_list ap; |
| |
| va_start( ap, format ); |
| _xvsnprintf( true, sprintf_buffer, SPRINTF_BUFFER_SIZE, format, ap ); |
| va_end(ap); |
| return sprintf_buffer; |
| } |
| |
| |
| |
| //-------------------------------------------------------------- |
| // kopiert einen String von src auf dst mit fester Laenge und |
| // ggf. Space paddings rechts |
| // |
| // - fuellt ggf. den dst-String auf size Laenge mit Spaces |
| // - setzt Terminierung's 0 bei dst auf Position size |
| //-------------------------------------------------------------- |
| void strncpyfill( char *dst, const char *src, size_t size) |
| { |
| uint8_t i; |
| uint8_t pad = false; |
| |
| for( i=0; i<size; i++) |
| { |
| if(*src == 0) pad = true; |
| |
| if( pad ) *dst = ' '; |
| else *dst = *src; |
| |
| src++; |
| dst++; |
| } |
| dst--; |
| *dst = 0; |
| } |
| |
| |
| |
| //-------------------------------------------------------------- |
| // entfernt rechte Leerzeichen aus einem String |
| //-------------------------------------------------------------- |
| void strrtrim( char *dst) |
| { |
| char *p; |
| |
| p = dst + strlen(dst) - 1; |
| |
| while( (p != dst) && (*p == ' ') ) p--; |
| |
| if( (*p != ' ') && (*p != 0) ) p++; |
| *p = 0; |
| } |
| |
| |
| |
| //-------------------------------------------------------------- |
| // INTERN - fuer strncpyat(), strncpyat_P() |
| //-------------------------------------------------------------- |
| void _strncpyat( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount, uint8_t progmem) |
| { |
| uint8_t i; |
| |
| if( progmem ) |
| strncpy_P( dst, src, size); |
| else |
| strncpy( dst, src, size); |
| |
| for( i=0; i<size; i++) |
| { |
| if( *dst == 0) return; |
| if( *dst == sepchar) |
| { |
| sepcharcount--; |
| if( sepcharcount==0 ) |
| { |
| *dst = 0; |
| return; |
| } |
| } |
| dst++; |
| } |
| dst--; |
| *dst = 0; |
| } |
| |
| |
| //-------------------------------------------------------------- |
| // strncpyat( dst, src, size, sepchar) |
| // |
| // kopiert einen String von 'src 'auf 'dst' mit max. Laenge 'size' |
| // oder bis 'sepchar' gefunden wird. |
| // |
| // src in PROGMEM |
| //-------------------------------------------------------------- |
| void strncpyat( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount) |
| { |
| _strncpyat( dst, src, size, sepchar, sepcharcount, false); |
| } |
| |
| |
| //-------------------------------------------------------------- |
| // strncpyat_P( dst, src, size, sepchar) |
| // |
| // kopiert einen String von 'src 'auf 'dst' mit max. Laenge 'size' |
| // oder bis 'sepchar' gefunden wird. |
| // |
| // src in RAM |
| //-------------------------------------------------------------- |
| void strncpyat_P( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount) |
| { |
| _strncpyat( dst, src, size, sepchar, sepcharcount, true); |
| } |
| |
| |
| |
| //-------------------------------------------------------------- |
| // UTCdatetime2local( PKTdatetime_t *dtbuffer, PKTdatetime_t dt ) |
| // |
| // konvertiert die UTC-Time 'dt' in die lokale Zeit und speichert |
| // dieses in 'dtbuffer' ab. |
| // |
| // Parameter: |
| // |
| // dtdst: Pointer Destination (PKTdatetime_t) (Speicher muss alloziiert sein!) |
| // dtsrc: Pointer Source (PKTdatetime_t) |
| // |
| // Hinweise: |
| // |
| // Schaltjahre (bzw. der 29.02.) werden nicht unterstuetzt |
| //-------------------------------------------------------------- |
| void UTCdatetime2local( PKTdatetime_t *dtdst, PKTdatetime_t *dtsrc ) |
| { |
| int8_t timeoffset; |
| int32_t v; |
| int8_t diff; |
| // 01 02 03 04 05 06 07 08 09 10 11 12 Monat |
| int8_t daymonth[] = {31,28,31,30,31,30,31,31,30,31,30,31}; |
| |
| //-------------------------- |
| // timezone: Einstellbereich -12 .. 0 .. 12 (+1 = Berlin) |
| // summertime: Einstellung: 0 oder 1 (0=Winterzeit, 1=Sommerzeit) |
| //-------------------------- |
| timeoffset = Config.timezone + Config.summertime; |
| //timeoffset = 2; // solange noch nicht in PKT-Config: Berlin, Sommerzeit |
| |
| |
| memcpy( dtdst, dtsrc, sizeof(PKTdatetime_t) ); // copy datetime to destination |
| |
| //-------------------------- |
| // Zeitzonenanpassung |
| //-------------------------- |
| if( dtdst->year != 0 && dtdst->month >= 1 && dtdst->month <= 12 ) // nur wenn gueltiges Datum vorhanden |
| { |
| //-------------------------- |
| // 1. Sekunden |
| //-------------------------- |
| v = (int32_t)dtdst->seconds; |
| v += timeoffset*3600; // Stunden korrigieren |
| diff = 0; |
| |
| if( v > 86400 ) // Tagesueberschreitung? (86400 = 24*60*60 bzw. 24 Stunden) |
| { |
| v -= 86400; |
| diff++; // inc: Tag |
| } |
| else if( v < 0 ) // Tagesunterschreitung? |
| { |
| v += 86400; |
| diff--; // dec: Tag |
| } |
| dtdst->seconds = (uint32_t)v; // SET: seconds |
| |
| //-------------------------- |
| // 2. Tag |
| //-------------------------- |
| v = (int32_t)dtdst->day; |
| v += diff; |
| diff = 0; |
| |
| if( v > daymonth[dtdst->month-1] ) // Monatsueberschreitung? |
| { |
| v = 1; // erster Tag des Monats |
| diff++; // inc: Monat |
| } |
| else if( v < 1 ) // Monatsunterschreitung? |
| { |
| if( dtdst->month > 1 ) |
| v = daymonth[dtdst->month-1-1]; // letzter Tag des vorherigen Monats |
| else |
| v = 31; // letzter Tag im Dezember des vorherigen Jahres |
| diff--; // dec: Monat |
| } |
| dtdst->day = (uint8_t)v; // SET: day |
| |
| //-------------------------- |
| // 3. Monat |
| //-------------------------- |
| v = (int32_t)dtdst->month; |
| v += diff; |
| diff = 0; |
| |
| if( v > 12 ) // Jahresueberschreitung? |
| { |
| v = 1; |
| diff++; // inc: Jahr |
| } |
| else if( v < 1 ) // Jahresunterschreitung? |
| { |
| v = 12; |
| diff--; // dec: Jahr |
| } |
| dtdst->month = (uint8_t)v; // SET: month |
| |
| //-------------------------- |
| // 4. Jahr |
| //-------------------------- |
| dtdst->year += diff; // SET: year |
| } |
| } |
| Property changes: |
|---|
| Added: svn:mime-type |
|---|
| +text/plain |
|---|
| \ No newline at end of property |
|---|