Probleme mit Taster in Funktion/Modus/PWM

Tobias N. OP #3438500
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.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Marcel Gast #3438556
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tobias N. OP #3443912
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #3443994
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tobias N. OP #3444122
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt. Bitte hier nur auf die ursprüngliche Frage antworten, für neue Fragen einen neuen Beitrag erstellen.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.