Most small microcontrollers will be capable of doing what you need. You could even ditch the Arduino "wrapper" and use a USB capable micro in it's place.
Microchip, Atmel, TI, ST, etc all have 8, 16, 32-bit uCs of varying RAM/FLASH/EEPROM sizes to pick from. All the modern uCs come with at least UART, SPI, I2C peripherals that can be used for your communications.
There is not a lot in them really, I'd just pick one and see how you like it.
I (currently) use ST's 32-bit ARMs and Microchip 8, 16 ,32-bit PICs.
I'd probably use a few PIC12F or 16Fs for the slave uCs and a PIC18F or PIC24F for the master.
You mention needing ~10kbits of memory (not quite clear what type or which uC needs it from your description to me though)
It's easy to determine what is suitable though, just check the RAM/ROM/EEPROM specs of each uC you look at.
For example the PIC16F1938 has:
Parameter Name Value
Program Memory Type Flash
Program Memory (KB) 28
CPU Speed (MIPS) 8
RAM Bytes 1,024
Data EEPROM (bytes) 256
So 28KB of program memory is more than enough to store non-volatile data if your program is small enough (on the newer PICs you can also read/write to program memory at run time) 10kbits will not quite fit into the RAM though, at 1024 * 8 = 8192 bits.
The 16F1527 has 1536 bytes of RAM though, so you could use this if necessary.
For the master (alternatives to Arduino) there is something like the 18F25J50 or similar, which has a USB 2.0 peripheral. Microchip provide a USB stack an plenty of example firmware to get you started with USB.
If you need something more powerful for the master, have a look at the PIC24 series with up to 256K of Flash and 96K of RAM. Or even the PIC32 which is 32-bit and up to 80MIPS.
The PICKit3 is a low price programmer that will program all the above mentioned PICs, and MPLAB (or MPLABX) is a free IDE for firmware development.
Communication can be done with I2C, which deals with the master/slave configuration and addressing easily. All you have to worry about is sending the data. 7 meters should be no problem with a reasonably quiet environment and the right setup (low value pullups - say 2.2k, low capacitance cable)
No. The touch-panel controllers that you'll have access to are designed for building capacitive button panels like those that might be found above your laptop keyboard or on the side of your TV, not for building high-resolution touchscreens. Quoting the datasheet:
16.0 CAPACITIVE SENSING MODULE
In a typical application, the capacitive
sensing module is attached to a pad on a Printed
Circuit Board (PCB), which is electrically isolated from
the end user. When the end user places their finger
over the PCB pad, a capacitive load is added, causing
a frequency shift in the capacitive sensing module.
For an example application, check out Sparkfun's MPR121 keypad, which uses an IC that performs a similar function as the capacitive module in your PIC.
You can build a rudimentary X-Y touch panel with 16 horizontal pixels and 16 vertical pixels (or 20 and 12, or whatever) by laying out your PCB like this:
As shown by the blue line, every other horizontal row is connected by a trace on the back side of the PCB.
Real touchscreens are constructed in a similar fashion, but have hundreds or thousands of these rows and as many channels. The rows and columns are laid in transparent metal layers of indium-tin oxide on glass layers. If you have to ask, it's probably not in your budget. If you really want a capacitive touchscreen, you'll be better off reverse-engineering the output of the OEM module with the capacitive sensing already built in. Note that your PIC16 doesn't have the horsepower required to decode this information; you'll need a big ARM processor or an FPGA for that.
Best Answer
You say your lookup table will contain
50000elements and each element will have the range of-9999 to 9999. That means each element will need 16 bits (= 2 bytes) of memory. So the whole LUT will need50000 x 2 bytes = 100000 bytes = aprox. 97.6 Kbytes.Your microcontroller has 256 Kbytes of Flash memory and 32 Kbytes of RAM. So your program/Flash memory would be enough for the LUT. To place the table in program memory you need to declare it as const:
const int16_t LUT[] = { ... };