Capacitive Sensing Robot Arm

Introduction

For our final project, we built a 2 axis robot arm with a capacitive sensor on the final member, which will allow the robot to detect a person near the robot. When there is an object detected, the arm will stop depending on the measured capacitance. The purpose of this type of sensor is to allow robots and humans to work in the environment safely. Functionally, this product will allow a user to move around the robot arm with potentiometers to complete a task as desired. In addition to that, the user can work alongside the robot with the risk of injury mitigated by the capacitance sensor on the robot.

High level Design

The overall design of this project is broken up into three interconnected parts: the mechanical robot
arm, electrical hardware including the capacitive sensor, and the software which runs on the PIC32.
The robot design is based on using servo motors connected directly together via 3d printed parts.
Each of the servois controlled by a PWM signal from the PIC32 processor. Each joint has a corresponding
potentiometer with a current-limiting resistor that the user can use to control the position of the arm.
To do this, we used the on-board ADC to determine the current potential of the potentiometer. From there
we converted it to a % duty cycle to control the servo motor position.

For the capacitive sensor portion, we used copper foil surrounding the arm (a rod) that acts as a very simple
capacitor. We have a function to measure the capacitance of the foil by charging it and measuring the voltage
through ADC. The CTMU charges the foil for certain amount of time with pre-set current so we have the charge.
Then we can calculate the Capacitance using the formula C = q/v. After reading the capacitance, we use a software low pass filter to give us a steady and accurate reading with minimal gitter. If the change in capacitance is over a certain threshold, that indicates a person has gotten very close to the robot. Once this occurs, the robot arm stops all movement until the user has moved away and the capacitance reading is back to its original reading. One of the difficulties in this process is that different environments and robot positions lead to a different nominal capacitance which makes tuning of our system difficult but vital to our project’s success.

On the hardware side, one of the biggest trade offs we made was due to our limited time and budget constraints.
The robot arm is less aesthetically pleasing than we would have liked, but we wanted to focus our efforts on the novelty of using capacitance on a robot arm to sense a person. Additionally we used cheap servo motors, which worked well for our application, but do not have as smooth operation as it would be for a final product.

In designing the capacitive sensor, we brainstormed a few ideas and made various prototypes. The first full-scale prototype we created involved a network of intertwining lines that were separated by a small gap to keep the two circuits separate. In this design, we would use a more traditional-looking capacitor where one end is the anode and the other the cathode as seen below.

Fig.1 – copper foil with pattern

We had great success with this prototype where we were able to get clear and consistent readings. Below is a table of our test on this design.

Distance

ADC Reading(low pass version)

from 0 to 1023

Far Away

124-128

touching(cupping)

26-30

1cm flat

108-111

2cm flat

111-115

3cm flat

114-119

0.5cm flat

102-104

0.1 flat

94-99

1cm cupping

101-102

2cm cupping

104-107

3cm cupping

111-115

0.5cm cupping

93-97

0.1cm cupping

79-83

Although we were able to clearly read the capacitance change, we thought we could do better. Our final design was ironically our first idea and also the simplest of all the designs. This design consists of a single strip of copper foil wrapped around the arm as seen below. We believe this is the best design due to its large surface area since capacitance is linearly proportional to surface area.

Fig.2 – Plain copper foil

We again tested this with the same type of tests with the following results:

Distance

ADC Reading (low passed version)

from 0 to 1023

Far Away

101- 105

Touching (cupping)

43 – 46

1cm

91-95

2cm

96-100

3

99-102

.5

90-92

.1

80-83

1cm cupping

88-90

2cm cuping

93-96

3cm cup

94-99

.5 cup

82-85

.1 cup

78-82

When comparing the two final designs, it is clear that the single copper foil design has a greater change in
capacitance with a hand near it. With this knowledge in hand, we were able to focus on the software component of this project.

Hardware Design

3d printed parts

Our physical design consists of two servo motors with 180 degrees of rotation connected together to make a simple arm with two degrees of freedom. The base motor is mounted with a 3D printed part onto a piece of 2×6 wood which serves as a base to keep the arm in place. Connected to the base servo is another 3D printed mount which connects to the second servo motor. Finally, a final mount connects the second servo to the arm which is simply a piece of carbon fiber tubing. Below is a diagram of the robot arm made.

