Sliders Timer: Some useful information

[brevik]

I don't know what the interest is on the timers from Sliders anymore, but considering that there hasn't been that much information about the reproduction of it provided online publicly, I figured that I should move all the info that I have to a thread here.

This mainly pertains to the Original Timer, but a lot of the resources can be, and will be converted for use with the other timer models.

A few files linked to Google Drive, for lack of a better place to upload files, so if there is any problem with the links or downloads, let me know.

__________________________________________________________________________________________________________________________
Faceplate Design Files

Original Timer Faceplate Design PDF Files download link here.
Upon doing some tangible sizing, I see now that this version of the faceplate is going to be too short for this build of the timer presented in the post. I am leaving the source files up in case anyone wants to edit them for their project for the time being. I will be updating them with the correct sizing as soon as I have the timer closer to completion. Then I will know the actual size that the faceplate should be.


__________________________________________________________________________________________________________________________
Electronic Parts List

This list is only the electronic components.

Starting from the top down:

Emitter LEDs:
High Intensity White LED
Two of these should do the trick.

Days Display:
0.3" Single Digit Display
I figured that these would work as they are slightly smaller than the main digit displays. It has been very tricky to track down a display that has three digits that fit the dimensions needed. Anyone have any other ideas?

Potentiometer (for the dial):
Sparkfun Thumbwheel Potentiometer
A thumbwheel pot is probably the best option for the knob on the original timer because of the low profile size of it. The original timer does not have much clearance under the black box, especially given that the knob is recessed into the enclosure.
I'm going to have to modify the thumbwheel to secure onto the knob, but that should be fairly simple to do.

Display drivers/multiplexers: EDIT: It seems that this link now goes to the thru-hole version of the IC, but I surface mount version will need to be used instead. Link has been updated for the SMT MAX7221 from Digikey.
MAX7219 - Eight Digit Display Driver
Two of these are needed for full functionality. I used the MAX7221, but these MAX7219's are more common and cheaper.

The main HH:MM:SS digit display:
0.36" Single Digit Display
These are single digits and should fit perfectly with the given dimensions. I am using the common cathode version because the MAX72xx chips require common cathode displays.

Colon LEDs:
Small Rectangular Red LEDs

Bargraph Displays:
10 Segment Green Bargraph Display
I like to use Sparkfun whenever I can because they have all the EagleCad libraries for all of their products, making it much easier to make a PCB design.

Tau/Zeta/Delta LEDs:
Rectangular 5mm x 2mm Color LED
Rectangular 5mm x 2mm Color LED
Rectangular 5mm x 2mm Color LED

Buttons:
I've decided on which button type to use. These will work great with eh dimensions needed.
Tactile Button Switches

New: USB micro SMD Connector:
Micro USB SMD Connector
So that I can interface with the timer through the bottom port directly to the computer and reprogram the timer without having to dismantle it.


MCU:
Arduino Micro Board
The main processor for the entire rig. I chose this because its small and can just be incorporated into the design, as-is, and simplifies things a lot, and has more analogue inputs than most of the small Arduino boards.

The circuit make-up will require some resistors and some capacitors and Sparkfun has the correct types:
330 Ohm SMD Resistors
100nF SMD Capacitors
10uF SMD Capacitors
Additional update: I have added some 1k ohm surface mount resistors for the LEDs that are constantly powered on the bargraphs
You can order them in a small quantity from DigiKey.com.
Green LEDs tend to be brighter in comparison to the power provided as compared to the other LEDs.

There will also be two other types of resistors for the current resistors that go with each display driver. Each resistor type will be of different value due to using three different display types (green bargraphs, main red HH:MM:SS display, and red days display, where the days display will have a different current rating than the main HH:MM:SS display, and the two different colors, red and green, will also have different current ratings because of the color difference).
I will have those resistor ratings later and I will post links to where to get them. I have a space on the PCB to place a socket for the resistors, and I'll figure out the best current limiting resistor for the displays after getting PCB installed under the faceplate, for best brightness and power consumption.

Pictures of many of the parts:

http://i71.servimg.com/u/f71/18/36/28/14/bgandb10.jpg

http://i71.servimg.com/u/f71/18/36/28/14/displa10.jpg

http://i71.servimg.com/u/f71/18/36/28/14/everyt10.jpg

I've tried to keep the entire circuit as simple as possible to keep the parts list to a bare minimum. One of the huge advantages to using the MAX72xx display drivers is that the current limiting is left up to a single Rset resistor because of the nature of multiplexing. So this really reduces the component count.
Now this is just the electronic components that I have figured out so far (mostly), but some are subject to change, and some, like the buttons, aren't entirely figured out quite yet. The enclosure and cosmetic parts list will be a separate section. Hopefully some experienced timer builders may have some suggestions for additions or changes.

_________________________________________________________________________________________________________________________
PCB Printing

The PCB that I have currently designed out I have currently ordered from oshpark.com and I'm waiting for it to be shipped to me.
Currently the PCB will look like this(front) and (back).
Source board files provided here.
Oshpark.com Shared Project page for the PCB here (older version without jumper connection and other improvements). : From here, you can order the most current board that I've developed so far.

Update: New board version HERE. I incorporated a line of jumper connections that connect the top of the board to the bottom, making room for better PCB wire routing. This frees up some mess in the HH:MM:SS area of the PCB enabling the proper use of through-hole component placement. I also moved the bargraphs and three LEDs down a tad to make it more screen accurate.

I kept the original PCB without jumper connection available above, but as long as everything works on the newer version, I suggest using the update version.

__________________________________________________________________________________________________________________________
Current Source Code (not complete)

The source code for the MCU is not complete yet because I have to decide how I am going to manage the battery power and the on/off function of it once I have the case made, but the input/output hardware is solid, and I have a microUSB connection on the bottom of the PCB that is accessible from the battery charger port on the Motorola phone case to reprogram the MCU without having to disassemble anything.

Video of the components in action on the breadboard:

The video includes the basic functions of the program but doesn't include the input to reset the time and such. I used the Arduino platform, so the code is main in C based off of the Arduino IDE and used the Arduino LED Control library.

Code here.

#include "LedControl.h"
/*
pin 12 DataIn 
pin 11  CLK 
pin 10 LOAD 
Two MAX7221's
*/
LedControl lc=LedControl(12,11,10,2);


//buttons and inputs
const int button0 = A0;
const int button1 = A1;
const int button2 = A2;
const int button3 = A3;
const int pot1 = A4;
const int greenpin = 5; //green LED
const int redpin = 6; //red LED
const int yellowpin = 8; //yellow LED
const int emitters = 3; //emitters are connected in serial
const int speaker = 4; //piezo
const int colons =  13; //colons are connected in serial

unsigned long totalsectime = 35; //this value is the beginning countdown time
//totalsectime will later be filled in by time set function by inputs

void setup() {
 randomSeed(analogRead(A5)); //sets pin A5 as an input to generate a random number
 pinMode(colons, OUTPUT);
 pinMode(speaker, OUTPUT);
 pinMode(emitters, OUTPUT);
 pinMode(button0, INPUT);
 pinMode(button1, INPUT);
 pinMode(button2, INPUT);
 pinMode(button3, INPUT);
 pinMode(pot1, INPUT);
 pinMode(greenpin, OUTPUT);
 pinMode(redpin, OUTPUT);
 pinMode(yellowpin, OUTPUT);

 // number of devices LedControl
 int devices=lc.getDeviceCount();
 //init all devices in a loop
 for(int address=0;address<devices;address++) {
   //take out of power saving mode
   lc.shutdown(address,false);
   // set brightness - depends on Rset values
   lc.setIntensity(0,15);
   lc.setIntensity(1,1);
   /* and clear the display */
   lc.clearDisplay(address);
   //sets the number of digits that each 7221 will scan through when multiplexing
   lc.setScanLimit(0, 6);
   lc.setScanLimit(1, 6);
 }
}

//COLON BLINK FUNCTION for normal countdown 2 blink/second
int colonsState = LOW;
long previouscolonsMillis = 0;
long colonsinterval = 250; 
void colonBlink(){

 unsigned long currentcolonsMillis = millis();

 if(currentcolonsMillis - previouscolonsMillis > colonsinterval) {
   // save the last time you blinked the LED 
   previouscolonsMillis = currentcolonsMillis;   

   // if the LED is off turn it on and vice-versa:
   if (colonsState == LOW)
     colonsState = HIGH;
   else
     colonsState = LOW;

   // set the LED with the ledState of the variable:
   digitalWrite(colons, colonsState);
 }
}

//GENSER SEQUENCE PREAMBLE
void genserOne() {  
 //GEnSEr
 //G  
 lc.setRow(0,0,B01011110);
 //E  
 lc.setChar(0,1,'E',false);
 //n
 lc.setRow(0,2,0x15);
 //S(5)
 lc.setChar(0,3,'5',false);
 //E
 lc.setChar(0,4,'E',false);
 //r
 lc.setRow(0,5,0x05);

 delay(400);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //random 1
 lc.setRow(0,0,B01001001);

 lc.setRow(0,1,B00010101);

 lc.setRow(0,2,B00100011);

 lc.setRow(0,3,B00000011);

 lc.setRow(0,4,B01010100);

 lc.setRow(0,5,B01000011);

 delay(200);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //CAluri
 //C
 lc.setRow(0,0,B01001110);
 //A
 lc.setChar (0,1,'A',false);
 //l(lowercase "L")
 lc.setRow(0,2,B00110000);
 //u
 lc.setRow(0,3,B00011100);
 //r
 lc.setRow(0,4,B00000101);
 //i
 lc.setRow(0,5,B00010000);

 delay(200);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //4th Sequence
 lc.setRow(0,0,B00100011);

 lc.setRow(0,1,B00000011);

 lc.setRow(0,2,B01010100);

 lc.setRow(0,3,B01000011);

 lc.setRow(0,4,B00010011);

 lc.setRow(0,5,B00011001);

 delay(200);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //Second CAluri sequence
 //C
 lc.setRow(0,0,B01001110);
 //A
 lc.setChar (0,1,'A',false);
 //l(lowercase "L")
 lc.setRow(0,2,B00110000);
 //u
 lc.setRow(0,3,B00011100);
 //r
 lc.setRow(0,4,B00000101);
 //i
 lc.setRow(0,5,B00010000);

 delay(200);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //6th Sequence
 lc.setRow(0,0,B00101010);

 lc.setRow(0,1,B00000011);

 lc.setRow(0,2,B00011010);

 lc.setRow(0,3,B01001000);

 lc.setRow(0,4,B01000001);

 lc.setRow(0,5,B01001001);

 delay(200);
 //clear
 lc.clearDisplay(0);
 delay(40);

 //6th Sequence
 lc.setRow(0,0,B00010011);

 lc.setRow(0,1,B00011001);

 lc.setRow(0,2,B00100010);

 lc.setRow(0,3,B00011000);

 lc.setRow(0,4,B01000001);

 lc.setRow(0,5,B00100101);

 delay(250);
 //clear
 lc.clearDisplay(0);
 delay(75);
} 


void displayFade() {
 //clear
 delay(100);
 //INSERT FUNCTION FOR DIGIT FADING AFTER ZERO 
 lc.setRow(0,0,B01111000);       //partially zapped 0
 lc.setRow(0,1,B01111110);       //0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B01111110);       //0
 lc.setRow(0,5,B00011110);       //partially zapped 0
 delay(30);
 lc.setRow(0,0,B00110000);       //partially zapped 0
 lc.setRow(0,1,B01111110);       //0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B10000000);       //0
 lc.setRow(0,5,B00000110);       //partially zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B01111110);       //0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B01111110);       //0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B01111000);       //partially zapped 0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B01000000);       //partially zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B00110000);       //partially zapped 0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B00000110);       //partially zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B00000000);       //fully zapped 0
 lc.setRow(0,2,B01111110);       //0
 lc.setRow(0,3,B01111110);       //0
 lc.setRow(0,4,B00000000);       //fully zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(55);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B00000000);       //fully zapped 0
 lc.setRow(0,2,B01111000);       //partially zapped 0
 lc.setRow(0,3,B01000000);       //partially zapped 0
 lc.setRow(0,4,B00000000);       //fully zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B00000000);       //fully zapped 0
 lc.setRow(0,2,B00110000);       //partially zapped 0
 lc.setRow(0,3,B00000110);       //partially zapped 0
 lc.setRow(0,4,B00000000);       //fully zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(30);
 lc.setRow(0,0,B00000000);       //fully zapped 0
 lc.setRow(0,1,B00000000);       //fully zapped 0
 lc.setRow(0,2,B00000000);       //fully zapped 0
 lc.setRow(0,3,B00000000);       //fully zapped 0
 lc.setRow(0,4,B00000000);       //fully zapped 0
 lc.setRow(0,5,B00000000);       //fully zapped 0
 delay(1000);
}

void displayWrap() {
 //INSERT DISPLAY WRAP
 delay(40);
 lc.setRow(0,0,B00000010);       
 lc.setRow(0,1,B00000010);       
 lc.setRow(0,2,B00000010);       
 lc.setRow(0,3,B00000010);       
 lc.setRow(0,4,B00000010);       
 lc.setRow(0,5,B00000010); 
 delay(40);
 lc.setRow(0,0,B01000000);       
 lc.setRow(0,1,B01000000);       
 lc.setRow(0,2,B01000000);       
 lc.setRow(0,3,B01000000);       
 lc.setRow(0,4,B01000000);       
 lc.setRow(0,5,B01000000); 
 delay(40);
 lc.setRow(0,0,B00100000);       
 lc.setRow(0,1,B00100000);       
 lc.setRow(0,2,B00100000);       
 lc.setRow(0,3,B00100000);       
 lc.setRow(0,4,B00100000);       
 lc.setRow(0,5,B00100000); 
 delay(40);
 lc.setRow(0,0,B00010000);       
 lc.setRow(0,1,B00010000);       
 lc.setRow(0,2,B00010000);       
 lc.setRow(0,3,B00010000);       
 lc.setRow(0,4,B00010000);       
 lc.setRow(0,5,B00010000); 
 delay(40);
 lc.setRow(0,0,B00001000);       
 lc.setRow(0,1,B00001000);       
 lc.setRow(0,2,B00001000);       
 lc.setRow(0,3,B00001000);       
 lc.setRow(0,4,B00001000);       
 lc.setRow(0,5,B00001000); 
 delay(40);
 lc.setRow(0,0,B00000100);       
 lc.setRow(0,1,B00000100);       
 lc.setRow(0,2,B00000100);       
 lc.setRow(0,3,B00000100);       
 lc.setRow(0,4,B00000100);       
 lc.setRow(0,5,B00000100);
 delay(40);
 lc.setRow(0,0,B00000010);       
 lc.setRow(0,1,B00000010);       
 lc.setRow(0,2,B00000010);       
 lc.setRow(0,3,B00000010);       
 lc.setRow(0,4,B00000010);       
 lc.setRow(0,5,B00000010);
 delay(40);
 lc.setRow(0,0,B01000000);       
 lc.setRow(0,1,B01000000);       
 lc.setRow(0,2,B01000000);       
 lc.setRow(0,3,B01000000);       
 lc.setRow(0,4,B01000000);       
 lc.setRow(0,5,B01000000);
 delay(40);
 lc.setRow(0,0,B00100000);       
 lc.setRow(0,1,B00100000);       
 lc.setRow(0,2,B00100000);       
 lc.setRow(0,3,B00100000);       
 lc.setRow(0,4,B00100000);       
 lc.setRow(0,5,B00100000);
 delay(40);
 lc.setRow(0,0,B00010000);       
 lc.setRow(0,1,B00010000);       
 lc.setRow(0,2,B00010000);       
 lc.setRow(0,3,B00010000);       
 lc.setRow(0,4,B00010000);       
 lc.setRow(0,5,B00010000);
 delay(40);
 lc.setRow(0,0,B00001000);       
 lc.setRow(0,1,B00001000);       
 lc.setRow(0,2,B00001000);       
 lc.setRow(0,3,B00001000);       
 lc.setRow(0,4,B00001000);       
 lc.setRow(0,5,B00001000);
 delay(40);
 lc.setRow(0,0,B00000100);       
 lc.setRow(0,1,B00000100);       
 lc.setRow(0,2,B00000100);       
 lc.setRow(0,3,B00000100);       
 lc.setRow(0,4,B00000100);       
 lc.setRow(0,5,B00000100);
 delay(40);
 lc.setRow(0,0,B00000010);       
 lc.setRow(0,1,B00000010);       
 lc.setRow(0,2,B00000010);       
 lc.setRow(0,3,B00000010);       
 lc.setRow(0,4,B00000010);       
 lc.setRow(0,5,B00000010);
 delay(40);
 lc.setRow(0,0,B00000001);       
 lc.setRow(0,1,B00000001);       
 lc.setRow(0,2,B00000001);       
 lc.setRow(0,3,B00000001);       
 lc.setRow(0,4,B00000001);       
 lc.setRow(0,5,B00000001);
}


void updatespeaker(){
 static int state = 0;
 static unsigned int beeptime = 250;
 static unsigned int sinterval = 500;
 static unsigned int freq = 2500;
 static unsigned long lasttimeon = 0;
 unsigned long m = millis();

 if (state == -1){
   lasttimeon = m;
   state = 1;
   tone(speaker,1000);
   noTone(speaker);
   tone(speaker,1000);
   return;
 }
 if (state == 0){
   if (m >= lasttimeon +sinterval){
     state = 1;
     tone(speaker,freq);
     lasttimeon = m;
   }
   return;
 }
 if (state == 1){
   if (m >= lasttimeon + beeptime){
     noTone(speaker);
     state = 0;
     beeptime = 100;
   }
   return;
 }
}

//setting up seconds time conversion
#define secondsinaday 86400  //((60*60)*24)
#define secondsinhour 3600  //(60*60)
#define secondsinminute 60

long countpreviousMillis = 0;   //stores count milliseconds    
long countinterval = 1000; //1 second 

void displayDate(){

 unsigned long countcurrentMillis = millis();

 if(countcurrentMillis - countpreviousMillis > countinterval) {
   // save the last time counted 
   countpreviousMillis = countcurrentMillis;   
   totalsectime--; //decrement of 1 second
   unsigned long sectime = totalsectime; 
   /*takes the totalsectime variable and converts it inside of this function
   so that the time conversions do not interfere with the later functions */
   
   unsigned long days = sectime/secondsinaday; //calculates seconds in a day
   sectime = sectime % secondsinaday; //takes the remainder of the previous calculation
   unsigned long hours = sectime/secondsinhour; //calculates seconds in an hour
   sectime = sectime % secondsinhour; //takes the remainder of the previous calculation
   unsigned long minutes = sectime/secondsinminute; //calculates seconds in a minute
   unsigned long seconds = sectime % secondsinminute; //takes the remainder, and that is seconds

/*below takes the values generated from above and makes variables for each digit to display 
based on on dividing the values by hundreds/tens/single numbers*/

   unsigned long days_hundreds = days/100; 
   unsigned long days_tens = (days %100)/10;
   unsigned long days_units = (days %100)%10;

   unsigned long hours_tens = (hours %100)/10;
   unsigned long hours_units = (hours %100)%10;

   unsigned long minutes_tens = (minutes %100)/10;
   unsigned long minutes_units = (minutes %100)%10;

   unsigned long seconds_tens = (seconds %100)/10;
   unsigned long seconds_units = (seconds %100)%10;

//below is where the magic happens
//sends digit to: 7221 device
//digit order
//variable from above calculations
//true/false for the decimal point
   lc.setDigit(1,0,days_hundreds,false);
   lc.setDigit(1,1,days_tens,false);
   lc.setDigit(1,2,days_units,false);

   lc.setDigit(0,0,hours_tens,false);
   lc.setDigit(0,1,hours_units,false);
   lc.setDigit(0,2,minutes_tens,false);
   lc.setDigit(0,3,minutes_units,false);
   lc.setDigit(0,4,seconds_tens,false);
   lc.setDigit(0,5,seconds_units,false);

   if(sectime==15){   //wrap-around when time reaches 15 seconds
     displayWrap();
   }
   if(totalsectime <=5 ) {   //lights emitter LEDs when time reaches 5 seconds and keeps speaker solid
     updatespeaker();
     digitalWrite(emitters, HIGH);
   }
   else{
     digitalWrite(emitters, LOW);
   }
   
   /*Below is the "reset" mode that I have worked out right now, but is due to change
   as I get more things sorted out, and this will do other things. Right now is just
   for testing/looks.*/
   
   if(totalsectime <= 0){
     delay(2500);
     displayFade();
     genserOne();
     displayWrap();
     updatespeaker();
     totalsectime = random(16756131);  
   }    
 }
 if(totalsectime > 5){   //colon blink function for normal countdown
   colonBlink();
   updatespeaker();
 }
}


void loop() { 

 displayDate();

}

If anyone recalls, I incorporated some of the code provided by Steven Genser on these forums; its kind of a novelty to have a virtual piece of the original prop included into it.

__________________________________________________________________________________________________________________________

Anyways, I figured that I would post what I have here because I see Sliders Timer topics pop up once in a while that only has the usual big plans that are never realized, or just pictures of already made prop replicas. Also the forum that I was posting this stuff on seemed to die off a bit. If anyone is interested, the original post was on Xslider13's timer forums.

 

[brevik]

I did some work on the first board over the weekend and I'm pretty happy with the over-all design




This only the first version, Oshpark sent me 3 boards. So on the second board I will need to tighten up the surface mount soldering jobs, as it took a bit of practice the first time to get the hang of it.
I will need to find a better way to surface mount solder the digit displays onto the board. As I am going from through-hole to surface mount with those, I tried using some IC sockets that I separated and grinded down the pins, but using those, its just too difficult to ensure that the displays line up perfectly straight.
Without the sockets on there, it will probably lower the digit displays down into the phone case, which will make them fit with the design (you can see in the pictures that the digits are a bit crooked and protruding upwards too much).

The second big issue that I noticed were the bargraph LED arrays. They are also protruding upwards too much. However, if I were to grind down the corner nubs down so that they lay perfectly flat, this will be just enough to line them up with the inside faceplate so that they don't stick up too high.

Bargraph "nubs" below:



I'm going to continue modding the motorola phone case a bit before I start on the second board to make sure that the two come together as smoothly as possible. I probably don't need to post much on how to mod the phone as I'm sure most members here are many times better at working with plastic and modeling things as I am. I will post the final techniques that I use once I am done though.


Also I thought it might be interesting to show that the USB port for the board turned out very well and accessible from the phone's original charging port. You can see here:
The top USB is the one thats built onto the Arduino Micro and the one on the bottom is the one that will be able to be plugged in without disassembling anything.

 

[Marlin2000]

Looks really great. Always liked this prop.

 

[RedWithEvil]

Happy Thanksgiving and beautiful work. I know timer props seemed a little more popular around the boards and abroad several years ago. But, these are the kinds of threads everyone was hoping/waiting for. It is apparent you've been consistent and worked hard with the details and nuances, I can't wait to see a video of it fired up. Assuming there was no "technical difficulties" lol. Despite there always of been talk, I think you may be the first to of actually took the steps toward a real functioning sliders PCB, aside from lightbenders.

Were you planning to do the "extended" battery thing to your phone shell? The additional thickness may free up some room. And were you planning on the thumbwheel having any functionality? I know it's a lot of effort and takes up more precious room, it seems more of a preference thing considering how scarcely it was utilized on the series, just wondering your thoughts on it.

Aside from that, the tactile buttons you chose to work with looks like a very good fit. Not sure why I felt the urge to point that out lol. Also it "appears" the emitter had more of a yellowness when it was activated... I wonder if at time period if it may of been incandescent? The egyptian one definitely seemed to have a uber white/maybe bright blue light. But again, it may be preference. I also saw somewhere (at some time) other small 7 segment digits (probably still 0.36) but they had black faces and they weren't as tilted. It seems commonplace for those sort of displays to have a 5 degree angle (not sure why) or if those were the norm in the early 90s as they are today. But, I know I've seen others that were slightly straighter.

Thank you for sharing this awesome post, keep up the good work and PLEASE keep this thread opened and updated no matter what... it's a really important cause, more important then an actual cause - and I'll see you on the other slide.

(had to do it) ;P


Cheers,

-R

 

[brevik]

I've been trying to take as many pictures of the work that I can so that I can (and this has been said soooo many times by so many people), put up a guide with detailed information about the construction, with more consistency than the forum posts.

All features will be utilized on the timer. I incorporated the 'days' display, all of the buttons are wired to the MCU, and yes, the thumbwheel potentiometer will be functional. I don't have a lot of features set in stone, as far as how it will all function in detail. When I started developing the project I left a lot of things open on the software side of things. I configured all of the hardware to the MCU so that it can be reprogrammed without have to change any hardware. If, later, I want to change how the inputs work, I will be able to do that by just plugging the USB port that is in the phone's charging port and upload the new program to it.

The emitters for this replica will be brightened white LEDs, so it will appear very white on the emitter. The show's prop actually did use an incandescent bulb.

I really wish that I was able to find some 0.36" dual 7-segment displays because that would really free up some space on the PCB. As it is now, the area where the main display is located at is kind of a wall where it is really hard to route the connections from the top of the timer to the bottom past the main displays. I will probably create a 4-layer board later on to address this and so that there is more leeway for some additions.

I have most of the pieces for the second board, so I will start on that soon and hopefully get a fully operational piece perfected without screwing up the soldering again and I'll post video online. Then its off to work on cosmetics of the project casing.

 

[brevik]

I have fastened the black box to the frame of the phone.

A couple of pictures here to outline how it fits inside of the phone case and what you need to do to make it fit nicely.

Lining up the black box to the phone to make the cuts on the phone is kind of tricky even if you have calipers, clamps and a straightedge. The phone isn't necessarily flat, and its not very easy to keep the plastic against the phone case without them slipping around.

One way that I used to line up the two was to prop open the flip plate of the phone and put the black box flush with it to square-up the two.



This will help to make sure that nothing is crooked and diagonal. Although I do suggest using some calipers to measure distance, some light claps to secure all reference materials on the phone and making some markings around the phone case before doing any cutting.


The back half of the phone case will also need to modded so that the box sits flush against the inside.


Need to cut/sand down the protruding supports. I circled them in red in the above picture. Also the top of this piece needs the top lip cut out so that the black box can sit flat (I didn't highlight that in this picture, but if you're at this point, you can see what needs to be cut out).
Once done cutting, the back should look like:

Hopefully yours looks cleaner than mine as I'm going at a cut-fit-cut some more,plan.

At this point, the black box should be able to slide right into the back there.


To secure the black box, I was originally going to use a complicated method of rare-earth magnets to fasten the thing together, but for now I just decided to settle with bolts.
I just drilled a hole through the black box on the inside and then lined it up with the phone case with what little wiggle room that it had left, secured it down centered and drilled holes through the phone case and just tightened the bolts and nuts down. Turned out pretty nice and secure.


The remaining tab support that is on the phone is perfect to line up the box to up against it


The remaining tab support that is on the phone is perfect to line up the box to up against it
These pictures were taken before I lined everything up perfectly, so be careful when tightening the bolts down, the back box will tilt a bit as its tightened.
On that inside picture you can see notches cut out of the black box on the inside. I had to make some room for the sides of the circuit board to slide into.

Before the notches are made, you can see that the black box is pushed up from the tapered edges of the circuit board. After cutting the notches, the black box fits nicely




Bargraphs-

I mentioned earlier cutting down the corners of the bottoms of the bargraphs so that they will be at the perfect height for the inside faceplate.
I just used an x-acto knife to slice it down level with the rest of the bottom.
Gotta be careful with this though, the end pins run through the plastic, so it can be really easy to damage the end pins if not done carefully.

 

[Zalaian]

Love the work, i too have built and programmed my own timer, the pieces i am missing however is the knob at the top and the grid plate on the flip part of the phone, do you have these and where did you obtain them?

 

[RedWithEvil]

Awesome ideas on securing the box. What size screws are those? Have you considered maybe adding washers to better help the stress points distribute evenly? It's very exciting watching this come together. I always thought the original timer was more intricate and visually appealing (as compared to the Egyptian one). Can't wait to see the circuit in action, the prototype of the TAU, DELTA and ZETA lights more unique to others I've seen. Great design work, what power supply(s) have you been considering/or projecting this to use?

Keep up the good work!


-R

 

[RedWithEvil]

It would be cool if you could show off some of your timer work Zalaian. In regard to the knob and flip grid thingy - I know there use to be a prop maker who went by the name (Sparticus), I think his name might of been Mark - you should know who I'm referring to, he made a couple really pretty timers few years back. I think he did his knob from scratch by pressing a marble into some resin putty, etc. Depending on preference, accuracy and convenience I think many have opted for doing their knobs and flips from scratch. It'd probably not be too difficult. I don't think those particular pieces were ever properly uncovered or found in the wild.

 

[brevik]

I'm planning on having to use a plastic mold for the knob and the keypad grid. I spoke to a guy at a hobby store that knows how to work with plastics much better than I do and he said that the knob looked very easy to mold. The keypad looks super easy too.
He also suggested that I mold the phone case itself, which I may do in the future due to the increasing rarity of the MicroTacs, but that is a bit in the future.
The power supply for this will be a battery separate from the phone's original battery. I'm not sure exactly what I will be using yet, but it will most likely be a rechargable between 5.2 - 5.5 volts.

The bolts holding the black box on are just arbitrary sized according to what I thought would work (small preferably, and low profile), just have to watch out for the length and make sure that they don't stick out very far.

I was able to attach the "1" and "4" button grid on the inside. If anyone has attempted a timer, I'm pretty sure that they will find this part kind of difficult to do securely.

I cut out the two button grid and then used some JB Weld to glue it together and then I did some really rough "plastic welding" with some slices off of parts that I cut off the phone and took and old soldering iron, and wrapped a paper clip around it.


Gotta hold that JB Weld together for a few hours.



Edges need to be cut down square now.


I obviously don't know what I'm doing.
Shaved off some thin pieces of the same plastic from the phone and used a high temperature old soldering iron that I had, wrapped some wire from a paper clip around the tip tightly.



Its not pretty, but its securely on there.

 

[Zalaian]

Lol yeah, i was thinking of making the knob and the grid myself, using resin after modeling out of clay. For my battery i removed everything from orginal battery housing and installed a Polymer Lithium Ion Battery, and charge point, as well as a step up board to 5v, after installed i realized i may have not needed the step up but oh wells, powers everything perfectly and i just take the battery pack off connect to usb for charging.

 

[Zalaian]

I also have all the parts to do the Egyptian and Jensen timer, just after all the time i spent learning c++ and the electronics aspect i kinda took a long break from it all. Yeah not a bad idea about casting the timer base, i got lucky to find the tac as well, and did damage it and cut a few wrong places in the build, but over all still turned out pretty nice.

 

[Risu]

This is an amazing thread. We've been waiting for this kind of thing for years. i can't wait to see it all come together, and I hope when the time comes you'll be releasing board layouts and whatnot for the final product, or even better, do a small group buy so we can't accidentally mess up on that part ourselves. I finally got an accurate phone last year, but didn't have any clue if I'd ever get to do anything to it.

 

[Zalaian]

Lol as i keep reading i have things to add, to red, i extended my battery back, i did it to incorporate some fake electronics for more authenticity to it, and i made my thumb wheel has power up functionality, with leds that light up as power increases. As you say this all starts adding issues with space, but i did cram it all in there in the end. I only extended my battey cause i got two motorlas one accurate one the 550 that people also mod, so i stripped it for parts for the primary timer.

 

[Zalaian]

Lol brevik, i searched everywhere for the dual segments i finally got them but took forever off ebay. I did research the hell out of this timer before i started building it, and read everything available here on the rpf.But as it has been said nothing really was completely finished or full accurate information was scarce at times.

 

[Zalaian]

I will post some pics of mine when I get a chance to take some of it, or find where i put the construction pics. Just like this thread will do logging the construction of the timer i did as well log everything from schematics of my electronics and code in a hard copy so if i had to fix it, or rebuild i could with ease. And a complete list of parts very similar to this one. Its great to see this thread, if Brevik does something different then i did and works better i may go back to my timer and adapt it lol.

 

[brevik]

Just real quick, I already have the board file that I am using available for download. The .brd and .sch files are linked up above on the main post, those include the actual board layout and design and also the schematic files, so that its easy to see what is going on with the connections. Those can be imported into most PCB design software and I used EagleCad to create the PCB design.

I also have the project shared on Oshpark.com publicly at https://www.oshpark.com/shared_projects/WXQhEQAE
From there, you can just order the board from them directly. A bit of warning though; although I have tested the board design to work correctly, and all connections work, I can't vouch 100% of its integrity (just an obligatory disclaimer in case I missed some obscure thing on the board).

This board is very proprietary to the exact layout and component list that I am using. However, in the future I would like to include additional version that can be used with other MCUs, as its not alway possible to find a place that has the Arduino Micro in stock, and there's no telling if it may be discontinued at any point.

Edit: I would also like to point out that this is the first version of the board that I built for my own construction. There are some quirks that make this board a pain to work with, like the display digits having to be soldered surface mount even though the actual components are through-hole. This is done because the area that the display digits are being run across the middle of the PCB is kind of no-man's-land where connections have a really hard time to get across. In the future I will have a separate component that jumps those connections over the area where the digits are, so that they can all be properly printed as through-hole.
I am still coming up with ideas that will make the soldering of these surface mount connections properly engineered so that I get a straight and even placement on the board (you can see in the pictures that the digits are all wonky and uneven with my socket use). An early and untested tip though, I am probably going to have to use solder paste with a hot air soldering gun. Don't worry though, I don't expect everyone that own one of these (I know I don't), so I will also come up with a way to solder them on with a conventional soldering iron.


Another good piece of advice for those that aren't really seasoned with soldering and electrical engineering is to go read up on surface mount soldering. Go check out some videos and some online guides (instructables/sparkfun/general google search) to get a good idea about what kind of materials are needed to do the job and what to expect before you start on a board.
Make sure that your soldering iron is one that you want use to work with these small spaces and small connections. I saw an adequate variable setting iron at Fry's Electronics for about $25.00 the other day. Also look for soldering irons that have a good variety of tips available. Precise tips are easier to soldering these components onto the board.
I always try to list off products that can physically be picked up with a local (US) store whenever I can and whenever its affordable. One of those situations where you suddenly realize that you need something for the project that you're working on always works out better when you can just run to the store and pick up what you need and get back to it the same day rather than having to order from online and halt the project for days at a time while waiting for something to ship to you.

I wouldn't suggest soldering anything onto a board until you have everything you need to do the job and are ready to do everything from start to finish. You will need access to parts of the board that could be covered up by some of the components if you do things in the wrong order. Some of these tiny surface mount resistors are underneath other larger components, so just get familiar with the connections before soldering anything on.

 

[Risu]

Got it, thanks! I missed that up above, didn't realize you could actually buy the boards there.

Well then, just putting it out there, if anybody else wants one (or two if you plan to screw up) of these, since they sell a minimum of 3, we can split an order. Just send me a PM.

 

[RedWithEvil]

Excitement is in the air. I'm by no wavy electronically-savvy unfortunately. However, the aspect of a timer board is exciting. I'd like to see this in action before I start freaking out, maybe wait for a version 2 - after all the testing and tweaking has commenced. I personally wouldn't mind if the days display and knob had no function at all, and not just because it'd be more accurate to the show prop but it'd would probably save some power and internal space?

That being said, from how it's seeming this is a deluxe model - that "could" end up doing everything. Like everyone else, I can't wait to see how this turns out. Curious on what list of functions will be used as well. For example: a pause button for the beeps? Does it continue to count when it's turned off, or does it just start over? (either is fine). If this thing is set for a couple days I don't think anyone would actually sit there and watch it (and listen to the beeps) lol.

As Risu stated about splitting orders with other members that's a economical and thoughtful notion. Assuming one would be able to handle the components aspect of putting it together, and if it'd work. I personally would probably get the minimum order of 3 just for myself cause I'm a weirdo

Also interested in seeing Zalaians, I think you guys may be able to work together in some capacity. I don't have a timer, so my contributions are limited. But, I'm still trying to remain in the band lol. I'd even excited about the boring stuff, the cosmetics of the case - like sanding the emitter. This thread is the gateway to endless possibilities.

Keep up the good work.



-R




"So you're telling me we can just slide through this thing and boom, we're on a different planet?" ... "No, same planet - different dimension"

 

[Risu]

Personally, I would love to see the knob crank that crescent moon shaped red light gauge that runs around it. Way back when I got the phone I considered rigging it up with what minimalist electronics I was capable of, so I figured I could put an array of LEDs underneath with a diffuser and attach a thin plastic shield to the knob so that when you twist it, more and more of the red array is exposed. Obviously, brevik is capable of way more than that. I also think it's essential that closing the flap at the bottom will deactivate everything except the main countdown, so only days and HH:MM:SS are displaying, no beeping. And an off switch that doesn't shut off the internal clock would be cool as well. If the countdown was something like 3 days, it might be cool to be able to turn it off to save battery long enough for it to get there, then watch it count down to the end and start over when the time comes. Just my two cents. I'm happy just to get something this functional at this point.