Monday, February 27, 2012

Toy traffic light - the next gen is here

After so much anxiety over how to build and secure the 7-segment LEDs to top of the signal tower--and at the same time permit the cap to be removed in case the incandescent bulbs need to be replaced--I've finally come up with a workable design and modified the original signal tower toy traffic light. I've also slightly revised the draft schematic and firmware (do check out that page for a primer on the circuit). Here's a summary--in images--of the build:

PCB artwork for the main board and the LED boards. Main board is 3 x 5". The three LED boards are all 1.25 x 1.5".



Freshly etched boards. I made an extra of what I call the "platform"--the board onto which the two 7-segment LED boards named ALPHA and BETA are soldered to at right angles.



Below is the panel broken into four boards using the score and snap method. These have already been drilled (except for the extra board).


A 9-pin connector runs from the main board to the platform board. I soldered two cables back-to-back. You can see the white female plugs at the top and bottom of the photo. The other bundle of wires is the original cable for the bulbs.






That round yellow thing is a rubber pad inserted so that the signal tower and the plastic box are not rigidly connected to one another. From the looks of it the box is made of (high impact) polystyrene and is brittle. Sharp knocks and blows will crack it. The rubber acts to partly absorb shocks and prevent breakage. The three screws are tightened only to the point that the rubber is compressed a little bit.



The biggest headache for me was finding a way to mount the LED display on top of the signal tower. Fortunately I found this plastic pill and trinket storage set. The individual canisters screw on top of one another with a final screw-on cap on top. Its diameter is 50mm--exactly the same as the signal tower's. I took the cap and one of the canisters and drilled the appropriate holes. I don't have a coping saw or router so I just used the drill bit to cut out the shapes for the connectors. Messy and crude but it worked.






The countdown timer installed on top of the tower. I discarded the original (beige) cap of the signal tower and screwed in the canister instead.




The main board before and after the various wires were connected. You will notice the chopstick extension piece glued to the yellow push button. As in the previous model that stick pokes through a hole on top half of the plastic box. The board is secured to the base of the box using hot melt glue.





Here's a vid showing how the traffic light works.




As I mentioned above I've made some revisions to the drafts of the schematic and firmware. Here are the final versions.



MCU = Microchip PIC16F1827 microcontroller
D1 = 1N5822 Schottky diode
VR = 78L05 +5V voltage regulator
7SEG1, 7SEG2 = 306IDB common anode 2-digit 7-segment LED
Q1, Q2, Q3 = TIP102 NPN Darlington transistors
Q4, Q5 = S9012 PNP transistors
Q6, Q7 = 2N7000 MOSFET transistors
Q8 = ULN2003 transistor array
LR, LR, LG = incandescent lamps


/*

Kids' Traffic Light with Countdown Timer Using an Industrial Signal Tower

Created:        January 2012
Processor:      PIC 16F1827
Compiler        mikroC Pro 5.0.0
Remarks:        see "kids traffic light.dwg" for schematic
Configuration:  power up timer, brownout reset (set to 2.5V), WDT, stack over/underflow reset -- all enabled, all others disabled

* Uses a 12VDC wall wart as power supply

* Tower light 12VDC red, amber, green incandescent lamps are switched by NPN Darlington transistors

* pushbutton:
     * when momentarily pressed: cycles through different possible modes:
          1. flashing amber
          2. flashing red
          3. alternating amber and red
          4. normal traffic light: green -> amber -> red

     * when pressed and kept depressed for over a couple of seconds LED display shows 1,2,3,4,5,6 in sequence corresponding to following go/stop on-time:
          1. 5sec
          2. 10sec
          3. 15sec
          4. 20sec
          5. 25sec
          6. 30sec
     * although LED readout can be made to show number of real-time seconds when selecting go/stop time
       showing it in the manner above provides an opportunity to teach the children how to multiply--in this case multiply by 5

* go/stop on-time is stored in EEPROM

* has 7-segment LED display
     * shows the go/stop on-time when selecting it
     * shows the remaining time before light changes
     * shows various non-numeric characters in other modes


*/



// ************************************************************************************************
//       input / output
// ************************************************************************************************

#define  lred                LATB.f3             // NPN darlington switches 12VDC incandescent lamp
#define  lamber              LATB.f2             // NPN darlington switches 12VDC incandescent lamp
#define  lgreen              LATB.f1             // NPN darlington switches 12VDC incandescent lamp

#define  pb                  PORTB.f6            // momentary contact push button
#define  tris_pb             TRISB.f6            // for setting pb pin as input
#define  wpu_pb              WPUB.f6             // for enabling weak pullup

#define  anode_ones          LATB.f5             // S9012 PNP transistor
#define  anode_tens          LATB.f4             // S9012 PNP transistor

#define  seg_a               LATA.f4             // segment a of seven segment LED common anode
#define  seg_b               LATA.f3             // segment b of seven segment LED common anode
#define  seg_c               LATA.f0             // segment c of seven segment LED common anode
#define  seg_d               LATA.f6             // segment d of seven segment LED common anode
#define  seg_e               LATA.f7             // segment e of seven segment LED common anode
#define  seg_f               LATA.f1             // segment f of seven segment LED common anode
#define  seg_g               LATA.f2             // segment g of seven segment LED common anode

// ************************************************************************************************
//       traffic light time duration
// ************************************************************************************************

#define  count_ini           250       // number of timer2 ticks to make one second

#define  ambertime           500       // in normal mode -- amount of time for amber light to be on after green and before red -- time in terms of timer2 ticks
#define  flashambertime      200       // in flashing amber mode -- amount of time for amber light to be on and amount of time to be off -- time in terms of timer2 ticks
#define  flashredtime        200       // in flashing red mode -- amount of time for red light to be on and amount of time to be off -- time in terms of timer2 ticks
#define  flashredambtime     200       // in red/amber alternate flashing mode -- amount of time for red light to be on and amount of time amber light to be on -- time in terms of timer2 ticks
#define  ledflashtime        25        // in normal mode during yield (amber light) -- amount of time the character displayed on 7-seg is flashed on and off

