loading
Picture of Arduino text'in
Arduino text‘in.

Key Features:
24 relays controlled by 4 I/O lines!
Cell phone text using your Arduino.

This project hacks a cell phone to text using normally open relays. After investigating cellular modules on the internet I decided it looks not only rather pricy, but also like a possibility that even after I had it working that a cellular provider might not let me put the device on their network. It seemed like a good cell phone hack was in order to make this work for me.
 
Remove these adsRemove these ads by Signing Up

Step 1:

Picture of
Phone screws 1.JPG
Purchase a cheap prepaid flip phone, activate and charge it. Mine was $20.00.

Flip phones are fairly easy to disassemble. You will need a very small screw driver set. The button pads on the inside are still large enough to allow for soldering wires in place without too much trouble. The prepaid plans let you text for pretty cheap too if you pick the right plan. Plus because its prepaid you can just let it run out whenever you are finished with it and best of all no contract.

Turn on the flip phone and take some notes about how it operates. Yours may access menus and things differently then mine does and its nice to know as you move forward with this.

Figure out what keys you still want to have access to once the phone is mounted. Because I used a prepaid phone I have to access it now and then to add more air time. It is also helpful to know how things are going with the phone when you can turn it on and activate it with the buttons after it is mounted to the board. The buttons on your cell phone board will be connecting directly to the phone. This way you can access the phone even if the rest of the circuit is off or maybe just doing other things.

Safety First. Remove the battery from the phone. Tear apart the flip phone. The circuit board inside is pretty delicate and has some sharp parts so use some caution. Do not break the LCD displays and be very careful not to destroy the very small ribbon cables that interconnect things. The part of the phone that houses the LCD, microphone and usually the camera will need to be taken completely out of the case. The flip phone I purchased had enough room to flip the camera around so that it can still take pictures. The case for the main board of the phone (where the battery is) will need to stay more or less intact. This makes it easier to put the battery back in and your not messing with the built in antenna so it should still have its normal signal strength.

Step 2:

Purchase / scavenge some electronics parts.
1 - Arduino Uno
24 - Normally Open buttons. These will replace the buttons on the phone.
3 - 74HC374 Octal D-Type Flip-Flop chips.
24 - Reed relays. I had a bunch laying around.
24 - NPN general purpose. I used 2N2222.
24 - 20 K Ohm resistors
24 to 48 General purpose diodes
  You don’t have to go overkill like I did. At minimum you need one diode across the relay coil to prevent voltage spikes when the coil turns off.
1 - Board to mount relay stuff.
1 - Board to mount cell phone
A bunch of jumper wires. Keep them neat. It makes it easier to trouble shoot.
1 - 12 volt power for relays.
1 - 5 volt power for 74hc374’s and Arduino.

Step 3:

Picture of
Layout your buttons on your board more or less like they are laid out on the cell phone. This makes it easier to know what buttons you are pressing. Notice that I have not used a few of the buttons.

Step 4:

Picture of
Find some small fairly flexible cable to use for all of the interconnecting soldering you are going to be doing. I used some spare ribbon cable. I cut it longer then I would need. I then tinned and  trimmed the end to go to the phone. Leave your wires long here because it is easier to cut wire off then it is to try to re-solder them. The circuit board on the phone can easily be damaged by too much heat so use caution. I found it easier to start with the button pads closest to my new buttons and move my way up from there.

Step 5:

Picture of
Once you have the part of the phone that houses the LCD apart you may need to cut or drill a hole in the mounting board for the ribbon cable to go through. The LCD will be mounting on the same side as the new buttons. I used some two sided tape to mount it. The main part of the cell phone will be mounted on the other side so it is closer to the relays.

Step 6:

Picture of
Before soldering the wires to the button pads on the phone check to be sure you are using normally open buttons also verify the way you have them soldered. The buttons on the phone board will also be going off to the relay board so your going to need some more ribbon cable.

I found it was easier if I mounted the cell phone body and LCD before I soldered to the buttons on the cell phone board. Be careful not to scratch the phones LCD.

Once you have all of the buttons on the phone board soldered and interconnected to the cell phone pads you can move on to getting the relay board assembled.

Step 7: RELAY BOARD

Picture of RELAY BOARD
RELAY SCHEMATIC.JPG
I love to expand the I/O on things as far as I can.
I use to have a few 74HC164 serial in, parallel out shift registers. I tried to order some more through a local electronics place and two years later I am still waiting for them to get in. Geographical oddity or something. So one day as I was looking at the circuit diagram for the 74hc164. I noticed it was similar to the 74hc374 except there would have to be some jumpers to make it function properly. The cool part about these is that it only takes two I/O (clock and data) to control up to eight outputs!
If you take more then one chip and tie all of the data lines together and only clock the one you want to have responding you can do even more. I tied 3 chips together and have 24 relays at the cost of 4 I/O.
I love that!

The 74hc374's needs 5 volts to operate. I built a regulator circuit with a 7805 voltage regulator and a few other components. Plus you can take the input 12 volts for powering the relays to run your 5 volt regulator.

Step 8:

Picture of
The relay board is a bit of an undertaking.
Do some good planning on lay out of your parts and its not too bad for soldering to a through hole solder board. If you need some help in the planning take a close look at the pictures. This board took a little while to put together so don’t get frustrated with it too quickly. Also, like they say there is more then one way to skin your knees… Anyway. The relay circuit I used worked for me. If you have a relay circuit you like, use it in place of the one I used. Its a good idea to bread board it first, or even a part of it to make sure it is going to work. It is not fun to get something all soldered together just to find something doesn’t like something else. The diode across the coil of the relay is important. If you decide not to use it don’t be surprised when things start acting funny and then one day decide not to work again. When the coil of the relay is turned off it can generate some reverse voltage spikes. That is not good for your circuit.

The heat sink in the middle of my board has the 7812 voltage regulator under it. If you use a wall wart you wont have that taking up room on your board.

Step 9:

Picture of
Relay board.JPG
The back side of my relay board.

Step 10:

Picture of
Once you have the relay board built decide what relay numbers are going to be for what buttons on the phone.
Mine are set up this way so this will match my program.

Chip 1 Relay 1 = Left select key
Chip 1 Relay 2 = up directional arrow key
Chip 1 Relay 3 = Right select key
Chip 1 Relay 4 = left directional arrow key
Chip 1 Relay 5 = OK key
Chip 1 Relay 6 = right directional arrow key
Chip 1 Relay 7 = down directional arrow key
Chip 1 Relay 8 = Direct to text messaging key. May not be on all phones.
Chip 2 Relay 1 = Send key
Chip 2 Relay 2 = Clear key
Chip 2 Relay 3 = End/Power key
Chip 2 Relay 4 = Number 1 key
Chip 2 Relay 5 = Number 2 key
Chip 2 Relay 6 = Number 3 key
Chip 2 Relay 7 = Number 4 key
Chip 2 Relay 8 = Number 5 key
Chip 3 Relay 1 = Number 6 key
Chip 3 Relay 2 = Number 7 key
Chip 3 Relay 3 = Number 8 key
Chip 3 Relay 4 = Number 9 key
Chip 3 Relay 5 = Star key
Chip 3 Relay 6 = Number 0 key
Chip 3 Relay 7 = Pound/Space in text key
Chip 3 Relay 8 = Spare. Connect to self destruct if you like.

Step 11: PHONE TESTING

Start with testing all of the new buttons that you soldered to the phone board.

These should all be going directly to the phone and shouldn’t need to have any power to the rest of the circuit.

Press what should be your end/power button to turn on the phone. Press each of the buttons and make sure they are correct. Example, If you press what should be button number 4 and something else pops up on the phone you need to check out your wiring on the buttons to the cell phone pads and do some correcting. If you don’t do the correcting your relays will probably be off too.

If everything here checks out you are good to move on.

Step 12: ADJUSTMENTS TO THE PHONE

My phone is a part of a larger project and it is built with that in mind.
You will need to delete the existing quick text. Then add some new quick text into the quick text section of your phone.
Mine are as follows.

Quick text number 1 = “ Error”
Quick text number 2 = “ Run time”
Quick text number 3 = “ Day low”
Quick text number 4 = “ Day high”
Quick text number 5 = “Outside”
Quick text number 6 = “Inside”
Quick text number 7 = “ Voltage”
If you want to send other things just make the adjustments in the quick text and in the program.

I text more then just myself whenever I send something so I decided to put everyone who should get a text in as a contact and then added them into group 1 in the grouping of the phone. You will want to add your number to this group so it can text you as we move on.

Also my phone has the enter key (like to go to next line) stored in the symbols.
If all of this seems to line up with what you have. Load my code.

Be ready to hit the end key a bunch if things are not just right.

Step 13: My Program

/*
10-11-2012 RAY McQUEEN
This is the completed cell phone project

The cell phone button arrangements work for the phone I have.
You may have to do some investigation on the phone you use.


*/
//
///////////////////////////
//74HC374 CHIPS TO RELAYS//
///////////////////////////
//
const int phn_data = 9; //74xx374 pin 3 data
const int phn_clk1 = 8; //74xx374 chip 1 clock
const int phn_clk2 = 7; //74xx374 chip 2 clock
const int phn_clk3 = 6; //74xx374 chip 3 clock
//
///////////////
//PHONE STUFF//
///////////////
//
int phn_A = 0; //character to be shifted, used in phn_on & chip1-3
int phn_B = 0; //relay number to use
//
//////////////////////////////////////
//THESE ARE FOR BREAKING OUT NUMBERS//
//////////////////////////////////////
int val1000s = 0;//register to hold 1000 count
int val100s = 0;//register to hold 100 count
int val10s = 0;//register to hold 10 count
int val1s = 0;//register for 1 count
int test_test = 0;//register to store number for testing/time also
int tst_val = 0; //place to store a copy for breaking out number
int voltage = 0;//storage for a number to test for sending
int copy = 0;//copy of whatever I put in it
//
int phn_val = 375; //relay on time (375 works very well) for phone
//
//***ARRAYS***
//arrays count starts at 0 not 1 and goes up
//
int phn_relays[] = {
  //this is for choosing the relay number to turn on
  //We only want one relay on at a time.
  0, 1, 2, 4, 8, 16, 32, 64, 128, 256 };
//
//
//
void setup() {
  pinMode(phn_data, OUTPUT); //define pin9 as output
  pinMode(phn_clk1, OUTPUT); //define pin8 as output
  pinMode(phn_clk2, OUTPUT); //define pin7 as output
  pinMode(phn_clk3, OUTPUT); //define pin6 as output
  //
  ////////////////
  //END OF SETUP//
  ////////////////
}
//
///////////////////
//BEGIN MAIN LOOP//
///////////////////
//
void loop() {
  //
  delay(30000);//wait for a little while before starting
  //
  measure();//pretend to take some kind of reading
  //
  clr_all();//make sure all relays are clear
  //
  ray_show();//writes "Arduino text'in" on 1st line "Ray McQueen" on second line.
  //but doesnt send as text
  delay(10000);//wait 10 seconds
  norm_send();//send a normal text
  //
  delay(30000);
  delay(30000);
  delay(30000);
  delay(30000);
  //
  ////////////////////
  //END OF MAIN LOOP//
  ////////////////////
  //
}
//
//
//
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//BEGIN PHONE ROUTINES                      \\
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//
//this sends to all people added into the base group
void norm_send() {
  delay(phn_val);
  phn_on();
  delay(30000);// 30 seconds delay so phone can start up
  //
  norm_text();//this opens the text window
  //
  phn_compose();//compose inside outside text
  //
  delay(5000);//wait for message to send
  e_nd();//message is sent. Turn off the phone
  delay(phn_val);
  e_nd();
  delay(phn_val);
  e_nd();
  delay(phn_val);
  phn_on();
  delay(10);
}
//
//
//this doesnt send a text
//it loads waits for a few then deletes text and shuts back down
void ray_show() {
  delay(phn_val);
  phn_on();//turn on phone
  delay(30000);// 30 seconds delay so phone can start up
  //
  norm_text();//this opens the text window
  //
  //this adds the "Aduino text'in Ray McQueen"
  ard_text();//
  //
  delay(30000);//wait to be able to read message
  e_nd();//message is complete. Turn off the phone
  delay(phn_val);
  e_nd();
  delay(phn_val);
  e_nd();
  delay(phn_val);
  phn_on();//turn phone back off in prep for normal text
  delay(10);
}
//
//nothing needs to be loaded before getting here
//this handles phone to turn on and off
//the phone will need 30 seconds more if powering up
void phn_on() {
  phn_B = 3;//relay 3
  phn_A = (phn_relays[phn_B]);//aray for the relay to turn on
  //select chip 2 relay number 3
  shiftOut(phn_data, phn_clk2, MSBFIRST, phn_A);
  delay (3000); //delay 3 seconds
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk2, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored in val
}
//
//this is to add the group for everyone and get to the
//text window so a text may then be composed
//this assumes the phone is already powered on but may
//be in standby
void norm_text() {
  //wake up phone in case in standy
  e_nd();
  //
  e_nd();
  //
  dir_text();
  //new text message
  numb_1();
  //text message
  numb_1();
  //add
  r_sel();
  //
  numb_4();
  //
  ok();
  //
  ok();
  //
  //the text window is now open and ready for text input
}
//
//*******************************************
//these are for calling the correct relays
//by the key name instead of having to remember the
//number to load into B and the chip number
//
void l_sel() {
  phn_B = 1;
  chip_1();//left select key
  delay(phn_val);
}
//
void r_sel() {
  phn_B = 3;
  chip_1();//right select key
  delay(phn_val);
}
//
void up_arrow() {
  phn_B = 2;
  chip_1();//up arrow key
  delay(phn_val);
}
//
void l_arrow() {
  phn_B = 4;
  chip_1();//left arrow key
  delay(phn_val);
}
//
void r_arrow() {
  phn_B = 6;
  chip_1();//right arrow key
  delay(phn_val);
}
//
void down_arrow() {
  phn_B = 7;
  chip_1();//down arrow key
  delay(phn_val);
}
//
void ok() {
  phn_B = 5;
  chip_1();//ok key
  delay(phn_val);
}
//
void dir_text() {
  phn_B = 8;
  chip_1();//direct to text key
  delay(phn_val);
  delay(phn_val);
}
//
void s_end() {
  phn_B = 1;
  chip_2();//send key
  delay(phn_val);
}
//
void c_lear() {
  phn_B = 2;
  chip_2();//clear key
  delay(phn_val);
}
//
void e_nd() {
  phn_B = 3;
  chip_2();//end key
  delay(phn_val);
}
//
void numb_1() {
  phn_B = 4;
  chip_2();//number 1
  delay(phn_val);
}
//
void numb_2() {
  phn_B = 5;
  chip_2();//number 2
  delay(phn_val);
}
//
void numb_3() {
  phn_B = 6;
  chip_2();//number 3
  delay(phn_val);
}
//
void numb_4() {
  phn_B = 7;
  chip_2();//number 4
  delay(phn_val);
}
//
void numb_5() {
  phn_B = 8;
  chip_2();//number 5
  delay(phn_val);
}
//
void numb_6() {
  phn_B = 1;
  chip_3();//number 6
  delay(phn_val);
}
//
void numb_7() {
  phn_B = 2;
  chip_3();//number 7
  delay(phn_val);
}
//
void numb_8() {
  phn_B = 3;
  chip_3();//number 8
  delay(phn_val);
}
//
void numb_9() {
  phn_B = 4;
  chip_3();//number 9
  delay(phn_val);
}
//
void numb_0() {
  phn_B = 6;
  chip_3();//number 0
  delay(phn_val);
}
//
void star_key() {
  phn_B = 5;
  chip_3();//star key
  delay(phn_val);
}
//
void pound_key() {
  phn_B = 7;
  chip_3();//pound key/space in text
  delay(phn_val);
}
//
//**************************************
//
// B needs to be loaded with the relay to turn on before gets here
void chip_1() {
  //use this for the first 8 relays
  phn_A = (phn_relays[phn_B]);//array for the relay number to turn on
  shiftOut(phn_data, phn_clk1, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk1, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
}
//
// B needs to be loaded with the relay to turn on before gets here
void chip_2() {
  //use this for the second 8 relays
  phn_A = (phn_relays[phn_B]);//array for the relay number to turn on
  shiftOut(phn_data, phn_clk2, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk2, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
}
//
// B needs to be loaded with the relay to turn on before gets here
void chip_3() {
  //use this for the third 8 relays
  phn_A = (phn_relays[phn_B]);//array for the relay number to turn on
  shiftOut(phn_data, phn_clk3, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk3, MSBFIRST, phn_A);
  delay(phn_val); //delay the amount of time stored
}
//
//
void measure() {
  //This takes a number and breaks it out to press the
  //proper buttons on the phone to send that number
  voltage = (95);//Any test number to send
  //
  //test 1000s
  val1000s = 0;//clear 1000 register
  test_test = voltage;//copy contents of voltage for testing
  while (test_test >= 1000) {
    test_test = test_test - 1000;//take away 1000 until you have no more
    val1000s++;//add one for each 1000 you have
  }
  //test 100s
  val100s = 0;//clear hundreads register
  while (test_test >= 100) {
    test_test = test_test - 100;//take away 100 until you have no more
    val100s++;//add one for each 100 you have
  }
  //test 10s
  val10s = 0;//clear tens for testing
  while (test_test >= 10) {
    test_test = test_test - 10;//take away 10 until you have no more
    val10s++;//add one for each 10 you have
  }
  //remainder is the ones
  val1s = test_test;//whats left over is you ones
  //
  //end testing
  //the number that was stored in test_test is now be broken
  //out into four register
  //val1000s = the number of 1000's in the test number
  //val100s = the number of 100's in the test number
  //val10s = the number of 10's in the test number
  //val1s = remainder, the number of 1's in the test number
  //
}
//
//
//This is used to enter the actual reading into the text to
//be sent from the phone. These are numbers to be entered
void phn_temps() {
  switch (copy) {
    case 0://number 0
    numb_0();
    break;
    //
    case 1://number 1
    numb_1();
    break;
    //
    case 2://number 2
    numb_2();
    break;
    //
    case 3://number 3
    numb_3();
    break;
    //
    case 4://number 4
    numb_4();
    break;
    //
    case 5://number 5
    numb_5();
    break;
    //
    case 6://number 6
    numb_6();
    break;
    //
    case 7://number 7
    numb_7();
    break;
    //
    case 8://number 8
    numb_8();
    break;
    //
    case 9://number 9
    numb_9();
    break;
  }
}
//
//
//THE TEXT WINDOW MUST BE OPEN BEFORE GETTING HERE
void phn_compose() {
  l_sel();//Abc mode
  numb_8();//Quick text
  numb_6();//Inside
  pound_key();//space
  l_sel();//Abc mode
  numb_5();//make sure its set for 123 mode
  if (val1000s >= 1) { //test to see if it needs to be blank
    copy = val1000s;//get a copy of register
    phn_temps();//figure out which number to press
  }
  if (val1000s >= 1 && val100s >= 1) {
    copy = val100s;//get copy of register
    phn_temps();//figure out which number to press
  }
  copy = val10s;//get copy of register
  phn_temps();//figure out whick number to press
  copy = val1s;//get copy of register
  phn_temps();//figure out which number to press
  l_sel();//Abc mode
  numb_6();//symbols
  r_sel();//1st symbol set
  r_sel();//2nd symbol set
  numb_9();//symbol 'return' key
  l_sel();//Abc mode
  numb_8();//quick text
  numb_5();//'outside'
  pound_key();//space
  l_sel();//Abc mode
  numb_5();//make sure its set for 123 mode
  if (val1000s >= 1) { //test to see if it needs to be blank
    copy = val1000s;//get a copy of register
    phn_temps();//figure out which number to press
  }
  if (val1000s >= 1 && val100s >= 1) {
    copy = val100s;//get copy of register
    phn_temps();//figure out which number to press
  }
  copy = val10s;//get copy of register
  phn_temps();//figure out whick number to press
  copy = val1s;//get copy of register
  phn_temps();//figure out which number to press
  ok();//send text
}
//
void ard_text() {
  l_sel();//Abc mode
  numb_3();//Abc
  numb_2();// A
  numb_7();
  numb_7();
  numb_7();//r
  numb_3();//d
  numb_8();
  numb_8();//u
  numb_4();
  numb_4();
  numb_4();//i
  numb_6();
  numb_6();//n
  r_arrow();//needed between letters on same number
  numb_6();
  numb_6();
  numb_6();//o
  pound_key();//space in text
  numb_8();//t
  numb_3();
  numb_3();//e
  numb_9();
  numb_9();//x
  numb_8();//t
  l_sel();//Abc mode
  numb_6();//symbols
  numb_9();//'
  numb_4();
  numb_4();
  numb_4();//i
  numb_6();
  numb_6();//n
  l_sel();//Abc mode
  numb_6();//symbols
  r_sel();
  r_sel();
  numb_9();//enter
  l_sel();//Abc mode
  numb_3();//Abc
  numb_7();
  numb_7();
  numb_7();//R
  numb_2();//a
  numb_9();
  numb_9();
  numb_9();//y
  pound_key();//space in text
  l_sel();//Abc mode
  numb_3();//Abc
  numb_6();//M
  numb_2();
  numb_2();
  numb_2();//c
  l_sel();//Abc mode
  numb_3();//Abc
  numb_7();
  numb_7();//Q
  numb_8();
  numb_8();//u
  numb_3();
  numb_3();//e
  r_arrow();//needed between letters on same number
  numb_3();
  numb_3();//e
  numb_6();
  numb_6();//n
}
//
void clr_all() {
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk1, MSBFIRST, phn_A);
  delay(10); //small delay
  //
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk2, MSBFIRST, phn_A);
  delay(10); //small delay
  //
  phn_A = 0;// this will clear the relay
  shiftOut(phn_data, phn_clk3, MSBFIRST, phn_A);
  delay(10); //small delay
}
//
//
//
Kinnishian7 months ago

I like the whole project. I'm thinking, however, that the buttons are probably designed not to sink more than 10-20mA, so you can always just route them direct to the arduino pins. Chances are it's a good bit less, too.

bearly2 years ago
Will you please specify what kind of Reed relays you're using. I don't have a bunch of those laying around and I could not find any details about which I need to purchase following your instructions.
Very valuable and inspiring instructable in many ways, you made.
ray74 (author)  bearly2 years ago
Any reed relay will do as long as you match the coil voltage requirements. You can get them at Radio shack, Jameco, Mouser etc. Mail order will probably be the cheaper route :)
Nice work.... Congratulations on a well deserved win! Maybe you can give me some pointers on the prize we won in the hackit contest... I have never heard of these things before!
poofrabbit2 years ago
Hey congratulations on being a finalist in the hack it contest! Good luck to you!
ray74 (author)  poofrabbit2 years ago
Thank you poofrabbit :)
Roger_M2 years ago
As each serial data stream is clocked in to the shift registers in real time each output will change state with the current clock pulse in accordance with the current state of the bit stream. It is only the fact that the data stream is loaded much faster than the relays can respond (several ms) which stops ALL the relays changing state as the bit stream data is clocked in. This could be prevented if the drivers to the relays were inhibited starting at the start of the first clock and uninhibited just after the last clock. A mono triggered by the first clock edge with a period exceding the time taken for 24 clock periods could be used.
ray74 (author)  Roger_M2 years ago
That is correct Roger_M.
This same technique also works with lcd displays. Shift registers are amazing :)
brenryan2 years ago
Great work! Really cool. Can you please please post a video if possible? I love the sound of relays, I would say it is most satisfying to hear them clacking away whilst it types a message :)
ray74 (author)  brenryan2 years ago
Thank you brenryan.
I will see what I can do about a video. I agree with you about the sound of relays. I used reed relays in this so they are really quiet. I did turn the sound on for the button activation on the phone and that is still very satisfying.
samaddon2 years ago
purely genius! but it requires a lot of hard work and that's not possible for a child! great work ! i can't get words for your creation!
ray74 (author)  samaddon2 years ago
Thank you samaddon. Though this project does require a bit of work. I think that you can do anything you set your mind to. :)
samaddon ray742 years ago
Hey! ray!
do the instructables gave you the pro membership as a gift for this great instructable?? cause i got for three months a promembership gift for my which is How to make a soldering iron with a 6 volts battery you can search it's featured!
ray74 (author)  samaddon2 years ago
Hi samaddon
Your instructable "How to make a soldering iron with a 6 volt battery" is very creative. I am amazed every day at how creative people can be. It had never occurred to me before looking at your project to try to make my own solder iron. Thank you for sharing your talent.
samaddon ray742 years ago
Hey! ray!
do the instructables gave you the pro membership as a gift for this great instructable?? cause i got for three months a promembership gift for my which is How to make a soldering iron with a 6 volts battery you can search it's featured!
Amazing project ...very nice code layout too!
Build_it_Bob
ray74 (author)  Build_it_Bob2 years ago
Thank you Bob.
askjerry2 years ago
Most cell phones, and electronics in general for that matter ground the pin to act as a keypress. So instead of using ($) relays you could use a transistor like this... http://www.digikey.com/product-detail/en/2N5210BU/2N5210-ND/1422

You can get 25 for $4... probably less than 2 relays. You are already using a transistor to drive a relay... see if you can drive the switch directly.

If that doesn't work you can look at something like this...
http://www.digikey.com/product-detail/en/CPC1972G/CLA224-ND/1025050

Then you won't need the transistor and relay... the device will do both making your circuit simpler. Here is the datasheet
http://www.clare.com/home/pdfs.nsf/0/E16FD7FE1462A2DD852570F800586DFD/$file/CPC1972.pdf

Just need a dropping resistor for the input... but that's pretty simple.

Jerry

ray74 (author)  askjerry2 years ago
Thank you Jerry. I will check it out and let you know how it goes.
not really ... my experiments told me that they are using cross matrix key pads. Therefore I used cmos switches to implement a "remote keyboard"
http://www.instructables.com/id/Samsung-MOD-fixed-...-mobile-...-TV/
starlino2 years ago
If you ever revise the design consider using digital switches instead of relays. Great work.
ray74 (author)  starlino2 years ago
I have not tried digital switches yet. Thank you.
This is epic &I admire your technique. Another good reason to keep old cell phones!
ray74 (author)  moebuspcgold2 years ago
Thank you. I enjoy taking them apart. :)
jolshefsky2 years ago
This is a really (relay, ha) cool idea. I too have seen the allure of cell phone modules, but it's more likely I'd want something cheap that I can guarantee will be permitted on a prepaid network.

You may be able to simplify your circuitry a lot. The keypad probably uses the ever-common "pull high, connect to ground" model of switches (that is, one side of each button is tied to an input pin somewhere and a high resistance pulls it to +V and the other side is connected to ground so when the button is pushed, the input sees 0V, otherwise +V.) If that's the case, you can then go with one wire to each button pad and one wire to a common ground. Also, since your phone is isolated from your Arduino, you can then just use an NPN transistor with the collector connected to the button pad and the emitter to the common ground which you'd then tie to the Arduino's ground. The transistor driver for the relay can then be used without the relay. I hope that's clear enough!
ray74 (author)  jolshefsky2 years ago
Thank you. And thanks for the advice.
agis682 years ago
this job is epic and chaotic on my eyes. You could had the same extact result using a nano duino or even if you the atmgega chip and then only the complete cellphone without be in so much trouble to transfer the keypad and screen on a prototype board. Connected by a cheap shield on the phone and all are ok....ofcourse the code remains. Tell me please why someone do all this trouble....the only anser for me is only to get more knowledge and some experience....but if you are so good with arduino there's no need all this. Simplicity my friend is the first rule of a scientist
paqrat2 years ago
Perhaps it is because I have little knowledge of electronics but I fail to see what this is for. You appear to have put much time and thought into it and it may be the greatest thing since sliced bread but I have not been able to decipher what its function is. What does this do? How would one use it? Why would I want to go to what was apparently a lot of labor to make these modifications?
Ummm... Couldn't you simply send AT commands to your cell phone using arduino? You can possibly do all you wanted to do here. And your phone would remain intact.
it works for some phones using AT-commands only. I did that with an old Siemens phone, that I connected to my Linux server.
http://www.instructables.com/id/The-S45-SMS-Alarming-System/
I am not shure how this works with Samsung phones. But I belive that it is possible, ate least using properitary AT codes of the manufacturer.
There I found an old manual of a device I also used for receiving and sending SMS messages with a computer.
http://www.falcom.de/uploads/media/a2dman.pdf
Maybe theses AT-commands work for other devices too ...
AndyPipkin2 years ago
Couldn't you use the Arduino to write AT commands to the phone as a modem, to send SMS?
james.m.k2 years ago
OK, are you saying that you can use these "Open Relays" at no cost other than keeping your phone active? Otherwise what's the point?

I, for instance, use TracFone, and get charged for every single message I send or receive. Though I do still have an older phone that gave me free messaging.

What would be REALLY neat would be if you could mount it all in a case small enough to fit in your pocket!

What would be the ultimate in cool is if you could still use it for sending and receiving calls. Then you wouldn't be forced to carry two phones, one for texting, and one for calls.
florinc2 years ago
A much easier and cheaper solution is using a GPRS shield, like this one
http://www.seeedstudio.com/depot/gprs-shield-p-779.html?cPath=132_134
with an Arduino.
I don't understand what this is doing. Is it using the arduino to act as a keyboard, taking it's input from the switches & using the relays to "Push" the same key on the phone ????
ray74 (author)  Lectric Wizard2 years ago
Hello Lectric Wizard,
The relays are controlled by the Arduino that is running the program. The Arduino doesn't actually monitor the buttons. The buttons are there so you may interface to the phone should you need to.
Thank you for the question.