•

Published June 1, 2026 © MIT

Showing Muscles with Capacitive Sensing

Follow us as we downscale an existing humanoid robotics demo to tabletop size and control the movement using capacitive sensing!

AdvancedFull instructions provided10 hours186

Things used in this project

Hardware components

Infineon CY8CPROTO-040T PSOC™ 4000T CAPSENSE™ prototyping kit

Servo motor e.g. S-7361

Other servos can be used; Please check in this case the mounting holes and opening; Mounting screws for the base and arm, should be provided with the servo motor;

USB Cable, USB Type C Plug

Used for programming and power supply.

Threaded insert M3

Insert for upper arm

M3x10 cylinder head screw

Connecting base to upper arm

Rubber feet

You can also reuse the ones which come on the bottom of the eval board

Acrylic glass

Optional part, thickness to be added and checked

Software apps and online services

Infineon ModusToolbox™ Software

Hand tools and fabrication machines

Soldering iron (generic)

3D Printer (generic)

Laser cutter (generic)

Optional, only needed if casing is wanted

Story

Introduction: From Large to Small

One of our latest demonstrators is focused around humanoid robots. More specifically, we have showcased a human-sized arm lifting a 2 kg dumbbell and highlighting position control performance as well as the compact 1kW inverter used as a motor driver. More info can be found here: https://community.infineon.com/t5/Blogs/Compact-1-kW-GaN-motor-drive-for-humanoid-robot-arms/ba-p/980886

As the demo drew a lot of attention, we wanted to make it possible for everyone to have their own tabletop humanoid demo. Here, the PSOC™ 4000T CAPSENSE™ prototyping kit comes into play, acting as both the base and human machine interface, allowing users to move the arm with touch commands.

By following this guide, and you will have your own small humanoid robotic arm on your table.

3D printing

Let’s start with the necessary 3D prints, which can already print while we focus on the software environment. In total, there is 3 different parts that need to be 3D printed, the base, the forearm and the upper arm.

All needed 3D-printed parts

For the base, we decided to go for a Marble PLA to give it a nice finish without distracting too much from the arm itself, for which we used PLA Metal Oxide Green, both from Bambu Lab. In case you are using a different servo, don't forget to double-check the dimensions, as the opening or screws need to be adjusted to fit. Both the upper arm and forearm were printed in an upright orientation. Especially for the fingers, take some time to figure out the best placement for the support structure.

Eval Board

While the 3D printer is doing it's part, let's have a look at the Eval board. The CY8CPROTO-040T is our CAPSENSE™ prototyping kit and comes with a pre-flashed software and a lot of documentation, including a Quick Start Guide and a user guide. You can find all of this information here: https://www.infineon.com/evaluation-board/CY8CPROTO-040T

It is best to take 5 minutes to look through the Quick Start Guide found in the documents section of the page and familiarize yourself with the hardware and features of the board.

Before we get hands-on and connect the board to the servo motor, let's first get the software running so we only need to solder the servo motor to the board.

Software

To develop the software for this project, we'll be using ModusToolbox: Infineon's development ecosystem, that supports a wide range of microcontroller devices. To get started, download and install ModusToolbox by following the instructions in the official ModusToolbox Software Installation Guide. Don´t forget to accept the default options during the installation process.

Once installed, launch the ModusToolbox Dashboard and open your preferred Integrated Development Environment (IDE). For this example, we'll be using the default IDE, Eclipse.

Launch your development environment from the ModusToolbox Dashboard

To create a new application, click the New Application link in the Quick Panel. This will launch the Project Creator tool in Eclipse, allowing you to start a new project.

Launch the Project Creator tool in Eclipse

With the Project Creator tool open, expand the PSOC 4 BSP category under Kit Name. Then, select the CY8PROTO-040T kit from the available options. This will configure your project for the correct hardware.

Choose Board Support Package (BSP)

Click Next > to proceed to the Select Application page. On this page, you'll see a list of template Applications available for the selected BSP, organized by category. For this project, expand the Sensing category and select the CY8PROTO-040T Demo template application. This will provide a foundation for our project, which we can then modify and extend as needed. Before proceeding, change the New Application Name and New BSP Name to "MiniRobotArm".

Select Application Template

With our project created, launch the Device Configurator from the Quick Panel to set up the peripherals.

Launch the Device Configurator in Eclipse

First, disable the Serial Communication Block (SCB) 1, since it is not needed. Next, enable the resource TCPWM 16-bit Counter 0 and set its personality to PWM-1.0. This will be used to generate the control signal for the servo motor. In the parameter panel, make the following changes:

