Why did most concurrent programming languages adopt the CSP model, and didn't use CCS or Pi calculus?

I'll answer the question by asking a new one: why do you think that "most of concurrent programming languages adopted CSP"? To the best of my knowledge, just http://en.wikipedia.org/wiki/Occam_(programming_language) and http://en.wikipedia.org/wiki/Go_(programming_language) adopted and were influenced by CSP. I'd say that most of concurrent languages nowadays were influenced more by the http://en.wikipedia.org/wiki/Actor_model. Regarding the answer, I think it is difficult to say. If you were to implement a new programming language, most probably the concurrent primitives of your choice will shape the language too, and the scope your language is trying to cover. For example, http://en.wikipedia.org/wiki/Erlang_(programming_language) adopted the Actor model, which made it possible to implement distribution in a very natural way, thanks to the inherent asyncronicity of the model. On the other hand, Go went for sinchronous meesage passing derived from CSP, which (despite inital efforts) proved difficult to allow for a naturally distributed system. I'm not saying that you cannot code distributed systems in Go - of course you can -, but you will need to use something else than channels to communicate between nodes, while in erlang you can transparently send messages to local and distributed processes. And yet, that limitation could also be a reason to go for CSP instead of a more complex model: analysing runtime performances of CSP is somewhat easier than in Pi calculus, because you know when context switch will occur (at message sending), and you don't have to think about unbound growth of Actors mailboxes (since communication is synchonous, no mailbox is necessary).

CSP and the "actor model" are variations on the theme of FSMs with message passing. Hardware description languages are quite good at the FSM piece, but not that good on the message passing, while Erlang is quite good at the communication piece (but ugly otherwise). Any paradigm that is OO and avoids shared memory is a good start. The advantage of CSP is it actually lets you talk about the communication channels, while most other approaches only talk about end-points (e.g. MPI).