Codeschnippsel
 |
| |
Diese Seite hier wollte ich schon lange einmal machen und bin nie dazu gekommen. Hier werden in loser Reihenfolge C-Funktionen eingestellt, die in sich abgeschlossen sind oder ebenfalls Funktionen nur von hier verwenden (bspw.bei den Stringfunktionen). Das alles ohne große Erklärungen und Beschreibung, denn die sind dann in den Kommentaren zu den Funktionen schon gegeben und in aller Regel selbst erklärend an denen ich mich selbst orientiere.
Wozu dann diese Seite: Ganz einfach, es sind einfache Funktionen, nicht wirklich etwas wo man sehr lange darüber nachdenken muß, die ich in aller Regel schon häufiger in einem Programm so programmiert habe, und das immer wieder. Einfach weil ich weiß dass ich es schon einmal programmiert habe, aber nicht mehr weiß in welchem Programm das war und auch einen Ordner Codesnippets oder Snippets oder wie auch immer, die ich angelegt habe 'verschwinden' immer wieder (wahrscheinlich in einem Anflug von digitalem Aufräumwahn), nur um dann, wenn man den Code nicht mehr braucht wieder aufzutauchen.
Deswegen stelle ich das jetzt hier ein, da weiß ich wo es ist und vielleicht kopiert sich ja der ein oder andere aus diesen Code Schnippseln etwas heraus.
Diese Seite gehört zu einer "Gesamtseite" mit einem Auswahl-Frame auf der linken Seite. Sollte diese Seite ohne diesen Frame angezeigt werden, bitte hier klicken!
|
Stringfunktionen |
/* ------------------------------------------
strdelch
"String delete Char"
loescht ein Zeichen aus einer Zeichen-
kette an Position pos
Uebergabe:
str : Ursprungstring
pos : Loeschposition
(relativ zur Position 0)
------------------------------------------ */
void strdelch(char *str, int pos)
{
int l,i;
char *hptr;
l= strlen(str);
hptr= str+pos;
for (i= pos+1; i!= l+1; i++)
{
*hptr= *(hptr+1);
hptr++;
}
}
/* ------------------------------------------
strinsch
"String insert Char"
fuegt ein Zeichen in eine Zeichenkette
ein.
Uebergabe:
ptrstr => Ursprungstring
pos => Einfuegeposition,
(relativ zur Position 0)
ch => einzufuegendes Zeichen
------------------------------------------ */
void strinsch(char *ptrstr, int pos, char ch)
{
int l,i;
char *hptr;
l= strlen(ptrstr);
hptr= ptrstr+l+1;
for (i=l; i!=(pos-1); i--)
{
*hptr= *(hptr-1);
hptr--;
}
ptrstr+= pos;
*ptrstr= ch;
}
/* ------------------------------------------
strinsstr
"String insert String"
fuegt eine Zeichenkette in eine andere
Zeichenkette ein.
Uebergabe:
ptrstrs => einzufuegende Zeichen-
kette (Source)
ptrstrd => Zeichenkette in die
eingefuegt wird
pos => Einfuegeposition
(relativ zur Position 0)
------------------------------------------ */
void strinsstr(char *ptrdest, char *ptrsource, int pos)
{
int ls,lt,i;
char *hptr;
ls = strlen(ptrsource);
hptr= ptrsource;
for (i=1; i!= ls+1; i++)
{
strinsch(ptrdest,pos,*hptr);
pos++;
hptr++;
}
}
/* -------------------------------------------------------------
strdelacwn
"String delete all char with number"
loescht alle Zeichen mit der Nummer number aus dem String
Uebergabe:
str : Ursprungstring
asc : zu loeschende Zeichen
Usage:
strdelawn(&txt[0],' '); // loescht alle Leer-
// zeichen aus dem String
------------------------------------------------------------- */
void strdelacwn(char *str, char asc)
{
int spos, slen;
char s[2];
s[0]= asc; s[1]= 0;
spos= strcspn(str,s);
slen= strlen(str);
while((spos != slen) & (slen > 0))
{
strdelch(str,spos);
spos= strcspn(str,s);
slen= strlen(str);
}
}
/* --------------------------------------------------
upperch
"upper char"
konvertiert Kleinbuchstaben a..z zu Grossbuch-
staben A..Z
Entspricht der Funktion "toupper" aus
die bspw. im CH32Fun Framework nicht funktioniert
Uebergabe:
ch: zu konvertierendes Zeichen
-------------------------------------------------- */
char upperch(char ch)
{
if ((ch> 'a'-1) && (ch< 'z'+1))
{
return (ch-32);
}
else
{
return ch;
}
}
/* --------------------------------------------------
strhicase
"String high case"
konvertiert alle Kleinbuchstaben eines Strings
zu Grossbuchstaben
Uebergabe: ptrstr => Ursprungstring
-------------------------------------------------- */
void strhicase(char *ptrstr)
{
uint8_t i;
for(i = 0; ptrstr[i]; i++)
{
ptrstr[i] = upperch(ptrstr[i]);
}
}
/* ----------------------------------------------------------
strfindch
"string find char"
sucht in einem String ein Zeichen.
Liefert einen Zeiger auf das erste Vorkommen von
ch in str bzw. den Wert NULL, wenn ch in str nicht
enthalten ist.
==> Ersatz fuer strchr aus welches mit dem
CH32FUN Framework augenscheinlich nicht richtig
funktioniert (liefert keinen NULL-Zeiger)
Uebergabe: str => Zeiger auf zu durchsuchenden
String
ch => zu suchendes Zeichen
Rueckgabe: Position des gefundenen Zeichens oder
NULL-Pointer wenn nicht gefunden
---------------------------------------------------------- */
char *strfindch(const char *str, char ch)
{
while(*str)
{
if (*str == ch) { return (char *)str; }
str++;
}
if ((*str == 0) && (ch== '\0')) return (char *)str;
return NULL;
}
/* ----------------------------------------------------------
my_pow10
my power of 10
einfache Funktion 10 hoch x
---------------------------------------------------------- */
int my_pow10(unsigned int x)
{
#define my_powbase 10
int i;
int result = my_powbase;
if (x== 0)
{
return 1;
}
else
{
for (i = 1; i < x; i++)
{
result *= my_powbase;
}
return result;
}
}
/* ----------------------------------------------------------
my_atoi
my ascii to integer
einfache Konvertierung eines Strings zu einem Integer-
wert bei nicht vorhandenseins eines atoi (benoetigt
my_pow10)
Uebergabe:
*str: Zeiger, der einen im String enthaltenen
Integerzahlenwert repraesentiert
Rueckgabe:
konvertierter Integerwert
---------------------------------------------------------- */
int my_atoi(char *str)
{
int i, j;
int res;
int sign;
int len;
i = 0;
res = 0;
sign = 1; // Vorzeichenflag, 1 = positiv, -1 = negativ
len= strlen(str);
while(str[i] == ' ' || (str[i] >= 9 && str[i] <= 13))
{
i++;
}
if(str[i] == '-')
{
sign = -1;
i++;
}
else if(str[i] == '+')
{
sign = 1;
i++;
}
j = i-1; // Index auf Stringanfang
i = len;
while (str[i] < '0' || str[i] > '9') // Suche nach der letzten gueltigen Ziffer
{
i--;
}
int num_end = i;
// Konvertierung mit der niederwertigsten Stelle beginnen
while(i > j)
{
if (str[i] >= '0' && str[i] <= '9')
{
res += my_pow10(num_end-i) * (str[i] - '0');
} else
{
num_end--; // ueberspringen einer ungueltigen Ziffer
}
i--;
}
return(res * sign);
}
/* ----------------------------------------------------------
my_aftok
my ascii float to komma
Konvertiert einen String, der einen Float darstellt
(keine wissenschaftliche Darstellung) zu einen
Integerwert, indem das Komma aus dem String entfernt
wird. Die Kommaposition wird zurueckgegeben, so dass
eine Darstellung mit einem abgespeckten my_printf und
dem Platzhalter "k" (in Verbindung mit printfkomma)
erfolgen kann.
Uebergabe:
*str: Zeiger, der einen im String enthaltenen
Floatwert repraesentiert
*kommapos: Zeiger auf eine Variable, der die Komma-
position aufnimmt, die der Kommaposition
des Floats entspricht
Rueckgabe:
konvertierter Integerwert
---------------------------------------------------------- */
int my_aftok(char *str, char *kommapos)
{
char *kptr;
char temptxt[15];
char kpos, kp;
int val;
strcpy(temptxt,str);
kptr= strfindch(str, '.');
kpos= kptr-str;
if (kptr != NULL)
{
strdelch(temptxt, kpos);
kp= strlen(temptxt) - kpos;
}
else
{
kp= 0;
}
val= my_atoi(temptxt);
*kommapos= kp;
return val;
}
/* ----------------------------------------------------------
my_aftof
my ascii float to float
Konvertiert einen String, der einen Float darstellt
(keine wissenschaftliche Darstellung) zu einem float.
Uebergabe:
*str: Zeiger, der einen im String enthaltenen
Hexadezimalwert repraesentiert
*kommapos: an der im konvertieren Wert das Festkomma
einzufuegen ist
Rueckgabe:
konvertierter Integerwert
---------------------------------------------------------- */
float my_aftof(char *str)
{
char kp;
int val;
float f;
val= my_aftok(str, &kp);
f= val;
if (kp)
{
do
{
f /= 10.0;
kp--;
} while(kp);
}
return f;
}
/* ----------------------------------------------------------
my_ahtoi
my ascii hex to integer
einfache Konvertierung eines Hex-Strings zu einem
Integerwert.
Uebergabe:
*str: Zeiger, der einen im String enthaltenen
Hexadezimalwert repraesentiert
Rueckgabe:
konvertierter Integerwert
---------------------------------------------------------- */
int my_ahtoi(char *str)
{
char ch;
uint32_t result;
char puffer[10];
char *ptr;
strcpy(puffer,str);
strhicase(puffer);
ptr= &puffer[0];
result= 0;
do
{
ch= *ptr;
if ((ch < '0') || ((ch > '9') && (ch < 'A')) || (ch > 'F') )
{
return 0xffffffff;
}
if (ch< 'A') { ch -= '0'; } else { ch -= 55; }
result = (result << 4) + ch;
ptr++;
} while (*ptr);
return result;
}
/* -------------------------------------------------------------
uc2bin
unsigned char to bin
Uebergabe:
s : Zeiger auf ein Array, das den konvertierten String
aufnimmt. Array muss 10 Bytes gross sein (8 Zeichen
fuer Binaerdarstellung, 1 Zeichen fuer den Nibble-
trenner plus 1 Zeichen fuer das Stringende
Usage:
char pufferstr[10];
uint8_t zahl = 0xe3;
uc2bin(&pufferstr[0], zahl);
printf("\n\r 0x%X = %sb \n\r", zahl, pufferstr);
------------------------------------------------------------- */
void uc2bin(char *s, uint8_t val)
{
int8_t b;
for (b= 7; b > -1; b--)
{
if (val & (1 << b)) { *s = '1'; } else { *s = '0'; }
s++;
if (b== 4)
{
*s = '.'; // Punktzeichen als Trenner zwischen Hi- und Lo-Nibble
s++;
}
}
*s= 0;
}
zurück zum Anfang der Codeschnippsel|
in_list |
/* -------------------------------------------------------------
in_list
stellt fest, ob ein Zeichen in einem Array vorhanden ist.
Da auch eine 0 gesucht werden kann, ist dieses Array KEIN
AsciiZ String, sondern im "Pascal-Style" mit einem Laengen-
index als nulltes Element versehen das angibt, wieviele
Zeichen im Array vorhanden sind.
Uebergabe:
*list : Zeiger auf zu durchsuchendes Array,
nulltes Element im Array gibt an, wieviele
Zeichen im Array vorhanden sind
z : gesuchtes Zeichen
Rueckgabe: 0 => Zeichen ist nicht vorhanden
1 => Zeichen ist vorhanden
------------------------------------------------------------- */
char in_list(int *list, int z)
{
int i, len;
int *hptr;
len= *list;
for (i= 0; i< len; i++)
{
list++;
if (*list == z) return 1;
}
return 0;
}
zurück zum Anfang der Codeschnippsel|
reverse_byte |
/* ---------------------------------------------------------
reverse_byte
Tauscht die Bitpositionen eines Bytes. Bits die zuvor
von links nach rechts zu lesen waren, sind danach von
rechts nach links zu lesen (entspricht einem Tauschen
von LSB zu MSB):
D7 <=> D0, D6 <=> D1, D5 <=> D2, D4 <=> D3
Uebergabe:
b : Byte in dem die Bits zu tauschen sind
Rueckgabe:
Byte mit getauschten Bits
--------------------------------------------------------- */
uint8_t reverse_byte(uint8_t b)
{
b= (b & 0xf0) >> 4 | (b & 0x0f) << 4;
b= (b & 0xcc) >> 2 | (b & 0x33) << 2;
b= (b & 0xaa) >> 1 | (b & 0x55) << 1;
return b;
}
zurück zum Anfang der Codeschnippsel13.06.2025 R. Seelig