Vorzeichen Ausgeben

Johann Gast #2563146
Lesenswert?
• ▲
▼ 
guten tag
ich möchte eine Variable Rauf und Runter zählen von -45 bis + 75, könnte 
das so funktionieren.

1
for (;;)

2
 {  

3
  signed int by ;

4
  char Buf[10]; 

5
      if ( by == 75 )

6
       {

7
         by++;

8
       }  

9
     

10
       if ( by == -45 )

11
       {

12
         by--;

13
       }

14
  

15


16
  sprintf( Buf, "%3d", by );

17
  uart_puts( Buf);

18


19
  }
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Michael H. #2563157
Lesenswert?
• ▲
▼ 
Nicht so ganz.

Du machst folgendens:

---------------
Nur wenn die Variable by den Wert 75 hat wird by 76
Nur wenn die Variable by den Wert -45 hat wird by 44

Augabe des Wertes
-------------

Sonnst passiert nichts im Code

if ( by == 75 ) --> bedeute ja mache was wenn genau gleich wie die 
angegebene Zahl
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563191
Lesenswert?
• ▲
▼ 
Was ich machen möchte  ist erstmal nur das vergleichen der Negativen 
werte hier -45 und das ausgen des negativen wertes, da stehe ich derzeit 
bischen auf'n Schlauch.
Meine Ausgabe ist  nicht -45 sonder 210.




1
for (;;)

2
 {  

3
  signed int by ;

4
  char Buf[10]; 

5
  char flag=0; 

6


7
  if (flag == 1) 

8
   {

9
     by++;

10
     

11
      if ( by == 75 )

12
       {

13
       sprintf( Buf, "%3d", by );

14
       uart_puts( Buf);

15
       flag=2; 

16
       }  

17
   }   

18


19
 if (flag == 2) 

20
   {

21
       by--;

22
      

23
       if ( by == -45 )

24
       {

25
        sprintf( Buf, "%3d", by );

26
        uart_puts( Buf);        

27
       }

28
  

29
   }

30


31


32
  }
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563208
Lesenswert?
• ▲
▼ 
OH


1
for (;;)

2
 {  

3
  signed int by ;

4
  char Buf[10]; 

5
  char flag=1; 

6


7
  if (flag == 1) 

8
   {

9
     by++;

10
     

11
      if ( by == 75 )

12
       {

13
       sprintf( Buf, "%3d", by );

14
       uart_puts( Buf);

15
       flag=2; 

16
       }  

17
   }   

18


19
 if (flag == 2) 

20
   {

21
       by--;

22
      

23
       if ( by == -45 )

24
       {

25
        sprintf( Buf, "%3d", by );

26
        uart_puts( Buf);        

27
       flag=1; 

28
       }

29
  

30
   }

31


32


33
  }
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563211
Lesenswert?
• ▲
▼ 
Zeig doch bitte deinen richtigen, kompletten Code.
Nicht irgendwelchen Code, den du fürs Forum zurecht gemacht hast.
Denn wie Daniel schon richtig eingewendet hat: Der Code, den du (um 
15:55) gepostet hast, gibt gar nichts aus.

Und selbst wenn er etwas ausgeben würde, dann ganz sicher nicht 210. Die 
müssen also von wo anders herkommen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Peter II Gast #2563223
Lesenswert?
• ▲
▼ 
bei dem letzen code wird immer 75 oder  -45  ausgegeben - das ist 
bestimmt nicht was du willst.

Teste doch bitte dein code einfach mal im simulator oder auf dem PC. 
Dann sieht doch doch selber was passiert.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563226
Lesenswert?
• ▲
▼ 
so hier ist er,

1
 signed int TempgWert[18];          //Grenzwerte für 18 DS18S20

2
 int activeTempgWert=15;            //Sensor 15 Voreinstellen

3
 

4
 int32_t  va1lt=0 ;

5
 int32_t  va2lt=0 ;

6


7
 char enc1tBuffer[10];

8
 char enc2tBuffer[10];

9


10
//###################################################################################

11
//Temperatur  Grenzwerte

12
void lcdtempgrenz(void)

13
//###################################################################################

14
{   

15
  

16
  

17
  

18
 //Sensor Wählen 

19
 va1lt += encod1e_read4(); //Zählt 1Schritt

20
  if(va1lt > 0){

21
    va1lt--;

22
      activeTempgWert--;

23
      if (activeTempgWert <= 1)

24
        activeTempgWert = 0;

25


26
  }  else if(va1lt < 0){

27
     va1lt++;

28
      activeTempgWert++;

29
      if (activeTempgWert >= 18)

30
        activeTempgWert = 0;

31


32
}

33


34
 

35
 

36
 

37


38
 //Grenzwert Einstellen

39
 va2lt += encod2e_read4(); //Zählt 1Schritt

40
  if(va2lt > 0){

41
    va2lt--;

42
         TempgWert[activeTempgWert]--;

43
         if( TempgWert[activeTempgWert] <= -45)

44
             TempgWert[activeTempgWert] = -44;

45


46
  }  else if(va2lt < 0){

47
     va2lt++;

48
         TempgWert[activeTempgWert]++;

49
         if( TempgWert[activeTempgWert] >= 76)

50
             TempgWert[activeTempgWert] = 75;

51
       

52


53


54
 }

55
 

56
 

57


58
} 

59


60


61


62
//###################################################################################

63
//Temperatur  Grenzwerte-Ausgeben

64
void lcdtempgrenzoutValue(void)

65
//###################################################################################