#define  changergtime        375       // minimum amount of time for button to be kept pressed before cycling through the green light on time -- time in terms of timer2 ticks
                                       // given 4ms timer2 tick, changergtime of 250 = 1sec real time

#define  prechangergtime     changergtime - 250  // amount of time after button is held down when all lights are turned off in preparation for possible change of green/red light on time

#define  rgtime_increm       1250      // amount of time for green/red light to be on, and multiples thereof upon continual button press -- value in terms of timer2 ticks.
#define  maxrgtime           6         // maximum allowed multiple of rgtime_increm

int16 REDGREENTIME;                    // amount of time for green/red light to be on -- time in terms of timer2 ticks
int8  RGTIME;                          // multiples of rgtime_increm such that RGTIME*rgtime_increm = REDGREENTIME


// ************************************************************************************************
//       for pushbutton
// ************************************************************************************************

#define  rising              1         // rising edge detected. used by PBedge
#define  released            1         // rising edge detected. used by PBedge
#define  falling             2         // falling edge detected. used by PBedge
#define  pressed             2         // falling edge detected. used by PBedge
#define  none                0         // no edge. used by PBedge

int8 PBval;                            // last eight values of the switch upon reading it
int8 PBedge;                           // edge detected?, 0 = no edge detect, 1 = rising edge, 2 = falling edge; other values = Not Used / Undefined for now
bit PBlevel;                           // voltage level of switch when not bouncing (hi = 1, lo = 0)

// ************************************************************************************************
//       general defines and variables
// ************************************************************************************************

#define  int1                bit
#define  int8                unsigned char
#define  int16               unsigned int
#define  int32               unsigned long

#define  on                  1
#define  off                 0

#define  input               1         // for TRISx
#define  output              0         // for TRISx

#define  analog              1         // for ANSELx
#define  digital             0         // for ANSELx

#define  addr_rgtime         0x10      // eeprom address for user selected green/red light on time

#define  disp_dash           111       // code to display a dash, for use with UpdateDisp()

#define  disp_3horiz         120       // code to display three horizontal segments, for use with UpdateDisp()
#define  disp_tophoriz       121       // code to display top horizontal segment, for use with SegmentAssign()
#define  disp_midhoriz       122       // code to display middle horizontal segment, for use with SegmentAssign()
#define  disp_botthoriz      123       // code to display bottom horizontal segment, for use with SegmentAssign()

#define  disp_brackets       130       // code to display brackets, for use with UpdateDisp()
#define  disp_left_bracket   131       // code to display left bracket, for use with SegmentAssign()
#define  disp_right_bracket  132       // code to display right bracket, for use with SegmentAssign()

#define  disp_topsquare      141       // code to display top square, for use with UpdateDisp()
#define  disp_bottsquare     142       // code to display bottom square, for use with UpdateDisp()

#define  disp_blank          255       // code to display nothing, for use with UpdateDisp()

int16 TIME = 0;                        // records how long a light has been on  -- in terms of timer2 ticks
int8  VALUE = disp_blank;              // number or character to be displayed on 7-seg LED
int8  RGSECONDS;                       // user-selected red/green on-time in real-time seconds


// ************************************************************************************************
//       for state machines
// ************************************************************************************************

// !! A C H T U N G !! 
// make sure all non user selectable modes such as _standby and _selectrgtime come AFTER user selectable
// and that _normal" is the last item in the valid user selectable modes because it is used as the max value in ProcessKey()
enum {_flashingamber, _flashingred, _flashingredamber, _normal, 
      /* the modes that follow are non-user selectable --> */ _standby, _selectrgtime} STATEMODE = _flashingamber;

enum {_stop, _yield_ini, _yield, _go} STATENORMAL = _stop;
enum {_init, _flash} STATEFLASHGREEN = _init;


// ===========================================================================================
//       LED 7-Segment Display
// ===========================================================================================

void SegmentAssign(int8 num)
{
  seg_a = 0;
  seg_b = 0;
  seg_c = 0;
  seg_d = 0;
  seg_e = 0;
  seg_f = 0;
  seg_g = 0;

  switch (num)
  {
    case 1:
      seg_b = 1;
      seg_c = 1;
      break;

    case 2:
      seg_a = 1;
      seg_b = 1;
      seg_d = 1;
      seg_e = 1;
      seg_g = 1;
      break;

    case 3:
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      seg_d = 1;
      seg_g = 1;
      break;

    case 4:
      seg_b = 1;
      seg_c = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case 5:
      seg_a = 1;
      seg_c = 1;
      seg_d = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case 6:
      seg_a = 1;
      seg_c = 1;
      seg_d = 1;
      seg_e = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case 7:
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      break;

    case 8:
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      seg_d = 1;
      seg_e = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case 9:
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      seg_d = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case 0:
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      seg_d = 1;
      seg_e = 1;
      seg_f = 1;
      break;

    case disp_dash:          // displays a dash - middle horizontal segment
      seg_g = 1;
      break;

    case disp_3horiz:        // displays three horizontal segments
      seg_a = 1;
      seg_d = 1;
      seg_g = 1;
      break;

    case disp_tophoriz:      // displays top horizontal segment
      seg_a = 1;
      break;

    case disp_botthoriz:     // displays bottom horizontal segment
      seg_d = 1;
      break;

    case disp_left_bracket:  // displays opening bracket
      seg_a = 1;
      seg_d = 1;
      seg_e = 1;
      seg_f = 1;
      break;

    case disp_right_bracket: // displays closing bracket
      seg_a = 1;
      seg_b = 1;
      seg_c = 1;
      seg_d = 1;
      break;

    case disp_topsquare:     // displays a square on upper half of LED
      seg_a = 1;
      seg_b = 1;
      seg_f = 1;
      seg_g = 1;
      break;

    case disp_bottsquare:    // displays a square on the lower half of the LED
      seg_c = 1;
      seg_d = 1;
      seg_e = 1;
      seg_g = 1;
      break;

    default:                 // if invalid value then display blank

    case disp_blank:         // segments have already been turned off at the start of this function so do nothing
      break;
  } // switch (num)
} // void SegmentAssign(int8 num)


