Forum: Mikrocontroller und Digitale Elektronik Probleme mit Taster in Funktion/Modus/PWM


Probleme mit Taster in Funktion/Modus/PWM
von Tobias N. (silberkristall)

Lesenswert?
• ▲
▼ 
Hallo,

ich habe mir ein Ambilight erstellt. Klappt soweit ganz gut, nur kann 
ich eine Sache nicht "umschalten".

Hier mal der Code:

1
#include <avr/io.h>

2
#include <avr/interrupt.h>

3
#include <util/delay.h>

4
#include <stdio.h>

5
#include <stdint.h>

6
7
#define  LICHTLIMIT  500

8
9
// ADC

10
/* ADC initialisieren */

11
void ADC_Init(void) {

12
 

13
  // die Versorgungsspannung AVcc als Refernz wählen:

14
  ADMUX = (1<<REFS0);    

15
  // oder interne Referenzspannung als Referenz für den ADC wählen:

16
  // ADMUX = (1<<REFS1) | (1<<REFS0);

17
 

18
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten

19
  // schon auf 0, also single conversion

20
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler

21
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

22
 

23
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest

24
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

25
 

26
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 

27
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten

28
  }

29
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten

30
     Wandlung nicht übernommen. */

31
  (void) ADCW;

32
}

33
 

34
/* ADC Einzelmessung */

35
uint16_t ADC_Read( uint8_t channel )

36
{

37
  // Kanal waehlen, ohne andere Bits zu beeinflußen

38
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

39
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

40
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten

41
  }

42
  return ADCW;                    // ADC auslesen und zurückgeben

43
}

44
45
// ADC Ende

46
47
// Taster entprellen

48
49
inline uint8_t debounce(volatile uint8_t *port, uint8_t pin)

50
{

51
    if ( !(*port & (1 << pin)) )

52
    {

53
        /* Pin wurde auf Masse gezogen, 100ms warten   */

54
        _delay_ms(10);   // Maximalwert des Parameters an _delay_ms 

55
        _delay_ms(10);   // beachten, vgl. Dokumentation der avr-libc

56
        if ( *port & (1 << pin) )

57
        {

58
            /* Anwender Zeit zum Loslassen des Tasters geben */

59
            _delay_ms(10);

60
            _delay_ms(10); 

61
            return 1;

62
        }

63
    }

64
    return 0;

65
}

66
67
// Taster entprellen ende

68
69
int MODUS = 1; // 1 = PWM, 2 = Fotowiderstand, 3 = Licht

70
int STATUSLED = 0; // 0 = Aus, 1 = wechsel, 2 = alle

71
int PWMSTATUS = 1; // 1 = wechsel, 2 = alle gleichzeitig

72
73
//PWM

74
int pwmalle;

75
int pwmseiten;

76
int pwmobenunten;

77
78
int pwmrun = 1;

79
80
//Licht Start Helligkeit

81
int brightness = 0;

82
83
int main(void)

