mikrocontroller.net

Forum: Projekte & Code PWM 12V Lampendimmer (Tiny26)


Autor: Stefan Gemmel (steg13)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
hier ein Anfängerprojekt:
über 2 Tasten kann die Helligkeit einer 12V Glühbirne gesteuert werden.

/*
;PWM mit Einstellung von a über 2 Tasten
;
; ================================================
;                   TINY26
; ================================================
;                 __   __
;   PWM-Aus  PB0 |1  |_| 28| PA0 Taste
;            PB1 |2   A  27| PA1 Taste
;            PB2 |3   T  26| PA2
;            PB3 |4   M  25| PA3
;            VCC |5   E  24| GND
;            GND |6   L  23| AVCC
;            PB4 |7      22| PA4
;            PB5 |8   A  21| PA5
;            PB6 |9   T  20| PA6
;   RESET    PB7 |10  m  19| PA7
;                |_________|
;
;
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

#define F_CPU    4000000      //Interner Taktgenerator auf 4MHz gestellt
                              //FUSE-BIT CKSEL2 und CKSEL3 gesetzt
#define TCCR1A  _SFR_IO8(0x30)
#define PWM1B   0
#define PWM1A   1
#define FOC1B   2
#define FOC1A   3
#define COM1B0  4
#define COM1B1  5
#define COM1A0  6
#define COM1A1  7

#define TCCR1B  _SFR_IO8(0x2F)
#define CS10    0
#define CS11    1
#define CS12    2
#define CS13    3
#define PSR1    6
#define CTC1    7

uint8_t a=10; //Pulspausenverhältnis

void Pause(void) //etwa 0,5s
{ uint8_t i;
  uint8_t j;

  for(i=0;i<30;i++)
  {
    for(j=0;j<250;j++) {}
}}

int main()
{

DDRB  = 0xFF; // PORTB als Ausgang schalten
DDRA  = 0;    // PORTA als Eingang
PORTA = TCCR1A|=(1<<0)|(1<<1); // PULLUP für Tasten Bit 0 und 1

TCCR1A|=(0<<COM1A1)|(1<<COM1A0)|(0<<COM1B1)|(0<<COM1B0)|(0<<FOC1A)|(0<<F 
OC1B)|(1<<PWM1A)|(1<<PWM1B);//  enable TimerA
TCCR1B|=(1<<CTC1)|(0<<PSR1)|(0<<CS13)|(0<<CS12)|(1<<CS11)|(1<<CS10); 
// Vorteiler Timer A
/*Vorteiler
CS13 CS12 CS11 CS10
 0    0    0    1   CK
 0    0    1    0   CK/2
 0    0    1    1   CK/4
 0    1    0    1   CK/16
 0    1    1    1   CK/64 */

OCR1B=0x00; // unten immer 0
OCR1C=240;  // Max Zählwert CK/Vorteiler/f (interner Oscill. 
4.000.000Hz)
OCR1A=a;  // oben a(%) * OCR1C (z.B. 50% Puls-Pausenverhältnis)
//Beispiel f=1000Hz

for(;;) //Abfrage der Tasten
  {

  if(bit_is_clear (PINA,0)){
  if(a<220){
    a=a+10;
    OCR1A=a;
  };
  }

  if(bit_is_clear (PINA,1)){
    if(a>10){
    a=a-10;
    OCR1A=a;
  };
  }

  Pause();
  }
}