void UpdateDisp()
{
  static bit anode;          // flag bit multiplexing display between tens and ones place
  int8 TENS, ONES;           // contains the digit or code of the non-numeric character to be displayed in the tens and ones place

  // turn off power to 7-segment LED display.
  anode_ones = off;
  anode_tens = off;

  if (STATEMODE != _standby)         // turn on LED display only when not in _standby mode
  {
    if (VALUE < 100)                 // values >= 100 are codes for non-numeric characters
    {
      TENS = VALUE/10;
      ONES = VALUE%10;
    } // if (VALUE < 100)
    else
    {
      switch (VALUE)
      {
        case disp_dash:
          TENS = disp_dash;
          ONES = disp_dash;
          break;

        case disp_3horiz:
          TENS = disp_3horiz;
          ONES = disp_3horiz;
          break;

        case disp_tophoriz:
          TENS = disp_tophoriz;
          ONES = disp_tophoriz;
          break;

        case disp_botthoriz:
          TENS = disp_botthoriz;
          ONES = disp_botthoriz;
          break;

        case disp_brackets:
          TENS = disp_left_bracket;
          ONES = disp_right_bracket;
          break;

        case disp_topsquare:
          TENS = disp_topsquare;
          ONES = disp_topsquare;
          break;

        case disp_bottsquare:
          TENS = disp_bottsquare;
          ONES = disp_bottsquare;
          break;

        default:                       // if invalid value then display blank

        case disp_blank:
          TENS = disp_blank;
          ONES = disp_blank;
          break;
      } // switch (VALUE)
    } // else if (VALUE >= 100)

    if (anode)
    {
      if (TENS != 0)                   // do not display tens place if it's zero
      {
        SegmentAssign(TENS);
        anode_tens = on;
      }
      anode = 0;
    }
    else
    {
      SegmentAssign(ONES);
      anode_ones = on;
      anode = 1;
    }
  } // if (display)
} // void UpdateDisp()


// ===========================================================================================
//       functions
// ===========================================================================================

void ComputeRedGreenTime()
{
  REDGREENTIME = RGTIME*rgtime_increm;
  RGSECONDS = RGTIME*5;
}

void AllLightsOff()
{
  lred = off;
  lamber = off;
  lgreen = off;
}

void IniReg()
{
  // set internal clock frequency to 2MHz
  OSCCON = 0b1100000;

  TRISA = output;
  TRISB = output;
  ANSELA = digital;
  ANSELB = digital;

  tris_pb = input;

  // enable weak pull up for pushbutton
  OPTION_REG.NOT_WPUEN = 0;
  wpu_pb = 1;
  
  AllLightsOff();            // necessary to make sure incandescent lamps which should be off upon start up are off

  // Timer2 is used for state machine and switch debouncing timing tick
  // with clock = 2MHz, PR2 = 125, prescale = 1:16, postscale = 1:1
  // TMR2 will count from zero to PR2 and timer2 interrupt occurs every 125*16 / (2MHz / 4) = 4ms = timer2 tick
  T2CON = 0b110;             // postscaler = 1:1, prescaler = 1:16, timer2 on
  TMR2 = 0;
  PR2 = 125;

  WDTCON = 0b1000;           // prescale = 1:512 (16ms typical)
                             // WDTE in configuration word is configured so that WDT enabled when MCU awake and disabled when MCU asleep

  // retrieve stored green/red light on time value.
  // If eeprom-stored value is out of valid range then set it to minimum and store this value in eeprom
  // stored values are in terms of multiples of rgtime_increm such that stored value multiplied by rgtime_increm = time in terms of TMR2 ticks
  RGTIME = EEPROM_Read(addr_rgtime);
  if (RGTIME == 0 || RGTIME > maxrgtime)
  {
    RGTIME = 1;
    EEPROM_Write(addr_rgtime, RGTIME);
  }
  ComputeRedGreenTime();                     // REDGREENTIME = RGTIME*rgtime_increm;

  // initialize push button
  PBval = 0xFF;
  PBlevel = hi;
} // void InitRegisters()


// amber flashes on and off at a rate determined by flashambertime
// LED display shows the character stored in VALUE
void FlashingAmber()
{
  static bit flag;

  if (++TIME < flashambertime)
  {
    if (flag)
    {
      lamber = on;
      VALUE = disp_brackets;
    }
    else
    {
      lamber = off;
      VALUE = disp_blank;
    }
  }
  else
  {
    if (flag)
      flag = 0;
    else
      flag = 1;
    TIME = 0;
  }
} // void FlashingAmber()


// red flashes on and off at a rate determined by flashredtime
// LED display shows the character stored in VALUE
void FlashingRed()
{
  static bit flag;

  if (++TIME < flashredtime)
  {
    if (flag)
    {
      lred = on;
      VALUE = disp_brackets;
    }
    else
    {
      lred = off;
      VALUE = disp_blank;
    }
  }
  else
  {
    if (flag)
      flag = 0;
    else
      flag = 1;
    TIME = 0;
  }
} // void FlashingRed()