Fig.3 – Rendered Image of 2 Axis Robot Arm in Autodesk Inventor

Each of the pieces that were 3D printed were made using Autodesk Inventor. The design for this was to be as simple and effective as possible while using minimal material. The bottom piece has four slots for wood screws to mount the piece to the wood base in addition to 2 5mm holes to place threaded heat set inserts for M3 screws. Each part made has these slots which allows us to easily attach the pieces to the motors and the carbon tube.The image above shows the design as rendered which we did before building the prototype.

Hardware Components Overview

Prototyping Board

In addition to the robot arm hardware, we also designed a simple soldered prototyping board which allows us to easily connect and disconnect the PIC32, motors, and power supply. Additionally, it made the control of the robot very clean and consistent without any possible loose wires.

Fig.4 – prototyping board

As shown in the diagram, the user uses the two potentiometers on the bottom to control the position of each joint of the robot. The power to the system is provided by a power supply connected by the screw terminals on the right side. Additionally, a 3.3V power line is attached near the potentiometers to allow the ADC to read the potentiometers as seen in the center of the board. The user connects the two PWM outputs from the PIC32 to the board directly. Finally each motor connects easily to this board completing all of the circuitry.

Fig.5 – Image of wiring of the protoboard

The figure above depicts the wiring of the protoboard described earlier. Each of the potentiometer are connected to the 3.3V line and ground via a 330 Ohm pull down resistor to ensure there are no current spikes which could damage the PIC32 board. Aside from this, the rest of the wires are just basic connectors making sure all of the headers have power as needed.

Software Design

Software Low Pass Filter

We defined alpha = 0.98 at the start of our program to filter out high frequency noise of two ADCs. Another reason of such high ratio would be explained in the CTMU section. Using the formula signal = alpha * oldsignal + (1- alpha ) * newsignal, any signal can be effectively low-passed using software. We use the same low pass formula to low pass CTMU but with alpha set to 0.9 since we want a faster response to the proximity.

CTMU

The CTMU(charge time measuring unit) module is the heart of our project. The CTMU act as a current source: it would first discharge the foil, then charge the copper foil for 2 microseconds with 5.5uA. And finally measure the voltage on the foil. The CTMU offers four options of current: 0.55uA, 5.5uA, 55uA and 550uA. By experimenting with our copper foil and referring from the final ADC value, we found that 0.55uA would be too small: the final ADC reading is around minimum. 55uA and 550uA would be too large: they always gave us a reading of maximum. To approximate the 2 uS charging time, we used the code from captain Bruce.

CTMU would work with only one analog pin connected to the foil. We don’t have many analog pin available to use because of the TFT screen.  The analog pin we chose was AN5, corresponding to the RPB3 on the big board.

Now with ADC value, we can calculate the final capacitance.

However, when we were writing the code to detect human proximity, we found that using capacitance for proximity detection was redundant since capacitance was derived from ADC reading. Working on ADC directly would be more efficient.

We tried different approaches for detecting human proximity. The most naive way of doing it would be setting a threshold: under which would be a catch. Then we just stopped reading ADCs values from potentiometers and it would stop the arm. This method face one problem: the capacitance of the foil was unstable even after low passing. We also observed that we achieve the highest ADC reading when the arm was vertical to the table (around 100) and lowest when the arm was parallel to the table(around 90). The problem may come from the distance between arm and table would alter the capacitance. If we set the threshold too high, moving toward table would stop the arm. If we set the threshold too low, it might be too late for the arm to stop.

To avoid the above problem, we tried detecting the proximity with a derivative term. By recording differences of a series of low passed ADC readings. If several consecutive negative results were detected, it mean human proximity. However we never got this method to work by tweaking around the parameters. The problem may come from the fact that the thread was running so quickly that the number of readings we recorded was too small.

But then we realized that the biggest problem we need to solve was that the arm was moving too quick and it might be the reason that we couldn’t stop it before. After a discussion of how to make arm move slower, we came up with different ideas like moving the arm to destination in steps but eventually we found that we can slow the motion of the arm just by simply low pass ADC readings with high alpha value.