Autor: unsichtbarer WM-Rahul (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Interessantes Konstrukt:
>PORTA = TCCR1A|=(1<<0)|(1<<1); // PULLUP für Tasten Bit 0 und 1

Warum das:
OCR1C=240;  // Max Zählwert CK/Vorteiler/f (interner Oscill
OCR1A=a;  // oben a(%) * OCR1C (z.B. 50% Puls-Pausenverhältnis)

Zumindest ist a kein % von OCR1C, sondern "pro 241".

Wie entprellst du die Tasten? (Man könnte den Timer "misbrauchen"...)

> (0<<..)
ist sehr sinnlos und verwirrt höchstens beim "flüchtigen" Lesen.

Die Defines sollte man sich eigentlich auch sparen können, weil sie in 
der io.h zum Tiny26 vorhanden sein sollten.

Sonst aber ein nettes Anfängerprojekt.

Autor: Stefan Gemmel (steg13)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
stimmt alles, danke für die Hinweise.
Neue Version:

/*
;PWM mit Einstellung von a über 2 Tasten
;
; ================================================
;                   TINY26
; ================================================
;                 __   __
;   PWM-Aus  PB0 |1  |_| 28| PA0 Taste
;            PB1 |2   A  27| PA1 Taste
;            PB2 |3   T  26| PA2
;            PB3 |4   M  25| PA3
;            VCC |5   E  24| GND
;            GND |6   L  23| AVCC
;            PB4 |7      22| PA4
;            PB5 |8   A  21| PA5
;            PB6 |9   T  20| PA6
;   RESET    PB7 |10  m  19| PA7
;                |_________|
;
;
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

#define F_CPU    4000000      //Interner Taktgenerator auf 4MHz gestellt
                              //FUSE-BIT CKSEL2 und CKSEL3 gesetzt

uint8_t a=10; //Pulsverhältnis zu 240

void Pause(void) //etwa 0,5s
{ uint8_t i;
  uint8_t j;

  for(i=0;i<30;i++)
  {
    for(j=0;j<250;j++) {}
}}

int main()
{

DDRB  = 0xFF; // PORTB als Ausgang schalten
DDRA  = 0;    // PORTA als Eingang
PORTA = (1<<0)|(1<<1); // PULLUP für Tasten Bit 0 und 1

TCCR1A|=(1<<COM1A0)|(1<<PWM1A)|(1<<PWM1B);// enable TimerA
TCCR1B|=(1<<CTC1)|(1<<CS11)|(1<<CS10);    // Vorteiler Timer A
/*Vorteiler
CS13 CS12 CS11 CS10
 0    0    0    1   CK
 0    0    1    0   CK/2
 0    0    1    1   CK/4
 0    1    0    1   CK/16
 0    1    1    1   CK/64 */

OCR1B=0x00; // unten immer 0
OCR1C=240;  // Max Zählwert CK/Vorteiler/f (interner Oscill. 
4.000.000Hz)
OCR1A=a;  // oberer Wert  (z.B. a=120 -> 50% Puls-Pausenverhältnis)

for(;;) //Abfrage der Tasten alle 0,5s (Pause)
  {

  if(bit_is_clear (PINA,0)){
  if(a<220){
    a=a+10;
    OCR1A=a;
  };
  }

  if(bit_is_clear (PINA,1)){
    if(a>10){
    a=a-10;
    OCR1A=a;
  };
  }

  Pause();
  }
}


Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn ich auch noch darf:

Ein aggressiv optimierender Compiler, lässt dir
davon:

void Pause(void) //etwa 0,5s
{ uint8_t i;
  uint8_t j;

  for(i=0;i<30;i++)
  {
    for(j=0;j<250;j++) {}
}}


nichts übrig.
Für Warteschleifen, gibt es die <util/delay.h>
und dort die Funktionen _delay_ms und _delay_us.

Achtung: Beide haben Obergrenzen, abhängig vom
Quarztakt. Du wirst die _delay_ms also in
eine Schleife packen muessen.

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und noch was:
Wenn du für Anfänger schreibst, was grundsätzlich
zu begrüssen ist, dann achte auf deine Code-Formatierung.
Deine Einrückungen da oben sind alles andere als konsistent.
  };
  }

Der ';' ist überflüssig.

