Forum: Mikrocontroller und Digitale Elektronik Arduino Mega 2560 verwirrt oder ich?


Arduino Mega 2560 verwirrt oder ich?
von M. N. (marco2228)

Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich bin gerade dabei drei Signale mit einem Arduino Mega 2560 
auszuwerten. (Ein-Aus, PWM, Analog)
Das Arduino Board erkennt weder high, noch low Signale. Entweder muss 
ich im Programm etwas falsch gemacht haben, oder das neue Board ist 
platt.

Das Auslesen und Anzeigen des Analogsignals funktioniert allerdings ohne 
Probleme.

Hier mal der Anfang vom Code:

1
//--------------------------------------------------------------------------------Isometer Initialisierung------------------------------------------------------------------------------

2
3
const int OK_HS = 8;

4
const int M_HS = 9;

5
6
long high;

7
long low;

8
long period;

9
long freq;

10
int duty_cycle;

11
int Rf=0;

12
int analog_temp=0;

13
int temp=0;

14
//---------------------------------------------------------------------------------Thermistor------------------------------------------------------------------------------------------

15
16
//   Thermistor an Pin A0

17
18
const int thermistor = A0;

19
20
void setup() {

21
  

22
  lcd.begin(16,2);

23
  lcd.display();

24
  lcd.clear();

25
  lcd.noCursor();

26
  lcd.print("IMD&Thermistor");

27
  

28
  pinMode(OK_HS, INPUT);

29
  pinMode(M_HS,INPUT);

30
  pinMode(thermistor,INPUT);

31
  delay(200);

32
  

33
  }

34
  

