75-String-Library (STM32F4)

Das hier ist weniger eine Library als eine Hilfe in C-Programmierung.

Aber weil viele Fragen dazu gestellt wurden, hab ich das jetzt in ein File gepackt.

Es geht um das konvertieren von Zahlen in Strings und umgekehrt.

Im Beispiel sind so ziemlich alle Arten von Umwandlungen zu sehen
(in der CoIDE wird “retarget printf” benötigt)

Zusätzlich sind noch 3 Funktionen dabei um Teilstrings zu kopieren
(die können im H-File auch abgeschaltet werden, falls nicht benötigt)

Funktionen :

1
2
3
4
5
6

void UB_String_FloatToDezStr(float wert);                       // wandelt eine FLOAT-Zahl in einen String
float UB_String_DezStringToFloat(char *ptr);                    // wandelt einen String in eine FLOAT-Zahl
int16_t UB_String_DezStringToInt(char *ptr);                    // wandelt einen String in eine INT-Zahl
void UB_String_Mid(char *ptr, uint16_t start, uint16_t length); // kopiert einen Teilstring von der Mitte
void UB_String_Left(char *ptr, uint16_t length);                // kopiert den linken Teil eines Strings
void UB_String_Right(char *ptr, uint16_t length);               // kopiert den rechten Teil eines String

Beispiel :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//--------------------------------------------------------------
// File     : main.c
// Datum    : 09.02.2014
// Version  : 1.0
// Autor    : UB
// EMail    : mc-4u(@)t-online.de
// Web      : www.mikrocontroller-4u.de
// CPU      : STM32F4
// IDE      : CooCox CoIDE 1.7.4
// GCC      : 4.7 2012q4
// Module   : CMSIS_BOOT, M4_CMSIS_CORE
// Funktion : Demo der String-Library
// Hinweis  : Diese zwei Files muessen auf 8MHz stehen
//              "cmsis_boot/stm32f4xx.h"
//              "cmsis_boot/system_stm32f4xx.c"
//--------------------------------------------------------------
 
#include "main.h"
#include "stm32_ub_uart.h"
#include "stm32_ub_string.h"
 
int main(void)
{
  uint16_t uint_wert;
  int16_t int_wert;
  int16_t int_wert2;
  float float_wert;
  float float_wert2;
 
  SystemInit(); // Quarz Einstellungen aktivieren
 
  UB_Uart_Init();
 
  UB_Uart_SendString(COM3, "Demo der String-Lib", LFCR);
 
  // unsigned integer Zahl in String wandeln
  UB_Uart_SendString(COM3, "unsigned INT Zahl:", LFCR);
  uint_wert=1234;
  sprintf(STRING_BUF,"%d",uint_wert);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  // signed integer Zahl in String wandeln
  UB_Uart_SendString(COM3, "signed INT Zahl:", LFCR);
  int_wert=-1234;
  sprintf(STRING_BUF,"%d",int_wert);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  // unsigned integer Zahl in 4stellig HEX wandeln (mit führenden Nullen)
  UB_Uart_SendString(COM3, "HEX Ausgabe:", LFCR);
  uint_wert=1234;
  sprintf(STRING_BUF,"%04X",uint_wert);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  // float Zahl in String wandeln
  UB_Uart_SendString(COM3, "float Zahl:", LFCR);
  float_wert=123.4567;
  UB_String_FloatToDezStr(float_wert);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  // String in float Zahl wandeln
  UB_Uart_SendString(COM3, "String in float:", LFCR);
  float_wert2=UB_String_DezStringToFloat("-345.6789");
  UB_String_FloatToDezStr(float_wert2);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  // String in signed integer Zahl wandeln
  UB_Uart_SendString(COM3, "String in integer:", LFCR);
  int_wert2=UB_String_DezStringToInt("-3456");
  sprintf(STRING_BUF,"%d",int_wert2);
  UB_Uart_SendString(COM3, STRING_BUF, LFCR);
 
  while(1)
  {
 
  }
}

Hier die Library zum Download :

ub_stm32f4_string_v101

Hier der komplette CooCox-Projektordner zum Download :

Demo_75_String

12 Antworten auf 75-String-Library (STM32F4)

1. Cortex-Einsteiger sagt:

   9. Februar 2014 um 15:12

   ein kleiner Helferlein, danke.
   Irgendwo hatte ich mal gelesen, dass die normale sprintf Umwandlung von float2string einen Bug hat.

2. Fabrice sagt:

   12. Februar 2014 um 20:02

   Letztes jahre habe ich andere string routine geschriben.
   Du kannst die an deine als upgrade addieren , sind auch oft benutzt.
   Datei : StrFnc.h
   