for(;;) //Abfrage der Tasten alle 0,5s (Pause)
  {

  if(bit_is_clear (PINA,0)){

Entscheide dich, wo du die { platzierst. Entweder
in der selben Zeile am Ende oder in einer neuen Zeile
drunter. Wenn neue Zeile, dann entweder unter dem Statement
oder eingerückt.
Aber nicht 3 verschiedene Stile in einer Source!

Das wichtigste an einem { } Setzungs- und Einrückstil ist
nicht wie er konkret aussieht, sondern dass man ihn konsequent
durchzieht.

Autor: Benedikt K. (benedikt) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nun mal zur Hardware: In der Schaltung fehlt ein Pufferelko für die 12V. 
Einige 100 bis 1000uF mit nicht allzuhohem ESR sollten es schon sein. 
Sowas ist bei PWM Pflicht. Ebenso der 100nF vor und hinter dem 5V Stabi 
(bzw. ein Elko davor).
Ebenso sollte an den Reset Pin ein kleiner Kondensator gegen Masse.

Der Mosfet Treiber dagegen ist vorbildlich.

Autor: Stefan Gemmel (steg13)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Danke euch.

Ich habe jetzt doch den Timer zur zyklischen Tastaturabfrage benutzt

Version 3:


/*
;PWM mit Einstellung des Tastgrades über 2 Tasten
;
; ================================================
;                   TINY26
; ================================================
;                 __   __
;   PWM-Aus  PB0 |1  |_| 28| PA0 Taste
;            PB1 |2   A  27| PA1 Taste
;            PB2 |3   T  26| PA2
;            PB3 |4   M  25| PA3
;            VCC |5   E  24| GND
;            GND |6   L  23| AVCC
;            PB4 |7      22| PA4
;            PB5 |8   A  21| PA5
;            PB6 |9   T  20| PA6
;   RESET    PB7 |10  m  19| PA7
;                |_________|
;
;
*/

#define F_CPU    1000000      // Interner Taktgenerator auf 1MHz 
gestellt
                              // FUSE-BIT CKSEL1,CKSEL2 und CKSEL3 
gesetzt
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/delay.h>

/*********** VARIABLEN **********/

uint8_t a=10;                 // Pulsverhältnis zu 240


/*********** FUNKTIONEN **********/

void timer0_init(void){      // timer 0 Zyklus zur Tastenabfrage
  TCCR0  |= (1 << CS02) | (0 << CS01) | (1 << CS00);// Prescaler Timer 0 
auf 1024 stellen
  TIMSK  |= (1 << TOIE0);                           // Overflow 
Interrupt enable
}

void timer1_init(void){      // timer 1 als PWM einstellen
  TCCR1A|=(1<<COM1A0)|(1<<PWM1A)|(1<<PWM1B);// enable Timer 1
  TCCR1B|=(1<<CTC1)|(1<<CS11)|(1<<CS10);    // Vorteiler Timer 1 hier 4
                                            /* Vorteilereinstellung:
                                             CS13 CS12 CS11 CS10
                                               0    0    0    1   CK
                                               0    0    1    0   CK/2
                                               0    0    1    1   CK/4
                                               0    1    0    1   CK/16
                                               0    1    1    1   CK/64 
*/

  OCR1B=0x00;                 // unten immer 0
  OCR1C=240;                  // max Zählwert
  OCR1A=a;                    // oberer Wert  (z.B. a=120 -> 50% 
Puls-Pausenverhältnis)
}


/*********** INTERRUPTS **********/

SIGNAL (TIMER0_OVF0_vect)     // bei Überlauf (255->0) wird dieser Int. 
ausgelöst)
{
  if(bit_is_clear (PINA,0)){  // wenn Taste gedrückt
    if(a<220){                // und max-wert noch nicht erreicht
      a=a+10;                 // erhöhe max-wert
      OCR1A=a;                // Toogle-wert Timer 1
    }
  }

  if(bit_is_clear (PINA,1)){  // wenn Taste gedrückt
    if(a>10){                 // und min-wert noch nicht erreicht
      a=a-10;                 // erniedrige min-wert
      OCR1A=a;                // Toogle-wert Timer 1
    }
  }

  TCNT0 = 100;                // Timer zählt nun nur noch von 155 bis 
255 (also 100 Takte)
}

/*********** HAUPTPROGRAMM **********/

int main(){
  DDRB  = 0xFF;               // PORTB als Ausgang schalten
  DDRA  = 0;                  // PORTA als Eingang
  PORTA = (1<<0)|(1<<1);      // PULLUP für Tasten Bit 0 und 1

  timer0_init();              // timer 0 Zyklus zur Tastenabfrage
  timer1_init();              // timer 1 als PWM einstellen

  sei();                      // Interrupts einschalten

  for(;;){                    // tue nichts Endlosschleife
  }
}

Autor: unsichtbarer WM-Rahul (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du fragst du Tasten jetzt zwar in der Timer-ISR ab, due entprellst sie 
aber immer noch nicht. Dazu musst du den aktuellen Zustand der Tasten 
mit dem letzten vergleichen. Wenn die beiden über eine bestimmte Zeit 
gleich bleiben, ist die Taste in einem stabilen Zustand.

Autor: Stefan Gemmel (steg13)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das verstehe ich nicht.
Tastenprellen ensteht doch nur beim Drücken oder?
Die Taste bleibt aber gedrückt bis die gewünschte Heligkeit eingestellt 
ist.
Etwa alle 0,5s wird abgefragt ob eine Taste gedrückt ist und 
entsprechend das Puls/Pausenverhältnis geändert.
Was soll da passieren ohne Entprellung?

Autor: Benedikt K. (benedikt) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich "entprelle" meine Taster genauso: Einfach den Taster alle 10-100ms 
abfragen. Man erhält nun eine Information ob der Taster gedrückt ist 
oder nicht. Prellt der Taster noch, kann die Information falsch sein 
(was aber nicht weiter stört), denn spätestens beim nächsten Abfragen 
stimmt es. Die Fehlinformation kann keinen zusätzlichen Tastendruck 
bewirken, denn entweder war die Fehlinformation eine 0 oder 1, also 
entweder wurde der eine Zustand zu früh erkannt, oder zu spät.
Ich setze allerdings immer ein Bit, das bedeutet das der Taster gedrückt 
wurde (oder es immer noch ist).

In diesem Fall hier, kann man auf ein Entprellen eigentlich aber 
komplett verzichten.

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Was soll da passieren ohne Entprellung?

In diesem konkreten Fall nichts. Das liegt daran, dass
es völlig Wurscht ist, ob der µC eine oder zwei Dimmstufen
zu hoch oder zu niedrig liegt. Die Wartezeit von 0.5
Sekunden tut ihr übriges. Allerdings ist 0.5 Sekunden
meist nicht akzeptabel. Im Grunde benutzt du ja die
0.5 Sekunden eigentlich als 'Taste-immer-noch-gedrückt-
Aktion-wiederholen' Timer. Und es gibt natürlich Benutzer
die mal ganz schnell den Taster antippen und wieder
loslassen. In weniger als 0.5 Sekunden. Wenn er Pech
hat, passiert dieser Tastendruck dann in der Zeit
in der der µC grade nicht hinsieht :-)

Anders ist es, wenn wirklich jeder Tastendruck zählt
und der Benutzer einen ganz bestimmten Wert einstellen
muss. Es ist einfach lästig, wenn du kurz auf die
Taste drückst und der µC zählt deine 7-Segment Anzeige
um 2 Einheiten hoch, weil er durch das Prellen die
Sequenz 000000001101111111000000 für den kurzzeitigen
Tastendruck eingelesen hat.

Autor: Stefan Gemmel (steg13)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Alles richtig und auch wichtig was ihr sagt.

Ich habe ja erst vor ein paar Wochen mir C angefangen.
Vorher habe ich einiges in Ass. geschreiben.

Das PWM war mein 2. Projekt, gleich nach einer blinkenden LED.
Ich wollte es anderen Anfängern zur Verfügung stellen, damit die weiter 
dran rumbasteln. Man ist ja manchmal froh wenn erst mal was 
funktioniert, das man dann anpassen kann.

Die SW hat noch einige Nachteile. z.B wenn ich eine höhere Taktrate 
nehme, geht die Tastenabfrage zu schnell.

Ihr könnt ja gerne hier mal ein paar Codeauschnitte reinstellen, wie man 
es besser machen kann. Dann kann jeder an dem Projekt lernen, weil es ja 
recht überschaubar ist und trotzdem PWM und Timerinter. benutzt.

Ausserdem hielt ich es für wichtig, mal eine funktionierende 
MOSFET-Ansteuerung hier zu verewigen.

Ich hänge hier gerade mal noch die Eagle-Datei dran.
Mit ISP-Stecker

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Die SW hat noch einige Nachteile. z.B wenn ich eine höhere Taktrate
> nehme, geht die Tastenabfrage zu schnell.
> Ihr könnt ja gerne hier mal ein paar Codeauschnitte reinstellen,
> wie man es besser machen kann


Für die Tastenabfrage gibt es eigentlich nur eine Antwort:

http://www.mikrocontroller.net/articles/Entprellung

Das Teil ist absolut genial.
Unterscheidet zwischen:
  Taste kurz gedrückt
  Benutzer ist auf der Taste eingeschlafen.

Ich würds so machen ( C-Skizze )
#define LED_PORT PORTB
#define LED_PIN  ( 1 << PINB1 )

uint8_t PWMCounter;
volatile uint8_t LEDValue;

//
// Der Interrupt implementiert die PWM
// Ein Zähler läuft von 0 bis 100 durch
// Liegt der Zähler unter dem Schwellwert einer Led, so wird
// die Led eingeschaltet. Liegt er darüber wird die Led ausgeschaltet.
// Durch Verändern das Schwellwertes kann also das Verhältnis
// der An-Zeit zur Aus-Zeit einer Led eingestellt werden. Je
// laenger eine Led in so einem Zyklus eingeschaltet ist,
// desto heller erscheint sie uns.
// Die Zyklen muessen natuerlich schnell genug erfolgen, ansonsten
// sehen wir nur ein Blinken.
//
SIGNAL( TIMER0_OVF0_vect )
{
  //
  // Den Zaehler erhoehen. Hat er 100 erreicht (entspricht
  // 100 PWM Stufen), dann wieder bei 0 anfangen
  //
  PWMCounter++;
  if( PWMCounter == 101 )
    PWMCounter = 0;

  //
  // Muss die LED ein oder ausgeschaltet sein?
  //
  if( LEDValue < PWMCounter )
    LED_PORT |= LED_PIN;     // Led ein
  else
    LED_PORT &= ~ LED_IN;    // Led aus
}


int main()
{
  LEDValue = 0;     // Led aus

  // Code zur initialisierung des Timers

  while( 1 ) {
    //
    // Die LED etwas heller stellen. Ist der Endwert erreicht
    // dann wieder bei ganz Dunkel anfangen
    //
    if( LEDValue == 100 )
      LEDValue = 0;
    else
      LEDValue++;

    _dealay_ms( 20 );    // etwas warten
  }
}


Das Wichtiste an diesem Code ist, dass dieser Code die eigentliche
PWM von einer ev. Auswertung von Tasten, die in main() gemacht
werden würde, trennt. Letztendlich ist es ja für die PWM
völlig egal, wie der Vorgabewert zustandekommt. Bei einer
Meiner Anwendungen hab ich zb. ein Schema aus Hellzeit, Dunkelzeit,
HellHelligkeit, DunkelHelligkeit. Alle 4 Parameter werden mit
Zufallszahlen zur Laufzeit berechnet. Der Effekt ist, dass eine
Ansammlung von 60 Leds völlig unabhängig voneinander vor sich
hinblinken. Mal heller, mal dunkler. Mal sieht es aus wie Sterne
die in einer kalten Winternacht funkeln, mal sieht es aus wie
die Blitzlichtgewitter in einem Sportstadion.

Autor: Stefan May (smay4finger)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@kbucheg: Deine Anwendung würde mich mal interessieren. Ich bin gerade 
dabei einen Sternenhimmel zu bauen, da sollen die "Sterne" dann auch 
funkeln. Ich habe aber bisher noch nicht die richtigen Parameter dafür 
gefunden. Hast Du da welche parat?

Auch die Ansteuerung würde mich interessieren. Wie steuerst Du 60 LEDs 
unabhängig voneinander?

mfg, Stefan.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Mega8, 12 Mhz
Daran eine Schieberegisterkette aus 595 + Treiber

Ich benutzte den CTC Modus um den Grundtakt zum raustakten
in die Schieberegister zu kriegen.

Jede Led durchläuft einen Zyklus
         Zyklusbegin                           Zyklusende
            |                                      |
            |                                      |
            v                                      v

Helligkeit
^
|           ------------------------+
|                                   |
|                                   |
|                                   |
|                                   |
|                                   |
|                                   +---------------
|
|
|
+---------------------------------------------------->  Zeit

Der erste Teil des Zyklus ist die 'Hellphase', der zweite
die 'Dunkelphase'.

Für jede Phase sind variabel:
  * die Zeitdauer
  * die Helligkeit

Jede der beiden Variablen folgt einer Gleichung
  Wert = Konstant + zufälliger Anteil

Halte ich den zufälligen Anteil klein, so wirkt sich nur
der konstante Anteil aus und alle LED's verhalten sich gleich.
Je höher ich den zufälligen Anteil wähle, desto größer sind
die Unterschiede von einer Led zur nächsten.

Für jede Led gibt es einen Zähler, der von der maximalen Zeit
(Hell + Dunkel) auf 0 herunterzählt. In der Idle Time, wenn also
der Prozessor nichts anderes zu tun hat, werden sukzessive
alle Zähler überprüft, ob einer davon 0 geworden ist. Wird
so einer aufgefunden, so werden dieser Led neue Werte
verpasst. Das heist die Zeiten wird nicht exakt eingehalten.
Das spielt aber keine grosse Rolle, denn ob die Led jetzt
1/100 Sekunde länger den vorhergehenden Zustand einhält
oder nicht, spielt keine Rolle.

Übrigens: Hell und Dunkelphase muss nicht heissen, dass
die Led in der Hellphase heller sind als in der Dunkelphase :-)
Eine lange Hellphase, in der die Led auf 5% sind und eine sehr
kurze aber helle Dunkelphase gibt auch einen netten Effekt.

Anbei mal das Pgm. Das ganze ist so ausgelegt, dass ich alle
Parameter über die UART verändern kann.
?   Hilfe
i   info über die momentane Einstellung.
g   Die Zyklus ab bzw. einschalten

Ein Besonderheit ist die Verarbeitung von Zahlen. Es wird
zuerst die Zahl angegeben und dann erst die Operation die
damit gemacht werden soll. Um also die konstante Helligkeit
in der Hellphase zu ändern, gebe ich ein:
30o

o ist dabei das Kommando um den konstanten Anteil der Helligkeit
den neuen Wert (in dem Fall 30) zu setzten.

Dazu kommt dann noch ein Bedienteil, der aus ebenfalls einem
Mega8, LCD und 3 Tastern besteht. Die Steuerung über die UART
werde ich beibehalten. Der Steuerteil sitzt hinter der abgehängten
Decke und den Bedienteil möchte ich natürlich bequem in Griffhöhe
haben.

Die Elektronik ist soweit fertig (der eigentliche Rechner für
das Bedienteil muss noch gebaut werden, gestern hab ich die
Platine gemacht, die LCD+Taster Platine ist fertig). Eine erste
Version seiner Programmierung läuft auch schon. Dann brauch
ich nicht mehr mit dem Laptop an den Himmel ran um damit zu
spielen.
Der Deckenaufbau ist soweit auch erledigt, LED eingebaut, der
Steuerrechner hängt noch aus dem Loch in der Decke (damit ich noch
an die RS232 rankomme).
Jetzt kommt der Aufbau der ganzen 'Wandgehäuse'.
Vielleicht mach ich noch ein Video von dem Teil 'in Action'

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hier das angekündigte Video

Youtube-Video "Himmel"

Ich hoffe mal das klappt. Ist meinerstes Video bei YouTube :-)

Autor: Patrick Dohmen (oldbug) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hm, tut's nicht...
This is a private video. If you have been sent this video, please make sure you accept the sender's friend request.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habs mal auf 'public' gesetzt.

Autor: Michael Wilhelm (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Karl heinz,

if( LEDValue == 100 )
      LEDValue = 0;
    else
      LEDValue++;

    _dealay_ms( 20 );

Das macht man aber eigentlich nicht, oder? Wenn das Programm 
umpfangreicher wird, kann durchaus LEDValue = 100 übergangen werden. 
Dann muss ein ganzer Zyklus vergehen, damit das wieder greift. Besser:

if( LEDValue > 99 )
...

MW

Autor: Karl heinz Buchegger (kbucheg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> kann durchaus LEDValue = 100 übergangen werden.

Im Moment kann das nicht passieren.
Das ist die einzige Stelle an der LEDValue geändert wird.

Das ist Code aus der main() Schleife. Die Idee dahinter
ist es, eine kleine Testanwendung zu haben, damit man
auch sieht, dass die LED gedimmt wird. In dem Fall
durchläuft sie eine Helligkeitsrampe. In einer realen
Applikation wird man dafür ja sowieso was anderes machen,
daher hab ich keinen besonderen Aufwand getrieben.

Autor: Fabian B. (fabs)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Karl-Heinz,
was für Treiber hast du denn benutzt hinter den hc595?
Hast du das Projekt denn jetzt finalisiert? Wärest du bereit zu teilen? 
;-)

Gruß
Fabian

Autor: Carsten H. (carsten29)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gibt es von diesem Projekt einen Schaltplan ?

Das wäre echt super !!


Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
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.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.