84
{

85
86
// PWM

87
88
DDRB |= (1<<PB1); // Port OC1A mit angeschlossener LED als Ausgang

89
TCCR1A = (1<<WGM11) |(1<<WGM10) | (1<<COM1A1); // PWM, phase correct, 8 bit.

90
TCCR1B = (1<<CS10); // Prescaler 64 = Enable counter

91
92
93
// PWM Ende

94
95
// Taster

96
DDRD &= ~ (1<<PD0); // Settings Taster

97
DDRD &= ~ (1<<PD1); // Modus Taster

98
99
// Fotowiderstand

100
DDRC &= ~ (1<<PC5);

101
102
// LEDs

103
DDRB |= (1<<PB0); // ModusLED Fotowiderstand

104
105
DDRD |= (1<<PD2); // StatusLED PWM alle

106
DDRD |= (1<<PD3); // StatusLED PWM wechsel

107
DDRD |= (1<<PD6); // ModusLED Licht

108
DDRD |= (1<<PD7); // ModusLED PWM

109
110
PORTB |= (1<<PB0); // ModusLED Fotowiderstand

111
112
PORTD |= (1<<PD2); // StatusLED PWM alle

113
PORTD |= (1<<PD3); // StatusLED PWM wechsel

114
PORTD |= (1<<PD6); // ModusLED Licht

115
PORTD |= (1<<PD7); // ModusLED PWM

116
117
// ADC

118
uint16_t adcval;

119
ADC_Init();

120
121
  while(1)

122
    {

123
    

124
    if (debounce(&PIND, PD1))

125
      {

126
        if (MODUS == 3)

127
          {

128
            MODUS = 1;

129
            OCR1A = 0;

130
          }

131
          else

132
          {

133
            MODUS++;

134
            OCR1A = 0;

135
          }

136
      }

137
        

138
      // LED status

139
      if (MODUS == 1) 

140
        {

141
          PORTB |= (1<<PB0);

142
          PORTD |= (1<<PD6);

143
          PORTD &= ~ (1<<PD7);

144
          STATUSLED = 1;

145
        }

146
    

147
      if (MODUS == 2)

148
        {

149
          PORTB &= ~(1<<PB0);

150
          PORTD |= (1<<PD6);

151
          PORTD |= (1<<PD7);

152
          STATUSLED = 0;

153
        }

154
      

155
      if (MODUS == 3) 

156
        {

157
          PORTB |= (1<<PB0);

158
          PORTD &= ~(1<<PD6);

159
          PORTD |= (1<<PD7);

160
          STATUSLED = 0;

161
        }

162
        

163
      if (STATUSLED == 0)

164
        {

165
          PORTD |= (1<<PD2);

166
          PORTD |= (1<<PD3);

167
        }

168
        

169
      if (STATUSLED == 1)

170
        {

171
          PORTD |= (1<<PD2);

172
          PORTD &= ~ (1<<PD3);

173
        }

174
        

175
      if (STATUSLED == 2)

176
        {

177
          PORTD &= ~ (1<<PD2);

178
          PORTD |= (1<<PD3);

179
        }

180
      

181
      // Programme

182
      

183
      if (MODUS == 1)

184
        {

185
          if (debounce(&PIND, PD0))

186
            {

187
              if (PWMSTATUS == 1) { PWMSTATUS = 2; STATUSLED = 2; pwmrun = 1; pwmseiten = 0; pwmobenunten = 1023;}

188
              if (PWMSTATUS == 2) { PWMSTATUS = 1; STATUSLED = 1; pwmrun = 1; pwmalle = 0;}

189
            }

190
          

191
          if (PWMSTATUS == 1)

192
            {

193
              if (pwmrun == 1)

194
                {

195
                  OCR1A = pwmseiten;

196
                  OCR1B = pwmobenunten;

197
                  pwmseiten++;

198
                  pwmobenunten--;

199
                  _delay_ms(15);

200
                  if (pwmseiten == LICHTLIMIT) { pwmrun = 2; }

201
                }

202
                

203
              if (pwmrun == 2)

204
                {

205
                  OCR1A = pwmseiten;

206
                  OCR1B = pwmobenunten;

207
                  pwmseiten--;

208
                  pwmobenunten++;

209
                  _delay_ms(15);

210
                  if (pwmseiten == 0) { pwmrun = 1; }

211
                }

212
            }

213
            

214
          if (PWMSTATUS == 2)

215
            {

216
              if (pwmrun == 1)

217
                {

218
                  OCR1A = pwmalle;

219
                  OCR1B = pwmalle;

220
                  pwmalle++;

221
                  _delay_ms(15);

222
                  if (pwmalle == LICHTLIMIT) { pwmrun = 2; }

223
                }

224
                

225
              if (pwmrun == 2)

226
                {

227
                  OCR1A = pwmalle;

228
                  OCR1B = pwmalle;

229
                  pwmalle--;

230
                  pwmobenunten++;

231
                  _delay_ms(15);

232
                  if (pwmalle == 0) { pwmrun = 1; }

233
                }

234
            }

235
        }

236
      

237
      if (MODUS == 2)

238
        {

239
          adcval = ADC_Read(5);

240
          OCR1A = adcval;

241
        }

242
      

243
      if (MODUS == 3)

244
        {

245
          if (debounce(&PIND, PD0))

246
            {

247
              if (brightness == LICHTLIMIT)

248
                {

249
                  brightness = 10;

250
                }

251
                else

252
                {

253
                  brightness = brightness + 10;

254
                }

255
            }

256
          OCR1A = brightness;

257
        }

258
      

259
    }

260
    return 0;

261
}