66
{   

67


68
    outtgValue( 175,0,0, 23,1,  TempgWert[0] );

69
    outtgValue( 175,0,0, 43,1,  TempgWert[1] );

70
    outtgValue( 175,0,0, 63,1,  TempgWert[2] );

71
    outtgValue( 175,0,0, 83,1,  TempgWert[3] );  

72
    outtgValue( 175,0,0, 103,1, TempgWert[4] );

73
    outtgValue( 175,0,0, 123,1, TempgWert[5] );

74


75
    outtgValue( 166,1,0, 23,1,  TempgWert[6] );

76
    outtgValue( 166,1,0, 43,1,  TempgWert[7] );  

77
    outtgValue( 166,1,0, 63,1,  TempgWert[8] );

78
    outtgValue( 166,1,0, 83,1,  TempgWert[9] );

79
    outtgValue( 166,1,0, 103,1, TempgWert[10] );

80
    outtgValue( 166,1,0, 123,1, TempgWert[11] );  

81


82
    outtgValue( 255,1,69, 23,1, TempgWert[12] );

83
    outtgValue( 255,1,69, 43,1, TempgWert[13] );

84
    outtgValue( 255,1,69, 63,1, TempgWert[14] );

85
    outtgValue( 255,1,69, 83,1, TempgWert[15] );  

86
    outtgValue( 255,1,69, 103,1,TempgWert[16] );

87
    outtgValue( 255,1,69, 123,1,TempgWert[17] );  

88
  

89
    outtgchan ( 180,1,0, 248,0, activeTempgWert );

90


91
} 

92


93


94
//###################################################################################

95
void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,uint8_t y1,uint8_t y2, uint8_t valuetg )

96
//###################################################################################

97
{

98
  char Buffertg[10];

99


100
  sprintf( Buffertg, "%3d", valuetg );

101
  gotoxy( x1,x2,x3, y1,y2 );

102
  uart_puts( Buffertg );

103
  

104
}

105


106


107


108
//###################################################################################

109
void outtgchan( uint8_t x1,uint8_t x2,uint8_t x3, uint8_t y1,uint8_t y2, uint8_t chantg )

110
//###################################################################################

111
{

112
  char chantgBuffer[10];

113


114
  sprintf( chantgBuffer, "%3d", chantg );

115
  gotoxy(x1,x2,x3, y1,y2 );

116
  uart_puts( chantgBuffer );

117
  

118
 

119
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563251
Lesenswert?
• ▲
▼ 
Abgesehen davon

1
void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,uint8_t y1,uint8_t y2, uint8_t valuetg )

2


3
void outtgchan( uint8_t x1,uint8_t x2,uint8_t x3, uint8_t y1,uint8_t y2, uint8_t chantg )


wozu brauchst du 2 Funktionen, die komplett das gleiche machen? Sowas 
verwirrt nur.
Du brauchst eine Funktion die einen 'int' ausgibt. Ob dieser int dann 
ein Wert oder eine Kanalnummer ist, ist ja der Funktion wieder wurscht. 
Die kriegt einen int, und den gibt sie aus.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563262
Lesenswert?
• ▲
▼ 
Karl Heinz Buchegger schrieb:
>> void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,
>                    uint8_t y1,uint8_t y2,
>
>                    uint8_t valuetg )
>                    *******
>
> das steckt der Übeltäter.
vielen Dank,wenn jemand anders drüberschaut ist es schnell gefunden

> Abgesehen davon
> void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,uint8_t y1,uint8_t y2, 
uint8_t valuetg )
>
> void outtgchan( uint8_t x1,uint8_t x2,uint8_t x3, uint8_t y1,uint8_t y2, uint8_t 
chantg )
>
> wozu brauchst du 2 Funktionen, die komplett das gleiche machen? Sowas
> verwirrt nur.
> Du brauchst eine Funktion die einen 'int' ausgibt. Ob dieser int dann
> ein Wert oder eine Kanalnummer ist, ist ja der Funktion wieder wurscht.
> Die kriegt einen int, und den gibt sie aus.

Ja stimmt ist Doppelt-gemoppelt
vielen Dank nochmals
mfg
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563266
Lesenswert?
• ▲
▼ 
Rein aus Neugier:
Kann es sein, dass du nicht verstanden hast, dass man eine Zahl auch 
programmtechnisch in High-Byte und Low-Byte zerlegen kann und zwar in 
einer möglichst tiefen Ausgabeschicht, damit derjenige der die 
Ausgabefunktionen benutzen will, sich nicht damit abplagen muss, mit dem 
Taschenrechner das zu tun?

Anders kann ich mir deine x und y Koordinaten nämlich nicht erklären. 
Und warum es da 3 x Koordinaten aber nur 2 y Koordinaten gibt, schon 
gleich gar nicht.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563268
Lesenswert?
• ▲
▼ 
Johann schrieb:
> Karl Heinz Buchegger schrieb:
>>> void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,
>>                    uint8_t y1,uint8_t y2,
>>
>>                    uint8_t valuetg )
>>                    *******
>>
>> das steckt der Übeltäter.
> vielen Dank,wenn jemand anders drüberschaut ist es schnell gefunden

Eben.
Und jetzt vergleich mal diesen Fehler mit dem was du ursprünglich 
gepostet hast :-)  Absolut kein Zusammenhang.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563287
Lesenswert?
• ▲
▼ 
Karl Heinz Buchegger schrieb:
> Rein aus Neugier:
> Kann es sein, dass du nicht verstanden hast, dass man eine Zahl auch
> programmtechnisch in High-Byte und Low-Byte zerlegen kann und zwar in
> einer möglichst tiefen Ausgabeschicht, damit derjenige der die
> Ausgabefunktionen benutzen will, sich nicht damit abplagen muss, mit dem
> Taschenrechner das zu tun?
>
> Anders kann ich mir deine x und y Koordinaten nämlich nicht erklären.
> Und warum es da 3 x Koordinaten aber nur 2 y Koordinaten gibt, schon
> gleich gar nicht.

Es handelt sich um ein 640x480Pixel LCD SW welches von einenm ATmega128 
Gesteuert wird.
outtgValue( 255,1,69, 23,1, TempgWert[12] );
Das heißt in X=255+255+69=579, setze den ersten Pixel in X bei 579
und in Y=255+23=278,setze den ersten Pixel in Y bei 278.
Da ich ja in 8Bit nur bis 255 zählen kann,Daher dieses Konstruct.
mfg
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563298
Lesenswert?
• ▲
▼ 
Johann schrieb:

> Das heißt in X=255+255+69=579, setze den ersten Pixel in X bei 579
> und in Y=255+23=278,setze den ersten Pixel in Y bei 278.
> Da ich ja in 8Bit nur bis 255 zählen kann,Daher dieses Konstruct.

Es ist ja nicht in Stein gemeisselt, dass die Stringausgabefunktion nur 
uint8_t Werte als Argumente haben darf :-)
Mach halt uint16_t draus, dann brauchst du beim Aufruf nicht selber die 
Bytes zu zerlegen, das kann die Stringausgabefunktion ganausogut auch 
selber erledigen.



    outtgValue( 175, 279,  TempgWert[0] );
    outtgValue( 175, 299,  TempgWert[1] );
    outtgValue( 175, 319,  TempgWert[2] );
    outtgValue( 175, 399,  TempgWert[3] );
...

liest sich doch gleich viel besser als

    outtgValue( 175,0,0, 23,1,  TempgWert[0] );
    outtgValue( 175,0,0, 43,1,  TempgWert[1] );
    outtgValue( 175,0,0, 63,1,  TempgWert[2] );
...


und ausserdem ermöglicht es dir dann auch, dass du die Werte errechnen 
kannst.

   for( i = 0; i < 6; i++ )
     outtgValue( 175, 279 + i * 20, TempgWert[i] );

Dasselbe nochmal für x (eine Formel finden) und noch ein bischen 
umformen und dein ganze "halbseitige" Ausgabefunktion dampft sich auf 
einen 3-Zeiler ein, bei dem #garantiert# ist, dass die Abstände immer 
gleich sind, auch ohne dass du 20 Minuten mit dem Taschenrechner 
händisch rumrechnest.

1
void lcdtempgrenzoutValue(void)

2
//###################################################################################

3
{   

4
  for( uint8_t i = 0; i < 18; i++ )

5
    outtgInt( 175 + ( i / 6 ) * 240, 279 + ( i % 6 ) * 20, TempgWert[i] );

6


7
  outtgInt( 436, 248, activeTempgWert );

8
}


oder meinetwegen, wenn dir die Rechnerei schon etwas zu suspekt ist

1
void lcdtempgrenzoutValue(void)

2
//###################################################################################

3
{   

4
  for( uint8_t i = 0; i < 6; i++ )

5
    outtgInt( 175, 279 + i * 20, TempgWert[i+0] );

6


7
  for( uint8_t i = 0; i < 6; i++ )

8
    outtgInt( 422, 279 + i * 20, TempgWert[i+6] );

9


10
  for( uint8_t i = 0; i < 6; i++ )

11
    outtgInt( 580, 279 + i * 20, TempgWert[i+12] );

12


13
  outtgInt( 436, 248, activeTempgWert );

14
}


Es lohnt nicht, bei den untersten Schichten faul zu sein. Du verschiebst 
damit Detailprobleme immer nur zum Aufrufer und machst dem mehr Arbeit 
als notwendig. Ganz abgesehen davon, dass sowas meistens Flexibilität 
kostet. So wie hier.

Sorg dir 'unten' für Komfort. Noch dazu, wo er wie in deinem Fall so 
einfach zu erreichen ist. Einen 16 Bit Wert in 2 Stück 8 Bit Werte zu 
zerlegen ist doch trivial.

   uint_16_t Wert = 279;

   uint8_t HighByte = Wert >> 8;
   uint8_t LowByte  = Wert;


Du musst dir Funktionen immer so schreiben, dass sie einfach zu benutzen 
sind! Und nicht die Argumente so wählen, dass du die Funktion einfach 
implementieren kannst. Denn damit verlagerst du die Arbeit nur an eine 
andere Stelle (im schlimmsten Fall an den Programmierer, und das ist die 
schlechteste aller Möglichkeiten)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2563412
Lesenswert?
• ▲
▼ 
ich habe nochmal eine Frage,
ich möchte 2 ARRAYs vergleichen

in TempWert steht meine Temperratur mit vorzeichen drin allerdings in 
ASCII
und in TempgWert mein Grenzwert in Dezimal,
Vielleicht kann mir jemand von ihnen weiterhelfen
mfg

1
          //so gehts

2
          if ( TempWert[0]=='+' && TempWert[1]=='2' && TempWert[2]=='2' ) 

3
          //so gehts nich

4
          if ( TempWert[0]=='+' && TempWert[1]==TempgWert[1] && TempWert[2]==TempgWert[2] )

5
          {

6
      gotoxy(155,0,0, 98,0 );

7
      uart_putc ('O');

8
      uart_putc ('K');  

9
     }

10
       

11
    else 

12
     {

13
      gotoxy(155,0,0, 98,0 );

14
      uart_putc ('N');

15
      uart_putc ('O');

16
     }


Die X,Y Position werde ich wie von ihnen vorgeschlagen noch umsetzen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
lalala Gast #2563452
Lesenswert?
• ▲
▼ 
Umrechnung ASCII-Dezimal: '0' (<--das ist für den Compiler eine Zahl!) 
von jeder Ziffer abziehen.

if ( TempWert[0]=='+' && TempWert[1]-'0'==TempgWert[1] && 
TempWert[2]'0'==TempgWert[2] )

Desweiteren:
-ordentlich einrücken
-du brauchst ein putstring:

