The matrix (like most keyboard matrices) is arranged with rows and columns. To read the matrix, you repeatedly put voltage on a single row (or column), and read all of the columns (or rows). For example, if you have rows A-D and columns 1-3, like on a telephone keypad, you could put voltage on column 1 and read rows A-D to see if any key in the first column was pressed. Then, switch to putting voltage on column B, and read rows A-D again. You need a total of (R+C) GPIO lines, with (say) all of the Rs configured as output and all of the Cs configured as input.

Another alternative is what Tari has suggested that I do for my TI-87 project (which is relevant, and which you should check out), where I may use a microcontroller to act as a keyboard controller for my Raspberry Pi clone.

It's not a terrible necropost, and you chose the right topic for it. No worries.

After looking through the bit of the chatlog from yesterday, we were on the topic of tearing down the main board to expose a pad to soldier something on to, as well as each row and column of keys being connected to a gpio port on the RPi to detect when x row and y column were blocked, it would send a pulse to put character z on screen.

So, that's not quite right. First, you're simplifying it a great deal. All that the keyboard does is give programs the opportunity to see if any key is being pressed. It's entirely up to the calculator's OS and programs to actually do anything with that information (like decide what character or word or menu it corresponds to, then talk to the LCD screen to display that character or word or menu). When I say that the keypad is an array of rows and columns, I mean that we have a series of rows where electrically, each row is connected across (but not to each other), and columns where each column is connected down (but not to each other). When you press a key on the keypad, it shorts a row to a column, so if you put a voltage on that key's row, a voltage will appear on that key's column. If you put a voltage on any other row, no voltage will appear on every column. By checking each combination of rows and columns, you can scan through all of the keys to see if they're pressed.

Hope that's clearer.

So do I not bother with the keypad and just rip apart the mainboard for that pad that can be soldiered?

You don't bother with which keypad? If your goal is to replicate my ongoing TI-87 project with minimal hardware, you probably want to find the points that correspond to the rows and columns of the keypad on your calculator's mainboard, then solder to those.

My project was to create a TI-84+cse out of a case and a RPi. From what you have said, if I tear apart the mainboard, there is a pad which can be connected to the RPi through soldiering. This can then read which key was pressed and then send that to the emulator, which would display it onscreen.

I have been searching for a while, and finally found a cheap Ti-84+cse on ebay ($2) Probably broken, but it doesn't matter as I'm only using it for the case and keyboard. Due to it being pink, I'm also getting a separate faceplate and slide case. Anyways, I have understood two different things, and they are different. One is that I would have to send voltage along the rows and columns of the keyboard, and connect each of the rows and columns to the RPi's GPIO ports. However, not all the keys line up. You have also mentioned that if I tear apart the mainboard some, there is a pad that connects to the keyboard, and if I soldier that, that's all I need to do. So which one should I do, and if it is the one with soldiering the pad, where is the pad and what should I use to soldier it? Also, should I use the screen already in the calculator, or should I get a different one to put in?
If at all possible, could I have a step by step guide of what to take apart and where to soldier each thing to?

If you're talking about this one, I guarantee it will sell for >$50, especially at this time of year. They are electrically arranged strictly in rows and columns, even though they don't physically form a perfect grid. No, I said that there are pads corresponding to each electrical row and column of the keyboard that you solder to, and that's what goes to the Raspberry Pi's GPIO. I doubt interfacing to the calculator's existing screen would be too easy, although since fbtft supports the ILI9340, and the calculator uses an ILI9335, it's possible you could use it.
Eventually, once I finish and document my TI-87 project.

So what I understand, at the beginning or end of each row/column, there is a small pad. If I solder each one of these to one of the GPIO pins on the raspberry pi, TilEm will read that and put it on screen. Also, for a beginner like me, what is the best tool to use for soldering. If I'm wrong, how would the RPi read the inputs and know what to put onscreen? Would it reqire a special program inside TilEm's files to interpret it?

So far here is what I know about the materials I am getting.
Case/pcb:Ti-82
Screen: http://amzn.to/1dZH67S
Soldering iron:http://amzn.to/1Rx9eym
RPi: model A+

If only I had bought the Ti-84 that gave me the idea for this project. It was already broken and selling for ridiculously cheap. If anyone else is reading this and has a Ti-84+CSE that you either don't need or is broken in some way, I would appreciate it if you could send it to me. Would that display be too small or is it ok?

That display should work, but you'll have to measure to determine if it will fit in the LCD aperture in the calculator's case. As you can see from this post in my TI-87 topic, a 2.4" screen may be too small for the opening. Of course, if your goal is to just have a working display, that shouldn't be a problem. Did you verify that that LCD can be interfaced with a Raspberry Pi?

That soldering iron looks fine; don't forget that you'll need a sponge (to wipe off the tip) and solder too.

Due to my inability to get a cheap TI-84 for my project, I have opted to use the TI-82 I got at a garage sale for $5, as they both use the same keyboard layout. My only question is where the pads for the rows and columns are, as I don't want to completely obliterate the main board. On a side note, are any of the chips worth keeping on the main board, or should I just take them off?

I have a few pictures of the Ti-82 I took closer to the start of my project, and in the folder are some unrelated iphone pictures.

If you're going to be interfacing directly with the keyboard, you'll probably want to remove the ASIC responsible for the peripherals on the TI-82 mainboard, and you'll have to use a multimeter in continuity-testing mode to figure out which of the pads the ASIC was using correspond to the rows and columns of the keyboard matrix.

For my edification what was this project for again, a class in school? If so, I'm not sure I should be spoon-feeding you the details of how to complete the project.

Sorry about that. I completely forgot to paste the link to the pictures. http://bit.ly/1Hhj709 The removed asic is in there too. How will I know which pads are the right ones? There are roughly 90 in there.

On the plus side, it looks like you removed the ASIC while damaging relatively few pads.

So essentially this: Obtain multimeter.
2: put it on each pad and trigger keys
3: Note which ones have a response
4:Solder GPIO's to responsive pads.
Is that about right?

Edit #1: With my luck, those few pads that are damaged are going to be the necessary ones.

Edit #2: So should I put one probe to a pad and the other to the key circles on the front of the board?

Edit #3: will this multimeter work? It looks like the lower red option has the right symbol.

In the future, please, oh please, do not post 4 messages in a row in 15 minutes. On Cemetech, this is called quadruple-posting, and even double-posting (replying to yourself before 24 hours have passed) is strongly frowned upon. In the future, please edit your post instead.

To answer your questions:
1) What multimeter? Any multimeter with the ability to measure resistance, which should be all multimeters, can be a continuity tester. You simply look for low/near-0-Ohm resistance
2) You should probe one key circle, then sweep around the pads where the ASIC was until you get a tone. You'll start finding a pattern.

I have previously asked these in the chat, however, you have been busy at the time, so I will post them here. First off, is it normal for the y= and 2nd keys to have pads all to themselves? Pads 8 and 9 up on the right side correspond only to those keys. If so, I may not have enough gpio pins. For the second question, how exactly do I solder to the gpios? I thought soldering was mainly for short distances, like an electronic glue. It seems like if I soldered all the way from the pads to the gpios, it would be a relatively long strand that would break easily.

I answered this twice on SAX soon after you asked each time. Yes, that's entirely possible. You solder a wire (24 AWG or preferably higher; 30 AWG would be ideal) to one pad, and the other end of the wire to the other pad (or in this case a connector for your RPi's GPIOs).

Ok, that makes a lot more sense.

Should it be a gpio ribbon with exposed ends?

Edit: I derped a lot.