Es handelt sich hierbei um folgende Zeilen:

1
          if (debounce(&PIND, PD0))

2
            {

3
              if (PWMSTATUS == 1) { PWMSTATUS = 2; STATUSLED = 2; pwmrun = 1; pwmseiten = 0; pwmobenunten = 1023;}

4
              if (PWMSTATUS == 2) { PWMSTATUS = 1; STATUSLED = 1; pwmrun = 1; pwmalle = 0;}

5
            }


Das ganze lässt sich nicht umschalten.

Ich hoffe ihr könnt mir da helfen.

Wenn ich ganz oft auf den Taster drücke dann startet die PWM in dem 
Status PWMSTATUS = 1 einfach neu, aber es erfolgt keine umschaltung auf 
den PWMSTATUS = 2.

Danke euch schonmal für eure Hilfen.

  


  




  

    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: Probleme mit Taster in Funktion/Modus/PWM
  


  

    

      von
      
        Marcel (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Tobias N. schrieb:
> if (debounce(&PIND, PD0))
>             {
>               if (PWMSTATUS == 1) { PWMSTATUS = 2; STATUSLED = 2; pwmrun
> = 1; pwmseiten = 0; pwmobenunten = 1023;}
>               if (PWMSTATUS == 2) { PWMSTATUS = 1; STATUSLED = 1; pwmrun
> = 1; pwmalle = 0;}
>             }

else if (PWMSTATUS == 2) { ... } . Sonst werden beide Abfragen immer 
wahr und beide ausgeführt.

  


  




  

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







      

      



  

    Re: Probleme mit Taster in Funktion/Modus/PWM
  


  

    

      von
      
        Tobias N.
        (silberkristall)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
1
#include <avr/io.h>

2
#include <avr/interrupt.h>

3
#include <util/delay.h>

4
#include <stdio.h>

5
#include <stdint.h>

6
7
#define  LICHTLIMIT  500

8
9
// ADC

10
/* ADC initialisieren */

11
void ADC_Init(void) {

12
 

13
  // die Versorgungsspannung AVcc als Refernz wählen:

14
  ADMUX = (1<<REFS0);    

15
  // oder interne Referenzspannung als Referenz für den ADC wählen:

16
  // ADMUX = (1<<REFS1) | (1<<REFS0);

17
 

18
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten

19
  // schon auf 0, also single conversion

20
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler

21
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

22
 

23
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest

24
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

25
 

26
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 

27
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten

28
  }

29
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten

30
     Wandlung nicht übernommen. */

31
  (void) ADCW;

32
}

33
 

34
/* ADC Einzelmessung */

35
uint16_t ADC_Read( uint8_t channel )

36
{

37
  // Kanal waehlen, ohne andere Bits zu beeinflußen

38
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

39
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

40
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten

41
  }

42
  return ADCW;                    // ADC auslesen und zurückgeben

43
}

44
45
// ADC Ende

46
47
// Taster entprellen

48
49
inline uint8_t debounce(volatile uint8_t *port, uint8_t pin)

50
{

51
    if ( !(*port & (1 << pin)) )

52
    {

53
        /* Pin wurde auf Masse gezogen, 100ms warten   */

54
        _delay_ms(10);   // Maximalwert des Parameters an _delay_ms 

55
        _delay_ms(10);   // beachten, vgl. Dokumentation der avr-libc

56
        if ( *port & (1 << pin) )

57
        {

58
            /* Anwender Zeit zum Loslassen des Tasters geben */

59
            _delay_ms(10);

60
            _delay_ms(10); 

61
            return 1;

62
        }

63
    }

64
    return 0;

65
}

