Projecten - Looplicht

Dit project laat zien hoe met de Arduino een eenvoudig looplicht kan worden gemaakt. Het looplicht bestaat uit acht LED's en daarmee kunnen we aantal patronen maken. Met een potentiometer regelen we de snelheid en met de DIP-switches stellen we het gewenste patroon in.

Met S1 stellen we in of de LEDs is één groep van acht LEDs werken of in twee groepen van vier. Met S2 stellen we in of de LEDs één kant op lopen of dat ze heen en weer bewegen. S3 gebruiken we om in te stellen of er telkens slechts één LED brandt (dot mode) of dat er een reeks van LEDs brandt (bar) mode. S4 werkt alleen als de LEDs in twee groepen van vier werken en geeft dan aan of de twee groepen dezelfde kant op bewegen of in tegengestelde richting.

Schakeling

Onderstaande schema laat een gedeelte van het geheel zien. Van de acht LEDs zijn er twee getekend en van de vier schakelaars zijn er ook twee getekend.

Onderdelen

Component	Type	Aantal
D1-D8	Rode 3mm LED	8
S1-S4	DIP switch 4 polig	1
T1-T8	BC549C	8
R1-R8	1 kΩ	8
R9-R20	10 kΩ	12
R21	10 kΩ potmeter	1

Sketch

//Sketch voor een eenvoudig looplicht
//
//Aansluitingen:
//  - Led 1 aan digitale pin 2
//  - Led 2 aan digitale pin 3
//  - Led 3 aan digitale pin 4
//  - Led 4 aan digitale pin 5
//  - Led 5 aan digitale pin 6
//  - Led 6 aan digitale pin 7
//  - Led 7 aan digitale pin 8
//  - Led 8 aan digitale pin 9
//
//  Switch voor 4 of 8 bits
//  - DIP switch 1 tussen digitale pin 10 en 5V
//  - 10 kΩ weerstand tussen digitale pin 10 en GND
//  Switch voor Uni- of bidirectioneel
//  - DIP switch 2 tussen digitale pin 11 en 5V
//  - 10 kΩ weerstand tussen digitale pin 11 en GND
//  Switch voor Dot of Bar
//  - DIP switch 3 tussen digitale pin 12 en 5V
//  - 10 kΩ weerstand tussen digitale pin 12 en GND
//  Switch voor Kopie of Spiegelbeeld (alleen voor 4 bits mode)
//  - DIP switch 4 tussen digitale pin 13 en 5V
//  - 10 kΩ weerstand tussen digitale pin 13 en GND
//
//  - 10 kΩ potmeter tussen 5V en GND, slede aan analoge pin 0


const int  NumberOfLeds     = 8;
const int  NumberOfSwitches = 4;

const int  BIT1 = 128;
const int  BIT2 =  64;
const int  BIT3 =  32;
const int  BIT4 =  16;
const int  BIT5 =   8;
const int  BIT6 =   4;
const int  BIT7 =   2;
const int  BIT8 =   1;

const int  Bits[NumberOfLeds] = {BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7, BIT8};

const int  M_4BITS = (BIT1 | BIT2 | BIT3 | BIT4);
const int  M_8BITS = (BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7 | BIT8);

const int LED1 =  2;
const int LED2 =  3;
const int LED3 =  4;
const int LED4 =  5;
const int LED5 =  6;
const int LED6 =  7;
const int LED7 =  8;
const int LED8 =  9;

const int BITS_MASK      = 1;
const int BITS_4         = 0;
const int BITS_8         = 1;
const int RICHTING_MASK  = 2;
const int RICHTING_UNI   = 0;
const int RICHTING_BI    = 2;
const int FILL_MASK      = 4;
const int FILL_DOT       = 0;
const int FILL_BAR       = 4;
const int SPLIT_MASK     = 8;
const int SPLIT_KOPIE    = 0;
const int SPLIT_SPIEGEL  = 8;

const int ModeBits       = 10;
const int ModeDirection  = 11;
const int ModeFill       = 12;
const int ModeBounce     = 13;

const int Leds[NumberOfLeds] = {LED1, LED2, LED3, LED4, LED5, LED6, LED7, LED8};
const int ModeSwitch[NumberOfSwitches] = {ModeBits, ModeDirection, ModeFill, ModeBounce};

const int SpeedSensor = A0;

#define  LEFT    0
#define  RIGHT   1

int  CurrentPattern;
int  CurrentDirection;
int  CurrentMode;

int Delay(void){
  return(analogRead(SpeedSensor));
}

void DisplayPattern(void){
  int  Bit;
  
  if (Is4Bit()){
    for (Bit = 0; Bit < 4; Bit++){
      if (CurrentPattern & Bits[Bit]){
        digitalWrite(Leds[Bit], HIGH);
        if (IsCopyMode()){
          digitalWrite(Leds[Bit+4], HIGH);
        } else {
          digitalWrite(Leds[7-Bit], HIGH);
        }
      } else {
        digitalWrite(Leds[Bit], LOW);
        if (IsCopyMode()){
          digitalWrite(Leds[Bit+4], LOW);
        } else {
          digitalWrite(Leds[7-Bit], LOW);
        }
      }
    }
  } else {
    for (Bit = 0; Bit < NumberOfLeds; Bit++){
      if (CurrentPattern & Bits[Bit]){
        digitalWrite(Leds[Bit], HIGH);
      } else {
        digitalWrite(Leds[Bit], LOW);
      }
    }
  }
}