#ifndef __STRFNC_H
#define __STRFNC_H

   #include „stm32f4xx.h“
   #include
   #include

   char *Mid(char *text, uint16_t start, uint16_t length);
   char *Left(char *text, uint16_t nbchar);
   char *Right(char *text, uint16_t length);
   uint8_t Asc(char *str);
   char Chr(uint8_t value);
   uint16_t Instr(uint16_t start, char *string1, char *string2);
   char *TrimStr(char *str);

   //————————————————————–
   #endif // __STRFNC_H

   Datei : StrFnc.c
   #include „StrFnc.h“
   #include
   #include

   // ********************************************************************
   // returns a string containing a specified number of characters
   // text: the input string
   // start: First char to get
   // length: How much char we extract
   // example: Mid(„input string“,2,6) will return ‚put st‘
   // ********************************************************************
   char *Mid(char *text, uint16_t start, uint16_t length)
   {
   uint16_t i;
   uint16_t cnt = 0;
   static char result[80]={„“};

   for (i=start;i strlen(text)) return result;
   result[cnt] = text[i];
   cnt++;
   }
   return result;
   }

   // ********************************************************************
   // extracts a substring from a string starting from the left-most character
   // text: the input string
   // nbchar: How much char we extract
   // example: Left(„input string“,7) will return ‚input s‘
   // ********************************************************************

   char *Left(char *text, uint16_t nbchar)
   {
   static char result[80];

   if (nbchar > 0 && nbchar 0 && length < strlen(text) )
   {
   strncpy(result,text + (strlen(text) – length), length);
   result[length] = “;
   }
   return result;
   }

   // ********************************************************************
   // returns the ASCII value of a character
   // str: the input string
   // example: Asc(„A“) will return 65
   // ********************************************************************
   uint8_t Asc(char *str)
   {
   char a;

   a = str[0];
   return a;
   }

   // ********************************************************************
   // Converts the specified ANSI character code to a character
   // value: the character code
   // example: Chr(65) will return ‚A‘
   // ********************************************************************
   char Chr(uint8_t value)
   {
   char a;

   a = value;
   return a;
   }

   // ********************************************************************
   // Return the place where String2 start into String1
   // start: where we start to search
   // string1: the input string
   // string2: the string to find into string1
   // example: Instr(„input string“,0,“s“) will return 6
   // ********************************************************************
   uint16_t Instr(uint16_t start, char *string1, char *string2)
   {
   uint16_t i;

   for(i=start;i<strlen(string1);i++)
   if(string1[i] == string2[0]) return i;
   return 0;
   }

   // ********************************************************************
   // Return the string without any space
   // str:the input string
   // example: TrimStr(„“. bla bla bla bla bla .“) will return ‚.blablablablabla.‘
   // ********************************************************************
   char *TrimStr(char *str)
   {
   uint16_t i = 0;
   uint16_t cnt = 0;
   static char result[80];

   for (i=0; i <= strlen(str) – 1 ; i++)
   if(str[i]!=‘ ‚)
   {
   result[cnt] = str[i];
   cnt++;
   }
   result[cnt]=0;
   return result;
   }

   Gruss.

   Fabrice.

   • admin_ub sagt:

     2. März 2014 um 10:16

     danke, habe 3 Stück hinzugefügt.

3. Fabrice sagt:

   12. Februar 2014 um 20:04

   Urgenswie sind 2 includes nicht sichtbar
   #include “StrFnc.h”
   #include
   #include
   Hoffen das dieses mal gut ist

4. Fabrice sagt:

   12. Februar 2014 um 20:06

   Nah ! , dan ist ein bug ins der blog message oder etwas ich nicht weis .
   Die 2 nicht sichtbar include sind :
   stdlib.h und cstring.h

5. AmirMohammad sagt:

   28. Februar 2014 um 07:44

   Hi
   by using the following step , you can use “sprintf” for float variables.

   *** just select “C Library” from “Repository” ***

   See photos below:
   http://www.up2www.com/uploads/1393565617431.png
   http://www.up2www.com/uploads/139356561752.png
   http://www.up2www.com/uploads/1393565617573.png
   http://www.up2www.com/uploads/1393565617644.png

   Source Code + Pictures in OneDrive:
   https://onedrive.live.com/redir?resid=EBE5A8A1DBF2F082!165&authkey=!ALTSaXOwAP3VavM&ithint

   • admin_ub sagt:

     1. März 2014 um 10:56

     ok, thanks
     in combination with the “retarget printf” Library from CooCox the “%f” didn’t work. The naked “C Library” reserverd a lot of flash, but you are right.

6. Mustafa sagt:

   7. Dezember 2014 um 16:02

   I’ve discovered this library and been using it in my SDIO code for data logging. Thank you for making this.

7. Joe sagt:

   25. Juni 2015 um 23:54

   Ich habe bemerkt dass die Funktion UB_String_FloatToDezStr am Randbereich nicht mehr richtig funktioniert.
   Also wird z.B. bei der Einstellung von zwei Nachkommastellen aus 24.999 dann anstatt 25.00.

   • Joerg B. sagt:

     26. Juni 2015 um 07:58

     Schon mal Zahlen gerundet? ab 6 wird aufgerundet…. was wird dann wohl aus 24,999 ???

8. Joe sagt:

   26. Juni 2015 um 21:58

   Das aufgerundet wird ist mir schon klar! Ich wollte hier nur zum Ausdruck bringen dass sich die Lib am Randbereich eben nicht wie z.B. sprintf verhält, was manche möglicherweise erwarten.

   Oben fehlt leider ein Teil meines Satzes.
   Gemeint war dass z.B. bei sprintf bei der Einstellung von zwei Nachkommastellen aus 24.999 dann 25.00 macht. Diese Lib hier macht aus 24.999 dann 24.10.

   • Thomas sagt:

     15. Januar 2016 um 10:45

     Zwei kleine Änderungen in der Funktion UB_String_FloatToDezStr beheben das Problem.
     Das Runden einfach direkt am Anfang machen und es unten entfernen.

     void UB_String_FloatToDezStr(float wert, char* buffer)
     {
     wert += 0.5 / STRING_FLOAT_FAKTOR;
     …..
     nachkomma = (uint16_t)(rest*(float)(STRING_FLOAT_FAKTOR));
     …..
     }

Wie hat Dir dieser Artikel gefallen?

(Noch keine Bewertungen)

Loading...