66
67
// Taster entprellen ende

68
69
int MODUS = 1; // 1 = PWM, 2 = Fotowiderstand, 3 = Licht

70
int STATUSLED = 0; // 0 = Aus, 1 = wechsel, 2 = alle

71
int PWMSTATUS = 1; // 1 = wechsel, 2 = alle gleichzeitig

72
73
//PWM

74
int pwmalle;

75
int pwmseiten;

76
int pwmobenunten;

77
int PWMTIME = 20;

78
79
int pwmrun = 1;

80
81
//Licht Start Helligkeit

82
int brightness = 0;

83
84
int main(void)

85
{

86
87
// PWM

88
89
DDRB |= (1<<PB1); // Port OC1A mit angeschlossener LED als Ausgang

90
DDRB |= (1<<PB2);

91
TCCR1A = (1<<WGM11) |(1<<WGM10) | (1<<COM1A1) | (1 << COM1B1); // PWM, phase correct, 8 bit.

92
TCCR1B = (1<<CS10); // Prescaler 64 = Enable counter

93
94
95
// PWM Ende

96
97
// Taster

98
DDRD &= ~ (1<<PD0); // Settings Taster

99
DDRD &= ~ (1<<PD1); // Modus Taster

100
101
// Fotowiderstand

102
DDRC &= ~ (1<<PC5);

103
104
// LEDs

105
DDRB |= (1<<PB0); // ModusLED Fotowiderstand

106
107
DDRD |= (1<<PD2); // StatusLED PWM alle

108
DDRD |= (1<<PD3); // StatusLED PWM wechsel

109
DDRD |= (1<<PD6); // ModusLED Licht

110
DDRD |= (1<<PD7); // ModusLED PWM

111
112
PORTB |= (1<<PB0); // ModusLED Fotowiderstand

113
114
PORTD |= (1<<PD2); // StatusLED PWM alle

115
PORTD |= (1<<PD3); // StatusLED PWM wechsel

116
PORTD |= (1<<PD6); // ModusLED Licht

117
PORTD |= (1<<PD7); // ModusLED PWM

118
119
// ADC

120
uint16_t adcval;

121
ADC_Init();

122
123
  while(1)

124
    {

125
    

126
    if (debounce(&PIND, PD1))

127
      {

128
        if (MODUS == 3)

129
          {

130
            MODUS = 1;

131
            OCR1A = 0;

132
            OCR1B = 0;

133
          }

134
          else

135
          {

136
            MODUS++;

137
            OCR1A = 0;

138
            OCR1B = 0;

139
          }

140
      }

141
        

142
      // LED status

143
      if (MODUS == 1) 

144
        {

145
          PORTB |= (1<<PB0);

146
          PORTD |= (1<<PD6);

147
          PORTD &= ~ (1<<PD7);

148
        }

149
    

150
      if (MODUS == 2)

151
        {

152
          PORTB &= ~(1<<PB0);

153
          PORTD |= (1<<PD6);

154
          PORTD |= (1<<PD7);

155
          STATUSLED = 0;

156
        }

157
      

158
      if (MODUS == 3) 

159
        {

160
          PORTB |= (1<<PB0);

161
          PORTD &= ~(1<<PD6);

162
          PORTD |= (1<<PD7);

163
          STATUSLED = 0;

164
        }

165
        

166
      if (STATUSLED == 0)

167
        {

168
          PORTD |= (1<<PD2);

169
          PORTD |= (1<<PD3);

170
        }

171
        

172
      if (STATUSLED == 1)

173
        {

174
          PORTD |= (1<<PD2);

175
          PORTD &= ~ (1<<PD3);

176
        }

177
        

178
      if (STATUSLED == 2)

179
        {

180
          PORTD &= ~ (1<<PD2);

181
          PORTD |= (1<<PD3);

182
        }

183
      

184
      // Programme

185
      

186
      if (MODUS == 1)

187
        {

188
          if (debounce(&PIND, PD0))

189
            {

190
              if (PWMSTATUS == 2) { PWMSTATUS = 1; STATUSLED = 1; pwmrun = 1; pwmalle = 0;}

191
              else { PWMSTATUS = 2; STATUSLED = 2; pwmrun = 1; pwmseiten = 0; pwmobenunten = 1023;}

192
            }

193
          

194
          if (PWMSTATUS == 1)

195
            {

196
              if (pwmrun == 1)

197
                {

198
                  OCR1A = pwmseiten;

199
                  OCR1B = pwmobenunten;

200
                  pwmseiten++;

201
                  pwmobenunten--;

202
                  _delay_ms(20);

203
                  if (pwmseiten == LICHTLIMIT) { pwmrun = 2; }

204
                }

205
                

206
              if (pwmrun == 2)

207
                {

208
                  OCR1A = pwmseiten;

209
                  OCR1B = pwmobenunten;

210
                  pwmseiten--;

211
                  pwmobenunten++;

212
                  _delay_ms(20);

213
                  if (pwmseiten == 0) { pwmrun = 1; }

214
                }

215
            }

216
            

217
          if (PWMSTATUS == 2)

218
            {

219
              if (pwmrun == 1)

220
                {

221
                  OCR1A = pwmalle;

222
                  OCR1B = pwmalle;

223
                  pwmalle++;

224
                  _delay_ms(20);

225
                  if (pwmalle == LICHTLIMIT) { pwmrun = 2; }

226
                }

227
                

228
              if (pwmrun == 2)

229
                {

230
                  OCR1A = pwmalle;

231
                  OCR1B = pwmalle;

232
                  pwmalle--;

233
                  pwmobenunten++;

234
                  _delay_ms(20);

235
                  if (pwmalle == 0) { pwmrun = 1; }

236
                }

237
            }

238
        }

239
      

240
      if (MODUS == 2)

241
        {

242
          adcval = ADC_Read(5);

243
          OCR1A = adcval;

244
          OCR1B = adcval;

245
        }

246
      

247
      if (MODUS == 3)

248
        {

249
          if (debounce(&PIND, PD0))

250
            {

251
              if (brightness == LICHTLIMIT)

252
                {

253
                  brightness = 10;

254
                }

255
                else

256
                {

257
                  brightness = brightness + 10;

258
                }

259
            }

260
          OCR1A = brightness;

261
          OCR1B = brightness;

262
        }

263
      

264
      //while(a>1){

265
        //OCR1A = a;

266
        //_delay_ms(15);

267
        //a--;

268
      //}   

269
270
      //while(a<500){

271
        //OCR1A = a;

272
        //_delay_ms(15);

273
        //a++;

274
      //}

275
      

276
    }

277
    return 0;

278
}