// red and amber turn on alternately at a rate determined by flashredambertime
// LED display shows the character stored in VALUE
void FlashingRedAmber()
{
  static bit flag;

  if (++TIME < flashredambtime)
  {
    if (flag)
    {
      lamber = off;
      lred = on;
      VALUE = disp_topsquare;
    }
    else
    {
      lred = off;
      lamber = on;
      VALUE = disp_bottsquare;
    }
  }
  else
  {
    if (flag)
      flag = 0;
    else
      flag = 1;
    TIME = 0;
  }
} // void FlashingRedAmber()


// normal traffic light operation: green --> amber --> red
// red/green light on-time is user selectable
// LED display shows the countdown time in seconds during red and green light 
// LED display shows a flashing "--" during amber light, blink rate determined by ledbflashtime
void Normal()
{
  static int8 COUNTER;
  static bit toggle;

  switch (STATENORMAL)
  {
    case _stop:
      if (++TIME < REDGREENTIME)
      {
        lred = on;
        if (--COUNTER == 0)
        {
          --VALUE;
          COUNTER = count_ini;
        }
      }
      else
      {
        STATENORMAL = _go;
        TIME = 0;
        COUNTER = count_ini;
        VALUE = RGSECONDS;
        lred = off;
      }
      break;

    case _yield_ini:
      toggle = 1;
      VALUE = disp_dash;
      COUNTER = ledflashtime;
      TIME = 0;
      STATENORMAL = _yield;
      break;

    case _yield:
      if (++TIME < ambertime)
      {
        lamber = on;

        if (--COUNTER == 0)
        {
          if (toggle)
          {
            VALUE = disp_blank;
            toggle = 0;
          }
          else
          {
            VALUE = disp_dash;
            toggle = 1;
          }
          COUNTER = ledflashtime;
        }
      }
      else
      {
        STATENORMAL = _stop;
        TIME = 0;
        COUNTER = count_ini;
        VALUE = RGSECONDS;
        lamber = off;
      }
      break;

    case _go:
      if (++TIME < REDGREENTIME)
      {
        lgreen = on;
        if (--COUNTER == 0)
        {
          --VALUE;
          COUNTER = count_ini;
        }
      }
      else
      {
        STATENORMAL = _yield_ini;
        lgreen = off;
      }
      break;

    default:
      TIME = 0;
      STATENORMAL = _yield;
  } // switch (STATENORMAL)
} // void StateMachNormal()


void StateMachMain()
{
  switch (STATEMODE)
  {
    case _normal:
      Normal();
      break;

    case _flashingamber:
      FlashingAmber();
      break;

    case _flashingred:
      FlashingRed();
      break;
      
    case _flashingredamber:
      FlashingRedAmber();
      break;

    case _standby:           // do nothing mode where all bulbs are off. used when changing red/green on-time
      break;
      
    case _selectrgtime:      // er uhhh, I guess we do nothing as well
      break;

    default:
      STATEMODE = _normal;
  }
} // void StateMachMain()


void DebounceSwitch()
{
  // shift all bits to the left
  // if switch reading is hi then let pb_val bit 0 = 1
  PBval <<= 1;
  if (pb)
    ++PBval;

  PBedge = none;

  // if level is lo and all bits of pb_val are now hi then
  // a rising edge has been detected
  // switch is considered just released when rising edge is detected
  // switch level is now hi
 if ((!PBlevel) && (PBval == 0xFF))
  {
    PBlevel = hi;
    PBedge = rising;
  }

  // if level is hi and all bits of pb_val are now low then
  // a falling edge has been detected
  // switch is considered just pressed when falling edge is detected
  // switch level is now lo
  if ((PBlevel) && (!PBval))
  {
    PBlevel = lo;
    PBedge = falling;
  }
} // void DebounceSwitch()


void ProcessKey()
{
  int8 MODE;                           // temporary storage of current STATEMODE

  static  int16  PBPRESSTIMETOTAL = 0; // Keeps track of how long PB is depressed in terms of timer2 ticks
                                       // Keeps track of total time from falling edge (switched pressed) to rising edge (switch released).
                                       // if less than changergtime then we know the keypress is momentary and user wants to change modes

  static  int16  PBPRESSTIME = 0;      // Keeps track of how long PB is depressed in terms of timer2 ticks
                                       // this variable is reset every time it exceeds changergtime
                                       // every time it exceeds changergtime red/green on-time is incremented until masrgtime and then it cycles back to one

  DebounceSwitch();
  MODE = STATEMODE;

  if (PBlevel == lo)
  {
    if (++PBPRESSTIMETOTAL == prechangergtime)
    {
      AllLightsOff();
      STATEMODE = _standby;
    }

    if (++PBPRESSTIME >= changergtime)
    {
      PBPRESSTIME = 0;
      if (++RGTIME > maxrgtime)
        RGTIME = 1;
//      EEPROM_Write(addr_rgtime, RGTIME);
//      ComputeRedGreenTime();                     // REDGREENTIME = RGTIME*rgtime_increm;
      STATEMODE = _selectrgtime;
      VALUE = RGTIME;                            // RGTIME will be displayed on the LED readout
    } // if (++PBPRESSTIME >= changergtime)
  } // if (PBlevel == lo)

  if (PBedge == released)
  {
    if (PBPRESSTIMETOTAL < changergtime)         // if pushbutton was only momentarily pressed then change to the next mode
    {
      STATEMODE = ++MODE;
      if (STATEMODE == _normal)
        STATENORMAL = _yield_ini;                // this is necessary to start normal traffic light mode properly
      else if (STATEMODE > _normal)
        STATEMODE = 0;
    } // if (PBPRESSTIMETOTAL < changergtime)
    else  // green/red light on time has been changed so go to normal traffic light mode and begin with amber light
    {
      EEPROM_Write(addr_rgtime, RGTIME);
      ComputeRedGreenTime();                     // REDGREENTIME = RGTIME*rgtime_increm;
      STATEMODE = _normal;
      STATENORMAL = _yield_ini;
    }

    AllLightsOff();          // turn off all bulbs and let state machine take care of which ones to turn on
    TIME = 0;                // reset timer so that whatever mode has been selected, light will go through full time allotted
    PBPRESSTIMETOTAL = 0;
    PBPRESSTIME = 0;
  } // if (PBedge == released)
} // void ProcessKey()