35
void loop() {

36
  

37
high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high

38
low = pulseIn(M_HS,LOW,1000000);                    // Measuring low

39
40
if(OK_HS == 1)                                       // Einlesen Status Pin OK_HS

41
{

42
  lcd.clear();

43
  lcd.setCursor(0,0);

44
  lcd.print("STATUS:");

45
  lcd.setCursor(0,1);

46
  lcd.print("NO FAULT-OKAY");

47
  delay(1000);

48
}

49
else

50
{

51
  lcd.clear();

52
  lcd.setCursor(0,0);

53
  lcd.print("STATUS:");

54
  lcd.setCursor(0,1);

55
  lcd.print("IMD ERROR");

56
  delay(1000);

57
}


Egal, was ich mache (z.B. if(OK_HS == 1)  ändern zu: if(OK_HS == 0) ) , 
er geht immer in die else "Option".

Findet Ihr einen Fehler im Code?

Besten Dank,
Marco

Edit:
Ich habe von den Eingängen des Arduino Boards zu der Arduino Masse ein 
Oszilloskop angeschlossen. Alle Werte sind gut. 4,96V am OK_HS und ein 
PWM Signal mit gleicher Spannung an M_HS.

  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Ape (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
const int OK_HS = 8;

Versuch mal if(OK_HS == 8) und überlege dann weiter ;).

Gruß

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M.N. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
1
const int OK_HS = 8;


...

1
if(OK_HS == 1)                                       // Einlesen Status Pin OK_HS

2
{

3
  ...

4
}

5
else

6
{

7
  ...

8
 }


Na, klingelts?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Fang doch erstmal einfach an z.B. Taster Einlesen und LED blinken 
lassen. Das hat noch keinem geschadet und danach weist du auch wie man 
mit dem Arduino einen Pin einliest.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
>
1
> if(OK_HS == 1)                                       // Einlesen Status Pin OK_HS

2
>


Seit wann liest man denn so den Status einer Leitung ein?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Oh je, verdammt, das ist logisch.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ok, ich habe es hin bekommen.

1
//-----------------------------------------------------------------------------------LCD Initialization--------------------------------------------------------------

2
#include <LiquidCrystal.h>

3
4
const int LCD_D7 = 2;

5
const int LCD_D6 = 3;

6
const int LCD_D5 = 4;

7
const int LCD_D4 = 5;

8
const int LCD_Enable = 6;

9
const int LCD_RS = 7;

10
11
LiquidCrystal lcd(LCD_RS, LCD_Enable, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

12
13
//--------------------------------------------------------------------------------Isometer Initialization------------------------------------------------------------------------------

14
15
int OK_HS = 8;

16
int M_HS = 9;

17
18
long high;

19
long low;

20
long period;

21
long freq;

22
int duty_cycle;

23
int Rf=0;

24
int analog_temp=0;

25
int temp=0;

26
//---------------------------------------------------------------------------------Thermistor------------------------------------------------------------------------------------------

27
28
//   The thermistor is connected of A0 pin of Arduino Mega

29
30
const int thermistor = A0;

31
32
void setup() {

33
  

34
  lcd.begin(16,2);

35
  lcd.display();

36
  lcd.clear();

37
  lcd.noCursor();

38
  lcd.print("IMD&Thermistor");

39
  

40
  pinMode(OK_HS, INPUT);

41
  pinMode(M_HS,INPUT);

42
  pinMode(thermistor,INPUT);

43
  delay(200);

44
  

45
  }

46
  

47
void loop() {

48
  

49
int OK_HS_state = digitalRead(OK_HS);

50
int M_HS_state = digitalRead(M_HS);

51
52
high =pulseIn(M_HS,HIGH, 1000000);                  // Measuring high for 2 seconds max

53
low = pulseIn(M_HS,LOW, 1000000);                    // Measuring low for 2 secs max

54
55
if(OK_HS_state == 1)                                       // Checking the status pin, OK_HS

56
{

57
  lcd.clear();

58
  lcd.setCursor(0,0);

59
  lcd.print("STATUS:");

60
  lcd.setCursor(0,1);

61
  lcd.print("NO FAULT-OKAY");

62
  delay(1000);

63
}

64
else

65
{

66
  lcd.clear();

67
  lcd.setCursor(0,0);

68
  lcd.print("STATUS:");

69
  lcd.setCursor(0,1);

70
  lcd.print("IMD ERROR");

71
  delay(1000);

72
}


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Weiter geht der Code wie folgt:
1
if(high==0)                                   // Means that f=0 Hz and the value is LOW

2
{

3
  lcd.clear();

4
  lcd.setCursor(0,0);

5
  lcd.print("IMD OFF OR");

6
  lcd.setCursor(0,1);

7
  lcd.print("SHORT TO KI.31");

8
  delay(1000);

9
}

10
else if (low==0)                              // Means that f=0 Hz and the value is HIGH

11
{

12
  lcd.clear();

13
  lcd.setCursor(0,0);

14
  lcd.print("SHORT TO");

15
  lcd.setCursor(0,1);

16
  lcd.print("Ub+(KI.15)");

17
  delay(1000);

18
}

19
20
if(high!=0 && low!=0)

21
{

22
  period = (high+low)/1000000;

23
  freq = 1/period;

24
  duty_cycle = (high/period)*100;              // Duty Cycle of PWM signal of M_HS calculated

25
  

26
  if(freq >= 9 && freq <= 11)

27
  {

28
    

29
    

30
    lcd.clear();

31
    lcd.setCursor(0,0);

32
    lcd.print("NORMAL CONDITION");

33
   

34
    delay(1000);

35
    

36
      //------------------------------------- Start 10 Hz-------------------------------------------------------------------

37
    if(duty_cycle >4.98 && duty_cycle < 5.02)

38
    {

39
      Rf=50000;                            //in kOhms

40
      lcd.clear();

41
      lcd.setCursor(0,0);

42
      lcd.print("Rf :");

43
      lcd.setCursor(0,1);

44
      lcd.print(Rf,DEC);

45
      lcd.setCursor(8,1);

46
      lcd.print("k Ohms");

47
      

48
      delay(1000);

49
    }

50
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

51
    {

52
      Rf=0;                            //in kOhms

53
      lcd.clear();

54
      lcd.setCursor(0,0);

55
      lcd.print("Rf :");

56
      lcd.setCursor(0,1);

57
      lcd.print(Rf,DEC);

58
      lcd.setCursor(8,1);

59
      lcd.print("k Ohms");

60
      

61
      delay(1000);

62
    }

63
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

64
    {

65
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

66
     

67
      lcd.clear();

68
      lcd.setCursor(0,0);

69
      lcd.print("Rf :");

70
      lcd.setCursor(0,1);

71
      lcd.print(Rf,DEC);

72
      lcd.setCursor(8,1);

73
      lcd.print("k Ohms");

74
      

75
      delay(1000);

76
    }

77
  }

78
  //------------------------------------- END 10 Hz-------------------------------------------------------------------

79
 

80
 

81
  //------------------------------------- Start 20 Hz-------------------------------------------------------------------

82
  if(freq >= 19 && freq <= 21)

83
  {

84
    

85
    

86
    lcd.clear();

87
    lcd.setCursor(0,0);

88
    lcd.print("UNDER VOLTAGE");

89
    lcd.setCursor(0,1);

90
    lcd.print("CONDITION");

91
    delay(1000);

92
    

93
    if(duty_cycle >4.98 && duty_cycle < 5.02)

94
    {

95
      Rf=50000;                            //in kOhms

96
      lcd.clear();

97
      lcd.setCursor(0,0);

98
      lcd.print("Rf :");

99
      lcd.setCursor(0,1);

100
      lcd.print(Rf,DEC);

101
      lcd.setCursor(8,1);

102
      lcd.print("k Ohms");

103
      

104
      delay(1000);

105
    }

106
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

107
    {

108
      Rf=0;                            //in kOhms

109
      lcd.clear();

110
      lcd.setCursor(0,0);

111
      lcd.print("Rf :");

112
      lcd.setCursor(0,1);

113
      lcd.print(Rf,DEC);

114
      lcd.setCursor(8,1);

115
      lcd.print("k Ohms");

116
      

117
      delay(1000);

118
    }

119
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

120
    {

121
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

122
     

123
      lcd.clear();

124
      lcd.setCursor(0,0);

125
      lcd.print("Rf :");

126
      lcd.setCursor(0,1);

127
      lcd.print(Rf,DEC);

128
      lcd.setCursor(8,1);

129
      lcd.print("k Ohms");

130
      

131
      delay(1000);

132
    }

133
  }

134
      

135
 //-------------------------------------------------------------20 Hz END---------------------------------------------------------------------------------------------

136
 

137
 //-------------------------------------------------------------30 Hz START---------------------------------------------------------------------------------------------

138
139
 if(freq >= 29 && freq <= 31)

140
  {

141
    

142
    

143
    lcd.clear();

144
    lcd.setCursor(0,0);

145
    lcd.print("SPEED START");

146
    lcd.setCursor(0,1);

147
    lcd.print("CONDITION");

148
    delay(1000);

149
    

150
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

151
    {

152
                        

153
      lcd.clear();

154
      lcd.setCursor(0,0);

155
      lcd.print("INSULATION:");

156
      lcd.setCursor(0,1);

157
      lcd.print("GOOD");

158
       delay(1000);

159
    }

160
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

161
    {

162
                        

163
      lcd.clear();

164
      lcd.setCursor(0,0);

165
      lcd.print("INSULATION:");

166
      lcd.setCursor(0,1);

167
      lcd.print("BAD");

168
       delay(1000);

169
    }

170
    

171
  }

172
    

173
 //-------------------------------------------------------------30 Hz END---------------------------------------------------------------------------------------------

174
175
 //-------------------------------------------------------------40 Hz START---------------------------------------------------------------------------------------------

176
177
 if(freq >= 39 && freq <= 41)

178
  {

179
    

180
    

181
    lcd.clear();

182
    lcd.setCursor(0,0);

183
    lcd.print("IMD ERROR");

184
    lcd.setCursor(0,1);

185
    lcd.print("DETECTED");

186
    delay(1000);

187
    

188
  }

189
  

190
  //-------------------------------------------------------------40 Hz END---------------------------------------------------------------------------------------------

191
192
  //-------------------------------------------------------------50 Hz START--------------------------------------------------------------------------------------------

193
 if(freq >= 49 && freq <= 51)

194
  {

195
    

196
    

197
    lcd.clear();

198
    lcd.setCursor(0,0);

199
    lcd.print("GROUND ERROR");

200
    lcd.setCursor(0,1);

201
    lcd.print("DETECTED");

202
    delay(1000);

203
  }

204
  

205
  //-------------------------------------------------------------50 Hz END--------------------------------------------------------------------------------------------

206
  

207
  analog_temp = analogRead(thermistor);

208
  

209
  temp = (0.955*analog_temp)-544.6;

210
  

211
   lcd.clear();

212
   lcd.setCursor(0,0);

213
   lcd.print("TEMPERATURE");

214
   lcd.setCursor(0,1);

215
   lcd.print(temp,DEC);

216
   delay(1000);


Habt ihr vielleicht noch nen Tipp, was ich bei der PulseIn Funktion 
falsch gemacht habe?

Danke

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Furchtbarer Code.



>   freq = 1/period;

Ich denke nicht, dass da irgendwas sinnvolles rauskommt. period ist ein 
long, damit kann diese Division nur 0 oder 1 ergeben. Hauptsächlich aber 
0.

Und selbst wenn da das Problem korrigierst, kann da nur ein Wert 
zwischen 0 und 1 rauskommen. Daher ist sowas

>   if(freq >= 9 && freq <= 11)

völlig sinnfrei


Lass dir halt mal die Werte die du errechnest ausgeben, ehe du sie 
weiter benutzt!

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
> Habt ihr vielleicht noch nen Tipp, was ich bei der PulseIn
> Funktion falsch gemacht habe?

Ich kann dir sagen was du generell falsch machst:
Du schreibst viel zu viel Code in einem Rutsch, in der irrigen Annahme, 
dass du es auf Anhieb hinkriegst. Das 'Wichtigste' in deinem Code 
scheint zu sein, dass beide Zeilen des LCD immer gut gefüllt sind. 
Funktion ist egal - die Haupzsache etwas steht auf dem LCD. Es sind zwar 
die Dinge, die zum momentanen Zeitpunkt noch keinen interessieren (weil 
du noch in der Entwicklungsphase bist und erst mal die Grundfunktion 
sicherstellen musst), aber das stört dich nicht weiter. Dabei könnte man 
das LCD so schön benutzen, damit einem das Programm gemessene bzw. 
errechnete Werte ausgibt, damit man auch mal die Zahlen sieht, die dann 
letzten Endes als die Basis deiner Ausgaben benutzt werden.

Und: du überlegst dir nicht, wie und wo du sinnvoll im Prinzip immer 
gleiche Codeteile in Funktionen auslagern kannst, so dass dein Hauptcode 
kürzer wird, damit du den Überblick behalten kannst.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Karl Heinz Buchegger schrieb:

>>   freq = 1/period;
>
> Ich denke nicht, dass da irgendwas sinnvolles rauskommt. period ist ein
> long, damit kann diese Division nur 0 oder 1 ergeben. Hauptsächlich aber
> 0.

Bzw. jetzt sehe ich es erst. Das zieht sich ja noch weiter vor.

  period = (high+low)/1000000;
  freq = 1/period;

period ist praktisch ständig 0.


> Habt ihr vielleicht noch nen Tipp, was ich ... falsch gemacht habe?

Du hast den Anfängerfehler Nummero Uno gemacht:
Du denkst du könntest das alles auch einfach so im vorübergehen 
irgendwie lernen und hast daher darauf verzichtet, dir mal in einem 
Einsteigerbuch die Grundlagen deiner Programmiersprache zu lernen. Ganz 
konkret das überaus wichtige Kapitel über Datentypen und wie sie in 
arithmetischen Ausdrücken sich auswirken.
Du unterschätzt die Komplexität die sich hinter dem Vorgang "Ein 
Programm schreiben" verbirgt aber ganz massiv. Ein paar Beispiele sich 
durchzulesen, reicht eben nicht um Programmieren zu lernen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hallo Karl Heinz,

vielen Dank für deine Nachrichten.
Es ist zwar ein privates Projekt, aber da ich keine Zeit hatte und 
Arduino nicht programmieren kann, hatte ich das Programmieren an einen 
Freelancer von Elance.com abgegeben.

Naja, nun bin ich schlauer und mache das nächstes Mal wohl besser 
selber.

Dann werde ich mal anfangen, mich in das Thema einzulesen.
Würdest du den Code komplett neu machen oder versuchen zu flicken?

Beste Grüße,
Marco

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:

> Dann werde ich mal anfangen, mich in das Thema einzulesen.
> Würdest du den Code komplett neu machen oder versuchen zu flicken?

Gibt es da noch mehr Code?

Das bisherige ist ja nicht so schwer zu flicken.

period, freq und duty_cycle müssen zumindest float sein.
1
float period;

2
float freq;

3
float duty_cycle;


Hier muss eine Gleitkommadivision hin
1
  period = (high+low) / 1000000.0;


und für die den Code unsäglich in die Länge ziehenden Ausgaben von 
konstanten Texten in die 2 Zeilen würde ich mir gleich mal eine Funktion 
schreiben

1
void lcdUpdate( const char* text1, const char* text2 )

2
{

3
  lcd.clear();

4
  lcd.setCursor(0,0);

5
  lcd.print( text1 );

6
  lcd.setCursor(0,1);

7
  lcd.print( text2 );

8
}


was den ganzen restlichen Code gleich mal verkürzt. Zb

1
  if( OK_HS_state )                                       // Checking the status pin, OK_HS

2
    lcdUpdate( "STATUS:", "NO FAULT-OKAY" );

3
  else

4
    lcdUpdate( "STATUS:", "IMD ERROR" );

5
6
  delay(1000);

7
}


anstelle von
1
if(OK_HS_state == 1)                                       // Checking the status pin, OK_HS

2
{

3
  lcd.clear();

4
  lcd.setCursor(0,0);

5
  lcd.print("STATUS:");

6
  lcd.setCursor(0,1);

7
  lcd.print("NO FAULT-OKAY");

8
  delay(1000);

9
}

10
else

11
{

12
  lcd.clear();

13
  lcd.setCursor(0,0);

14
  lcd.print("STATUS:");

15
  lcd.setCursor(0,1);

16
  lcd.print("IMD ERROR");

17
  delay(1000);

18
}


und beim restlichen Code sind ähnliche Einsparungen in der Länge (und 
damit Gewinn an Überschaubarkeit) zu erzielen, indem man sich ein paar 
angepasste Ausgaberoutinen schreibt, die zb die Kombination aus Label + 
Wert + Einheit in einer Funktion zusammenfasst.

1
void lcdUpdate( const char* label, long value, const char* unit )

2
{

3
  lcd.clear();

4
  lcd.setCursor(0,0);

5
  lcd.print( label );

6
  lcd.setCursor(0,1);

7
  lcd.print( value, DEC );

8
  lcd.setCursor(8,1);

9
  lcd.print( unit );

10
}


damit dampft sich dann zb ein:
1
  if(freq >= 9.0 && freq <= 11.0)

2
  {

3
    lcdUpdate( "NORMAL CONDITION", "" );

4
    delay(1000);

5
    

6
      //------------------------------------- Start 10 Hz-------------------------------------------------------------------

7
    if(duty_cycle > 4.98 && duty_cycle < 5.02)

8
      Rf = 50000;

9
10
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

11
      Rf = 0;

12
13
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

14
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

15
16
    lcdUpdate( "Rf :", Rf, "k Ohms");

17
    delay(1000);

18
  }

19
20
  else if( freq >= 19 && freq <= 21 )

21
  {

22
    ....


und das ist schon ganz was anderes, als der genau gleiche Code im 
Original, der sich anstatt über 17 Zeilen über ganze 2 Seiten hinzieht.
Jetzt sieht man auch, dass da mit den Grenzabfragen was nicht so ganz 
stimmen kann. Welche Ausgabe soll denn gemacht werden, wenn der 
duty_cycle sich zu 4.5 errechnet hat? Wird das dann einfach ignoriert 
oder was? D.h. Hier ist noch gar nicht fertig programmiert worden. 
Zumindest sollte ein offensichtlich unsinniger Wert angezeigt werden, 
damit wenigstens überhaupt etwas angezeigt wird (und der Benutzer eine 
Rückmeldung hat) und nicht wie im Original einfach nichts.


Und PS: alleine die delay da drinnen zeigen schon, dass der ganze 
Programm- bzw. Anzeigen-Aufbau nicht stimmt.


> aber da ich keine Zeit hatte und Arduino nicht programmieren kann

Das hat auch weniger mit Arduino zu tun als damit, ob man generell 
programmieren kann. Denn die Sachen um die es jetzt geht, die sind in 
allen Programmiersprachen mehr oder weniger gleich (sofern es Datentypen 
in der Sprache gibt).

> Naja, nun bin ich schlauer und mache das nächstes Mal
> wohl besser selber.
>
> Dann werde ich mal anfangen, mich in das Thema einzulesen.

Bei allem Respekt.
Aber bist du sicher, dass du es dadurch nicht noch schlimmer machst?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
> hatte ich das Programmieren an einen Freelancer von Elance.com abgegeben.

Ich hoffe du hast ihm für dieses Machwerk nicht zu viel bezahlt.
Wenn mir jemand bei einem Bewerbungsgespräch so etwas als Beispiel 
vorlegt, für etwas das er schon gemacht hat, dann würde ich ihn nicht 
nehmen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Karl Heinz Buchegger schrieb:
>> hatte ich das Programmieren an einen Freelancer von Elance.com abgegeben.
>
> Ich hoffe du hast ihm für dieses Machwerk nicht zu viel bezahlt.
> Wenn mir jemand bei einem Bewerbungsgespräch so etwas als Beispiel
> vorlegt, für etwas das er schon gemacht hat, dann würde ich ihn nicht
> nehmen.

So wie es aussieht scheinbar definitiv zuviel.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:
> Karl Heinz Buchegger schrieb:
>>> hatte ich das Programmieren an einen Freelancer von Elance.com abgegeben.
>>
>> Ich hoffe du hast ihm für dieses Machwerk nicht zu viel bezahlt.
>> Wenn mir jemand bei einem Bewerbungsgespräch so etwas als Beispiel
>> vorlegt, für etwas das er schon gemacht hat, dann würde ich ihn nicht
>> nehmen.
>
> So wie es aussieht scheinbar definitiv zuviel.

Es heißt zwar immer "Unter Blinden ist auch der Einäugige ein König" 
aber das Gebotene ist mir auch für einen Einäugigen zu wenig, als dass 
ich ihn als Führer engagieren würde. :-)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Nun bin ich bis hier gekommen:

1
#include <LiquidCrystal.h>

2
3
const int LCD_D7 = 2;

4
const int LCD_D6 = 3;

5
const int LCD_D5 = 4;

6
const int LCD_D4 = 5;

7
const int LCD_Enable = 6;

8
const int LCD_RS = 7;

9
10
LiquidCrystal lcd(LCD_RS, LCD_Enable, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

11
12
int OK_HS = 8;

13
int M_HS = 9;

14
15
long high;

16
long low;

17
float period;

18
float freq;

19
float duty_cycle;

20
int Rf=0;

21
int analog_temp=0;

22
int temp=0;

23
24
const int thermistor = A0;

25
26
void setup() {

27
  

28
  lcd.begin(16,2);

29
  lcd.display();

30
  lcd.clear();

31
  lcd.noCursor();

32
  lcd.print("IMD&Thermistor");

33
  

34
  pinMode(OK_HS, INPUT);

35
  pinMode(M_HS,INPUT);

36
  pinMode(thermistor,INPUT);

37
  delay(200);

38
  }

39
  

40
void loop() {

41
  

42
  int OK_HS_state = digitalRead(OK_HS);

43
  int M_HS_state = digitalRead(M_HS);

44
45
  high =pulseIn(M_HS,HIGH, 1000000);                  // Measuring high for 2 seconds max

46
  low = pulseIn(M_HS,LOW, 1000000);                    // Measuring low for 2 secs max

47
48
49
  if( OK_HS_state )                                       // Checking the status pin, OK_HS

50
    lcdUpdate( "STATUS:", "NO FAULT-OKAY" );

51
  else

52
    lcdUpdate( "STATUS:", "IMD ERROR" );

53
54
  delay(1000);

55
  }

56
57
  if(high==0)                                   // Means that f=0 Hz and the value is LOW

58
{

59
    lcd.clear();

60
    lcd.setCursor(0,0);

61
    lcd.print("IMD OFF OR");

62
    lcd.setCursor(0,1);

63
    lcd.print("SHORT TO KI.31");

64
    delay(1000);

65
}

66
else if (low==0)                              // Means that f=0 Hz and the value is HIGH

67
{

68
  lcd.clear();

69
  lcd.setCursor(0,0);

70
  lcd.print("SHORT TO");

71
  lcd.setCursor(0,1);

72
  lcd.print("Ub+(KI.15)");

73
  delay(1000);

74
}

75
76
if(high!=0 && low!=0)

77
{

78
  period = (high+low) / 1000000.0;

79
  freq = 1/period;

80
  duty_cycle = (high/period)*100;              // Duty Cycle of PWM signal of M_HS calculated

81
  

82
  if(freq >= 9.0 && freq <= 11.0)

83
  {

84
    lcdUpdate( "NORMAL CONDITION", "" );

85
    delay(1000);

86
    

87
    if(duty_cycle >4.98 && duty_cycle < 5.02)

88
      Rf=50000;                            //in kOhms

89
      

90
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

91
      Rf=0;                            //in kOhms

92
 

93
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

94
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

95
      

96
    lcdUpdate( "Rf :", Rf, "k Ohm");

97
    delay(1000);

98
  }

99
  

100
  else if(freq >= 19.0 && freq <= 21.0)

101
  {

102
    lcdUpdate( "UNDERVOLTAGE", "CONDITION");

103
    delay(1000);

104
    

105
    if(duty_cycle >4.98 && duty_cycle < 5.02)

106
      Rf=50000;                            //in kOhms

107
      

108
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

109
      Rf=0;                            //in kOhms

110
111
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

112
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

113
      

114
    lcdUpdate( "Rf :", Rf, "k Ohm");

115
    delay(1000); 

116
    }

117
  

118
 else if(freq >= 29.0 && freq <= 31.0)

119
  {

120
    lcdUpdate( "Schnellstart", "");

121
    delay(1000);    

122
  

123
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

124
    lcdUpdate( "Riso:", "OK");

125
    delay(1000);

126
     

127
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

128
     lcdUpdate( "Riso", "Schlecht");

129
     delay(1000); 

130
  }

131
    

132
 if(freq >= 39 && freq <= 41)

133
  {

134
    lcdUpdate( "Isometer", "nicht OK");

135
    delay(1000);

136
    

137
  }

138
  

139
 if(freq >= 49 && freq <= 51)

140
  {

141
    lcdUpdate( "GND", "Fehler");

142
    delay(1000);

143
  }

144
145
  

146
  analog_temp = analogRead(thermistor);

147
  

148
  temp = (0.955*analog_temp)-544.6;

149
  

150
  lcdUpdate ("Temperatur:", temp, "Grad")

151
  delay(1000);

152
}

153
}

154
void lcdUpdate( const char* label, long value, const char* unit )

155
{

156
  lcd.clear();

157
  lcd.setCursor(0,0);

158
  lcd.print( label );

159
  lcd.setCursor(0,1);

160
  lcd.print( value, DEC );

161
  lcd.setCursor(8,1);

162
  lcd.print( unit );

163
}


Wie kann ich den Code hier so posten, wie du es tust? Das ist wirklich 
super übersichtlich. Besser als im Arduino Editor.
Nochmal Danke für deine Mühe;)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        STK500-Besitzer (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:
> Wie kann ich den Code hier so posten, wie du es tust? Das ist wirklich
> super übersichtlich.

Guck mal in den oberen Teil des  Textfensters. Das steht etwas von 
"Formatierung".
Für Arduino dürfte "[ c ]" und "[ /c ]" ohne Leerzeichen gelten.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
STK500-Besitzer schrieb:
> M. N. schrieb:
>> Wie kann ich den Code hier so posten, wie du es tust? Das ist wirklich
>> super übersichtlich.
>
> Guck mal in den oberen Teil des  Textfensters. Das steht etwas von
> "Formatierung".
> Für Arduino dürfte "[ c ]" und "[ /c ]" ohne Leerzeichen gelten.

Danke:)

Habe versehentlich den falschen Code hochgeladen, daher kann ich es 
direkt mal ausprobieren.

1
#include <LiquidCrystal.h>

2
3
const int LCD_D7 = 2;

4
const int LCD_D6 = 3;

5
const int LCD_D5 = 4;

6
const int LCD_D4 = 5;

7
const int LCD_Enable = 6;

8
const int LCD_RS = 7;

9
10
LiquidCrystal lcd(LCD_RS, LCD_Enable, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

11
12
13
int OK_HS = 8;

14
int M_HS = 9;

15
16
long high;

17
long low;

18
float period;

19
float freq;

20
float duty_cycle;

21
int Rf=0;

22
int analog_temp=0;

23
int temp=0;

24
25
//   The thermistor is connected of A0 pin of Arduino Mega

26
27
const int thermistor = A0;

28
29
void setup() {

30
  

31
  lcd.begin(16,2);

32
  lcd.display();

33
  lcd.clear();

34
  lcd.noCursor();

35
  lcd.print("Riso & Motortemp");

36
  

37
  pinMode(OK_HS, INPUT);

38
  pinMode(M_HS,INPUT);

39
  pinMode(thermistor,INPUT);

40
  delay(200);

41
  

42
  }

43
  

44
void loop() {

45
  

46
  int OK_HS_state = digitalRead(OK_HS);

47
  int M_HS_state = digitalRead(M_HS);

48
49
  high =pulseIn(M_HS,HIGH, 1000000);                  // Measuring high for 2 seconds max

50
  low = pulseIn(M_HS,LOW, 1000000);                    // Measuring low for 2 secs max

51
52
53
  if( OK_HS_state )                                       // Checking the status pin, OK_HS

54
    lcdUpdate( "Status:", "Kein Fehler" );

55
  else

56
    lcdUpdate( "Status:", "FEHLER" );

57
58
  delay(1000);

59
  }

60
61
  if(high==0)                                   // Means that f=0 Hz and the value is LOW

62
{

63
   lcdUpdate ("IMD aus oder","Kurzschl. Kl.31");

64
   delay(1000);

65
}

66
else if (low==0)                              // Means that f=0 Hz and the value is HIGH

67
{

68
   lcdUpdate ("Kurzschluss zu","Ub+ / Kl.15");

69
   delay(1000);

70
}

71
72
if(high!=0 && low!=0)

73
{

74
  period = (high+low) / 1000000.0;

75
  freq = 1/period;

76
  duty_cycle = (high/period)*100;              // Duty Cycle of PWM signal of M_HS calculated

77
  

78
  if(freq >= 9.0 && freq <= 11.0)

79
  {

80
    lcdUpdate( "Normalzustand", "" );

81
    delay(1000);

82
    

83
    if(duty_cycle >4.98 && duty_cycle < 5.02)

84
      Rf=50000;                            //in kOhms

85
      

86
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

87
      Rf=0;                            //in kOhms

88
 

89
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

90
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

91
      

92
    lcdUpdate( "Rf :", Rf, "k Ohm");

93
    delay(1000);

94
  }

95
  

96
  else if(freq >= 19.0 && freq <= 21.0)

97
  {

98
    lcdUpdate( "Unterspannung", "erkannt");

99
    delay(1000);

100
    

101
    if(duty_cycle >4.98 && duty_cycle < 5.02)

102
      Rf=50000;                            //in kOhms

103
      

104
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

105
      Rf=0;                            //in kOhms

106
107
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

108
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

109
      

110
    lcdUpdate( "Rf :", Rf, "k Ohm");

111
    delay(1000); 

112
    }

113
  

114
 else if(freq >= 29.0 && freq <= 31.0)

115
  {

116
    lcdUpdate( "Schnellstart", "Messung");

117
    delay(1000);    

118
  

119
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

120
    lcdUpdate( "Isolation", "OK");

121
    delay(1000);

122
     

123
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

124
     lcdUpdate( "Isolation", "Fehlerhaft");

125
     delay(1000);

126
    

127
  }

128
    

129
 if(freq >= 39 && freq <= 41)

130
  {

131
    lcdUpdate( "Geraetefehler", "erkannt");

132
    delay(1000);

133
    

134
  }

135
  

136
 if(freq >= 49 && freq <= 51)

137
  {

138
    lcdUpdate( "Erdungsfehler", "erkannt");

139
    delay(1000);

140
  }

141
  

142
  

143
  analog_temp = analogRead(thermistor);

144
  

145
  temp = (0.955*analog_temp)-544.6;

146
  

147
  lcdUpdate ("Temperatur:", temp, "Grad")

148
  delay(1000);

149
}

150
}

151
void lcdUpdate( const char* label, long value, const char* unit )

152
{

153
  lcd.clear();

154
  lcd.setCursor(0,0);

155
  lcd.print( label );

156
  lcd.setCursor(0,1);

157
  lcd.print( value, DEC );

158
  lcd.setCursor(8,1);

159
  lcd.print( unit );

160
}


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
1
 else if(freq >= 29.0 && freq <= 31.0)

2
  {

3
    lcdUpdate( "Schnellstart", "Messung");

4
    delay(1000);    

5
  

6
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

7
    lcdUpdate( "Isolation", "OK");

8
    delay(1000);

9
     

10
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

11
     lcdUpdate( "Isolation", "Fehlerhaft");

12
     delay(1000);

13
    

14
  }


Du hast Glück, dass es sich nur um die Delays handelt aber nichts desto 
trotz hast du mit deiner Änderung die Logik verändert.

Code-Einrückung ist KEIN akademisches Gefasel, damit man Schüler quälen 
kann! Code-Einrückung ist ein WErkzeug um die Struktur des Codes, seine 
logische Struktur sehen zu können!

1
 else if(freq >= 29.0 && freq <= 31.0)

2
  {

3
    lcdUpdate( "Schnellstart", "Messung");

4
    delay(1000);    

5
  

6
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

7
      lcdUpdate( "Isolation", "OK");

8
     

9
    else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

10
      lcdUpdate( "Isolation", "Fehlerhaft");

11
12
    delay(1000);

13
  }


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
1
}

2
}


