Ik zoek een (schijnbaar) eenvoudige schakeling.

[Frits van Mourik]

Beste mensen,

Ik zoek een eenvoudige schakeling:
-Een kastje heeft een aan- en een uit- drukknop.
Het kastje is voorzien van vijf LEDjes; ABCDE.
Na één druk op de "aan"-knop gaat LED A aan, na 2 seconden LED B, na 2 seconden LED C; enzovoorts.
Na één druk op de "uit"- knop gaat LED E uit, na 2 seconden LED D, na 2 seconden LED C; enzovoorts.
Get my drift?

Kan iemand mij in de juiste richting sturen?

[Dirk_Hendrik]

En als A-E alle 5 aan zijn? Moet er dan niets gebeuren tot de uit toets wordt ingedrukt.

Je schakeling is idd heel simpel. 10 weerstanden, 5 transistoren, 5 leds. en een Atmel AVR van 3 euro. Een "discretere" oiplossing, met TTL of CMOS IC's gaat meteen fors uitgebreider worden.

[HaroldA]

Is het een trage "KITT" schakeling die pas na een druk op de knop terug gaat?

[nico verduin]

En als A-E alle 5 aan zijn? Moet er dan niets gebeuren tot de uit toets wordt ingedrukt.

Je schakeling is idd heel simpel. 10 weerstanden, 5 transistoren, 5 leds. en een Atmel AVR van 3 euro. Een "discretere" oiplossing, met TTL of CMOS IC's gaat meteen fors uitgebreider worden.Als ie niet meer als LEDjes van 20mA max gebruikt, dan komt ie weg met een ATTiny24/44/84 (beetje afhankelijk van hoeveel Flash nodig is) met 8 weerstanden en zelfs geen transitoren:
- ATtinyxx
- 5 x 330 ohm 0.25W
- 3 x 10K 0.25W (reset + knoppen[pull-down]
- 2 x 100nF (1 x Vcc en 1 x reset)
- 5 x LED 20 mA

tutti

@edit: Nog niet getest maar dit zou het hele programma zijn:



//
// pin definitions
//
#define LEDA 0
#define LEDB 1
#define LEDC 2
#define LEDD 3
#define LEDE 4
#define KNOP_AAN 5
#define KNOP_UIT 6
//
// overige defines
//
#define DEBOUNCE_TIJD 50 // 50 milliseconde debounce tijd
#define VERSPRING_TIJD 2000 // elke 2 seconden verspringen
//
// global variables
//
unsigned long milliSecondeTimer;// teller om de leds na verloop te laten verspringen
uint8_t ledVerwijzer; // geeft de huidige actieve LED aan
boolean oplopen; // indicator dat hij aan het oplopen is
boolean aflopen; // indicator dat hij aan het aflopen is

uint8_t ledArray[5] = // tabel met LED verwijzingen
{
LEDA,
LEDB,
LEDC,
LEDD,
LEDE
};

/**
* @name setup()
* initializes the program
*/
void setup()
{
//
// opzetten outputs en zet de LEDS voor de zekerheid uit (bekende situatie)
//
for (uint8_t i = 0; i < sizeof(ledArray); i++) {
//
// output modus
//
pinMode(ledArray[i], OUTPUT);
//
// LED uit
//
digitalWrite(ledArray[i], LOW);
}
oplopen = false;
aflopen = false;
}
/**
* @name loop()
* oneindige loop van het programma
*/
void loop()
{
uint8_t knopAan;
uint8_t knopUit;
//
// kijk eerst of de beide knoppen zijn ingedrukt. Er mag maar een knop tegelijk ingedrukt zijn
//
if (!digitalRead(KNOP_AAN) && !digitalRead(KNOP_UIT)) {
//
// beide knoppen zijn aan dus doen we ff niets
//
} else {
//
// kijk of de knop AAN is ingedrukt
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopAan = 1;
} else {
knopAan = 0;
}
} else {
knopAan = 0;
}
//
// kijk of knop UIT is ingedrukt
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopUit = 1;
} else {
knopUit = 0;
}
} else {
knopUit = 0;
}
}
//
// nu de knoppen verwerken
//
if (knopAan) {
//
// check eerst of dit de allereerste keer is
//
if (!oplopen) {
//
// hij deed nog niets
//
oplopen = true; // we gaan oplopen
aflopen = false;
ledVerwijzer = 0; // begin bij eerste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten oplopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de volgende LED
//
ledVerwijzer++;
//
// maar kijk wel of we niet voorbij de laatste LED zijn
//
if (ledVerwijzer > sizeof(ledArray)) {
//
// in dit geval gaan we niet verder
//
ledVerwijzer = sizeof(ledArray) - 1;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer - 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de eerste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
if (knopUit) {
//
// check eerst of dit de allereerste keer is
//
if (!aflopen) {
//
// hij deed nog niets
//
aflopen = true; // we gaan aflopen
oplopen = false;
ledVerwijzer = sizeof(ledArray); // begin bij laatste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten aflopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de vorige LED
//
ledVerwijzer--;
//
// maar kijk wel of we niet voorbij de eerste LED zijn
//
if (ledVerwijzer == 255) { // 8bit loop around
//
// in dit geval gaan we niet verder
//
ledVerwijzer = 0;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer + 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de laatste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
}
/**
* @name Delay(unsigned long duur)
* @param duur vertragingstijd in milliseconden
* Dit is een eenvoudige delay routine die ook op de ATTiny werkt.
*/
void Delay(unsigned long duur) {
unsigned long ctr;
ctr = millis() + duur;
while (millis() <= ctr){};
}




Alleen een beetje ruzie met de tab spatiëring #$%$#@

[Frits van Mourik]

Hallo beste vrienden,

Bedankt voor jullie reacties!

Het is idd. de bedoeling, dat na een druk op de "on"-druktoets iedere LED na twee seconden aangaat en dan ook aanblijft.
Na een druk op de "off"-druktoets dooft de laatste LED , daarna na 2 sec dooft de vorige LED , enz...

Helaas, met de geboden ideeën kan ik niet zoveel.
Mijn programmeerkennis beperkt zich tot het simpele Sinclair ZX81 BASIC.
Hoewel ik de "flow" van Nico's programming wel enigszins kan volgen, heb ik geen ID,
hoe ik dit in zo'n "moderne" chip moet krijgen...
Als iemand dit voor mij kan doen, zou ik dit zeer OK vnden! Hoeft niet voor nix!

[nico verduin]

Hoi Frits, Mail me maar ff :)

[obiwanjacobi]

//
// pin definitions
//
#define LEDA 0
#define LEDB 1
#define LEDC 2
#define LEDD 3
#define LEDE 4
#define KNOP_AAN 5
#define KNOP_UIT 6
//
// overige defines
//
#define DEBOUNCE_TIJD 50 // 50 milliseconde debounce tijd
#define VERSPRING_TIJD 2000 // elke 2 seconden verspringen
//
// global variables
//
unsigned long milliSecondeTimer;// teller om de leds na verloop te laten verspringen
uint8_t ledVerwijzer; // geeft de huidige actieve LED aan
boolean oplopen; // indicator dat hij aan het oplopen is
boolean aflopen; // indicator dat hij aan het aflopen is

uint8_t ledArray[5] = // tabel met LED verwijzingen
{
LEDA,
LEDB,
LEDC,
LEDD,
LEDE
};

/**
* @name setup()
* initializes the program
*/
void setup()
{
//
// opzetten outputs en zet de LEDS voor de zekerheid uit (bekende situatie)
//
for (uint8_t i = 0; i < sizeof(ledArray); i++) {
//
// output modus
//
pinMode(ledArray, OUTPUT);
//
// LED uit
//
digitalWrite(ledArray[i], LOW);
}

[I] pinMode(KNOP_AAN, INPUT);
pinMode(KNOP_UIT, INPUT);


oplopen = false;
aflopen = false;
}
/**
* @name loop()
* oneindige loop van het programma
*/
void loop()
{
uint8_t knopAan;
uint8_t knopUit;
//
// kijk eerst of de beide knoppen zijn ingedrukt. Er mag maar een knop tegelijk ingedrukt zijn
//
if (!digitalRead(KNOP_AAN) && !digitalRead(KNOP_UIT)) {
//
// beide knoppen zijn aan dus doen we ff niets
//
} else {
//
// kijk of de knop AAN is ingedrukt
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopAan = 1;
} else {
knopAan = 0;
}
} else {
knopAan = 0;
}
//
// kijk of knop UIT is ingedrukt
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopUit = 1;
} else {
knopUit = 0;
}
} else {
knopUit = 0;
}
}
//
// nu de knoppen verwerken
//
if (knopAan) {
//
// check eerst of dit de allereerste keer is
//
if (!oplopen) {
//
// hij deed nog niets
//
oplopen = true; // we gaan oplopen
aflopen = false;
ledVerwijzer = 0; // begin bij eerste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten oplopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de volgende LED
//
ledVerwijzer++;
//
// maar kijk wel of we niet voorbij de laatste LED zijn
//
if (ledVerwijzer > sizeof(ledArray)) {
//
// in dit geval gaan we niet verder
//
ledVerwijzer = sizeof(ledArray) - 1;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer - 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de eerste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
if (knopUit) {
//
// check eerst of dit de allereerste keer is
//
if (!aflopen) {
//
// hij deed nog niets
//
aflopen = true; // we gaan aflopen
oplopen = false;
ledVerwijzer = sizeof(ledArray); // begin bij laatste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten aflopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de vorige LED
//
ledVerwijzer--;
//
// maar kijk wel of we niet voorbij de eerste LED zijn
//
if (ledVerwijzer == 255) { // 8bit loop around
//
// in dit geval gaan we niet verder
//
ledVerwijzer = 0;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer + 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de laatste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
}
/**
* @name Delay(unsigned long duur)
* @param duur vertragingstijd in milliseconden
* Dit is een eenvoudige delay routine die ook op de ATTiny werkt.
*/
void Delay(unsigned long duur) {
unsigned long ctr;
ctr = millis() + duur;
while (millis() <= ctr){};
}




Ik zou ook de PinMode van de knoppen nog even zetten... ;-)

[Dirk_Hendrik]

Maar de algemene concensus is dus identiek.
Doe het in software.

[nico verduin]

//
// pin definitions
//
#define LEDA 0
#define LEDB 1
#define LEDC 2
#define LEDD 3
#define LEDE 4
#define KNOP_AAN 5
#define KNOP_UIT 6
//
// overige defines
//
#define DEBOUNCE_TIJD 50 // 50 milliseconde debounce tijd
#define VERSPRING_TIJD 2000 // elke 2 seconden verspringen
//
// global variables
//
unsigned long milliSecondeTimer;// teller om de leds na verloop te laten verspringen
uint8_t ledVerwijzer; // geeft de huidige actieve LED aan
boolean oplopen; // indicator dat hij aan het oplopen is
boolean aflopen; // indicator dat hij aan het aflopen is

uint8_t ledArray[5] = // tabel met LED verwijzingen
{
LEDA,
LEDB,
LEDC,
LEDD,
LEDE
};

/**
* @name setup()
* initializes the program
*/
void setup()
{
//
// opzetten outputs en zet de LEDS voor de zekerheid uit (bekende situatie)
//
for (uint8_t i = 0; i < sizeof(ledArray); i++) {
//
// output modus
//
pinMode(ledArray, OUTPUT);
//
// LED uit
//
digitalWrite(ledArray[i], LOW);
}

[I] pinMode(KNOP_AAN, INPUT);
pinMode(KNOP_UIT, INPUT);


oplopen = false;
aflopen = false;
}
/**
* @name loop()
* oneindige loop van het programma
*/
void loop()
{
uint8_t knopAan;
uint8_t knopUit;
//
// kijk eerst of de beide knoppen zijn ingedrukt. Er mag maar een knop tegelijk ingedrukt zijn
//
if (!digitalRead(KNOP_AAN) && !digitalRead(KNOP_UIT)) {
//
// beide knoppen zijn aan dus doen we ff niets
//
} else {
//
// kijk of de knop AAN is ingedrukt
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_AAN) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopAan = 1;
} else {
knopAan = 0;
}
} else {
knopAan = 0;
}
//
// kijk of knop UIT is ingedrukt
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// wacht de debounce tijd even af en lees opnieuw
//
Delay(DEBOUNCE_TIJD);
//
// nog steeds ingedrukt?
//
if (digitalRead(KNOP_UIT) == LOW) {
//
// nee dus kunnen we hem nu aan zetten
//
knopUit = 1;
} else {
knopUit = 0;
}
} else {
knopUit = 0;
}
}
//
// nu de knoppen verwerken
//
if (knopAan) {
//
// check eerst of dit de allereerste keer is
//
if (!oplopen) {
//
// hij deed nog niets
//
oplopen = true; // we gaan oplopen
aflopen = false;
ledVerwijzer = 0; // begin bij eerste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten oplopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de volgende LED
//
ledVerwijzer++;
//
// maar kijk wel of we niet voorbij de laatste LED zijn
//
if (ledVerwijzer > sizeof(ledArray)) {
//
// in dit geval gaan we niet verder
//
ledVerwijzer = sizeof(ledArray) - 1;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer - 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de eerste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
if (knopUit) {
//
// check eerst of dit de allereerste keer is
//
if (!aflopen) {
//
// hij deed nog niets
//
aflopen = true; // we gaan aflopen
oplopen = false;
ledVerwijzer = sizeof(ledArray); // begin bij laatste led
milliSecondeTimer = 0; // de timer lossen we verder op
}
//
// we gaan de LEDS laten aflopen maar kijk eerst of de timer al loopt
//
if (milliSecondeTimer != 0) {
//
// de timer loopt al dus kijk of we moeten verspringen
//
if (millis() > milliSecondeTimer) {
//
// we gaan naar de vorige LED
//
ledVerwijzer--;
//
// maar kijk wel of we niet voorbij de eerste LED zijn
//
if (ledVerwijzer == 255) { // 8bit loop around
//
// in dit geval gaan we niet verder
//
ledVerwijzer = 0;
}
//
// zet de vorige LED uit
//
if (ledVerwijzer != 0) {
digitalWrite(ledArray[ledVerwijzer + 1], LOW);
}
//
// zet de LED aan
//
digitalWrite(ledArray[ledVerwijzer], HIGH);
//
// en zet de timer weer opnieuw
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
}
} else {
//
// zet de laatste LED aan en start de timer
//
milliSecondeTimer = millis() + VERSPRING_TIJD;
digitalWrite(ledArray[ledVerwijzer], HIGH);
}
}
}
/**
* @name Delay(unsigned long duur)
* @param duur vertragingstijd in milliseconden
* Dit is een eenvoudige delay routine die ook op de ATTiny werkt.
*/
void Delay(unsigned long duur) {
unsigned long ctr;
ctr = millis() + duur;
while (millis() <= ctr){};
}




Ik zou ook de PinMode van de knoppen nog even zetten... ;-)
Voor de netheid ja :) maar is op zich niet nodig. Maar daar zitten nog wel meer zaken in :). ff gauw in elkaargeflanst heh :). Is default INPUT.

[nico verduin]

Maar de algemene concensus is dus identiek.
Doe het in software.Ook wij moeten moderniseren :) Wel grappig dat deze site ook CODE tags ondersteunt :)