void main()
{
  IniReg();

  while(1)
  {
    if (PIR1.TMR2IF)
    {
      PIR1.TMR2IF = 0;
      asm{clrwdt}
      UpdateDisp();
      ProcessKey();
      StateMachMain();
    } // if (PIR1.TMR2IF)
  } // while(1)
} // void main()

Monday, February 20, 2012

AC load switching via infrared remote control

Laziness is the mother of invention. Not wanting to get out of bed to turn off the room lights, it occurred to me to build a circuit--one that I may end up using or not--which would switch the lights off/on when it receives the proper signals from a TV remote control. Here's the original design:


After breadboarding and testing the above it hit me: Why not add more features such as setting the amount of time the light (or whatever load it may be) will remain on, or time elapsed before it automatically turns on. Adding these capabilities would merely require changes to the software. But because I would need the LEDs as indicator lights for various functions--eg. making them blink as user feedback--they have to be controlled separately from the triac/load. Since the 8-pin MCU has unused pins it was trivial assigning each LED a MCU pin of its own. Here's the final circuit. I've changed the triac gate current limiting resistor value as well:


MCU = Microchip PIC12F615 microcontroller
IRR = Osram SFH5110-38 IR receiver 38kHz
Z1 = 1N4734A 5.6V 1W zener diode
Q1 = 2N7000 n-channel enhancement MOSFET transistor
TRIAC = Teccor Q401E3 400V 1A triac

Z1, C1, C2, and D1 comprise a half-wave transformerless power supply providing approximately 5VDC. With C1 = 1uF the circuit is designed to run off 220VAC 60Hz mains, providing a theoretical maximum current of around 80mA RMS. The above may or may not work with 110VAC since at that voltage the available DC current is halved. For 110VAC 60Hz use, doubling the capacitance to 2uF will halve the capacitive reactance and thus let through twice the current. Capacitive reactance is given by:

XC = (6.28fC)-1

where
f = frequency of the AC line in Hertz
C = capacitance in farads 

Therefore, with C = 2uF XC = 1327ohms. RMS current is therefore = 110VAC/1327 = 83mA RMS

One leg of the mains is common to both DC and AC lines. This is necessary for the triac to be triggered by the DC circuit.

Because the circuit doesn't use a transformer any part of it is potentially lethal to the touch. The net labeled 5V is 5VDC with respect to the circuit ground. But it is 220VAC with respect to the other leg of the AC line and it can be as much as 110VAC with respect to earth ground, so beware! It goes without saying that errors in connecting/ soldering of the components of the power supply could result in unintended and undesirable fireworks and tripping of the building's breakers/fuses. Be damn careful when designing and building circuits involving mains voltage. I come down with OCD and anxiety disorder every time. You can't check and recheck enough times that you've done everything right.

R1 is an ordinary carbon resistor and functions as a fuse. It's supposed to blow if current through the circuit (but not the load and MT1 to MT2 of the triac) exceeds around 100mA. Given an 18-ohm 250mW resistor, current at which its dissipation is 250mW is = √(0.25/18) = 118mA. So the resistor should theoretically fry if it exceeds this value for over a fraction of a second.

Note, however, that given 220V RMS, its peak voltage = 220√2 = 311V. With C1 = 1uF XC = 2653ohms. Therefore, peak current = 311/2653ohms = 117mA. Thus the resistor experiences instantaneous dissipation of 250mW 120 times a second (two peaks per cycle for a 60Hz line). If this fuse keeps blowing for no apparent reason, lower it to 15ohms. Of course this is a poor man's version of a fuse resistor and is suboptimal and may even fail to protect the components downstream. Better than none though.

R2 and C3 were added as per suggestion of the Osram datasheet. When I was bench testing the breadboarded version which I powered using the PICkit2, I found that adding R2 and C3 did boost the performance. Apparently the PICkit2 wasn't supplying clean or sufficient power. Having used the above transformerless power supply design for about a decade in a good number of circuits I know there are regulated voltage and ripple voltage issues with it (because it's just a half-wave supply). And so adding R2 and C3 is mandatory.

Triac gate trigger is such that current flows from MT1 to gate (rather than from gate to MT1), hence the triac operates in Quadrants 2 and 3--which require much less gate trigger current. For a discussion of triac quadrants and triggering read the section "Load Switching."

Given the zener voltage of 5.6V and D1 forward voltage VF of 0.7V @20mA (see graphs for 1N400x), our VDD = 5.6 - 0.7 = 4.9VDC. According to the Teccor datasheet maximum required gate current for quadrants 2 and 3 operation is 10mA while maximum gate voltage VGT is 1.3V. Deducting VGT from VDD we're left with 4.9 - 1.3 = 3.6V. There's also a voltage drop across Q1. According to the graphs in the 2N7000 specs sheet the drain-to-source resistance RDS at a gate-to-source voltage of 5.0V and gate current of 10mA is almost 1.5ohms. Using Ohm's Law the drain-to-source voltage VDS = 1.5ohms x 10mA = 15mV. This is negligible, and even if quadrupled VDS would still be just around 60mV. So we can disregard the Q1 voltage drop and take 3.6V as the voltage across triac gate resistor RT. To obtain 10mA of gate current we apply good ol' Ohm's Law again: 3.6V / 10mA = 360ohms. Closest standard 5% resistor value is either 390 or 330ohms. We pick the lower value to make sure there's enough current to meet the maximum requirement of 10mA. With 330ohms the triac gate current = 3.6 / 330 = 10.9mA. Resistor power dissipation  = I2R = 0.01092(330) =39mW. Ostensibly this means we can use a 1/8-watt resistor. But the 10mA current we obtained is just a theoretical value. Its true value depends largely on the triac's VGT which will probably be much less than the maximum quoted 1.3V. Now supposing that VGT = 0 and our 5% tolerance 330-ohm resistor has in fact a value = 330*95% = 313 ohms. Gate current would then be 4.9V / 313ohms = 16mA. Resistor power dissipation would thus be = 0.0162313 = 80mW. This is still some 35% less than 1/8W. Therefore, we can in fact use a 1/8-watt resistor.