da stimmt was in der Einrückungshierarchie nicht!

Nach jeder öffnenden { wird der nachfolgende Code um 2 Zeichen 
eingerückt. Bis zur schliessenden }. Diese wird wieder um 2 Zeichen 
ausgerückt. Die letzte } einer Funktion muss wieder ganz am linken Rand 
sein, sonst stimmt in der Einrückung etwas nicht. Und: 2 } können 
niemals untereinander stehen.


Und? Funktioniert der Code noch?
Du testest hoffentlich regelmässig, ob noch alles geht?
Der Hauptpunkt war meiner Meinung nach das Umändern der Berechnung. 
Danach hätte dein Programm schon funktionieren müssen. Die Schritte 
danach sind Kosmetik um den Stil des Programmes zu verbessern. Aber sie 
ändern nichts mehr an der Funktionalität.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Habe Ordnung in in den Code gebracht und die Klammern passen nun auch, 
aber der Code funktioniert leider nicht mehr, bekomme einige Fehler 
ausgegeben.

der Erste: ISO_neu1_2:56: error: invalid conversion from 'const char*' 
to 'long int'
bezieht sich auf die Zeile:

     lcdUpdate( "Status:", "Kein Fehler" );

Naja, ich hätte eigentlich gern direkt den vernünftigen Code zum Laufen 
gebracht. Aber ich finde in angemessener Zeit nichtmal den ersten 
Fehler. Daher werde ich nun mal versuchen, das Ganze mit der 
modifizierten Berechnung zum Laufen zu bringen;)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:

> der Erste: ISO_neu1_2:56: error: invalid conversion from 'const char*'
> to 'long int'
> bezieht sich auf die Zeile:
>
>      lcdUpdate( "Status:", "Kein Fehler" );

Kann ja nicht so schwer sein.
So viele Funktionen lcdUpdate, die 2 Argumente nimmt hast du ja nicht 
:-)

Also Funktionsdefinition der lcdUpdate Funktion suchen und nachsehen, wo 
du das Argument verbummelt hast.

Wenn ich raten müsste, dann hast du wahrscheinlich hier
1
void lcdUpdate( const char* label, long value, const char* unit )

2
{

3
  ...


das 3. Argument 'unit' irgendwo verbummelt.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
> Naja, ich hätte eigentlich gern direkt den vernünftigen Code
> zum Laufen gebracht.

Tu das.
Es bringt nichts, an dem alten Code rumzuschnitzen, nur weil dir der 
neue Probleme macht.


> Daher werde ich nun mal versuchen, das Ganze mit der
> modifizierten Berechnung zum Laufen zu bringen;

Aha. Das heißt du hast den Fehler Nummero Due gemacht:
Zuviele Änderungen auf einmal, ohne jede einzelne zu testen.

OK. in dem Fall: Gehe zurück auf Start, ändere die Berechnung, und sieh 
erst mal zu, dass du dein Programm in einen korrekten Zustand bringst.

Und dann geht die Aufräumaktion wieder von vorne los.
Lehrgeld - mussten wir alle zahlen


Im Ernst: Eines der Um und Aufs in der Softwareentwicklung ist das 
Arbeiten in kleinen Schritten. Niemand, auch die Profis nicht, kann ein 
hinreichend großes Programm in einem Zug schreiben. Das ist einfach ein 
Trugschluss! Die Komplexität wächst mit der Codelänge schneller, als wir 
Menschen sie überblicken können! Daher: kleine Schritte machen. 
Zwischenziele stecken. Beim Erreichen des Zwischenziels: testen, testen, 
testen. Dabei festgestellte Fehler erst korrigieren, ehe es dann weiter 
geht zum nächsten Zwischenziel.
Der Unterschied zwischen dir und mir ist, dass meine Schritte größer 
sind.

Und natürlich, dass ich mit Fehlermeldungen vom Compiler was anfangen 
kann. Ein 'funktioniert nicht', ist bei mir immer eine Sache, das in der 
Programmlogik was faul ist und nicht, dass ich die Syntax nicht 
hinkriege.
Zweiteres kann man lernen, so wie man eine Fremdsprache an einer 
Volkshochschule lernen kann. Aber ersteres ist dann die Fähigkeit einen 
ansprechenden Roman in dieser Sprache zu schreiben. Natürlich geht das 
nicht von heute auf morgen, aber eine ausreichende Kentniss vom ersteren 
ist eigentlich Grundvoraussetzung, damit der Beginn eines Romans 
überhaupt Sinn macht. Wer kein Englisch kann, hat nun mal schon von 
vorneherein verloren, wenn er einen Krimi auf Englisch schreiben will.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Karl Heinz Buchegger schrieb:
> M. N. schrieb:
>
>> der Erste: ISO_neu1_2:56: error: invalid conversion from 'const char*'
>> to 'long int'
>> bezieht sich auf die Zeile:
>>
>>      lcdUpdate( "Status:", "Kein Fehler" );
>
> Kann ja nicht so schwer sein.

Aaahhh. Reihenfolge der Funktionen im Code!

Sie muss so sein
1
.....

2
3
void lcdUpdate( const char* text1, const char* text2 )

4
{

5
  lcd.clear();

6
  lcd.setCursor(0,0);

7
  lcd.print( text1 );

8
  lcd.setCursor(0,1);

9
  lcd.print( text2 );

10
}

11
12
void lcdUpdate( const char* label, long value, const char* unit )

13
{

14
  lcd.clear();

15
  lcd.setCursor(0,0);

16
  lcd.print( label );

17
  lcd.setCursor(0,1);

18
  lcd.print( value, DEC );

19
  lcd.setCursor(8,1);

20
  lcd.print( unit );

21
}

22
23
void setup()

24
{

25
  ....

26
}

27
28
void loop()

29
{

30
  ....

31
}


Einfaches Prinzip:
Lies den Code von oben nach unten (genau das macht der Compiler auch). 
Bevor du eine Funktion verwenden kannst (also einen Aufruf machst), muss 
die Funktion bekannt sein.
Damit ergibt sich im einfachsten Fall: Zieh die Funktion vor die erste 
Verwendung, und alles ist in Butter.

Der Compiler sucht sich nicht kreuz und quer die Einzelteile zusammen. 
Er liest den Code von oben nach unten. Und zwar nur ein einziges mal.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        R. F.
        (rfr)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Villeicht sollte der TO Gebrauch von verschiedenen Hilfsmittels machen, 
zB die automatische Einrückfunktion seiner IDE und der Gebrauch von 
Assert und Debugausgaben.

Gruss

Robert

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Soo... habe das Gerät am Laufen. Allerdings noch mit dem unaufgeräumten 
Code. Werde das nun mal zusammenfrickeln.

Der Stratege von Elance hat es auch noch geschafft, den Duty-Cycle Wert 
falsch zu berechnen. µs und s sollte man nicht in eine Gleichung 
werfen^^.

Danke nochmal für die ganze Hilfe bisher:)