int GetShiftInValue(int direction, int pattern){
  int  ShiftOutBit;
  int  ShiftInBit;
  
  if (direction == LEFT){
    ShiftOutBit = (pattern & BIT1) ? 1 : 0;
  } else { //direction == RIGHT
    if (Is8Bit()){
      ShiftOutBit = (pattern & BIT8) ? 1 : 0;
    } else { //Is4Bit() == true
      ShiftOutBit = (pattern & BIT4) ? 1 : 0;
    }  
  }
  if (IsBarMode()){
    ShiftInBit = 1 - ShiftOutBit;
  } else {
    ShiftInBit = ShiftOutBit; 
  }
  return(ShiftInBit);
}

boolean Is4Bit(void){
  return((CurrentMode & BITS_MASK) == BITS_4);
}

boolean Is8Bit(void){
  return((CurrentMode & BITS_MASK) == BITS_8);
}

boolean IsUnidirectional(void){
  return((CurrentMode & RICHTING_MASK) == RICHTING_UNI);
}

boolean IsBidirectional(void){
  return((CurrentMode & RICHTING_MASK) == RICHTING_BI);
}

boolean IsDotMode(void){
  return((CurrentMode & FILL_MASK) == FILL_DOT);
}

boolean IsBarMode(void){
  return((CurrentMode & FILL_MASK) == FILL_BAR);
}

boolean IsCopyMode(void){
  return((CurrentMode & SPLIT_MASK) == SPLIT_KOPIE);
}

boolean IsMirrorMode(void){
  return((CurrentMode & SPLIT_MASK) == SPLIT_SPIEGEL);
}

int ReadMode(void){
  int  Flag;
  int  FlagValue;
  int  Mode;
  
  Mode = 0;
  FlagValue = 1;
  
  for (Flag = 0; Flag < NumberOfSwitches; Flag++){
    if (digitalRead(ModeSwitch[Flag])){
      Mode |= FlagValue;
    }
    FlagValue <<= 1;
  }
  return(Mode);
}

void SetDirection(){
  if (IsBidirectional()){
    if (CurrentDirection == RIGHT){
      if (Is8Bit()){
        if (CurrentPattern & BIT8){
          CurrentDirection = LEFT;
        }
      } else {
        if (CurrentPattern & BIT4){
          CurrentDirection = LEFT;
        } 
      }
    } else {
      if (IsDotMode()){
        if (CurrentPattern & BIT1){
          CurrentDirection = RIGHT;
        }
      } else {
        if ((CurrentPattern & BIT1) == 0){
          CurrentDirection = RIGHT;
        }
      }
    }
  }
}

void SetNextPattern(void){
  int ShiftInValue;
  int ShiftInBit;
  
  ShiftInValue = GetShiftInValue(CurrentDirection, CurrentPattern);
  if (CurrentDirection == LEFT){
    CurrentPattern <<= 1;
  } else {
    CurrentPattern >>= 1;
  }
  if (Is8Bit()){
    CurrentPattern &= M_8BITS;
  } else {
    CurrentPattern &= M_4BITS;
  }
  if (CurrentDirection == LEFT){
    if (Is4Bit()){
      ShiftInBit = 4;
    } else {
      ShiftInBit = 8; 
    }
  } else {
    ShiftInBit = 1;
  }
  if (ShiftInValue == 0){
    CurrentPattern &= (M_8BITS - Bits[ShiftInBit-1]);
  } else {
    CurrentPattern |= Bits[ShiftInBit-1];
  }
}

void SetStartDirection(void){
  CurrentDirection = RIGHT;
}

void SetStartPattern(void){
  CurrentPattern = BIT1;
}

void setup(void){
  int LED;
  int Switch;
  
  for (LED = 0; LED < NumberOfLeds; LED++){
    pinMode(Leds[LED], OUTPUT);
    digitalWrite(Leds[LED], LOW);
  }
  for (Switch = 0; Switch < NumberOfSwitches; Switch++){
    pinMode(ModeSwitch[Switch], INPUT);
  }
  CurrentMode = ReadMode();
  SetStartDirection();
  SetStartPattern();
}

void loop(void){
  int Mode;
  
  Mode = ReadMode();
  if (Mode != CurrentMode){
    SetStartDirection();
    SetStartPattern();
    CurrentMode = Mode;
  }
  
  DisplayPattern();
  delay(Delay());
  SetDirection();
  SetNextPattern();
}

Bovenstaande sketch is compleet en werkt zonder aanpassingen als deze gekopieerd wordt naar de Arduino ontwikkelomgeving versie 1.0.1.

Eerste publicatie op 5 april 2013

Laatste modificatie op 5 april 2013