Currently the only buttons on the TV remote control which will make the circuit do anything are the keys for digits 1 and 0. Pressing "1" turns load on, while "0" switches it off. Upon power up the load is forced to turn on. In the case of the room light, this means that flipping the wall switch on will turn the light on--as we would want it to. The light can then be turned off via this switch or through the use of the remote control.

The firmware I have thus far is tailored for the Philips RC-5 infrared communications protocol (visit that link for an explanation for the rationale/basis of the signal decoding firmware below). I'm planning to make the circuit respond to both the RC-5 and Sony SIRC protocol, letting the firmware determine which of the protocols it's receiving (and rejecting other protocols) and deciding of course whether the received codes correspond to any of those which it should respond to and take action. As I said above, I want to extend the range of capabilities of this circuit and add stuff like timer features. So it's back to the drawing board deciding which buttons will serve as timer functions and writing the appropriate software. And as has probably already popped into your head, we wouldn't want our lights or whatever load to turn on/off when we intended to change channels on the TV! Such techniques as using two-button codes (e.g. the "Menu" and "1" buttons need to be pressed in rapid succession--i.e., within a prescribed time frame--to turn the load on) or keeping the button pressed for one second or so (e.g., command is received by the circuit, say, 5 to 10 times before action is taken) may be employed.  

/*

AC LOAD SWITCHING USING A TV REMOTE CONTROL
February 2012

processor = PIC12F615
compiler = mikroC v5.0.0
configuration word = power up timer, brownout reset, and WDT enabled; all else disabled. Internal Oscillator = 4MHz

*/


#define  load                GPIO.f2             // 2N7000 sinks triac gate current
#define  ledg                GPIO.f4             // green led  -- multifunction status led, not just on indicator
#define  ledr                GPIO.f1             // red led    -- multifunction status led, not just off indicator

#define  irr                 GPIO.f5             // Osram SFH5110-38 infrared receiver
#define  tris_irr            TRISIO.f5           // for use with setting the appropriate pin as input
#define  ioc_irr             IOC.f5              // for use with enable interrupt on change for irr

// RC5 decoding defines

#define  _full               1
#define  _half               0

// one full bit period for RC5 = 1.778ms; one half bit period = 0.889ms
// given clock = 4MHz and TMR0 initial value = 0 and timer0 prescale = 1:16, TMR0 overflows every 256 x 16 / 1MHz = 4.096ms
// 4.096ms / TMR0 count = 4.096 / 256 = 0.016ms per TMR0 count
// 1.778 / 0.016ms = 111   this is the TMR0 count when time elapsed is 1.778ms
#define  _fullbit            111                                     // full bit period of RC5
#define  _tolerance          25                                      // tolerance in percent, to be added/subtracted to/from half and full bit periods to create range of acceptable pulse widths
                                                                     // !! THIS HAS TO BE INTEGER NOT FLOATING POINT !!
                                                                     // !! MAXIMUM VALUE = 33%, ELSE halfbit_uplim WILL BE GREATER THAN fullbit_uplim

#define  _halfbit            _fullbit / 2                            // half bit period of RC5

#define  halfbit_lolim       _halfbit - (_halfbit * _tolerance / 100) // minimum pulse duration for half bit period
#define  halfbit_uplim       _halfbit + (_halfbit * _tolerance / 100) // maximum pulse duration for half bit period
#define  fullbit_lolim       _fullbit - (_fullbit * _tolerance / 100) // minimum pulse duration for full bit period
#define  fullbit_uplim       _fullbit + (_fullbit * _tolerance / 100) // maximum pulse duration for full bit period


#define  int1                bit
#define  int8                unsigned char
#define  int16               unsigned int
#define  int32               unsigned long

#define  on                  1
#define  off                 0

#define  input               1         // for TRISx
#define  output              0         // for TRISx

#define  analog              1         // for ANSELx
#define  digital             0         // for ANSELx


// ===========================================================================================
//       Global Variables
// ===========================================================================================

int8     PULSEWIDTH;         // contains the measured pulse width (to get the real value in millisec multiply by 16)
int8     RC5BITS;            // contains the bit number (excluding the start bit) of the RC5 word currently being received
int8     RC5FCSYS;           // contains the RC5 Field bit, Control Bit, and the 5-bit System Address
int8     RC5COMM;            // contains the RC5 6-bit Command code
int8     RC5COMMPREV;        // contains the previous RC5 6-bit Command code
int8     TEMP;               // temporary memory

bit      rc5_on;             // 1 = irr output has been high for >4millisec and then goes low; this indicates a RC5 start bit
                             // 0 = irr output has been low for >4millisec and then goes high. This is an abnormal state and is an error
                             // rc5_on is also reset to 0 when all bits of word have been received
bit      halfper_prev;       // 1 = the last IOC was a half bit period, 0 = the last IOC occured after a full bit period
bit      key_pressed;        // 1 = button has been pressed and valid RC5 word stored