Achja, ich hatte gestern keinen Zugang mehr zum Arduino Board und dem 
Isowächter, den es auswerten soll. Daher habe ich quasi auf "gut Glück" 
losgelegt.

Hier nun der vorläufige, fast komplett funktionierende Code.

1
//-----------------------------------------------------------------------------------LCD Initialization--------------------------------------------------------------

2
#include <LiquidCrystal.h>

3
4
const int LCD_D7 = 2;

5
const int LCD_D6 = 3;

6
const int LCD_D5 = 4;

7
const int LCD_D4 = 5;

8
const int LCD_Enable = 6;

9
const int LCD_RS = 7;

10
11
LiquidCrystal lcd(LCD_RS, LCD_Enable, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

12
13
//--------------------------------------------------------------------------------Isometer Initialization------------------------------------------------------------------------------

14
15
const int OK_HS = 8;

16
const int M_HS = 9;

17
18
long high;

19
long low;

20
float period;

21
float freq;

22
float duty_cycle;

23
int Rf=0;

24
int analog_temp=0;

25
int temp=0;

26
//---------------------------------------------------------------------------------Thermistor------------------------------------------------------------------------------------------

27
28
//   The thermistor is connected of A0 pin of Arduino Mega

29
30
const int thermistor = A0;

31
32
void setup() {

33
  

34
  lcd.begin(27,2);

35
  lcd.display();

36
  lcd.clear();

37
  lcd.noCursor();

38
  lcd.print("Riso & Motortemp");

39
  

40
  pinMode(OK_HS, INPUT);

41
  pinMode(M_HS,INPUT);

42
  pinMode(thermistor,INPUT);

43
  delay(200);

44
  

45
  }

46
  

47
void loop() {

48
 

49
int OK_HS_state = digitalRead(OK_HS);

50
int M_HS_state = digitalRead(M_HS);

51
  

52
high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high for 2 seconds max

53
low = pulseIn(M_HS,LOW,1000000);                    // Measuring low for 2 secs max

54
55
if(OK_HS_state != 1)                                       // Checking the status pin, OK_HS

56
{

57
  lcd.clear();

58
  lcd.setCursor(0,0);

59
  lcd.print("STATUS:");

60
  lcd.setCursor(0,1);

61
  lcd.print("FEHLER");

62
  delay(1000);

63
}

64
65
66
if(high==0)                                   // Means that f=0 Hz and the value is LOW

67
{

68
  lcd.clear();

69
  lcd.setCursor(0,0);

70
  lcd.print("IMD aus oder");

71
  lcd.setCursor(0,1);

72
  lcd.print("Kurzschl. Kl.31");

73
  delay(1000);

74
}

75
else if (low==0)                              // Means that f=0 Hz and the value is HIGH

76
{

77
  lcd.clear();

78
  lcd.setCursor(0,0);

79
  lcd.print("Kurzschluss zu");

80
  lcd.setCursor(0,1);

81
  lcd.print("Ub+ / KI.15");

82
  delay(1000);

83
}

84
85
if(high!=0 && low!=0)

86
{

87
  period = (high+low)/1000000.0;

88
  freq = 1/period;

89
  duty_cycle = (high/(period*1000000))*100;              // Duty Cycle of PWM signal of M_HS calculated

90
  

91
  if(freq >= 9 && freq <= 11)

92
  {

93
    

94
    

95
    lcd.clear();

96
    lcd.setCursor(0,0);

97
    lcd.print("Normalzustand");

98
    lcd.setCursor(0,1);

99
    lcd.print(freq);

100
   

101
    delay(1000);

102
    

103
      //------------------------------------- Start 10 Hz-------------------------------------------------------------------

104
    if(duty_cycle >4.98 && duty_cycle < 5.02)

105
    {

106
      Rf=50000;                            //in kOhms

107
      lcd.clear();

108
      lcd.setCursor(0,0);

109
      lcd.print("Rf :");

110
      lcd.setCursor(0,1);

111
      lcd.print(Rf,DEC);

112
      lcd.setCursor(8,1);

113
      lcd.print("k Ohm");

114
      

115
      delay(1000);

116
    }

117
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

118
    {

119
      Rf=0;                            //in kOhms

120
      lcd.clear();

121
      lcd.setCursor(0,0);

122
      lcd.print("Rf :");

123
      lcd.setCursor(0,1);

124
      lcd.print(Rf,DEC);

125
      lcd.setCursor(8,1);

126
      lcd.print("k Ohm");

127
      

128
      delay(1000);

129
    }

130
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

131
    {

132
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

133
     

134
      lcd.clear();

135
      lcd.setCursor(0,0);

136
      lcd.print("Rf :");

137
      lcd.setCursor(0,1);

138
      lcd.print(Rf,DEC);

139
      lcd.setCursor(8,1);

140
      lcd.print("k Ohm");

141
      

142
      delay(1000);

143
    }

144
    else

145
    {

146
      lcd.clear();

147
      lcd.setCursor(0,0);

148
      lcd.print ("Duty Cycle nicht erkannt");

149
    }

150
  }

151
  //------------------------------------- END 10 Hz-------------------------------------------------------------------

152
 

153
 

154
  //------------------------------------- Start 20 Hz-------------------------------------------------------------------

155
  if(freq >= 19 && freq <= 21)

156
  {

157
    

158
    

159
    lcd.clear();

160
    lcd.setCursor(0,0);

161
    lcd.print("Unterspannung");

162
    lcd.setCursor(0,1);

163
    lcd.print("erkannt");

164
    delay(1000);

165
    

166
    if(duty_cycle >4.98 && duty_cycle < 5.02)

167
    {

168
      Rf=50000;                            //in kOhms

169
      lcd.clear();

170
      lcd.setCursor(0,0);

171
      lcd.print("Rf :");

172
      lcd.setCursor(0,1);

173
      lcd.print(Rf,DEC);

174
      lcd.setCursor(8,1);

175
      lcd.print("k Ohm");

176
      

177
      delay(1000);

178
    }

179
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

180
    {

181
      Rf=0;                            //in kOhms

182
      lcd.clear();

183
      lcd.setCursor(0,0);

184
      lcd.print("Rf :");

185
      lcd.setCursor(0,1);

186
      lcd.print(Rf,DEC);

187
      lcd.setCursor(8,1);

188
      lcd.print("k Ohm");

189
      

190
      delay(1000);

191
    }

192
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

193
    {

194
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

195
     

196
      lcd.clear();

197
      lcd.setCursor(0,0);

198
      lcd.print("Rf :");

199
      lcd.setCursor(0,1);

200
      lcd.print(Rf,DEC);

201
      lcd.setCursor(8,1);

202
      lcd.print("k Ohm");

203
      

204
      delay(1000);

205
    }

206
  }

207
      

208
 //-------------------------------------------------------------20 Hz END---------------------------------------------------------------------------------------------

209
 

210
 //-------------------------------------------------------------30 Hz START---------------------------------------------------------------------------------------------

211
212
 if(freq >= 29 && freq <= 31)

213
  {

214
    

215
    

216
    lcd.clear();

217
    lcd.setCursor(0,0);

218
    lcd.print("Schnellstart");

219
    lcd.setCursor(0,1);

220
    lcd.print("Messung");

221
    delay(1000);

222
    

223
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

224
    {

225
                        

226
      lcd.clear();

227
      lcd.setCursor(0,0);

228
      lcd.print("Isolation:");

229
      lcd.setCursor(0,1);

230
      lcd.print("in Ordnung");

231
       delay(1000);

232
    }

233
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

234
    {

235
                        

236
      lcd.clear();

237
      lcd.setCursor(0,0);

238
      lcd.print("Isolation:");

239
      lcd.setCursor(0,1);

240
      lcd.print("Fehlerhaft");

241
       delay(1000);

242
    }

243
    

244
  }

245
    

246
 //-------------------------------------------------------------30 Hz END---------------------------------------------------------------------------------------------

247
248
 //-------------------------------------------------------------40 Hz START---------------------------------------------------------------------------------------------

249
250
 if(freq >= 39 && freq <= 41)

251
  {

252
    

253
    

254
    lcd.clear();

255
    lcd.setCursor(0,0);

256
    lcd.print("Geraetefehler");

257
    lcd.setCursor(0,1);

258
    lcd.print("erkannt");

259
    delay(1000);

260
    

261
  }

262
  

263
  //-------------------------------------------------------------40 Hz END---------------------------------------------------------------------------------------------

264
265
  //-------------------------------------------------------------50 Hz START--------------------------------------------------------------------------------------------

266
 if(freq >= 49 && freq <= 51)

267
  {

268
    

269
    

270
    lcd.clear();

271
    lcd.setCursor(0,0);

272
    lcd.print("Erdungsfehler");

273
    lcd.setCursor(0,1);

274
    lcd.print("erkannt");

275
    delay(1000);

276
  }

277
  

278
  //-------------------------------------------------------------50 Hz END--------------------------------------------------------------------------------------------

279
  

280
  analog_temp = analogRead(thermistor);

281
  

282
  temp = (0.955*analog_temp)-504.6;

283
  

284
   lcd.clear();

285
   lcd.setCursor(0,0);

286
   lcd.print("Motortemperatur");

287
   lcd.setCursor(0,1);

288
   lcd.print(temp,DEC);

289
   delay(1000);

290
  }

291
292
}


Was noch nicht funktioniert ist, dass "Kurzschluss zu Ub+ /Kl.15" 
ausgegeben wird, wenn ich dauerhaft 5V anlege.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
fertig:
1
#include <LiquidCrystal.h>

2
3
const int LCD_D7 = 2;

4
const int LCD_D6 = 3;

5
const int LCD_D5 = 4;

6
const int LCD_D4 = 5;

7
const int LCD_Enable = 6;

8
const int LCD_RS = 7;

9
10
LiquidCrystal lcd(LCD_RS, LCD_Enable, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

11
12
const int OK_HS = 8;

13
const int M_HS = 9;

14
15
long high;

16
long low;

17
float period;

18
float freq;

19
float duty_cycle;

20
int Rf=0;

21
int analog_temp=0;

22
int temp=0;

23
24
const int thermistor = A0;

25
26
27
void setup() 

28
{

29
  lcd.begin(27,2);

30
  lcd.display();

31
  lcd.clear();

32
  lcd.noCursor();

33
  lcd.print("Riso & Motortemp");

34
  

35
  pinMode(OK_HS, INPUT);

36
  pinMode(M_HS,INPUT);

37
  pinMode(thermistor,INPUT);

38
  delay(200);

39
}

40
41
void lcdtext( const char* text1, const char* text2 )

42
{

43
  lcd.clear();

44
  lcd.setCursor(0,0);

45
  lcd.print( text1 );

46
  lcd.setCursor(0,1);

47
  lcd.print( text2 );

48
}

49
50
51
void lcdUpdate( const char* label, long value, const char* unit )

52
{

53
  lcd.clear();

54
  lcd.setCursor(0,0);

55
  lcd.print( label );

56
  lcd.setCursor(0,1);

57
  lcd.print( value, DEC );

58
  lcd.setCursor(8,1);

59
  lcd.print( unit );

60
}

61
62
  

63
void loop() {

64
  

65
  int OK_HS_state = digitalRead(OK_HS);

66
  int M_HS_state = digitalRead(M_HS);

67
  

68
  high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high for 2 seconds max

69
  low = pulseIn(M_HS,LOW,1000000);                    // Measuring low for 2 secs max

70
71
  if(OK_HS_state != 1)                                       // Checking the status pin, OK_HS

72
  {

73
    lcdtext( "Status:", "FEHLER" );

74
    delay(1500);

75
  }

76
77
78
  if(high==0)                                   // Means that f=0 Hz and the value is LOW

79
  {

80
   lcdtext ("IMD aus oder","Kurzschl. Kl.31");

81
  }

82
  else if (low==0)  // Means that f=0 Hz and the value is HIGH

83
  {

84
   lcdtext ("Kurzschluss zu","Ub+ / Kl.15");

85
  delay(1500);

86
  }

87
88
  if(high!=0 && low!=0)

89
  {

90
  period = (high+low)/1000000.0;

91
  freq = 1/period;

92
  duty_cycle = (high/(period*1000000))*100;              // Duty Cycle of PWM signal of M_HS calculated

93
  

94
  if(freq >= 9.0 && freq <= 11.0)

95
  {

96
    lcdtext( "Normalzustand", "" );

97
    delay(1500);

98
    

99
    if(duty_cycle >4.98 && duty_cycle < 5.02)

100
      Rf=50000;                            //in kOhms

101
      

102
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

103
      Rf=0;                            //in kOhms

104
 

105
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

106
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

107
      

108
    lcdUpdate( "Isolationswid.", Rf, "k Ohm");

109
    delay(1500);

110
  }

111
  

112
  else if(freq >= 19.0 && freq <= 21.0)

113
  {

114
    lcdtext( "Unterspannung", "erkannt");

115
    delay(1500);

116
    

117
    if(duty_cycle >4.98 && duty_cycle < 5.02)

118
      Rf=50000;                            //in kOhms

119
      

120
    else if(duty_cycle > 94.98 && duty_cycle < 95.02)

121
      Rf=0;                            //in kOhms

122
123
    else if (duty_cycle > 5.02 && duty_cycle < 94.98)

124
      Rf = ((0.9*1200)/((duty_cycle-5)/100))-1200;

125
 

126
    lcdUpdate( "Isolationswid.", Rf, "k Ohm");

127
    delay(1500); 

128
    }

129
  

130
 else if(freq >= 29.0 && freq <= 31.0)

131
  {

132
    lcdtext( "Schnellstart", "Messung");

133
    delay(1500);    

134
  

135
    if(duty_cycle > 4.98 && duty_cycle < 10.02)                    // FOR 5-10% duty cycle PWM

136
      lcdtext( "Isolation", "OK");

137
     

138
     else if(duty_cycle > 89.89 && duty_cycle < 95.02)                   // FOR 90-95% duty cycle PWM

139
       lcdtext( "Isolation", "fehlerhaft");

140
       

141
     delay(1500);

142
  }

143
    

144
 if(freq >= 39 && freq <= 41)

145
  {

146
    lcdtext( "Geraetefehler", "erkannt");

147
    delay(1500);

148
    

149
  }

150
  

151
 if(freq >= 49 && freq <= 51)

152
  {

153
    lcdtext( "Erdungsfehler", "erkannt");

154
    delay(1500);

155
  }

156
  

157
  //-------------------------------------------------------------50 Hz END--------------------------------------------------------------------------------------------

158
  

159
  analog_temp = analogRead(thermistor);

160
  

161
  temp = (0.955*analog_temp)-504.6;

162
  lcdUpdate ("Temperatur", temp, "Grad");

163
  delay(1500);

164
  }

165
}


Nun muss ich nochmal schauen, warum die 5V 0Hz nicht erkannt werden.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:

> Nun muss ich nochmal schauen, warum die 5V 0Hz nicht erkannt werden.

Dann würde ich vorschlagen, du gibst dir erst mal hier

1
  high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high for 2 seconds max

2
  low = pulseIn(M_HS,LOW,1000000);                    // Measuring low for 2 secs max


die gemessenen Werte aus. Dank deiner Codeaufräumaktion ist das ja jetzt 
ein Klacks, weil du ja eine schöne Funktion hast, die du benutzen kannst 
:-)

1
  high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high for 2 seconds max

2
  low = pulseIn(M_HS,LOW,1000000);                    // Measuring low for 2 secs max

3
4
  lcdUpdate( "High ", high, "" );

5
  delay( 1000 );

6
  lcdUpdate( "Low ", low, "" );

7
  delay( 1000 );


und wenn du die konkreten Zahlen vor Augen hast, dann weiß man dann 
meist auch schon mehr oder kriegt zumindest einen Hinweis.


:-)
Hat sich schon gelohnt, den Code aufzuräumen und zu strukturieren. Ab 
jetzt arbeitet diese in die Vorleistung investierte Zeit für dich und 
spielt sich sukzessive wieder rein, weil du in der Fehlersuche schneller 
bist :-)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Karl Heinz Buchegger schrieb:

