Friday, January 27, 2012

Toy traffic light--the next generation

Just minutes after I presented the signal tower traffic light to the kids last week and briefed them on how it works and how to change the go/stop time duration, the eldest told me I should put a digital countdown timer on top of the tower so they'll know how many seconds there are remaining before red turns green and green turns amber. I was dumbstruck. Why the heck didn't I think of that?! His suggestion is nothing short of brilliant. These kids are geniuses (of course I'm fracking biased!).

So it was back to the drawing board for v2.0. My boss wants his traffic light by this week. Told him I can't since I need time to design the circuit and the pcb and write the software and think about how to mount the LED readouts and then finally put everything together. Working for 7-year olds is tough.

Well, writing the firmware was a breeze. The state machine structure lends itself to easy modification. And in the process bulbs went off in my head and I added other features including a new mode wherein the red and amber lights alternate, with the same on-time as the flashing red and flashing amber modes of 0.8sec. And since a seven segment LED display is going to be used anyway why not put it to use even in modes other than normal traffic light mode. So during the flashing red, flashing amber, and alternating red and amber modes the LED will be showing various non numeric characters just to add to the light show. And most importantly I've dumped the use of the green bulb as feedback for the number of seconds for go/stop on-time. The LED now displays "1", "2"... up to "6" to indicate 5sec, 10sec,... 30sec of go/stop on-time. I could easily show the actual number of seconds on the display but I didn't because I think it would be good multiplication practice for the kids. At least they get to know by heart the products of 1 x 5, 2 x 5, ... up to 6 x 5.



Parts list:
PS - AC to DC adapter 12VDC 1000mA output
D1 - 1N5822 Schottky diode
MCU - PIC16F1827 microcontroller
VR - 78L05 voltage regulator
7SEG1, 7SEG2 - seven segment LED display common anode
Q1, Q2 - S9012 PNP transistors
Q3, Q4 - 2N7000 n-channel enhancement MOSFET
Q5, Q6, Q7 - TIP102 NPN Darlington transistor
Q8 - ULN2003 transistor array

My initial design had the LED powered from the 5V rail. This required using an L7805 which has an output capacity of at least 1000mA instead of the 78L05 which can only put out 100mA. Computations showed that because of the large headroom (12V - 5V) and large current draw (around 150mA) the power dissipation of the voltage regulator would raise its temperature close to 100 Celsius and thus necessitate a heatsink. Shudder! A heatsink eats up so much space. So it occurred to me to just power the LED directly off the unregulated supply of 12V. Of course the power dissipation issue would move over to the LED current limiting resistors but that is easily taken care of by employing 1/4-W resistors instead of 1/8-W. Trivial. In the initial 5V design it was a simple matter of using PNP transistors to provide power to the common anode seven segment LEDs. But with the emitter at 12V the base of the PNP can no longer be directly hooked up to the 5-volt MCU. In order to switch the PNP I've opted to use the 2N7000 MOSFET. Using an NPN would've been just as effective but it would've required the addition of a base current limiting resistor. The less components on the board the better. In order for the MOSFET and PNP setup to work properly the base of the PNP must be pulled up to the emitter voltage when the 2N7000 is off, else the base will be left floating. Thus, the 51Kohm resistor. When the 2N7000 is turned off the pull-up resistor brings the base voltage to 12V thus switching off the PNP and cutting supply to the LED display.

I've decided to install two LED displays back-to-back both showing exactly the same readout. Each segment will be provided around 10mA. Because the current draw is double (two LED displays) and because of the 12VDC supply the MCU pins cannot be used to directly sink the current. Therefore a ULN2003 transistor array takes care of the power switching.

The tens and ones digits on the display are multiplexed and switched every 4ms giving a frequency of 1/ (4ms x 2) = 125Hz. That's more than fast enough to provide a flicker-free display.

Because of the additional function calls to update the LED display I've increased the the clock rate from the previous 500kHz to 2MHz. Timer2 tick is still 4ms. A check using the Saleae Logic shows that at 2MHz it usually takes only about half a millisecond to go through all the functions. However, when go/stop on-time is changed the time consumed jumps to over 3ms. Measurement shows the ComputeRedGreenTime() function takes 0.50ms. Multiplication does take time but I discovered the king of snails is the EEPROM write. Storing the one byte stop/go on-time takes a whopping 2.66ms. But this is actually better than the datasheet spec of 4.0ms typical and 5.0ms max. Given the half millisecond average (when the user is not selecting a stop/go time), I could actually have retained the 500kHz clock. The savings on power is, however, marginal and negligible compared to what the bulbs and LEDs consume.

I'll post a vid and pics of the new and improved traffic light when I finally build the circuit and figure out how to mount the seven segment LED boards on top of the tower and still be able to have access to the screw of the tower's cap and protect the boards from the 7-, 6-, and 4-yr old demotion team!.

/*

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

Created:        January 2012
Processor:      PIC 16F1827
Compiler        mikroC Pro 5.0.0
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.f4                       // NPN darlington switches 12VDC incandescent lamp
#define  lamber    LATA.f6                       // NPN darlington switches 12VDC incandescent lamp
#define  lgreen    LATB.f5                       // NPN darlington switches 12VDC incandescent lamp

#define  pb        PORTA.f5                      // momentary contact push button
#define  tris_pb   TRISA.f5

#define  anode_ones          LATA.f0             // S9012 PNP transistor
#define  anode_tens          LATA.f1             // S9012 PNP transistor

#define  seg_a               LATA.f2             // 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.f4             // segment c of seven segment LED common anode
#define  seg_d               LATB.f0             // segment d of seven segment LED common anode
#define  seg_e               LATB.f1             // segment e of seven segment LED common anode
#define  seg_f               LATB.f2             // segment f of seven segment LED common anode
#define  seg_g               LATB.f3             // 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  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


#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  hi                  1         // switch level high
#define  lo                  0         // switch level low

// ************************************************************************************************
//       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 IniReg()
{
  TRISA = output;
  TRISB = output;
  ANSELA = digital;
  ANSELB = digital;

  tris_pb = input;

  // enable weak pull up for pushbutton and unused pins
  OPTION_REG.NOT_WPUEN = 0;
  WPUA = 0xFF;
  // WPUB = wpullup;

  // set internal clock frequency to 2MHz
  OSCCON = 0b1100000;

  // 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 AllLightsOff()
{
  lred = off;
  lamber = off;
  lgreen = off;
}

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
    {
      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()

Optimizing print quality of PCB artwork on transparency films

Over the past eight months or so I've tried three different transparency films (most probably made by different manufacturers). Joy Transparency Film comes in a box of 50 sheets. Inside every 5 sheets has its own plastic envelope. The label says the films each have a paper backing, but unfortunately there's none. There is no information on the packaging as to manufacturer and country of origin, even if "Japan" is prominently printed at the upper right hand corner of the plastic bag and "Japan Standard" on the bottom right. Entering "Joy transparency film" and "OF280" (its product number) on Google doesn't turn up anything. Price per sheet is approximately USD0.34.



Fullmark TPICL50 (Made in EU) comes in a black plastic bag containing 50 sheets. Searching the Fullmark website fails to turn up this particular product. In fact Fullmark doesn't seem to carry transparencies anymore (or they haven't updated their website). As with the Joy brand, Fullmark films don't have a paper backing. Price is around USD0.33/sheet.



The last type of film has no brand and has been repacked by the office supply store from which I bought it. This one has a paper backing and is the most expensive at USD0.60/sheet.


Of the three only Joy films produce very good quality printouts. The other two show substantial crazing of the ink. Fullmark is the worst offender. Depending on the printer settings it can border on being useless. Crazing can be detrimental since the cracks allow light to pass through and expose the photosensitive layer of the pcb.

Having found a transparency film that is near optimal I needed to find out what printer settings would provide the most opaque printout and highest ink density. I could've varied the settings and compared the results but fortunately while searching for transparency brands I stumbled upon the recommendations for the JetStar Inkjet Artwork Film:
3. Check printer settings. Make sure printer is set for the highest resolution and print quality, with High Speed Setting OFF. Note that the higher the resolution, the slower the print. Next, set the Media Setting to Matte, Heavyweight Matte, Archival Matte or Inkjet Backlight Film. For Epson Ink Jet Printers, set the Brightness control slider to +25 and although a black print always print in colour Mode. Options will vary based on printer and software available. Then, set ink deposit for optimum results. TIP: Experiment with the setting options available with your printer to determine the best set-up for your requirements. If positive seems light or lacks density, try increasing the print quality or amount of ink deposit. [emphasis added]
I tried those settings and it turns out that on the Epson T10 inkjet printer leaving "print in black ink only" unselected and setting all the sliders to maximum (+25) actually gives a better ink density than printing in black only (I used to tick the print in black only option). Here are screenshots showing the settings I now currently use for the T10 .




The same settings as in the screenshots:

Advanced
  Paper and Quality Options
    Epson Matte
    Best Photo
    [paper size as required]
  Print Options
    Fix Red-Eye - uncheck
    High Speed - uncheck
    Edge Smoothing - check
    Print Preview - check
    Black Ink Only - uncheck
  Color Management
    Color Controls - select
  Color Mode
    Epson Vivid
    Settings:
      Brightness: +25 (max) 
      Contrast: +25 (max)
      Saturation: +25 (max)
      Density: +25 (max)
      Horizontal: 0
      Vertical: 0

Thursday, January 19, 2012

Toy traffic light using a signal tower

Just finished building a toy traffic light for the kids. It uses a signal tower (used on factory floors to provide visual alarms and indication of machine status) which employs 12VDC incandscent lamps. I haven't checked but the bulbs look like the same size and actually have same socket type as automobile tailight lamps.

There's nothing particularly unique or special about this circuit, although I haven't come across any toy traffic light design that uses signal towers. What I do like about this circuit is the fact that a single user interface--a momentary contact pushbutton--controls all the functions, and that I didn't have to include any indicator LED or buzzer and instead could use the lamps of the traffic light itself to provide feedback to the user.



Operation

There are three modes:
1. Flashing amber (0.8sec on, 0.8sec off)
2. Flashing red (0.8sec on, 0.8sec off)
3. Normal traffic light operation: green --> amber --> red (variable red/green on-time, amber on-time = 2sec)

Upon power up the traffic light starts in mode 1. Modes are selected by pressing the button momentarily.

The stop (red) and go (green) time is user selectable. This is accomplished by pressing and holding the button down (regardless of what mode the traffic light is in). 1.5 seconds after pressing the button all lights will be turned off indicating the green light is about to begin showing the amount of go/stop time. Three seconds after pressing the button the green light will go through sets of blinking. The number of flashes per set indicates the go/stop time:

Number of flashes per set Go/Stop time in seconds
1 5
2 10
3 15
4 20

As with the modes keeping the button depressed will eternally cycle through the four sets. To choose a go/stop time the user releases the button after the particular set of flashes has occured. So letting go of the button after the set of three flashes of the green light will set the go time and stop time to 15 seconds. The selected go/stop time is stored in EEPROM so the circuit doesn't forget even when powered down. Once the button is released the traffic light goes into mode 3 and begins with the yield (amber) light on. 

Hardware


I originally planned to use the PIC12615 which is more than adequate. Unfortunately I need EEPROM which the 615 lacks. The only 8-pin PIC with EEPROM that I have right now is the 12F1822 and so that's what I ended up using for the MCU.

The circuit has a polarity reversal protection in the form of a 1N5822 Scottky diode (D1 in the schematic) which has a rated capacity of 3A. Although the wall wart has a no-load measured output of 16VDC, this drops to around 12V when any of the lamps is on. Each of the power transistors also has a voltage drop across their collector-emitter. So to minimize further dip in voltage across the the incandescents I opted to use a Schottky instead of an ordinary rectifier. I've used the TIP102 NPN Darlington since as I reported in the Darlington transistor test, the 102 has the least collector-emitter voltage in the three types I was able to get hold of and play around with. As stated in that test using this very same signal tower, the power dissipation in the Darlingtons is such that heatsinks can be dispensed with.

Here's the finished board with all the components soldered. You'll notice there are several drill holes around the MCU. I've added pads to the unused MCU pins as well to the +5V rail and to the pushbutton tracks. These are "just in case" pads if ever I need to modify the board. The additional pushbutton pads are 0.1" apart and will accommodate a 2-way (2-pin) connector. I was going to solder the connector in case things don't work out and the board-mounted pushbutton doesn't work the way I planned. That rod sticking out of the blue pushbutton is a one and quarter inch piece of bamboo cut from a disposable chopstick. It extends out of case (through a small drilled hole) and will act as the button the user will pushing. It's the rod-poking-out-of-the-case part which I wasn't sure would work--and thus the backup connector for a case-mounted pushbutton. I applied a coat of nail polish to the chopstick just to seal the pores and prevent it from being attacked by molds (I've noticed that some brand new but long stored chopsticks have molds on them and I've seen molds appear on a bamboo chopping board after it had been left damp for some 24 hours).

I made the 12VDC traces to and from the incandescent lamps including ground really wide--150 mils--to minimize voltage drop. The traces narrow to just 50mils near the TO-220 pads to prevent shorts. Yes, the text at the bottom of the board is a dedication to the users of this circuit--my young nephews and niece. Naturally I chose Comic Sans as the font. You might notice scratches on the green photosensitive coating (which I always intentionally leave on the tracks). There was a lot of flux residue after soldering so I washed the board with detergent and scrubbed it using a toothbrush. So the blame for those unsightly scratches rests squarely on the shoulders of that brush!

Although the case has provisions--standoffs with holes in them--for screw mounting of boards, I couldn't find small enough screws that would fit. So I just dabbed copious amounts of hot melt glue on the standoffs and pressed the board onto them. Part of the glue oozed through the drilled holes of the board and formed nice hemispherical beads. The hefty black wall wart is at the bottom right. Its wire is too short so I added a meter more so the kids have leeway in placing the traffic light in their play area.

One of my concerns is that the children will knock this thing over and break it. So I cut out a sponge in the shape of circle with a diameter one and a half times larger than the signal tower. I can just glue it on top of the tower. It'll definitely break any falls and save the polystyrene or acrylic lenses from cracking and breaking. But the sponge solution is ugly to state it mildly. So I might instead superglue something akin to an O-ring around the sides of top cap of the tower. Not as elastic and shock absorbing as the sponge but it's still better than nothing at all. Another is option would be a quarter inch PVC or rubber tubing.

Firmware

I simply adapted the firmware I used for the 4-way traffic light I built the kids last year. This signal tower version is actually a lot simplier--no charlieplexing necessary. I opted to just clock the MCU using its default power-on frequency of 500kHz. Only one timer is used. I can no longer remember why I chose timer2 instead of timer0. For expediency's sake I didn't bother changing what ain't broken. A state machine is used with a timer tick of 4ms. In the configuration word, watchdog timer, power up timer, brownout reset, stack over/underflow reset are all enabled. All other options are disabled. Internal oscillator is used with I/O function on all pins.

/*

Kids' Traffic Light Using a Signal Tower

Created:        January 10 2012
Processor:      PIC 12F1822
Compiler        mikroC Pro 5.0.0


* 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. normal traffic light: green -> amber -> red
          2. flashing amber
          3. flashing red
     * when pressed and kept depressed for over a couple of seconds: cycles through different green/red light on time:
          1. 5sec
          2. 10sec
          3. 15sec
          4. 20sec.

* green/red light on time is stored in EEPROM


--------------------------+--------------------------------------
No. of green flashes/set  |   Green/red light on time in seconds
--------------------------+--------------------------------------
         1                |            5
         2                |           10
         3                |           15
         4                |           20
--------------------------+--------------------------------------

*/



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

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

#define  tris_red  TRISA.f0
#define  tris_amber TRISA.f1
#define  tris_green TRISA.f2

#define  pb        PORTA.f3                      // momentary contact push button
#define  tris_pb   TRISA.f3

#define  wpullup   0b111000                      // for WPUA -- enable pull ups on pb and unused pins


// ************************************************************************************************
//       for traffic light
// ************************************************************************************************

#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  flashgreentime      50        // during selection of green/red light on time -- amount of time for green light to be on and amount of time to be off when it is flashing -- time in terms of timer2 ticks

#define  changergtime        750       // 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 - 375  // 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  maxgtime            4         // 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


// ************************************************************************************************
//       eeprom
// ************************************************************************************************

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

// ************************************************************************************************
//       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  _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  hi                  1         // switch level high
#define  lo                  0         // switch level low

int16 TIME = 0;                        // records how long a light has been on  -- in terms of timer2 ticks

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

enum {_normal, _flashingamber, _flashingred, _flashgreen, _standby} STATEMODE = _flashingamber;
enum {_go, _yield, _stop} STATENORMAL = _stop;
enum {_init, _flash} STATEFLASHGREEN = _init;

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


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

void IniReg()
{
  TRISA = input;
  ANSELA = digital;
  
  tris_red = output;
  tris_amber = output;
  tris_green = output;

  // enable weak pull up for pushbutton and unused pins
  OPTION_REG.NOT_WPUEN = 0;
  WPUA = wpullup;
  
  // default clock frequency is 500kHz upon power up.
  // Timer2 is used for state machine and switch debouncing timing tick
  // with clock = 500kHz, PR2 = 125, prescale = 1:4, postscale = 1:1
  // TMR2 will count from zero to PR2 and timer2 interrupt occurs every 125*4 / (500kHz / 4) = 4ms = timer2 tick
  T2CON = 0b101;             // postscaler = 1:1, prescaler = 1:4, 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 > maxgtime)
  {
    RGTIME = 1;
    EEPROM_Write(addr_rgtime, RGTIME);
  }
  ComputeRedGreenTime();                     //REDGREENTIME = RGTIME*rgtime_increm;

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


// normal traffic light operation: green --> amber --> red
// red/green light on time is user selectable
void Normal()
{
  switch (STATENORMAL)
  {
    case _go:
      if (++TIME < REDGREENTIME)
        lgreen = on;
      else
      {
        STATENORMAL = _yield;
        TIME = 0;
        lgreen = off;
      }
      break;

    case _yield:
      if (++TIME < ambertime)
        lamber = on;
      else
      {
        STATENORMAL = _stop;
        TIME = 0;
        lamber = off;
      }
      break;

    case _stop:
      if (++TIME < REDGREENTIME)
        lred = on;
      else
      {
        STATENORMAL = _go;
        TIME = 0;
        lred = off;
      }
      break;

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


// amber flashes on and off
void FlashingAmber()
{
  static bit flag;

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


// red flashes on and off
void FlashingRed()
{
  static bit flag;

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


// when user selects red/green light on time the green light is flashed 1,2,3,or 4 times 
// to indicate 5, 10, 15, 20sec of on time
void FlashGreen()
{
  static int8 i, CYCLES;
  static bit flag;
  
  switch (STATEFLASHGREEN)
  {
    case _init:
      i = 0;
      flag = 1;
      TIME = 0;
      CYCLES = RGTIME*2-1;
      STATEFLASHGREEN = _flash;
      break;

    case _flash:
      if (++TIME < flashgreentime)
      {
        if (flag)
          lgreen = on;
        else
          lgreen = off;
      }
      else
      {
        if (flag)
          flag = 0;
        else
          flag = 1;
        TIME = 0;
        if (++i >= CYCLES)
        {
          lgreen = off;
          STATEMODE = _standby;
        }
      }
      break;
  } // switch (STATEFLASHGREEN)
} // void FlashGreen()


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

    case _flashingamber:
      FlashingAmber();
      break;

    case _flashingred:
      FlashingRed();
      break;

    case _flashgreen:        // green light is flashed to indicate to user the length of time green/red light are on during normal mode
      FlashGreen();
      break;

    case _standby:           // do nothing mode where all lights are off. used when changing green on time
      break;

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


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

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 depreesed 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 is meant to cycle through the various traffic light modes

  static  int16  PBPRESSTIME = 0;      // Keeps track of how long PB is depreesed in terms of timer2 ticks
                                       // this variable is reset every time it exceeds changergtime
                                       // every time it exceeds changergtime green on time is incremented

  DebounceSwitch();
  MODE = STATEMODE;
  
  if (PBlevel == lo)
  {
    if (++PBPRESSTIMETOTAL == prechangergtime)
    {
      AllLightsOff();
      STATEMODE = _standby;
    }
    
    if (++PBPRESSTIME >= changergtime)
    {
      PBPRESSTIME = 0;
      if (++RGTIME > maxgtime)
        RGTIME = 1;
      EEPROM_Write(addr_rgtime, RGTIME);
      ComputeRedGreenTime();                 //REDGREENTIME = RGTIME*rgtime_increm;
      STATEMODE = _flashgreen;
      STATEFLASHGREEN = _init;
    } // if (++PBPRESSTIME >= changergtime)
  } // if (PBlevel == lo)

  if (PBedge == released)
  {
    if (PBPRESSTIMETOTAL < changergtime)
    {
      switch (MODE)
      {
        case _flashingred:
          STATEMODE = _normal;
          STATENORMAL = _yield;
          break;
          
        case _normal:
          STATEMODE = _flashingamber;
          break;
           
        case _flashingamber:
          STATEMODE = _flashingred;
          break;
          
        default:
          STATEMODE = _normal;
      } // switch (MODE)
    } // if (PBPRESSTIMETOTAL < changergtime)
    else  // green/red light on time has been changed so go to normal traffic light mode and begin with amber light
    {
      STATEMODE = _normal;
      STATENORMAL = _yield;
    }
    
    AllLightsOff();
    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}
      ProcessKey();
      StateMachMain();
    } // if (PIR1.TMR2IF)
  } // while(1)
} // void main()



----

10am Addendum:

Rummaged through the junk bins and found this silicone gasket. It's probably from some old thermos bottle. Still very elastic, has an internal diameter several millimeters smaller than the signal tower's and even matches the cream color of the signal tower and circuit board's plastic case. Great find.

I wiped down the sides of the cap with alcohol, let it dry, coated it with a thin layer of cyanoacrylate adhesive, and then slipped the gasket on. The only problem is I didn't expect the superglue to set within 10 seconds (usually takes about half a minute) so part of what is now the rubber bumper isn't properly aligned with the cap. Oh well.

I knocked the tower over a couple of times. From the sound of the thud it still doesn't match the exceptional shock absorbing properties of the sponge but this will have to do. It certainly beats having no bumpers at all.

Saturday, January 14, 2012

NPN Darlington test

Am currently modding a signal tower I bought the nephews months ago and converting it into a multi-featured traffic light for them to play with. The tower has 12VDC red, amber and green incandescent lamps. Back when I bought it I just wired individual rocker switches for each of the lamps and powered it via a 12VDC wall cube. It was a fully manual system where any combination of lights could be turned on.

I've removed all the switches and will be adding a brain so it can function automatically. Initial measurements showed the incandescents draw about half an ampere each. To switch them I'd need either relays or power transistors. I've opted to use NPN Darlingtons instead of relays even if Darlingtons will have a substantial voltage drop across the collector-emitter. A more major concern, however, is the power dissipation because of a Darlington's high voltage drop. Dissipation translates to heat which means high temperatures which, if high enough, would require the use of heatsinks--something I would rather not have to resort to. So in order to find out whether I'd be better off using miniature PCB mounted relays, I bought a few Darlingtons and tested their VCE and the temperature of their cases.

The corner store from which I get my parts doesn't have a good range of Darlingtons and so the parts I ended up testing were the TIP102, TIP112, and TIP120. I breadboarded the following circuit and powered it off my bench supply.

Resistor R5 represents the incandescent lamp. The following tables show the measurements I obtained for each of the bulbs and transistors. VCE is the voltage across the collector and emitter. IC is the current going the lamp. Case temperature was measured using a Fluke 62 infrared thermometer around two inches away from the Darlington. I recorded the maximum reading. VCE drifted as the transistor temperature went up so I gave the circuit a settling time of between two to three minutes before taking the measurements. I previously took some measurements of the inrush current (without using the Darlingtons) using a Fluke 87V's Peak-Min-Max function and the highest value I obtained was 5.2A. 

TIP120 NPN DARLINGTON
Red Amber Green
VCE (volts) 0.735 0.744 0.745
IC (amperes) 0.363 0.467 0.469
Case Temp. (Celsius) 41 43 43

TIP112 NPN DARLINGTON
Red Amber Green
VCE (volts) 0.714 0.728 0.730
IC (amperes) 0.360 0.467 0.469
Case Temp. (Celsius) 40 43 43

TIP102 NPN DARLINGTON
Red Amber Green
VCE (volts) 0.691 0.700 0.697
IC (amperes) 0.362 0.468 0.470
Case Temp. (Celsius) 40 41 42


The TIP102 clearly stands out as having the least VCE and consequently the lowest power dissipation. The temperature as measured by the IR thermometer is of course hardly accurate (I could've used the 87V's thermocouple but I wasn't in the mood to go through the hassle). Since we have all the values necessary let's compute for the (near actual) case temperature. The TO-220 package has a junction to ambient thermal resistance of 62.5°C/W. Current draw of the green bulb is 0.47A. VCE = 0.697V. Power dissipation is therefore 0.697 x 0.47 = 0.328W. Temperature rise of the case is therefore 62.5 x 0.328 = 20.5°C. Ambient temperature was measured to be 30°C. So case temp. ought to be approximately 30 + 20.5 = 50.5°C.

The TIP102 is the most expensive amongst the three Darlingtons, but by less than 10% over the cheapest. Given how I'm averse to designing in heatsinks for this toy I'll use the TIP102, despite the fact that its temperature will be a mere 1.4° less than if I use the TIP120.