bit      rc5_read_error;     // 1 = read error, pulse width of either a zero or one bit is outside the acceptable limits; the data packet should be discarded
bit      bit_period;         // _full = 1 = one full bit period, _half = 0 = half bit period
bit      curr_bit;           // contains the latest decoded value of the bit of the RC5 word being received
bit      con_bit_prev;        // contains the control bit of the previous decoded RC5 word

// used to monitor if a key has been pressed and if yes is the key being held down or is a new press
// _key_none = no key pressed
// _key_new = new key pressed. It may be the same button but it was released and pressed again, ie., the Control bit has toggled
// _key_same = IR signal from the same key. Button is depressed and has not been released.
enum {_key_none, _key_new, _key_same} KEY = _key_none;


// ===========================================================================================
//       Functions
// ===========================================================================================

void IniReg()
{
  ANSEL = digital;
  TRISIO = output;
  GPIO = 0;
  
  tris_irr = input;

  OPTION_REG = 0b10000011;   // prescaler assigned to timer0
                             // prescale = 1:16
                             // timer0 uses internal clock instruction cycle
                             // weak pull ups disabled

  // enable interrupt on change
  // intialize pin connnected to ir receiver to interrupt on input change
  INTCON.GPIE = on;
  ioc_irr = on;

  INTCON.GIE = 1;
  INTCON.PEIE = 1;

  key_pressed = 0;
  load = on;
  ledg = on;
  ledr = off;
} // void IniReg()



// this function determines whether the key pressed is a:
// 1. _key_none = no key press has been detected
// 2. _key_new = a different key has been pressed or the same key has been released and pressed again
// 3. _key_same = the same key is still held down
// If no key is press is detected for > _idle_time then firmware goes into standby mode and display is turned off
void ProcessKey()
{
  if (key_pressed)
  {
    key_pressed = 0;
    if ((RC5COMM == RC5COMMPREV) && (RC5FCSYS.f5 == con_bit_prev))
      KEY = _key_same;
    else           // if current key is not the same as previous key or if current control bit not the same as previous
      KEY = _key_new;

    RC5COMMPREV = RC5COMM;
    con_bit_prev = RC5FCSYS.f5;
  } // if (key_pressed)
  else
    KEY = _key_none;
} // void ProcessKey()


void LoadControl()
{
  switch (KEY)
  {
    case _key_new:
      switch (RC5COMM)
      {
        case 0:
          load = 0;
          ledg = off;
          ledr = on;
          break;
        
        case 1:
          load = 1;
          ledg = on;
          ledr = off;
          break;

        default:
          break;
      } // switch (RC5COMM)
      break;
    
    case _key_same:
      break;

    case _key_none:
      break;

  } // switch (KEY)
} // void LoadControl()


void interrupt()
{
  // interrupt on change
  if (INTCON.GPIF)
  {
    PULSEWIDTH = TMR0;
    TMR0 = 0;
    TEMP = GPIO;            // a read of GPIO is necessary before GPIF can be cleared
    INTCON.GPIF = 0;

    if (rc5_on && !rc5_read_error)
    {
      if (PULSEWIDTH >= halfbit_lolim && PULSEWIDTH <= halfbit_uplim)
        bit_period = _half;
      else if (PULSEWIDTH >= fullbit_lolim && PULSEWIDTH <= fullbit_uplim)
        bit_period = _full;
      else
        rc5_read_error = 1;

      if (bit_period == _half && halfper_prev == 0)
      {
        halfper_prev = 1;    // last IOC occured after a full bit period, so this current half bit period needs to be paird with the half bit period
      }
      else // if (bit_period == _full || halfper_prev == 1)
      {
        halfper_prev = 0;
        if (irr)             // rising edge, indicates logic zero
          curr_bit = 0;
        else                 // falling edge, indicates logic one
          curr_bit = 1;

        if (RC5BITS <= 6)
        {
          RC5FCSYS <<= 1;
          RC5FCSYS.f0 = curr_bit;
        }
        else
        {
          RC5COMM <<= 1;
          RC5COMM.f0 = curr_bit;
        }
        if (++RC5BITS >=13)
        {
          rc5_on = 0;
          key_pressed = 1;
        }
      } // else
    } // if (rc5_on && !rc5_read_error)

    // if timer0 interrupt flag is set then ir_rx output was low/high for >4ms before the IOC that just occurred
    if (INTCON.T0IF)
    {
      INTCON.T0IF = 0;
      RC5BITS = 0;
      RC5FCSYS = 0;
      RC5COMM = 0;
      rc5_read_error = 0;
      rc5_on = 0;
      if (!irr)                        // falling edge; pulse was high for >4ms so this is considered the start bit of RC5 word
        rc5_on = 1;
    } // if (INTCON.T0IF)
  } // if (INTCON.GPIF)
} // void interrupt()


void main()
{
  IniReg();

  while(1)
  {
    asm{clrwdt}
    ProcessKey();
    LoadControl();
  }
}


Decided to print a dual board artwork--just copied and pasted the original pcb layout. Each board is 2x2". Since the effort and time that goes into developing and etching one presensitized panel is practically the same whether it's 1x1" or 4x6" might as well make a dual board. Going for four is too much, specially since this is a prototype. I scored and snapped the panel into two boards after drilling all the holes.


The following pcb board has been tested to work. I used a 23-watt compact fluorescent lamp as the load. Unfortunately, it doesn't perform as flawlessly as the breadboarded version. Commands sent to the board are not always picked up properly and so the load doesn't get switched immediately upon key press. I suspect a power supply issue. I'm going to use a 220VAC-to-220VAC isolation transformer to power the board and probe the circuit with a DMM.



You will notice that the LEDs are pointing up while the adjacent infrared receiver is facing 90 degrees away. I'll bend either the sensor or the LEDs to make them face the same way after I've decided which way this board is going to be mounted and where the IR receiver needs to point.

Sunday, February 19, 2012