> und wenn du die konkreten Zahlen vor Augen hast, dann weiß man dann
> meist auch schon mehr oder kriegt zumindest einen Hinweis.

Aber ich schätze mal, das Problem wird sein, dass du bei konstantem 
Eingangspegel hier
1
  high =pulseIn(M_HS,HIGH,1000000);                  // Measuring high for 2 seconds max

2
  low = pulseIn(M_HS,LOW,1000000);                    // Measuring low for 2 secs max


zwei mal eine 0 kriegen wirst. Die Funktion heißt nicht umsonst pulseIn. 
Und wo kein Puls ist (wegen konstantem Pegel) kann man auch keinen Puls 
messen.

Damit kann dann diese Asuwertung
1
  if(high==0)                                   // Means that f=0 Hz and the value is LOW

2
  {

3
   lcdtext ("IMD aus oder","Kurzschl. Kl.31");

4
  }

5
  else if (low==0)  // Means that f=0 Hz and the value is HIGH

6
  {

7
   lcdtext ("Kurzschluss zu","Ub+ / Kl.15");

8
  delay(1500);

9
  }


auch nicht funktionieren. Denn wenn high gleich 0 ist, dann wird ja 
bereits das erste if genommen und das else hat keinen Effekt mehr.

D.h. die ganze Auswertung ist falsch. Anhand der high bzw. low Zeiten 
alleine kannst du nicht feststellen, wie der Pegel an der Leitung ist. 
Da musst du schon die Leitung selber befragen, welchen Pegel sie hat.


