Capacitive Touch Sensing using a Coin & ARM Cortex M4

Couple of years ago, I bought a Capsense add-on from Texas Instruments for MSP-430 Launchpad. It worked right out of the box as expected but a closer observation showed me that the board was nothing but a colored copper plate PCB with catchy SMD LEDS beneath. Curiosity drove me to internet and books which taught me the concept of Capacitive touch sensing. Armed with the following tools, I set myself to make my own capacitive sensor circuit.

Components Used:

Stellaris LM4F120XL ARM Cortex M4F board
Resistors - 2 x 2.2 M ohm
Wires + Conductive surface ( I used a Coin)

PROJECT:

The aim to design a simple capacitive touch sensing circuit and code an ARM cortex microcontroller to sense the capacitance change when a human touches the sensor.

STELLARIS LM4F120XL:

The Stellaris launchpad from Texas Instruments is the main processing core of the project.

The following are its features

ARM - Cortex M4F core ( Floating point)
256 KB Flash and 32 KB Flash, 2KB EEPROM
2 x 12-bit Analog to Digital Converter
USB, UART, SPI and lot more

SCHEMATIC:

WORKING:

The stellaris microcontroller powers this RC circuit through one of its GPIO Port and scans for voltage across the capacitor( conductive surface). Human finger has finger capacitance which is in the order of pico farads. So, when I touch the surface, it affects the surface capacitance of the conductor ( a coin here ) which in turn affects the charging time of the capacitor.

Many designs employ ADC to achieve CapSense; but I have used a simple General Purpose Input port to sense it using the fact that any voltage above 1.8V will be seen as HIGH by the microcontroller. So we calculate the approximate number of CPU cycles required to 'see' the input pin as HIGH.

The voltage across the capacitor should charge above 1.8V to be sensed as HIGH.

Consider the following equation:

Voltage across the capacitor after time 't' in an RC circuit is given as

Vc= V ( 1- e^(-t/RC) )

Here I have used 2 x 2.2 Megaohm resistors in place of R. Since the capacitance value is extremely small (in pFs) we need a larger resistance to limit the current going to the capacitor to charge it. So a larger value of R implies slower charging time.

Even at this value, the charging time is in microseconds.

But, the microcontroller is running at 80MHz which means 0.0125us is one cycle !! This is precise enough to calculate the number of cycles it takes to charge to 1.8V after the supply port to RC circuit is turned HIGH.

Results:

Cycles it took to charge prior to the touch : 30 -40

Cycles it took to charge after the touch : 100 - 700 ( Range depends on finger position)

DEMO:

Comments

Shell Scripting to Display Bar Graphs in Linux Terminal

This week was quite hectic for me with course assignments and their merciless deadlines. One such assignment in Advanced Computer Architecture was simulation of various benchmarks in alpha architecture in simplescalar , a well-known computer architecture simulator. I was supposed to run a total of 4 benchmarks with different configurations of cache memory, instruction issue widths, commit widths, in-order execution modes, etc and I had to plot the required performance parameters for every benchmark. A conservative estimate would be around 40 plots! Since the simulation platform was Linux, I could breathe a sigh of relief since most things can be automated using a powerful tool called shell. Scripting made my life easier here since I can automate a bunch of simulations without having to keep an eye on each and every simulation which would take anywhere from 20 minutes to 20 hours. The problem arose when it came to plotting the performance results. Because, each simulation

Programming STM32 ARM microcontrollers in Arch Linux

Once upon a time, not so long ago, the 8-bit microcontrollers were ruling the hobbyist embedded world. But today, the 32-bit ARM Cortex Microcontrollers are so inexpensive and power efficient that there is no good reason to ignore them. Here, let us see how to program a STM32 ARM cortex Microcontroller in Linux environment. The specific microcontroller used here is an STM32F103C8 (ARM cortex M3) programmed in Arch linux. Components Generic STM32F103 board (blue pill) STLINK-V2 (STM32 programmer) Female-Female connectors All the above components can be bought from ebay for less than $10 total. The STLINK-V2 is optional since you can use any of USB-SERIAL converters like FT232, CP2102, PL2303, CH340 and the built-in UART bootloader of STM32 chip to program. So if you already have any of the above serial converters, you don't really need STLINK to program the STM32F103 microcontroller. But STLINK helps if you plan to use in circuit debugging functionalities. Software The

JTAG - Test Access Port (TAP)Controller based Xilinx FPGA configuration using Raspberry Pi

JTAG - Joint Test Action Group is an IEEE 1149.1 standard used in many silicon devices for programming and debugging purposes. Xilinx FPGAs support this JTAG protocol for their configuration. Here I have designed a JTAG FPGA bitstream programmer using Raspberry Pi which programs the bit file into FPGA in fraction of seconds! JTAG physical bus has four lines: TMS (Test Mode Select) TDI (Test Data In) TDO (Test Data Out) TCK (Test Clock) Components Used: Raspberry-Pi Xilinx Spartan 3E FPGA (XC3S250E in Papilio One) Jumper wires BLOCK DIAGRAM: TAP CONTROLLER: The TAP(Test Access Port) controller is a state machine inside the FPGA which changes it's state based on TMS input. For instance, let us assume that the state machine is in " Test-Logic-Reset " state. Now if I drive the TMS pin low and toggle the TCK pin, the state machine will go to " Run-Test/ Idle " state. This is how we move to different states. Note

Electronics Adventures

Search This Blog