Hier nochmal der Code. Also soweit klappt alles ganz gut, nur habe ich 
ein PWM Problem.

Also es geht dabei um folgenden Code:

1
          if (PWMSTATUS == 1)

2
            {

3
              if (pwmrun == 1)

4
                {

5
                  OCR1A = pwmseiten;

6
                  OCR1B = pwmobenunten;

7
                  pwmseiten++;

8
                  pwmobenunten--;

9
                  _delay_ms(20);

10
                  if (pwmseiten == LICHTLIMIT) { pwmrun = 2; }

11
                }

12
                

13
              if (pwmrun == 2)

14
                {

15
                  OCR1A = pwmseiten;

16
                  OCR1B = pwmobenunten;

17
                  pwmseiten--;

18
                  pwmobenunten++;

19
                  _delay_ms(20);

20
                  if (pwmseiten == 0) { pwmrun = 1; }

21
                }

22
            }


Problem ist bei dem pwmrun == 1, die PWM OCR1B dimmt runter, und wenn er 
bei 0 angekommen ist blitzt das licht einmal kurz auf, und dann dimmt er 
wieder ganz normal auf und wieder ab, sobald er wieder komplett 
abgedimmt hat blitzt das licht einmal auf und dimmt dann wieder ganz 
normal auf. an OCR1A ist das nicht so, nur bei ORC1B, da blitzt er 
jedesmal wenn er auf 0 ist einmal auf.