Set the name of the resource to CYBSP_PWM.
Configure the Clock Prescaler to Divide by 4.
Set the Period to 48000 and the Compare value to 24000.
Select 16-bit Divider 0 clk as the Clock Signal Input.
Assign the PWM output to P2[2] digital_out.

TCPWM 16-bit Counter 0 settings

Then, move on to the TCPWM 16-bit Counter 1 resource. This resource will be used to trigger an interrupt service routine, responsible for updating the duty cycle values for the servo motor. Rename it to CYBSP_TIMER and set its personality to Counter-1.0. In the Parameter panel, update the following settings:

Set the Clock Prescaler to Divide by 4.
Set the period to 48000 and the Compare value to 24000.
Select Overflow & Underflow as Interrupt Source.
Again, select 16-bit Divider 0 clk as the Clock Signal Input.

TCPWM 16-bit Counter 1 settings

Last, switch to the Pins tab and configure the settings for pin P2[2], which is used to drive the servo motor. Set the Drive Mode to Strong Drive,Input buffer off.

Setting the Drive Mode of pin P2[2]

Save your changes in the Device Configurator by going to File > Save. Then, close the Device Configurator. Next, locate the main.c file in the Project Explorer and open it. Replace the application template code with the code provided in the main.c file in the Code section. With the code updated, we're now ready to program the application to the microcontroller. To do this, click on MiniRobotArm Program in the Quick Start Panel. This will initiate the programming process.

Flash program to microcontroller

Instead of setting up the project manually, the archive file MiniRobotArm.zip is attached for use. This file contains the complete ModusToolbox project. To use it, extract the contents of the zip file and follow the instructions outlined in the included readme file, which provides a step-by-step guidance on importing and setting up the project.

Assembly

Once the firmware is flashed and the 3D-printed parts are ready, let's start with the assembly! In order to connect the servo motor to the board, we recommend to solder them directly to the respective pins on the PCB as indicated in the figure. As a first step, cut away the header of the servo connector right on the plastic connector so to keep the cables as long as possible. The final trimming will be done just before the assembly for a tidy cable management.

Where to connect the servo motor to the CY8CPROTO-040T

We are using Pin6 on connector j9, which is connected to P2.2, as the signal pin instead of the marked pins next to the CAPSENSE™ area, so that the touch area is not obstructed.

In order to P2.2 to be connected to the MCU, make sure the slider switch SW2 is in the left position at I2C. The power supply for the servo can be taken from j4 in the debug section of the board.

Now the servo motor should be mounted onto the base. To do this, place the servo into the opening in the base.

Feed the cable through this opening and layout the cables to the respective pins they need to be soldered and only then cut the cables to the needed length.

Afterward, feed the cables through the small opening to keep everything nice and tidy. Then, place the eval board into the base and check on how long the cables need to be. Depending on the model of the board, it may come with rubber feet attached. These should be removed first, but can be reused and attached to the bottom of the base.

For the cabling, we recommend a layout similar to the one in the picture. The cables do not need to be super stretched; it is better to have a few millimeters spare in case something goes wrong during soldering. Once the cables are cut to their final length, remove the isolation and solder them to the respective pins. Best to remove the eval board from the base, to avoid burning the plastic of the base.

Once this is done, the servo can be screwed onto the base and the board can be clipped in. Then, let's go ahead with the first functional test.

First Test

Before mounting the forearm, we need to make sure that the servo shaft is in the "lower" position, which is defined as the starting position for the robot arm. Therefore, simply make sure the switch SW2 on the board is set to the left (marked I2C), and then connect the board via USB-C. Depending on the position of the servo, you should hear it moving. Then you can already go ahead and test the CAPSENSE™ functionality.

Before mounting the arm, it is best to disconnect and reconnect the USB-C cable, after which the servo will move to its start position. Once this is done, you can go ahead and mount the forearm. Make sure not to rotate the servo while mounting, and fix the arm at a position where the back of the forearm is nearly touching the base and the switch SW2. As this will be the starting position, all movements will be based on it.

Recommended mounting position of the forearm. This is also the starting position from which all other movements are based on.

Final Assembly

To wrap up the build, we still need to install the upper arm as well as, optionally, the acrylic housing and rubber feet. For the upper arm, the M3 threaded insert needs to be molded into the 3D print. In case you have never worked with this kind of insert, this a good starting point for information. As the upper arm doesn't need to be perfectly flush and the insert doesn't need to be at a specific angle, this may also be good practice for a first try. After the insert is in place, you can then use an M3x10 cylinder head screw to mount the upper arm to the base.