Saturday, February 4, 2012

Just having a little fun

This circuit was meant to test an idea but the idea turned out to be a dead end. So I ended up just playing with the circuit. Red, green and blue LEDs are turned on in sequence. Because of the difference in light intensity I've used different resistors values for each of the colors to try and even the output. Position of the potentiometer is read by the PIC16F1824's ADC. The two least significant bits of the 10-bit ADC output are ignored and the 8-bit value is copied to TMR0 and timer0 sets the amount of time each LED is on.

The white cylinder over the LEDs is just an old milky-white colored 35mm film canister. But it makes a heck of difference on how the light output is seen by the human eye. Certainly far more interesting with it. By varying the direction in which the LEDs point different light patterns on the cylinder can be created.

The MCU is run at 1MHz. LED switching occurs in the interrupt service routine. Maximum switching frequency is approximately 325Hz--each LED is on for just around 1ms. Minimum frequency is around 1.27Hz. Period T = on-time of each LED x number of LEDs. Frequency = 1/T. Timer0 is used for timing the LEDs. Its prescale is set to 256. With the clock running at 1MHz, time for one instruction cycle = 4/1MHz = 4µs. Timer0 tick = TMR0 x 256 x 4µs. The reset value of TMR0 can range from zero to 255 depending on the position of the potentiometer.

Timer2 is used to periodically read the pot and store its value in a variable which then gets copied to TMR0 during every timer0 interrupt.




#define  int1                bit
#define  int8                unsigned char
#define  int16               unsigned int
#define  int32               unsigned long

#define  on                  1
#define  off                 0

#define  _on                 0
#define  _off                1

#define  yes                 1
#define  no                  0

#define  input               1         // for TRISx
#define  output              0         // for TRISx

#define  analog              1         // for ANSELx
#define  digital             0         // for ANSELx

#define  lred                LATC.f0             // red led
#define  lgreen              LATC.f1             // green led
#define  lblue               LATC.f2             // blue led

#define  tris_lred           TRISC.f0            // for setting LED pin as output
#define  tris_lgreen         TRISC.f1            // for setting LED pin as output
#define  tris_lblue          TRISC.f2            // for setting LED pin as output

#define  an_lred             ANSELC.f0           // for setting LED pin as digital
#define  an_lgreen           ANSELC.f1           // for setting LED pin as digital
#define  an_lblue            ANSELC.f2           // for setting LED pin as digital

#define  ch_pot              3                   // analog channel of potentiometer

// ==================================================================================================================
//          global variables
// ==================================================================================================================

int8 TMR0COUNT;

// ==================================================================================================================
//          functions
// ==================================================================================================================

void IniReg()
{
  OSCCON    = 0b1011000;     // internal clock = 1MHz

  // set LED pins as output
  tris_lred = 0;
  tris_lgreen = 0;
  tris_lblue = 0;
  
  // set LED pins as digital
  an_lred = 0;
  an_lgreen = 0;
  an_lblue = 0;

  lred = 1;                  // start off with red LED
  
  // Timer0 setup
  OPTION_REG = 0b10000111;   // Weak pull ups disabled
                             // timer0 uses internal clock,
                             // prescaler assigned to timer0, prescaler = 1:256
  TMR0 = 0;
  INTCON.TMR0IE = 1;         // timer0 interrupt enable
  
  // Timer2 setup
  // with a 1MHz clock, prescale = 1:16, postscale = 1:1, PR2 = 200
  // timer2 tick = 250 * 64 / (1MHz/4) = 64ms
  T2CON = 0b111;             // timer2 on, prescale = 1:64, postscale = 1:1
  PR2 = 250;                 // timer2 counts up from zero until the value of PR2 and then resets

  // Analog to Digital Coverter setup
  ADCON0 = ch_pot << 2;      // shift in analog channel to be made active
  ADCON0.ADON = 1;           // turn on ADC
  ADCON1 = 0;                // left justified, Fosc/2, Vss as negative reference, Vdd as positive reference

  INTCON.GIE = 1;            // global interrupt enabled
} // void IniReg()


/* =========================================================================================================

According to PIC12F1824 Silicon Errata sheet DS80510D the ADC unit in certain silicon revisions is buggy:

"An ADC conversion may not complete under these conditions:
1. When FOSC is greater than 8 MHz and it is the clock source used for the ADC converter.
2. The ADC is operating from its dedicated internal FRC oscillator and 
the device is not in Sleep mode (any FOSC frequency). 
When this occurs, the ADC Interrupt Flag (ADIF) does not get set, the GO/DONE bit does not get cleared, 
and the conversion result does not get loaded into the ADRESH and ADRESL result registers."

mikroC Pro compiler's Adc_Read() built-in ADC function uses the FRC oscillators o it cannot be used.

The workaround used here is as per method 1 in the said errata:
"Select the system clock, FOSC, as the ADC clock source 
and reduce the FOSC frequency to 8 MHz or less when performing ADC conversions."

=========================================================================================================  */

int8 ADC()
{
  ADCON0.GO = 1;                       // start ADC conversion
  while (ADCON0.GO) ;                  // just wait until AD conversion is done
  return ADRESH;                       // return only the 8 most significant bits of the 10-bit value
}


void interrupt()
{
  if (INTCON.TMR0IF)
  {
    TMR0 = TMR0COUNT;
    if (lred)
    {
      lgreen = on;
      lred = off;
    }
    else if (lgreen)
    {
      lblue = on;
      lgreen = off;
    }
    else
    {
      lred = on;
      lblue = off;
    }
    INTCON.TMR0IF = 0;
  }
}


void main()
{
  IniReg();

  while(1)
  {
    if (PIR1.TMR2IF)
    {
      TMR0COUNT = ADC();
      PIR1.TMR2IF = 0;
    }
  } // while(1)
} // void main()