After slowing down the motion by setting alpha from 0.8 to 0.98, the problem we had that the capacitance of the robot arm was changing with its position also disappeared. It might be due to the reason that the speed of the arm slowed from an instant moving to a several seconds process. Then we tested the arm with naive threshold approach and it worked with both of our hands.  When the CTMU get an ADC reading below the threshold, we set a variable ‘prox’ to 1 which mean human proximity detected. Two ADC readings for PWM controls would always check ‘prox’ value first and proceed if its 0.

PWM

We used pulse width modululus to control the position and speed of the servo motors in our system. The motor we used in the project has a pulse period of 20ms. And duty ratio from 0.5ms to 2.5ms. We had the timer2 running at 40Mhz. In order to get a pulse period of 20ms, we need 800000 counts for each period. By setting prescaler to 256, we got a range of 800000/256 = 3125 range of duty cycle. Since the duty ratio should be 0.5ms to 2.5ms. The corresponding duty we should set should be from lowest: 3125/40 ~= 78 to highest 3125/8 ~= 390. The formula we used in the code was:

The image above shows the two PWM signals running simultaneously with the top signal being at 2.5ms and the lower at .5ms. Both of the pulse widths are significantly smaller than the major period of 20ms.

TFT

We displayed all the ADC readings and calculated capacitance to the TFT screen.

ADC

Initially we were trying to make 3 motors work at the same time but we found out that we only have 3 analog pins left that we can use on the big board since we were using TFT screen. One is needed for CTMU so we can only have 2 analog pins left for PWM control. Two analog pins we chose for ADC readings were AN9 and AN11, corresponding to RPB13 and RPB 15. Since we have 3 ADCs, we could not do it with sampleA and sample B. We also tried scan mode and it didn’t work either. We chose manual mode eventually, for every ADC reading, we set the channel to that pin, acquire, convert, and read. The final parameters for enabling ADC was like this:

Note that we might make a mistake that we were doing 3 samples instead of 1 by setting ADC_SAMPLES_PER_INT_3. Which may lead to the biggest problem in our project.

Compiling it Together

We wrote everything in one thread in the final version of the project. However, we wrote two ADC readings and CTMU in 3 different threads. For this version, we have many yield through out each thread. It worked fine initially and displayed 3 ADC values correctly  but when we tried to make any change to the code, for example: changing how many ms to yield in any yield command, or changing the size of text to print on TFT, would make the ADC reading for CTMU not valid at all. The ADC reading went from 0 to 1023 randomly. However, the ADC readings for PWM controls worked well as usual. Due to that factor, we believe that the charging time of the CTMU might be different due to yielding to the other threads. But since the thread was not pre-emptive,we questioned how the scheduler was involved during the charging.   We tried many different approaches and spent days to solve this issue. But we couldn’t find a solution while using multithread. Then we consulted with Captain Bruce who gave us the advice that we might want to remove all the yield and write everything in one thread to solve this issue. We rewrote everything in one thread and it worked.

The final version consists of 2 functioning thread: One timer thread that only updates the time on TFT. Another main thread that do all the work: First, check the variable ‘prox’, if 0, then perform two ADC readings and convert to PWM signals. If 1, then skip this step. Then we discharge the foil, charge it and measure the ADC. From there we can set the ‘prox’ and calculate capacitance. Finally we printed all information on TFT screen.

Design Result

The motion of the robot is very smooth after our extensive low passing of the ADC value to control the speed. Additionally, since we have all of the calculations in one thread, the reading of the capacitance is extremely fast. We sadly were not able to get an exact number on the speed of the readings, but imagine it is in the range of 300-1000 readings per second.  We noticed that after our extensive tuning, when we move the robot near our body, the arm constantly is able to stop  before hitting our hand! We tested this out at two seperate locations and with the arm at different positions and our product continued to work. The only time where we noticed an issue is if we move just a finger in front of the arm. Occasionally the robot would bump into our finger, but once it makes contact, it halts. This is due to the low surface area of our finger compared to an arm or hand.

Interference Concerns

Our design only contains ADC, PWM and CTMU; Since none of those functions cause any high frequency noise, our system will be interference free for other people and devices in the area.

Conclusion

Overall we were able to meet all of our major objectives in creating this robot arm which has fairly fluid motion while detecting and stopping when there is a human in the way of its movement. We were very happy with how we were able to create the sensing part of this even though neither of us had used the CTMU or implemented capativie sensing before. Although we were not able to build the system using three joints, the main outcome was to get the sensing working well and in the future we or others can join this technology with a higher DOF robot arm or system.

If we had to complete this project again knowing what we know now, we would make a few changes with the system. The first would be to take more time with the design of the arm and it’s housing. Although the arm works as expected, it is not aesthetically pleasing to look at or watch move around. We focused a lot on the capacitive sensing and were worried that we might run out of time if we were to design a good-looking arm. Additionally, another thing we would have liked to add is a joystick-like controller instead of an open PCB board with a bunch of wires coming off of them.

There are many more possibilities that we haven’t explored yet. Such as by calculating the direction of the human proximity, the robot can either follow the object, or move away from the object. To do this, we might need multiple foils on different robot locations while keeping tracking which direction the robot is moving.

On the software side we wrote all of our own code besides some setup code taken from Bruce Land’s headers and from previous labs which we completed. Although the idea of capacitive sensing is not a new or novel idea, with a little more work on the tuning of the system, it would be possible for us to publish our work. Currently, we do not have plans to do so, but are both open to it if we have time early next semester.

Safety Considerations

Since safety was the primary objective in creating an active sensing arm, we were sure that the construction and operation of the arm is safe. Each component runs on 5V which is safe to handle by any user. Additionally since the robot arm is able to sense if a person is near, our product is able to avoid any major collisions that could cause any harm to anyone.

Ethical Considerations

To our knowledge, our project is consistent with the IEEE code of ethics and have satisfied all 10 articles as detailed on the IEEE website.

Appendix

/*
                    * File:        Final Project 12/2/2019
                    *              Capacitive sensing Robot Arm
                    * Author:      Bruce Land modified by Ximeng Zhang & Matt Daniel
                    * Adapted from:
                    *              main.c by
                    * Author:      Syed Tahmid Mahbub
                    * Target PIC:  PIC32MX250F128B
                    */
                   
                   // graphics libraries
                   //#include "config.h" // new one is config_1_3_2.h as seen line 21
                   #include "tft_master.h"
                   #include "tft_gfx.h"
                   // need for rand function
                   #include 
                   
                   // threading librar
                   #include 
                   
                   // config.h sets 40 MHz
                   #define	SYS_FREQ 40000000
                   
                   #include "config_1_3_2.h"
                   // threading library
                   //#include "pt_cornell_1_2_3.h"
                   #include "pt_cornell_1_3_2.h"
                   // yup, the expander
                   #include "port_expander_brl4.h"
                   //#include "pt_cornell_TFT.h"
                   
                   ///////////////////////////////////
                   // lock out timer interrupt during spi comm to port expander
                   // This is necessary if you use the SPI2 channel in an ISR
                   #define start_spi2_critical_section INTEnable(INT_T2, 0);
                   #define end_spi2_critical_section INTEnable(INT_T2, 1);
                   // string buffer
                   char buffer[60];
                   
                   //initialize control signals
                   static double alpha = 0.98;
                   int adc_val2 = 0;
                   int old_val2 = 0;
                   int adc_val3 = 0;
                   int old_val3 = 0;
                   int raw_adc = 0;
                   int old_raw = 0;
                   static float I[4]={550e-6, 0.55e-6, 5.5e-6, 55e-6} ; // current settings in amps
                   static float I_set;
                   float C;
                   // some precise, fixed, short delays
                   // to use for cap charging time
                   #define NOP asm("nop");
                   // 1/2 microsec
                   #define wait20 NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
                   // one microsec
                   #define wait40 wait20;wait20;
                   #define Vdd 3.3
                   #define ADC_max 1023.0
                   
                   
                   // ==============PWM SETUP Vars / Defines//
                   // defines PWM
                   #define clockspeed 40000000 //40MHz clock
                   #define PWM_Pulse_Width_Ms 20
                   #define PWM_Pulse_Width_Cycles (int)800000/256 // 20ms clock timer
                   
                   
                   
                   //== Timer 2 interrupt handler ===========================================
                   volatile SpiChannel spiChn = SPI_CHANNEL2 ; // the SPI channel to use
                   volatile int spiClkDiv = 4 ; // 10 MHz max speed for port expander!!
                   
                   // human proximity
                   int prox =0;
                   // dutycycles for motor 1 and motor 2
                   int dutycycle1;
                   int dutycycle2;
                   // ==============END PWM SETUP Vars;
                   
                   
                   // ISR to clear interrupt flag for PWM
                   void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void){
                     mT2ClearIntFlag(); // clear interrupt flag 
                     
                   }
                   
                   
                   // === thread structures ============================================
                   // thread control structs
                   // note that UART input and output are threads
                   static struct pt pt_timer, pt_control, pt_ctmu,pt_screen;
                   int sys_time_seconds ;
                   // === Timer Thread =================================================
                   // update a 1 second tick counter
                   static PT_THREAD (protothread_timer(struct pt *pt)){
                     PT_BEGIN(pt);
                     while(1) {
                           // yield time 1 second
                       PT_YIELD_TIME_msec(1000) ;
                       sys_time_seconds++;
                       tft_setCursor(3, 3);
                       tft_setTextColor(ILI9340_WHITE);  tft_setTextSize(1);
                       tft_fillRoundRect(3,3, 180, 24, 1, ILI9340_BLACK);// x,y,w,h,radius,color
                       sprintf(buffer,"Time:%d \n",sys_time_seconds);
                       tft_writeString(buffer);
                   
                       // NEVER exit while
                       } // END WHILE(1)
                     PT_END(pt);
                   } // timer thread
                   
                   
                   
                   // === Screen Update Thread =============================================
                   static PT_THREAD (protothread_screen(struct pt *pt))
                   {
                     PT_BEGIN(pt);
                     while(1) {
                           // yield time 100 millisecond
                             // display varibles / warnings here at 5Hz
                       PT_YIELD_TIME_msec(200);
                           //update the screen at 5 times a second
                         } // END WHILE(1)
                         PT_END(pt);
                   } // screen update thread
                   
                   
                   
                   
                   // === Control Thread =================================================
                   // read 3 ADC values
                   static PT_THREAD (protothread_control(struct pt *pt))
                   {
                     PT_BEGIN(pt);
                   
                     tft_setCursor(0, 80);
                     tft_setTextColor(ILI9340_WHITE);  tft_setTextSize(1);
                     tft_writeString("ADC     C\n");
                     CTMUCONbits.ON = 1; // Turn on CTMU
                     while(1) {
                         if(!prox){
                   //===============Getting the first Control ADC value ==========================
                       //adc_val1 = ReadADC10(0); 
                       // adc_val1 is now CTMU
                       SetChanADC10(ADC_CH0_POS_SAMPLEA_AN9 | ADC_CH0_NEG_SAMPLEA_NVREF);
                       // PT_YIELD_TIME_msec(1); // wait
                       wait40;wait40;
                       AcquireADC10(); // start ADC sampling -- connects ADC sample cap to circuit
                       ConvertADC10(); // end sampling & start conversion       
                       // wait for complete
                       while (!AD1CON1bits.DONE){}; // Wait for ADC conversion
                       adc_val2 = ReadADC10(0); // get the value for 1st control 
                       adc_val2 = (int)(old_val2 * alpha + (1-alpha)*adc_val2);// low pass the result
                       dutycycle1= (int)((int)(adc_val2  * (390 - 78))/1023 + 78);// This code converts adc value to duty cycle.
                       // the smallest duty cycle is 78, highest is 390
                       // by calculating 800000 / 256 = 3125 ===> full duty cycle
                       // our Motor :
                       //	  Pulse Width: 500-2500
                       //	  Duty Ratio: 0.5ms-2.5ms
                       //	  Pulse Period: 20ms
                       //    Thus, 3125/40 ~= 78, 3125/8 ~= 390
                       SetDCOC1PWM(dutycycle1);
                       old_val2 = adc_val2;
                   //===============Getting the second Control ADC value ==========================
                       SetChanADC10(ADC_CH0_POS_SAMPLEA_AN11 | ADC_CH0_NEG_SAMPLEA_NVREF);
                       //PT_YIELD_TIME_msec(3); // wait
                       wait40;wait40;
                       AcquireADC10(); // start ADC sampling -- connects ADC sample cap to circuit
                       ConvertADC10(); // end sampling & start conversion       
                       // wait for complete
                       while (!AD1CON1bits.DONE){}; // Wait for ADC conversion
                       adc_val3 = ReadADC10(0);
                       adc_val3 = (int)(old_val3 * alpha + (1-alpha)*adc_val3);// low pass the result
                       dutycycle2= (int)((int)(adc_val3  * (390 - 78))/1023 + 78);
                       SetDCOC2PWM(dutycycle2);
                   
                       old_val3 = adc_val3;
                           }// end of proximity checking 
                   //===============Getting the CTMU ADC value ==========================
                       //PT_YIELD_TIME_msec(100);
                       // choose a current level
                       // using 55e-6 current
                        I_set = I[2];
                       CTMUCONbits.IRNG = 2;
                       SetChanADC10(ADC_CH0_POS_SAMPLEA_AN5 | ADC_CH0_NEG_SAMPLEA_NVREF);
                       // dischrge the cap
                       AcquireADC10(); // start ADC sampling -- connects ADC sample cap to circuit
                       // and discharge
                       CTMUCONbits.IDISSEN = 1; // start drain of circuit
                       PT_YIELD_TIME_msec(1); // wait for discharge
                       CTMUCONbits.IDISSEN = 0; // End drain of circuit
                       // start charging and wait 2 microsecs
                       CTMUCONbits.EDG1STAT = 1;
                       wait40;wait40;
                       // end charging
                       CTMUCONbits.EDG1STAT = 0;
                       // stop samping and start conversion
                       // note that in:
                       //#define PARAM1  ADC_FORMAT_INTG16 | ADC_CLK_MANUAL | ADC_AUTO_SAMPLING_OFF
                       // clock is manual and auto sampling is off
                       ConvertADC10(); // end sampling & start conversion       
                       // wait for complete
                       while (!AD1CON1bits.DONE){}; // Wait for ADC conversion       
                       // read the result of channel from the idle buffer
                       //==== checking for proximity ========================
                       raw_adc =  ReadADC10(0) ; 
                       // cannot be here since the noise, need low pass it first
                       // set to 0.6 for a faster response. 
                       raw_adc = (int)(old_raw * 0.9 + (0.1)*raw_adc);// low pass the result
                       
                       if(raw_adc < 96){ // check for human proximity
                           prox = 1; // if there is, set prox and stop reading ADC
                       }
                       else prox = 0; // if there is no one, resume operation
                       old_raw = raw_adc;
                       
                       // convert raw to resistance ADC reads 11 at zero resistance
                       // Vref = Vdd = 3.3 ; 2 microsec charge pulse
                       C = (I_set * 2e-6) / ((float)(raw_adc)/ADC_max * Vdd)  ; // c = q/v
                       // draw capacitance results
                   //==================== update outputs on TFT screen =====================
                       tft_fillRoundRect(0,140, 240, 80, 1, ILI9340_BLACK);// x,y,w,h,radius,color
                       tft_setTextColor(ILI9340_WHITE);  tft_setTextSize(2);
                       tft_setCursor(0, 140);
                       sprintf(buffer,"ADC2Reading: %d\nADC3Reading: %d\n D1Reading: %d\n D2Reading: %d\n ",adc_val2,adc_val3,dutycycle1,dutycycle2);
                       tft_writeString(buffer);
                       tft_setCursor(0, 100);
                       tft_fillRoundRect(0,100, 240, 30, 1, ILI9340_BLACK);
                       tft_setTextColor(ILI9340_WHITE); tft_setTextSize(2);
                       sprintf(buffer,"%d %6.2e", raw_adc, C); // display the capacitance and the raw_adc 
                       tft_writeString(buffer);
                       PT_YIELD_TIME_msec(10);
                       }
                     PT_END(pt);
                   }
                   
                   
                   
                   void main() {
                     //SYSTEMConfigPerformance(PBCLK);
                   
                     ANSELA = 0; ANSELB = 0; 
                   
                     // === config threads ==========
                     // turns OFF UART support and debugger pin, unless defines are set
                     PT_setup();
                   
                     // === setup system wide interrupts  ========
                     INTEnableSystemMultiVectoredInt();
                   
                     // ==========the ADC===========
                     // configure and enable the ADC
                       CloseADC10();	// ensure the ADC is off before setting the configuration
                   
                       // define setup parameters for OpenADC10
                   
                       // Turn module on | ouput in integer | trigger mode auto | enable autosample
                     // ADC_CLK_AUTO -- Internal counter ends sampling and starts conversion (Auto convert)
                     // ADC_AUTO_SAMPLING_ON -- Sampling begins immediately after last conversion completes; SAMP bit is automatically set
                     // ADC_AUTO_SAMPLING_OFF -- Sampling begins with AcquireADC10();
                     #define PARAM1  ADC_FORMAT_INTG16 | ADC_CLK_MANUAL | ADC_AUTO_SAMPLING_OFF //want fast adc read, so auto sampling is on
                   
                       // define setup parameters for OpenADC10
                       // ADC ref external  | disable offset test | disable scan mode | do 1 sample | use single buf | alternate mode off
                       #define PARAM2  ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_OFF | ADC_SAMPLES_PER_INT_3 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF
                           //
                       // Define setup parameters for OpenADC10
                     // use peripherial bus clock | set sample time | set ADC clock divider
                     // ADC_CONV_CLK_Tcy2 means divide CLK_PB by 2 (max speed)
                     // ADC_SAMPLE_TIME_5 seems to work with a source resistance < 1kohm
                     #define PARAM3 ADC_CONV_CLK_PB | ADC_SAMPLE_TIME_5 | ADC_CONV_CLK_Tcy2 //ADC_SAMPLE_TIME_15| ADC_CONV_CLK_Tcy2
                   
                       // define setup parameters for OpenADC10
                       // set AN11 and  as analog inputs
                       #define PARAM4	 ENABLE_AN9_ANA | ENABLE_AN5_ANA | ENABLE_AN11_ANA
                   
                       // define setup parameters for OpenADC10
                       // do not assign channels to scan
                       //#define PARAM5	SKIP_SCAN_AN0 |SKIP_SCAN_AN1 |SKIP_SCAN_AN2 |SKIP_SCAN_AN3 |SKIP_SCAN_AN4 |SKIP_SCAN_AN10 |SKIP_SCAN_AN6 |SKIP_SCAN_AN7 |SKIP_SCAN_AN8 
                       #define PARAM5 SKIP_SCAN_ALL
                       // use ground as neg ref for A | use AN11 for input A     
                       // configure to sample AN11 
                       SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF ); // configure to sample AN11 
                       OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using the parameters defined above
                       EnableADC10(); // Enable the ADC
                     // ========PWM Setup ==========
                     // turn on TIMER2
                     OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_256, PWM_Pulse_Width_Cycles);
                   
                     // Need ISR to compute PID controller
                     ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_2);
                   
                     // set up compare1 for PWM mode
                     OpenOC1(OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0,0); //
                     
                     // OC1 is PPS group 1, map to RPB7
                     PPSOutput(1, RPB7, OC1);
                   
                   
                     // OC2 is in group 2  
                     // allowed to output to : RPA1 RPB5 RPB1 RPB11 
                     //                        RPB8 RPA9 RPC8 RPA9
                     OpenOC2(OC_ON|OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE,0,0);
                     // GROUP 2,   output TO RPB 8
                     PPSOutput(2, RPB8, OC2);
                     // set dutycycles for testing
                     //SetDCOC2PWM(2000);
                     //SetDCOC1PWM(2000); //for testing   
                     // clear flag to let run 
                     mT2ClearIntFlag();
                   
                   
                   // ========end PWM Setup ==========
                   
                   
                     PT_INIT(&pt_timer);
                     PT_INIT(&pt_control);
                     PT_INIT(&pt_screen);
                   
                   
                        // init the display
                     tft_init_hw();
                     tft_begin();
                     tft_fillScreen(ILI9340_BLACK);
                     //240x320 vertical display
                     tft_setRotation(0); // Use tft_setRotation(1) for 320x240
                     while (1){
                       PT_SCHEDULE(protothread_timer(&pt_timer));
                       PT_SCHEDULE(protothread_control(&pt_control));
                       PT_SCHEDULE(protothread_screen(&pt_screen));
                       //PT_SCHEDULE(protothread_control(&pt_ctmu));
                       }
                     
                   }// main
                   
                   
                   // === end  ======================================================

Schematics

Source: Capacitive Sensing Robot Arm

Leave a Comment

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.