Example on how it should look like; If it is not perfect, don't worry it is anyways hidden from sight.

Ready for pumping iron

Optional Steps

There are still two optional steps that one can do. First, it is beneficial to mount some rubber feet to the bottom of the base. You can either buy some of them cheaply online, or you can reuse the ones that were mounted on the back of the kit.

If you also have access to a laser cutter, we have uploaded the DXF files for an acrylic housing. It consists of 5 individual parts that need to be glued together at their edges. The last step is a bit tedious and one needs to work very cleanly in order not to get super glue where it doesn't belong.

Also, before gluing, it is best to do a dry run by placing the pieces onto the base and clearly identifying the face on which each part must be glued. The two small side walls are sandwiched between the two large panels, and the top surface is glued onto the sides of each wall, not the other way around.

Individual parts with the green cover still on and how it should look at the end

Code

/*******************************************************************************
 * File Name: main.c
 * Author: P. Haselwanter
 * Date: 22-04-2026
 * Company: Infineon Technologies Austria AG
 *******************************************************************************
 Firmware for the Mini Robotic Arm Project using the CY8CPROTO-040T PSoC 4000T
 CAPSENSE Prototyping Kit. This software controls a 3D printed robotic arm
 actuated by a servo motor, utilizing the TCPWM block. The system reads input
 from CAPSENSE buttons and sliders, allowing for modification of the robotic
 arm's position based on sensor data.
 ******************************************************************************/

/*******************************************************************************
 * Include header files
 ******************************************************************************/
#include "cy_result.h"
#include "cy_syslib.h"
#include "cy_tcpwm.h"
#include "cy_tcpwm_counter.h"
#include "cy_tcpwm_pwm.h"
#include "cybsp.h"
#include "cycfg_capsense.h"
#include "cy_capsense_sensing.h"
#include "cy_capsense_structure.h"
#include "cy_gpio.h"
#include "cycfg_peripherals.h"
#include "gpio_psoc4000t_24_qfn.h"

/*******************************************************************************
 * Macros
 ******************************************************************************/
/* Define macros for interrupt priorities */
#define CAPSENSE_MSC0_INTR_PRIORITY     (3u)
#define TCPWM_COUNTER1_INTR_PRIORITY	(2u)

#define CY_ASSERT_FAILED                (0u)

/* Define macros for LED states */
#define CYBSP_LED_OFF                   (0u)
#define CYBSP_LED_ON                    (1u)

/* Define macros for minimum and maximum duty cycles */
#define MIN_DUTY_CYCLE					(45.0f)
#define MAX_DUTY_CYCLE					(58.0f)

/*******************************************************************************
 * Global variables
 ******************************************************************************/
/* Define a struct to hold servo data */
typedef struct
{
	float32_t target_duty;
	float32_t current_duty;
} servo_data_t;
/* Initialize a servo_data_t struct with duty cycle values */
servo_data_t servo = {MIN_DUTY_CYCLE,MIN_DUTY_CYCLE};

/*******************************************************************************
 * Function prototypes
 ******************************************************************************/
static void initialize_gpio(void);
static void initialize_pwm(void);
static uint32_t get_pwm_compare_value(float32_t);
static void initialize_timer(void);
static void tcpwm_counter1_isr(void);
static void initialize_capsense(void);
static void capsense_msc0_isr(void);
static void process_touch(void);

/*******************************************************************************
 * Function Name: main
 ******************************************************************************/
int main(void)
{
	cy_rslt_t result;
	/* Initialize the board */
	result = cybsp_init();

	/* Check if board initialization was successful */
	if(result != CY_RSLT_SUCCESS)
	{
		/* If not, stop program execution */
		CY_ASSERT(CY_ASSERT_FAILED);
	}

	/* Enable global interrupts*/
	__enable_irq();
	/* Initialize peripherals */
	initialize_gpio();
	initialize_pwm();
	initialize_timer();
	initialize_capsense();
	/* Main loop: scan CAPSENSE widgets and process touch events */
	while(1)
	{
		Cy_CapSense_ScanAllSlots(&cy_capsense_context);
		/* Wait for scan to finish */
		while(Cy_CapSense_IsBusy(&cy_capsense_context));
		/* Process touch events */
		process_touch();
	}
	return 0;
}

/*******************************************************************************
 * Function Name: initialize_gpio
 ******************************************************************************/
static void initialize_gpio(void)
{
	/* Set LED2 to off state */
	Cy_GPIO_Write(P3_0_PORT,P3_0_NUM,CYBSP_LED_OFF);
	/* Set LED3 to off state */
	Cy_GPIO_Write(P1_0_PORT,P1_0_NUM,CYBSP_LED_ON);
}

/*******************************************************************************
 * Function Name: initialize_pwm
 ******************************************************************************/
static void initialize_pwm(void)
{
	Cy_TCPWM_PWM_Init(CYBSP_PWM_HW,CYBSP_PWM_NUM, &CYBSP_PWM_config);
	/* Enable the initialized PWM */
	Cy_TCPWM_PWM_Enable(CYBSP_PWM_HW,CYBSP_PWM_NUM);
	/* Set initial compare value*/
	Cy_TCPWM_PWM_SetCompare0(CYBSP_PWM_HW,CYBSP_PWM_NUM,get_pwm_compare_value(MIN_DUTY_CYCLE));
	/* Then start the PWM */
	Cy_TCPWM_TriggerReloadOrIndex(CYBSP_PWM_HW,CYBSP_PWM_MASK);
}

/*******************************************************************************
 * Function Name: get_pwm_compare_value
 ******************************************************************************/
static uint32_t get_pwm_compare_value(float32_t duty_cycle)
{
	return (uint32_t)(CYBSP_PWM_config.period0*duty_cycle/100.0);
}


/*******************************************************************************
 * Function Name: initialize_timer
 ******************************************************************************/
static void initialize_timer(void)
{
	Cy_TCPWM_Counter_Init(CYBSP_TIMER_HW,CYBSP_TIMER_NUM,&CYBSP_TIMER_config);
	/* Enable the initialized counter */
	Cy_TCPWM_Counter_Enable(CYBSP_TIMER_HW,CYBSP_TIMER_NUM);
	/* Then start the counter */
	 Cy_TCPWM_TriggerStart(CYBSP_TIMER_HW,CYBSP_TIMER_MASK);
	 /* Interrupt configuration*/
	 const cy_stc_sysint_t tcpwm_counter1_interrupt_config =
    {
		.intrSrc = CYBSP_TIMER_IRQ,
		.intrPriority = TCPWM_COUNTER1_INTR_PRIORITY,
    };
	 /* Initialize interrupt */
	 Cy_SysInt_Init(&tcpwm_counter1_interrupt_config,tcpwm_counter1_isr);
	 NVIC_ClearPendingIRQ(tcpwm_counter1_interrupt_config.intrSrc);
	 NVIC_EnableIRQ(tcpwm_counter1_interrupt_config.intrSrc);
}

static void tcpwm_counter1_isr(void)
{
	static int led_ctr = 0;
	static int servo_inact_ctr = 0;
	
	Cy_TCPWM_ClearInterrupt(CYBSP_TIMER_HW,CYBSP_TIMER_NUM, CY_TCPWM_INT_ON_TC);
	
	if(servo.current_duty < (servo.target_duty - 0.15))
	{
		/* Target duty cycle not reached - increment current duty cycle */
		servo.current_duty += 0.2;
		Cy_TCPWM_PWM_Enable(CYBSP_PWM_HW,CYBSP_PWM_NUM);
		Cy_TCPWM_PWM_SetCompare0(CYBSP_PWM_HW,CYBSP_PWM_NUM,get_pwm_compare_value(servo.current_duty));
		Cy_TCPWM_TriggerReloadOrIndex(CYBSP_PWM_HW,CYBSP_PWM_MASK);
		servo_inact_ctr = 0;
	}
	else if(servo.current_duty > (servo.target_duty + 0.15))
	{
		/* Target duty cycle not reached - decrement current duty cycle */
		servo.current_duty -= 0.2;
		Cy_TCPWM_PWM_Enable(CYBSP_PWM_HW,CYBSP_PWM_NUM);
		Cy_TCPWM_PWM_SetCompare0(CYBSP_PWM_HW,CYBSP_PWM_NUM,get_pwm_compare_value(servo.current_duty));
		Cy_TCPWM_TriggerReloadOrIndex(CYBSP_PWM_HW,CYBSP_PWM_MASK);
		servo_inact_ctr = 0;
	}
	else
	{
		servo_inact_ctr++;
	}
	/* Disable the PWM if the servo is inactive for the given period */
	if(servo_inact_ctr == 50)
	{
		Cy_TCPWM_PWM_Disable(CYBSP_PWM_HW,CYBSP_PWM_NUM);
	}
	
	if(led_ctr == 200)
	{	
		/* LED2 toggle */
		Cy_GPIO_Inv(P3_0_PORT,P3_0_NUM);
		/* LED3 toggle */
		Cy_GPIO_Inv(P1_0_PORT,P1_0_NUM);
		led_ctr = 0;
	}
	led_ctr++;
}

/*******************************************************************************
 * Function Name: initialize_capsense
 ******************************************************************************/
static void initialize_capsense(void)
{
	cy_capsense_status_t status = CY_CAPSENSE_STATUS_SUCCESS;

    /* CAPSENSE&trade; interrupt configuration MSCLP 0 */
    const cy_stc_sysint_t capsense_msc0_interrupt_config =
    {
		.intrSrc = CY_MSCLP0_LP_IRQ,
		.intrPriority = CAPSENSE_MSC0_INTR_PRIORITY,
    };

    /* Capture the MSC HW block and initialize it to the default state. */
    status = Cy_CapSense_Init(&cy_capsense_context);

    if(CY_CAPSENSE_STATUS_SUCCESS == status)
    {
		/* Initialize CAPSENSE&trade; interrupt for MSC 0 */
        Cy_SysInt_Init(&capsense_msc0_interrupt_config, capsense_msc0_isr);
        NVIC_ClearPendingIRQ(capsense_msc0_interrupt_config.intrSrc);
        NVIC_EnableIRQ(capsense_msc0_interrupt_config.intrSrc);

        status = Cy_CapSense_Enable(&cy_capsense_context);
    }

    if(status != CY_CAPSENSE_STATUS_SUCCESS)
    {
        /* This status could fail before tuning the sensors correctly.
         * Ensure that this function passes after the CAPSENSE&trade; sensors are tuned
         * as per procedure give in the Readme.md file */
    }
}

/*******************************************************************************
 * Function Name: capsense_msc0_isr
 ******************************************************************************/
static void capsense_msc0_isr(void)
{
    Cy_CapSense_InterruptHandler(CY_MSCLP0_HW, &cy_capsense_context);
}

/*******************************************************************************
 * Function Name: process_touch
 ******************************************************************************/
static void process_touch(void)
{
	uint32_t button0_status;
    uint32_t button1_status;
	cy_stc_capsense_touch_t *slider_touch_info;
	uint16_t slider_pos;
    uint8_t slider_touch_status;
	
	/* Initialize static variables to store previous touch status */
	static uint32_t button0_status_prev;
    static uint32_t button1_status_prev;
    static uint16_t slider_pos_prev;
	
	Cy_CapSense_ProcessAllWidgets(&cy_capsense_context);
	/* Get button0 status*/
	button0_status = Cy_CapSense_IsWidgetActive(CY_CAPSENSE_BUTTON0_WDGT_ID, &cy_capsense_context);
	/* Get button1 status*/
	button1_status = Cy_CapSense_IsWidgetActive(CY_CAPSENSE_BUTTON1_WDGT_ID, &cy_capsense_context);
	/* Get slider status */
	slider_touch_info = Cy_CapSense_GetTouchInfo(CY_CAPSENSE_LINEARSLIDER0_WDGT_ID, &cy_capsense_context);
	slider_touch_status = slider_touch_info->numPosition;
   	slider_pos = slider_touch_info->ptrPosition->x;

	/* Detect new touch on button0 */
	if((0u != button0_status) && (0u == button0_status_prev))
	{
		servo.target_duty = MAX_DUTY_CYCLE;
	}
	/* Detect new touch on button1*/
	if ((0u != button1_status) && (0u == button1_status_prev))
	{
		servo.target_duty = MIN_DUTY_CYCLE;
	}
	/* Detect new touches on the slider*/
	if ((0 != slider_touch_status) && (slider_pos != slider_pos_prev))
	{
		/* Set the target duty cycle based on the slider position */
		servo.target_duty = (float32_t)(slider_pos*100)/cy_capsense_context.ptrWdConfig[CY_CAPSENSE_LINEARSLIDER0_WDGT_ID].xResolution;
		servo.target_duty = ((MAX_DUTY_CYCLE-MIN_DUTY_CYCLE)*(1-servo.target_duty/100)) + MIN_DUTY_CYCLE;
	}
	
	/* Update previous touch status */
    button0_status_prev = button0_status;
    button1_status_prev = button1_status;
    slider_pos_prev = slider_pos;
}
/* [] END OF FILE */

Showing Muscles with Capacitive Sensing