void putstring (char * c)
{
  for(;*c,c++)
    uart_putc(*c);
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
lalala Gast #2563454
Lesenswert?
• ▲
▼ 
Sorry Tippfehler, oberen Beitrag bitt löschen.

Umrechnung ASCII-Dezimal: '0' (<--das ist für den Compiler eine Zahl!)
von jeder Ziffer abziehen.

if ( TempWert[0]=='+' && TempWert[1]-'0'==TempgWert[1] &&
TempWert[2]-'0'==TempgWert[2] )

Desweiteren:
-ordentlich einrücken
-du brauchst ein putstring:

void putstring (char * c)
{
  for(;*c,c++)
    uart_putc(*c);
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
lalala Gast #2563458
Lesenswert?
• ▲
▼ 
Bitt zweimal löschen... Sry.

Umrechnung ASCII-Dezimal: '0' (<--das ist für den Compiler eine Zahl!)
von jeder Ziffer abziehen.

if ( TempWert[0]=='+' && TempWert[1]-'0'==TempgWert[1] &&
TempWert[2]-'0'==TempgWert[2] )

Desweiteren:
-ordentlich einrücken
-du brauchst ein putstring:

void putstring (char * c)
{
  for(;*c;c++)
    uart_putc(*c);
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2563872
Lesenswert?
• ▲
▼ 
> in TempWert steht meine Temperratur mit vorzeichen drin
> allerdings in ASCII

An dieser Stelle musst du dich schon mal fragen: Warum?

Warum hast du eine Stringrepräsentierung für eine Zahl und versuchst mit 
der weiterzuarbeiten.
Wenn du Zahlen hast, und Temperaturen sind zweifellos welche, dann 
speichere sie auch als Zahlen und nicht als Strings. Denn dann wird 
alles plötzlich wieder trivial: Zahlen kann man leicht auf größer oder 
kleiner vergleichen.


Das ist im Grunde wieder genau das gleiche wie weiter oben: Du machst 
dir selbst das Leben schwer, weil du an den falschen Stellen ansetzt. 
Wenn du die Temperatur von irgendeinem Sensor oder von einer 
Benutzereingabe in Textform bekommst, dann wandle dir die beim Einlesen 
SOFORT in eine Zahl um. Zögerst du das hinaus, dann wirds nur in 
weiterer Folge aufwendiger, aber gewonnen hast du nichts dabei. Selbst 
wenn es auf den ersten Blick so aussehen mag als ob, weil du ja so toll 
den Wert vom Sensor gleich auf ein LCD ausgeben kannst. Das du dich 
dabei bei der Verarbeitung des Zahlenwertes in Textform selbst 
behinderst, übersiehst du dabei geflissentlich. Dabei hättest du auch 
noch so eine schöne Ausgabefunktion, mit der du so einen int wieder ganz 
leicht ausgeben kannst, d.h. der Vorteil von zuerst ist in Wirklichkeit 
gar keiner, weil dich die Temperatur in einem int gespeichert nämlich 
überhaupt nicht bei der Ausgabe behindert.

Also: Wo kommt diese Temepratur her, die du nur in Textform hast. Dort 
ist dein Ansatzpunkt. Den String, der den Wert hält, den wirfst du raus 
und ersetzt ihn durch ebenfalls einen int. Und plötzlich wird alles ganz 
einfach.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2564693
Lesenswert?
• ▲
▼ 
ich habe hier das kommplette Programm welches die Temperratur 
einliesst,Ausgibt und wo ich mein Grenzwert für jeden Sensor einstelle.
Das Temperratur-EEinlesen ist vielleicht nicht die beste lösung.
im Anhang das Programm welches die Temperratur sendet.
mfg

1
signed int TempgWert[18];          //Grenzwerte für 18 DS18S20

2
 int activeTempgWert=1;

3


4
 int TempWert[96];           //18Sensoren mal 5Werte

5
 

6
 char RX0Buffer[30];

7
 char c;

8
 int BufferLen = 30;

9


10
 int32_t  va1lt=0 ;

11
 int32_t  va2lt=0 ;

12


13
 char enc1tBuffer[10];

14
 char enc2tBuffer[10];

15


16
//###################################################################################

17
//Temperatur  Einlesen

18
void lcdtemp(void)

19
//###################################################################################

20
{

21


22
   unsigned int by;

23
   int i = 0;

24
   signed int j = 0;  

25


26
   

27
    c = uart_getchar();

28
    

29
     if (c=='1')

30
       {

31
  

32
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

33
    

34
      RX0Buffer[ i++ ] = c;

35
        RX0Buffer[i] = '\0';

36
        j=1;

37
      i = 0;

38
       }

39


40
     if (c=='2')

41
       {

42
  

43
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

44
    

45
      RX0Buffer[ i++ ] = c;

46
        RX0Buffer[i] = '\0';

47
        j=2;

48
      i = 0;

49
       }    

50
     

51
     if (c=='3')

52
       {

53
  

54
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

55
    

56
      RX0Buffer[ i++ ] = c;

57
        RX0Buffer[i] = '\0';

58
        j=3;

59
      i = 0;

60
       }         

61
     

62
     if (c=='4')

63
       {

64
  

65
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

66
    

67
      RX0Buffer[ i++ ] = c;

68
        RX0Buffer[i] = '\0';

69
        j=4;

70
      i = 0;

71
       }         

72
     

73
     if (c=='5')

74
       {

75
  

76
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

77
    

78
      RX0Buffer[ i++ ] = c;

79
        RX0Buffer[i] = '\0';

80
        j=5;

81
      i = 0;

82
       }         

83
     

84
     if (c=='6')

85
       {

86
  

87
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

88
    

89
      RX0Buffer[ i++ ] = c;

90
        RX0Buffer[i] = '\0';

91
        j=6;

92
      i = 0;

93
       }         

94
     

95
     if (c=='7')

96
       {

97
  

98
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

99
     

100
      RX0Buffer[ i++ ] = c;

101
        RX0Buffer[i] = '\0';

102
        j=7; 

103
      i = 0;

104
       } 

105


106
     if (c=='8')

107
       {

108
  

109
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

110
     

111
      RX0Buffer[ i++ ] = c;

112
        RX0Buffer[i] = '\0';

113
        j=8;

114
        i = 0;

115
       }    

116


117
     if (c=='9')

118
       {

119
  

120
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

121
    

122
      RX0Buffer[ i++ ] = c;

123
        RX0Buffer[i] = '\0';

124
        j=9;

125
      i = 0;

126
       }    

127


128
     if (c=='A')

129
       {

130
  

131
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

132
    

133
      RX0Buffer[ i++ ] = c;

134
        RX0Buffer[i] = '\0';

135
        j=10;

136
      i = 0;

137
       }    

138


139
     if (c=='B')

140
       {

141
  

142
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

143
    

144
      RX0Buffer[ i++ ] = c;

145
        RX0Buffer[i] = '\0';

146
        j=11;

147
      i = 0;

148
       }    

149
     

150
     if (c=='C')

151
       {

152
  

153
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

154
    

155
      RX0Buffer[ i++ ] = c;

156
        RX0Buffer[i] = '\0';

157
        j=12;

158
      i = 0;

159
       }     

160


161
     if (c=='D')

162
       {

163
  

164
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

165
    

166
      RX0Buffer[ i++ ] = c;

167
        RX0Buffer[i] = '\0';

168
        j=13;

169
      i = 0;

170
       }    

171


172
     if (c=='E')

173
       {

174
  

175
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

176
    

177
      RX0Buffer[ i++ ] = c;

178
        RX0Buffer[i] = '\0';

179
        j=14;

180
      i = 0;

181
       }          

182


183
     if (c=='F')

184
       {

185
  

186
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

187
    

188
      RX0Buffer[ i++ ] = c;

189
        RX0Buffer[i] = '\0';

190
        j=15;

191
      i = 0;

192
       }    

193


194
     if (c=='G')

195
       {

196
  

197
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

198
    

199
      RX0Buffer[ i++ ] = c;

200
        RX0Buffer[i] = '\0';

201
        j=16;

202
      i = 0;

203
       }    

204
     

205
     if (c=='I')

206
       {

207
  

208
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

209
    

210
      RX0Buffer[ i++ ] = c;

211
        RX0Buffer[i] = '\0';

212
        j=17;

213
      i = 0;

214
       }         

215
     

216
     if (c=='H')

217
       {

218
  

219
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

220
    

221
      RX0Buffer[ i++ ] = c;

222
        RX0Buffer[i] = '\0';

223
        j=18;

224
      i = 0;

225
       }         

226
  

227


228
//###################################################################################

229


230
    

231
      if ( j == 1 )

232
       {

233
       for(i=0; i<5; i++)

234
         {

235
           by=RX0Buffer[i];

236
           TempWert[i]=by;

237
         }

238
           gotoxy(175,0,0, 98,0 );

239


240
        

241
         for(i=0; i<5; i++)

242
         {

243
           by=TempWert[i];

244
           uart_putc (by);

245
       }

246


247
         

248


249
      if (TempWert[0]=='+' && TempWert[1]-'0'==TempgWert[1] && TempWert[2]-'0'==TempgWert[2] ) 

250
           {

251
       gotoxy(125,0,0, 98,0 );

252
       uart_putc ('O');

253
       }

254
       

255
      else 

256
         {

257
         gotoxy(125,0,0, 98,0 );

258
         uart_putc ('m');

259


260
         }

261
     }  

262
     

263
      if ( j == 2 )

264
       {

265
       for(i=0; i<5; i++)

266
         {

267
           by=RX0Buffer[i];

268
           TempWert[i+5]=by;

269
         }

270
           gotoxy(175,0,0, 119,0 );

271
        

272
         for(i=0; i<5; i++)

273
         {

274
           by=TempWert[i+5];

275
           uart_putc (by);

276
       }

277
     }  

278
    

279
    

280
      if ( j == 3 )

281
       {

282
       for(i=0; i<5; i++)

283
         {

284
           by=RX0Buffer[i];

285
           TempWert[i+15]=by;

286
         }

287
           gotoxy(175,0,0, 140,0 );

288


289
        

290
         for(i=0; i<5; i++)

291
         {

292
           by=TempWert[i+15];

293
           uart_putc (by);

294
       }

295
     }  

296


297
     

298
      if ( j == 4 )

299
       {

300
       for(i=0; i<5; i++)

301
         {

302
           by=RX0Buffer[i];

303
           TempWert[i+20]=by;

304
         }

305
           gotoxy(175,0,0, 161,0 );

306


307
        

308
         for(i=0; i<5; i++)

309
         {

310
           by=TempWert[i+20];

311
           uart_putc (by);

312
       }

313
     }  

314


315
     

316
      if ( j == 5 )

317
       {

318
       for(i=0; i<5; i++)

319
         {

320
           by=RX0Buffer[i];

321
           TempWert[i+25]=by;

322
         }

323
           gotoxy(175,0,0, 182,0 );

324


325
        

326
         for(i=0; i<5; i++)

327
         {

328
           by=TempWert[i+25];

329
           uart_putc (by);

330
       }

331
     }  

332


333
     

334
      if ( j == 6 )

335
       {

336
       for(i=0; i<5; i++)

337
         {

338
           by=RX0Buffer[i];

339
           TempWert[i+30]=by;

340
         }

341
           gotoxy(175,0,0, 205,0 );

342


343
        

344
         for(i=0; i<5; i++)

345
         {

346
           by=TempWert[i+30];

347
           uart_putc (by);

348
       }

349
     }  

350
     

351
      if ( j == 7 )

352
       {

353
       for(i=0; i<5; i++)

354
         {

355
           by=RX0Buffer[i];

356
           TempWert[i+35]=by;

357
         }

358
           gotoxy(166,1,0, 98,0 );

359


360
        

361
         for(i=0; i<5; i++)

362
         {

363
           by=TempWert[i+35];

364
           uart_putc (by);

365
       }

366
     }  

367


368
     

369
      if ( j == 8 )

370
       {

371
       for(i=0; i<5; i++)

372
         {

373
           by=RX0Buffer[i];

374
           TempWert[i+40]=by;

375
         }

376
           gotoxy(166,1,0, 119,0 );

377


378
        

379
         for(i=0; i<5; i++)

380
         {

381
           by=TempWert[i+40];

382
           uart_putc (by);

383
       }

384
     }  

385


386
     

387
      if ( j == 9 )

388
       {

389
       for(i=0; i<5; i++)

390
         {

391
           by=RX0Buffer[i];

392
           TempWert[i+45]=by;

393
         }

394
           gotoxy(166,1,0, 140,0 );

395


396
        

397
         for(i=0; i<5; i++)

398
         {

399
           by=TempWert[i+45];

400
           uart_putc (by);

401
       }

402
     }  

403


404
     

405
      if ( j == 10 )

406
       {

407
       for(i=0; i<5; i++)

408
         {

409
           by=RX0Buffer[i];

410
           TempWert[i+50]=by;

411
         }

412
           gotoxy(166,1,0, 161,0 );

413


414
        

415
         for(i=0; i<5; i++)

416
         {

417
           by=TempWert[i+50];

418
           uart_putc (by);

419
       }

420
     }  

421


422
     

423
      if ( j == 11 )

424
       {

425
       for(i=0; i<5; i++)

426
         {

427
           by=RX0Buffer[i];

428
           TempWert[i+55]=by;

429
         }

430
           gotoxy(166,1,0, 182,0 );

431


432
        

433
         for(i=0; i<5; i++)

434
         {

435
           by=TempWert[i+55];

436
           uart_putc (by);

437
       }

438
     }  

439


440
     

441
      if ( j == 12 )

442
       {

443
       for(i=0; i<4; i++)

444
         {

445
           by=RX0Buffer[i];

446
           TempWert[i+60]=by;

447
         }

448
           gotoxy(166,1,0, 205,0 );

449


450
        

451
         for(i=0; i<5; i++)

452
         {

453
           by=TempWert[i+60];

454
           uart_putc (by);

455
       }

456
     }  

457


458
     

459
      if ( j == 13 )

460
       {

461
       for(i=0; i<5; i++)

462
         {

463
           by=RX0Buffer[i];

464
           TempWert[i+65]=by;

465
         }

466
           gotoxy(255,1,69, 98,0 );

467


468
        

469
         for(i=0; i<5; i++)

470
         {

471
           by=TempWert[i+65];

472
           uart_putc (by);

473
       }

474
     }  

475


476
     

477
      if ( j == 14 )

478
       {

479
       for(i=0; i<5; i++)

480
         {

481
           by=RX0Buffer[i];

482
           TempWert[i+70]=by;

483
         }

484
           gotoxy(255,1,69 ,119,0 );

485


486
        

487
         for(i=0; i<5; i++)

488
         {

489
           by=TempWert[i+70];

490
           uart_putc (by);

491
       }

492
     }  

493


494
     

495
      if ( j == 15 )

496
       {

497
       for(i=0; i<5; i++)

498
         {

499
           by=RX0Buffer[i];

500
           TempWert[i+75]=by;

501
         }

502
           gotoxy(255,1,69, 140,0 );

503


504
        

505
         for(i=0; i<5; i++)

506
         {

507
           by=TempWert[i+75];

508
           uart_putc (by);

509
       }

510
     }  

511


512
     

513
      if ( j == 16 )

514
       {

515
       for(i=0; i<5; i++)

516
         {

517
           by=RX0Buffer[i];

518
           TempWert[i+80]=by;

519
         }

520
           gotoxy(255,1,69, 161,0 );

521


522
        

523
         for(i=0; i<5; i++)

524
         {

525
           by=TempWert[i+80];

526
           uart_putc (by);

527
       }

528
     }  

529


530
     

531
      if ( j == 17 )

532
       {

533
       for(i=0; i<5; i++)

534
         {

535
           by=RX0Buffer[i];

536
           TempWert[i+85]=by;

537
         }

538
           gotoxy(255,1,69, 182,0 );

539


540
        

541
         for(i=0; i<5; i++)

542
         {

543
           by=TempWert[i+85];

544
           uart_putc (by);

545
       }

546
     }  

547


548
     

549
      if ( j == 18 )

550
       {

551
       for(i=0; i<5; i++)

552
         {

553
           by=RX0Buffer[i];

554
           TempWert[i+90]=by;

555
         }

556
           gotoxy(255,1,69, 205,0 );

557


558
        

559
         for(i=0; i<5; i++)

560
         {

561
           by=TempWert[i+90];

562
           uart_putc (by);

563
       }

564
     }  

565
       

566
   } 

567
 

568
//###################################################################################

569
//Temperatur  Grenzwerte

570
void lcdtempgrenz(void)

571
//###################################################################################

572
{   

573
  int i; 

574
    

575
 //Sensor Wählen 

576
 va1lt += encod1e_read4(); //Zählt 1Schritt

577
  if(va1lt > 0){

578
    va1lt--;

579
      activeTempgWert--;

580
      if (activeTempgWert <= 1)

581
        activeTempgWert = 0;

582


583
  }  else if(va1lt < 0){

584
     va1lt++;

585
      activeTempgWert++;

586
      if (activeTempgWert >= 18)

587
        activeTempgWert = 0;

588


589
}

590


591
 

592
 

593
 

594


595
 //Grenzwert Einstellen

596
 va2lt += encod2e_read4(); //Zählt 1Schritt

597
  if(va2lt > 0){

598
    va2lt--;

599
         TempgWert[activeTempgWert]--;

600
         if( TempgWert[activeTempgWert] <= -45)

601
             TempgWert[activeTempgWert] = -44;

602


603
  }  else if(va2lt < 0){

604
     va2lt++;

605
         TempgWert[activeTempgWert]++;

606
         if( TempgWert[activeTempgWert] >= 76)

607
             TempgWert[activeTempgWert] = 75;

608
       

609


610


611
 }

612
 

613


614


615
} 

616


617


618


619
//###################################################################################

620
//Temperatur  Grenzwerte-Ausgeben

621
void lcdtempgrenzoutValue(void)

622
//###################################################################################

623
{   

624


625
    outtgValue( 175,0,0, 23,1,  TempgWert[0] );

626
    outtgValue( 175,0,0, 43,1,  TempgWert[1] );

627
    outtgValue( 175,0,0, 63,1,  TempgWert[2] );

628
    outtgValue( 175,0,0, 83,1,  TempgWert[3] );  

629
    outtgValue( 175,0,0, 103,1, TempgWert[4] );

630
    outtgValue( 175,0,0, 123,1, TempgWert[5] );

631


632
    outtgValue( 166,1,0, 23,1,  TempgWert[6] );

633
    outtgValue( 166,1,0, 43,1,  TempgWert[7] );  

634
    outtgValue( 166,1,0, 63,1,  TempgWert[8] );

635
    outtgValue( 166,1,0, 83,1,  TempgWert[9] );

636
    outtgValue( 166,1,0, 103,1, TempgWert[10] );

637
    outtgValue( 166,1,0, 123,1, TempgWert[11] );  

638


639
    outtgValue( 255,1,69, 23,1, TempgWert[12] );

640
    outtgValue( 255,1,69, 43,1, TempgWert[13] );

641
    outtgValue( 255,1,69, 63,1, TempgWert[14] );

642
    outtgValue( 255,1,69, 83,1, TempgWert[15] );  

643
    outtgValue( 255,1,69, 103,1,TempgWert[16] );

644
    outtgValue( 255,1,69, 123,1,TempgWert[17] );  

645
  

646
    outtgValue ( 180,1,0, 248,0, activeTempgWert );

647


648
} 

649


650


651
//###################################################################################

652
void outtgValue( uint8_t x1,uint8_t x2, uint8_t x3,uint8_t y1,uint8_t y2, signed int valuetg )

653
//###################################################################################

654
{

655
  char Buffertg[10];

656
  sprintf( Buffertg, "%3d", valuetg );

657
  gotoxy( x1,x2,x3, y1,y2 );

658
  uart_puts( Buffertg );

659


660
}
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
troll Gast #2564709
Lesenswert?
• ▲
▼ 
Der ganze Krempel
1
   if (c=='1')

2
       {

3
  

4
        while   ( ( c = uart_getchar() ) != '\r'   && i < BufferLen  - 1 )

5
    

6
      RX0Buffer[ i++ ] = c;

7
        RX0Buffer[i] = '\0';

8
        j=1;

9
      i = 0;

10
       }

11


12
     if (c=='2')

13
...

lässt sich mit etwas Mathematik auf ein paar Zeilen zusammenstreichen. 
Für den Rest des Programms gilt vermutlich das selbe...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2564758
Lesenswert?
• ▲
▼ 
troll schrieb:

> Für den Rest des Programms gilt vermutlich das selbe...

tut es.

Puuuh. Wo soll man da blos anfangen?
Copy&Paste ist nun mal kein Ersatz für fehlendes Wissen bzw. 
Kreativität.

Johann.
Dein ganzer bisheriger Code lässt sich auf weniger als eine 
Bildschirmseite programmieren.

Ich bin schon fast versucht zu sagen: Schmeiss ihn weg. Das taugt nix. 
Hol dir ein Einsteigerbuch für C und mach um Gottes Willen die ersten 
paar Kapitel durch!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2564795
Lesenswert?
• ▲
▼ 
ich hatte ja schon gesagt das mann dass sicher besser machen kann,
meine Werte vom Temperraturmodul kommen jetzt nicht mehr als ASCII.
Ich brauche doch 2ARRAYs einmal der Tempwert und einmal der Grenzwert 
oder irre ich mich da.
Mein Problem ist j wie ich die 2 Werte miteinander vergleiche.
Das War ja meine Frage.
Mfg
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2564807
Lesenswert?
• ▲
▼ 
Johann schrieb:
> ich hatte ja schon gesagt das mann dass sicher besser machen kann,

Nicht'kann' - MUSS

> meine Werte vom Temperraturmodul kommen jetzt nicht mehr als ASCII.
> Ich brauche doch 2ARRAYs einmal der Tempwert und einmal der Grenzwert
> oder irre ich mich da.

Genau.

> Mein Problem ist j wie ich die 2 Werte miteinander vergleiche.

Du hast das falsche Problem.
Dein Problem ist, wie kann ich den Wert, den ich vom Sensor bekomme und 
der eine Textrepräsentierung einer Zahl ist, in eine Zahl umwandeln.

atoi macht das

Aber erst mal muss dein Code restrukturiert werden. So wie der jetzt 
ist, kann das nicht bleiben. Da kannst du keine Änderungen vornehmen, 
ohne dass du dich zu Tode editierst.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2564827
Lesenswert?
• ▲
▼ 
OK.
Erst mal musst du den Prozess des Einlesens der Werte von den Sensoren 
von deren Anzeige trennen.

Dann musst du für die Werte, die du vom Sensor bekommt Variablen 
anlegen.
Fangen wir mit letzterem an.

Ich nenne die dafür notwendigen 18 Stück INteger einfach mal Temperatur. 
Die Variable  int TempWert[96]; brauchst du nicht mehr. Lösch sie gleich 
raus.

1
// Grenzwerte

2
signed int TempgWert[18];          //Grenzwerte für 18 DS18S20

3
int activeTempgWert=1;

4


5
// aktuelle Temperaturwerte aller Sensoren

6
int Temperature[18];


to be continued (muss mich erst mal weiter orientieren, wies weiter 
geht)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2564890
Lesenswert?
• ▲
▼ 
OK.
Der erste Streich.

Das Einlesen eines Sensorwertes funktioniert offenbar so, dass da ein 
Text daherkommt, desen erstes Zeichen '1'..'9' 'A'..'H' den Sonsor 
identifiziert und danach kommt der Sensorwert

Dafür machen wir gleich mal eine Funktion, die eine Zeile einliest und 
anhand des ersten Zeichens entscheidet um welchen Sensor es sich handelt 
und den gelesenen Wert als Zahl(!) in den richtigen Array Eintrag im 
Temperatur Array schreibt.

1
void getSensor()

2
{

3
  char    inLine[20];

4
  char    c;

5
  uint8_t i;

6
  uint8_t sensorNr;

7


8
  // eine Zeile komplett einlesen

9
  c = uart_getchar();

10
  while( c != '\r' && i < sizeof(inLine) - 2 ) {

11
    if( c != '\n' && c != ' ')

12
      inLine[i++] = c;

13
  }

14
  inLine[i] = '\0';

15


16
  // das erste Zeichen sagt aus, welcher Sensor das ist

17
  if( inLine[0] >= '0' && inLine[0] <= '9' )

18
    sensorNr = inLine[0] - '0';

19
  else if( inLine[0] >= 'A' && inLine[0] <= 'H' )

20
    sensorNr = inLine[0] - 'A' + 10;

21
  else

22
    sensorNr = 255;

23


24
  // wenn es sich um eine gültige Sensor Nummer handelt

25
  // dann wandle den Rest des Strings in eine Zahl um

26
  // und speichere sie im Temperatur Array zum korrekten Sensor

27
  if( sensorNr != 255 ) {

28
    int messWert = atoi( &inLine[1] );

29
    Temperatur[sensorNr] = messWert;

30
  }

31
}


Fertig. Diese Funktion handhabt schon mal jegliche Eingabe von der UART.
Da du eine schöne Funktion hast, die einen int anzeigen kann, kannst du 
dir damit schon mal alle Sensorwerte am LCD ausgeben lassen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2564892
Lesenswert?
• ▲
▼ 
An dem Müll, wie du Positionen am LCD identifizierst, musst du noch 
arbeiten! Das ist immer noch der gleiche Unsinn.

           gotoxy(175,0,0, 98,0 );

so kommst du nicht weiter.
Dein µC kann rechnen! Der tut nichts lieber als das.

Wenn du das hast, kannst du nämlich dann benutzen:
Deine x bzw. y Positionen am LCD lassen sich ganz leicht ausrechnen, 
wenn du die Sensornummer hast. Aber dazu musst du die Ausgabe vernünftig 
machen!

Du willst gotoxy so benutzen können, dass du x und y angibst. Und zwar 
ohne dass du sich um Bytegrenzen kümmern musst. Du willst x direkt als 
Wert von 0 bis 639 angeben können. Und du willst y als Wert von 0 bis 
379 angeben können!

Denn dann kannst du dir aus der Sensornummer die x Koordinate errechnen

   x = 175 + sensorNr / 6 * 247;

und du kannst dir aus der Sensornummer die y Koordinate errechnen

   y = 98 + sensorNr % 6 * 21;

Deine ganze Ausgabeorgie dampft sich damit ein zu

1
void outputSensor( uint8_t sensorNr )

2
{

3
  int x = 175 + sensorNr / 6 * 247;

4
  int y =  98 + sensorNr % 6 * 21;

5


6
  outtgValue( x, y, Temperatur[sensorNr] );

7


8
  if( Temperatur[sensorNr] > TempgWert[sensorNr] ) {

9
    gotoxy( x - 50, y );

10
    uart_puts( "O" );

11
  }

12
  else {

13
    gotoxy( x - 50, y );

14
    uart_puts( "m" );

15
  }

16
}



Fertig. Diese paar Codezeilen (dieser Post und der vorhergehende) 
ersetzen die ganze komplizierte "Orgie" die du da hattest.

Aber du musst anfangen zu programmieren und nicht einfach nur COde zu 
duplizieren! Dein µC kann rechnen! Benutze das. UNd wenn dir Funktionen 
dafür nicht passen (wie zb die gotoxy) dann musst du sie dir eben 
passend machen!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2564959
Lesenswert?
• ▲
▼ 
Hallo Karl Heinz Buchegger,
vielen vielen Dank das hätte ich in so kurzer zeit nicht Geschaft.
Um die Pixelposition so wie von Ihnen vorgeschlagen muss ich den 
LCD-Controller noch Umschreiben.
Vom Temperratur-Modul kommen die  Werte wie folgt:
SensorNummer, Vorzeichen, 2stellen vorm Punkt, Punkt,1 stellen nachdem 
Punkt
zb.+18.4
Im Display wird mir 29127 angezeigt.
mfg
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2565130
Lesenswert?
• ▲
▼ 
Johann schrieb:

> SensorNummer, Vorzeichen, 2stellen vorm Punkt, Punkt,1 stellen nachdem
> Punkt
> zb.+18.4

Das Vorzeichen wäre kein Problem. atoi würde damit klarkommen.
Aber der Dezimalpunkt.

Du hast überall nur int vorgesehen, daher bin ich davon ausgegangen, 
dass es keine Nachkommastellen gibt.
Aber ist kein Problem. Dann wird eben im int immer das 10-fache des 
Temperaturwertes gespeichert. Die Zeile muss dann etwas anders zerlegt 
werden um die Zahl als Zahl zu erhalten.

> Im Display wird mir 29127 angezeigt.

Dann geht mit der Übertragung was schief. Lass durch doch mal die 
empfangene Zeile auf deinem LCD ausgeben, nachdem sie zusammengesetzt 
wurde.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann Gast #2565847
Lesenswert?
• ▲
▼ 
ich habe beim Tempmodul Testweise erstmal nur die ersten 4 Zeichen 
ausgeben lassen,1+22 für einen Sensor.
Bekomme leider immernoch null angezeigt.
Sende ich die Zeichen zum Terminal in ASCII wirds mir korrekt angezeigt.
mfg
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #2568496
Lesenswert?
• ▲
▼ 
Johann schrieb:
> So nun gehts :)
> eine Frage hät ich noch, wie kann ich mit atoi mein Vorzeichen mit
> ausgeben.
> kann mir bitte einer von ihnen weiterhelfen

Du kannst ja bei der Ausgabe zb prüfen, ob deine Zahl >= 0 ist und wenn 
ja, erst mal ein '+' ausgeben.

(Andere Möglichkeit wäre sprintf zu benutzen. Das kann man auch anweisen 
auf jeden Fall ein Vorzeichen zu erzeugen)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren