# How many concurrent senders can CDMA support for a code length of n?

I understand how CDMA works (kind of). I'm just not sure how to go about figuring out how many orthogonal signals can be produced from a code length of a given number.

• There's some really, really hairy math to get that number. I took a grad course in wireless and we didn't cover that formula. Have you tried Google Scholar? This is definitely something that would have ended up in a publication. Nov 30, 2011 at 2:27
• I haven't tried it. I read the book we have and went over the lecture notes. This is an entry level networking class for my undergrad degree. I'm feeling a little overwhelmed by this question. Nov 30, 2011 at 3:12
• @MikeDeSimone I am not sure what the hairy math that you are talking about would be. The only thing I can think of is when you start to look more at power usage, noise, etc. Nov 30, 2011 at 13:58
• The hairy math was in identifying the needed code patterns. Your example is simple, but it looks like TDMA, and I thought that you could get more users than code bits if you were willing to trade off some interference. (Noise isn't nearly as much of an issue in cell phone systems as interference, so they usually speak of an S/I ratio.) In other words, I see your solution as a lower bound, but I'm not sure it has to be an upper bound. Dec 1, 2011 at 3:58
• @MikeDeSimone The OP specifically asked about orthogonal signals which is what I answered to. This is not TDMA at all as the orthogonal domain that I am talking about is the code domain, not the time domain. If you increase your codes beyond what I have described, you will be almost guaranteed to have bit errors when all of your users are talking concurrently, which is also what he asked about. Dec 1, 2011 at 14:53

Note: I am going to go into a bit of the algebra that goes into understanding CDMA fully. It might be a little overwhelming at first, but I will try to keep it as simple as I can. If you just want the answer, jump to the bottom, but it really isn't as difficult as you might think. Also, I am an engineer, not a mathematician, and many of the things engineers do with math drive mathematician crazy. I may simplify things to the point that the math gets a little fuzzy, but it is all for the sake of understanding.

In order to fully understand how many concurrent senders you can have, you need to step back and make sure you understand what it means to be orthogonal. The simplest way to look at orthogonality is to visualize it in a 2-d or 3-d plane. 2 vectors are orthogonal when they are at 90* angles of each other. So for a 2d plane you get something like this:

These two vectors might be represented as something like [01] and [10].

As it works out, there is no way for you to add a 3rd vector to those existing 2 vectors and and have it also be at a 90* angle to both existing vectors. It is possible to add a line that would be at a 90* angle to one of the existing lines, but not both, you should be able to see that visually. This can also be called a basis set, but that isn't overly important unless you want to dive deeper.

This then can also be extended visually into a length 3 vector space which shown graphically is like this:

where the line to the bottom left is actually coming out at you in a 3d model. As you can see we were able to add 1 more vector that is at 90* to both of the existing two vectors. We were unable to do this until we extended the length of our vector to 3. These 3 vectors could be represented as [100] [010] and [001].

So as you hopefully can see from my above examples, you are able to have N vectors that are orthogonal to each other when the vectors are of length N. In other words. Length 2 means you can get 2 orthogonal vectors out of it, length 3 means you can get 3 orthogonal vectors out of it.

Now, how does that apply to CDMA and number of users? Well each CDMA channel is created by an orthogonal code, so you can support as many concurrent users as you have orthogonal codes, and you can have as many orthogonal codes as you have length of the code. (if you need more help understanding this part I will be willing to add more, just let me know)

So to summarize, a length N code results in being able to support N number of concurrent users.

• Thank you for the help. Your answer is a lot more in depth than that of the professor or the text book. Dec 1, 2011 at 14:37