Wo ist der Fehler?

Danke euch

  


  




  

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







      

      



  

    Re: Probleme mit Taster in Funktion/Modus/PWM
  


  

    

      von
      
        Tobias N.
        (silberkristall)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
ich habe das jetzt so gelöst:

1
if (pwmseiten == LICHTLIMIT) { pwmrun = 2; pwmobenunten = 0; }


Jetzt läuft alles so wie es soll.

;)

  


  




  

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







      

      



  

    Re: Probleme mit Taster in Funktion/Modus/PWM
  


  

    

      von
      
        Karl H.
        (kbuchegg)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Du hast hier im PWMStatus 2
1
              if (pwmrun == 1)

2
                {

3
                  OCR1A = pwmalle;

4
                  OCR1B = pwmalle;

5
                  pwmalle++;

6
                  _delay_ms(20);

7
                  if (pwmalle == LICHTLIMIT) { pwmrun = 2; }

8
                }

auf pwmobenunten vergessen.
Dadurch werden dir die Werte von pwmalle asynchron und laufen dir 
auseinander, so dass nicht mehr garantiert ist, dass pwmobenunten auch 
dann wieder seinen maximalwert erreicht wenn pwmalle den Wert 0 bekommt.


Wenn du es ein wenig schlauer angegangen wärst, dann hättest du bemerkt, 
dass du die Variable pwmobenunten überhaupt nicht brauchst. Denn du 
kannst diesen Wert jederzeit aus pwmalle errechnen. Zwischen den beiden 
Zahlenwerten besteht eine fixe Beziehung.

Im PWMStatus gleich 1 hättest du auch schreiben können
1
...

2
     OCR1A = pwmalle;

3
     OCR1B = 1023 - pwmalle;

4
...

und es würde auf das gleiche rauskommen. Nur dass du dann keinen Fehler 
mehr machen kannst, indem du auf pwmobenunten irgendwo vergisst, weil es 
die Variable dann überhaupt nicht mehr gibt.

  


  



  

  
:
    Bearbeitet durch User
  

  


  

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







      

      



  

    Re: Probleme mit Taster in Funktion/Modus/PWM
  


  

    

      von
      
        Tobias N.
        (silberkristall)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hi,

cool, danke, läuft super :)

Jetzt habe ich noch ein anliegen g, ich poste mal gleich ein Video 
davon. Läuft ganz gut. Ich habe noch einen Fotowiderstand eingebaut für 
eine Lichtsteuerung. Aber nunja, sieht man ja im Code, ich setze den ADC 
wert halt einfach auf die PWM um, das klappt nicht ganz so toll, Ich 
muss den Wert irgendwie an das umgebungslicht anpassen nur weiss ich 
nicht wie, also das bei "leichter" dunkelheit halt noch nichts passiert, 
ist ja halt so, weil der Fernseher an der Wand steht aber wenn es dann 
im Raum schon nicht "ganz so hell" ist. Also muss ich irgendwie 
einstellen das der von z.b. 800 - 1023, anstatt 0 - 1023 geht und dann 
halt wieder so, das 1023 gleich der maximale lichtwert, also 500 ist, 
und nicht die volle stärke (1. zu hell, 2. macht das das netzteil dann 
nicht mit, kann nur 1A).

Und dann dimmt der schneller ab als auf, wie kann ich das angleichen?

ADMUX = (1<<REFS0); was muss dahin das der AREF als Referenzspannung 
nimmt und nicht intern oder AVCC?

Und was muss ich hier machen :

1
if (MODUS == 3)

2
        {

3
          if (debounce(&PIND, PD0))

4
            {

5
              if (brightness == LICHTLIMIT)

6
                {

7
                  brightness = 10;

8
                }

9
                else

10
                {

11
                  brightness = brightness + 10;

12
                }

13
            }

14
          OCR1A = brightness;

15
          OCR1B = brightness;

16
        }


Das wenn man den Taster hält, er dann z.b. im sekundentakt "hochrechnet" 
und man man nicht drücken loslassen drücken loslassen muss?

Danke schonmal.

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    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.