Ist aber alles geschätzt und abgeleitet davon, wie ich mir denke, wie 
die pulseIn Funktion arbeitet.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        M. N.
        (marco2228)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Treffer -- Versenkt.

Nun funktioniert es.

Habe den Code geändert zu:

1
 if(high==0 && M_HS_state==0)                                   

2
  {

3
   lcdtext ("IMD aus oder","Kurzschl. Kl.31");

4
  }

5
  else if (low==0 && M_HS_state==1)                              

6
  {

7
   lcdtext ("Kurzschluss zu","Ub+ / Kl.15");

8
  delay(1500);

9
  }


Gibt bestimmt einen eleganteren Weg, das zu lösen. Aber es funktioniert.

Danke nochmal für die Hilfe:)
Das nächste mal werde ich es versuchen, selbst zu machen. Wenn es dann 
am Ende funktioniert, machts noch mehr Spaß:)

Kannst du eine gute Einsteigerlektüre empfehlen?
Macht es Sinn sich auf Arduino zu beschränken oder dann besser ein C 
Buch zu nehmen?

Aber dazu findet sich bestimmt im Netz auch einiges.

Gruß,
Marco

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Arduino Mega 2560 verwirrt oder ich?
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
M. N. schrieb:

> Macht es Sinn sich auf Arduino zu beschränken oder dann besser ein C
> Buch zu nehmen?

Du brauchst beides.
Erst mal ein gutes Verständnis der Grundlagen von C++ (du programmierst 
C++ und nicht C. Auch wenn es so ähnlich aussieht).

Und dann darauf aufbauend die Spezialitäten der Programmierung auf dem 
Arduino.

Die generelle Empfehlung ist, erst mal einen soliden Grundstock in 
allgemeiner Programmierung zu erwerben und erst dann den Schritt auf die 
Speizialitäten der µC-Programmierung zu gehen.


> Aber dazu findet sich bestimmt im Netz auch einiges.

mit Sicherheit.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.