Automated Resistor Sorter with GUI

Hardware Construction

The hardware for this project was designed in Autodesk Fusion 360 with intentions to be 3D printed on a Makerbot 2.0. The Makerbot imposes limits on size of the objects to print. Using a larger design and printer could allow easier operation. Included in the appendices are the STLs for printing, please contact Nathan Lambert at [email protected] if you desire the raw CAD files.

Electrical Component Design

In order to provide an interface between the mechanical design, the user, and the PIC32 software, 6 major electrical parts were used:

1. 1. Futaba S3003 Servo motor – We chose to use a servo motor to operate the arm that raised and lowered the resistor from the feed mechanism to the measurement contacts. Since the PIC32 can produce a PWM control signal via its output compare channel that is sufficient to control a servo, and the limited range of motion is not an issue since only moving between the contacts and the bins is needed, the servo was a logical choice.

1. 1. PF35T-48L4 Stepper motor – We needed a motor to rotate the bins underneath the measurement arm. We chose a stepper motor since this motor could easily be rotated continuously, but also in discrete angular steps so that we could control which bin the arm was over at any point in time without any additional feedback or sensor required. In addition to being easy to operate for this application, we were able to scavenge a suitable motor from the lab bins at no cost to us.

      In order to operate the stepper, we used a spawned protothread to send pulses of 100 ms through to the ULN2003A driver chip as seen in Appendix C. The chip contained transistor arrays with flyback diodes which would supply up to 0.5A of current from the 5V supply to the motor when turned on. Through testing, we found that the time constant of the motor was such that, with the load of the bins connected to it, we could not operate significantly faster than 100ms between steps, else the motor would not complete the rotation in the time period and simply jitter in place.

1. 1. Adafruit Mini Solenoid – We used the solenoid to actuate the feed mechanism to drop a resistor out of the hopper. Testing indicated that using the solenoid at its full rated 5V caused too strong a response, with resistors often flying out of the feed mechanism. In addition, the solenoid would tend to heat up, since it drew significant current. We added a power resistor in series to reduce the operating voltage of the solenoid to under 2V, which improved performance and reduced power consumption. The Control circuit schematic is part of Appendix C, and consists of a power NMOSFET for turning on the solenoid at the command of the PIC32, and a flyback diode to handle inductive spikes when the solenoid is turned off.

1. 1. Electrical Contacts – We created electrical contacts for the resistor out of conductive copper tape soldered to wire. We placed wire connections on both the top and bottom of the contacts to improve the connection which could be different based on irregularities in the resistor.

1. 1. 10 turn potentiometer – We used a 10 turn potentiometer to select menu items and set bin limits. The wiper was connected to a PIC32 input pin to be read by the ADC.

1. Push Button Switch – A simple push button was used to select menu items. This was connected with a 10k Ohm pull down resistor to ground and to the PIC32. The debouncing was handled in software.

Software Design

Overview of Software & State Machine

The menu navigation is handled by a state machine that guides the user through operational decisions to allow simple navigation to the user’s end goal. Each screen has a char value corresponding to its purpose; these are stored in vectors that contain all possible options for the state variable given a certain starting state. Start Menu and Sort Menu each have these vectors, with a few char values which each represent a potential next state. When navigating the menus, the user is changing the index value within these indices. Selection simply loads this value into the state variable, pushing the machine into the next state. The control thread determines which state is shown and translates inputs into variable values. The display thread reads the state and index variables and adjusts the display accordingly every ⅕ of a second to minimize flicker.

With respect to sorting, the menus serve to define bin limits for the sorting operation. Once defined, the menus also tell the system when to jump into the sorting procedure. The machine cyclically releases one resistor into the measuring arm, brings the resistor to the measurement leads, measures and prints the resistance of the resistor, and rotates the bins so the correct bin is aligned to the measuring arm. Finally, the arm releases the resistor into the correctly aligned bin. Figure 2 in the introduction shows the general progression of steps in the software.

The arm is controlled with a simple servo which we control by setting the duty cycle of the PIC32 output compare PWM channel. The rotating bins are controlled with a stepper motor, simply by turning on and off the appropriate channels at 100mSec increments. The rotation code is placed in a separate spawned protothread instead of a function since it requires the use of yield times. The resistor release is controlled with a solenoid that pushes a plastic stopper when driven with a high enough threshold voltage. These mechanical devices were all calibrated in timing timed through the PIC32 to create the correctly timed action described above.

The measurement autoranging feature and the CTMU is controlled by the PIC software. We first initialize the CTMU by modifying CTMUCONbits to turn on the CTMU module, disable the discharging, and enable the charging of the circuit. We initially start off with current level 1, the lowest possible current output by the CTMU. If the ADC reading is greater than 99 (~0.32 V) then we break out of the loop and use this value of current to calculate the resistance. Otherwise, the loop iterates through increasing current levels until an ADC value of 99 or the maximum current is reached. Therefore, we keep the current safely low and gradually step it up only when we know the next step will not exceed the tolerable voltage.

GUI Design

The GUI is designed to convey the required information as simply and efficiently as possible. The real estate available on the TFT screen is very limited, restricting the design to simple text. For selection, the most area-efficient option is a selection bar inverting the color of the text. This approach required no margin, saving area. This design was kept uniform for every screen for simplicity and consistency in the design.

After the design for the individual screens, the GUI was planned out to use as few screens as possible with clear options that facilitate easily navigated menus. Our sorter has a limited number of functionalities, so the menu system can be very simple. The pathing to each functionality is clear from the start, so the user should not need to search around the menus.

Usability

A concern throughout the design process has been usability; the user’s experience should feel straightforward and intuitive, while enabling the full range of functionalities designed into the project. The inputs should be as few as possible to simplify how the user interacts with our system, within reason. To these ends, the control system was designed to easily navigate the user to their desired functionality.

One considered input for the controller was a back button to reverse through the menu screens. In keeping the controller simple, we determined there are few enough menu screens that a back button is unnecessary. Reset fulfills this functionality in returning to the initial screen, meaning the back button would only be useful in returning to the sorting method screen from the custom select screen. This functionality is already available through a reset followed by choosing “sort” (the initial option) which is two button presses. The ease of this process and the limited use options for the back button helped us determine its implementation was unnecessary. Doubling the number of additional buttons (considering the reset button comes attached by default) was not justifiable considering the limited use the back button would have.

The final design for the control system is therefore a hand-held controller wired into the main device with two buttons and a dial. The controller is hand held to allow the user to read the screen at any comfortable position. In future iterations, designed with form in mind, the controller should have a designated place to rest on the sorting machine.

The first button is the hard-wired reset button, enabling the user to easily restart the machine. This button is out of the way, because when the user needs it, they are not concerned with anything else on the controller. The reset button is also out of the way to prevent accidentally pressing it while handling the controller.

Next is the selection button and analog wheel. The functionality of the device is selected through 2 menu screens the user navigates with these tools. The wheel is used to move a selection bar up and down the screen. The button is used to progress to the stage selected on screen. The menu navigation is relatively simple, since the device has few operation modes. Figure 13 below shows the menu screens and navigation options in the system.

The analog potentiometer is used over, say, selection arrows (up and down) because the dial is eventually used to input value ranges for the resistor. This functionality with buttons would be arduous. The analog wheel, which can serve both required needs, is therefore implemented.

We must create a simple state machine to debounce button presses so users’ presses do not cause the system to jump ahead. The debounced button is a simple debouncer state machine, which double checks each button press and release to ensure they are not simply the product of noise. The state machine is implemented in the debounce() helper function as described below in Figure 14.

Results

Execution Time

At the moment, the execution speed of our resistor sorter is, on average, 10 seconds. The sorting stage can vary in execution speed since it depends on the number of bins that must be rotated through to get to the appropriate bin. For prototype development, we have a 5 second delay before each resistor feed for ease of mechanical debugging. In a production design, this could be reduced to 1 second, yielding a potential average execution speed of 6 seconds per resistor. This is significantly faster than a human can read a resistor with a multimeter and bin it appropriately. The table in the next section gives detailed time breakdown by step.

Mechanical Execution

This project was inherently limited by its mechanical accuracy. The accuracy of each moving mechanism contributes to the whole, and characterizing each individual part provides the most precise feedback for how to improve the system. For analysis, the three mechanical functions are the same as explained in high level design:

1. Feed (70 ± 15% accuracy): The feed mechanism was the largest source of error. This is due to the inherently difficult shape that is a resistor. When feeding, it is imperative for orientation to remain as intended, or else there will be difficulty in later stages. This is a contrast to many sorting and feed mechanisms encountered in regular life where the feed mechanism takes advantage of the flexibility of the shapes being entered, such as round candies or coins. The failure modes for the feed mechanism predominantly are jamming issues and uncontrolled expulsions.

   Jamming issues occur because of the precise movement needed for the mini solenoid in the feed and the manufacturing error of low cost 3D printing. The feed plunger arm either would not move if the package was compact or the system has cracks where resistor leads get caught when leaving enough room for motion. Optimizing between these two by regluing and shaving pieces down gave us our best results. Sometimes when a resistor jams, waiting a cycle will allow the solenoid to activate again and the resistor can properly exit the second time.

   Uncontrolled resistor expulsions occur because of the fast activation of the solenoid. Even when reducing the power delivered to the solenoid, the actuation speed and power is high enough to induce more motion than needed in our device. This causes resistors to fly out of the track and past the resistor measurement arm. Once the resistor is not in place, there is no chance of measuring it and the system needs to be reset.

2. Measurement (85 ± 7.5% accuracy): Physical resistor measurement was the next major source of error, but the errors were simpler as the moving parts in this stage need less precision. The measurement arm is designed precisely for ¼ watt resistors, which minimizes random error as long as the inputs follow that recommendation. The sources of error are mis-measuring the resistor by not making a solid contact to the measurement platform and lodging the resistor into the arm so it cannot be dropped.

   Mis-measurement occurs when resistor does not rest well on the copper arm contacts, so the resistor measurement circuit sees open circuit and places the resistor into the largest bin. This error occurs to the precise nature of our design. Even when a resistor is added by hand, there is a chance that the thing metal resistor leads do not line up properly.

   Permanently lodged resistors occur when the alignment of the resistor arm is too precise and resistors become lodged in the slot of the arm as it is pressed into the measurement apparatus. The soft nature of the copper measurement tape causes the copper to form to resistor leads, and over time the arm becomes more precisely shaped. This wire shaped indention grabs lightly onto the resistors through the entire range of motion of the measurement arm.

3. Sorting (99 ± 1% accuracy): Sorting occurs after the measurement, and is a relatively minor source of error due to the precision of stepper motors. The only error is when the slots of the bins are misaligned.

   Bin mis-alignment is primarily human induced error. When starting the system, the user needs to make sure the current bin number reading on the TFT display agrees with the bin positions. One misaligned, the bins do not automatically correct, so errors will persist. If aligned properly at the beginning, no new errors in alignment come about.

Accuracy & Calibration

In order to ensure that our resistor sorter would accurately measure the resistors it was presented with, we needed to calibrate the reference current source of the Charge Time Measurement Unit (CTMU) of the PIC32. While this component is given nominal specified current outputs, it does not have tolerance ranges on its specified output. We initially used the specified current and the measured voltage from the Analog to Digital Conversion Unit (ADC) to calculate the resistance with Ohm’s Law. However, we found that the results from this calculation were not sufficiently accurate. Through extensive testing, we identified five variables that affected the accuracy of the resistance measurement:

1. ADC Autosampling: Using the ADC in autosampling mode significantly reduced the range of resistors we could measure. With autosample on, an open circuit would read around 100k Ohms. Turning off the Autosample greatly improved the range of resistors we could measure into the Megaohm range.
2. ADC Sampling & Clock Speed: Running the ADC at high speeds caused unusual nonlinear voltage and current relations. When sampling at high speed, the charge/discharge time of the internal capacitor in the ADC can become longer than the sampling rate with high resistances attached. We solved the issues caused by this change by increasing the sample rate to the lowest speed possible (ADC_SAMPLE_TIME_31) and adding the largest possible clock divider (32) to decrease the ADC’s Clock rate (ADC_CONV_CLK_32Tcy).
3. Wait Time between Setting Current and Sampling ADC: We realized that our Resistance Measurement code would give seemingly random answers if no time was given between changing the current source setting and sampling the ADC. It appears that making the change to the current source to output at a new level takes more time than a CPU instruction. We added 100 mSec of yield time to allow the new current level to settle before reading.
4. Chip Manufacturing Variations in the CTMU Current Source: There are no accuracy specifications on the CTMU current source, and in our testing we found that in some instances our chip provided currents that were over 10 percent from nominal. In addition, the CTMU has a series resistance that is also poorly specified to the pin. We overcame this by using linear regression as described below to calibrate our measurement system.
5. Intrinsic resistance of the current source when measuring high resistances: When measuring resistances in excess of 1M Ohm, the intrinsic resistance of the current source (likely implemented through FETs) becomes significant relative to the measured resistances. In order to combat this problem, we used a 3rd order polynomial regression model over our calibration set in order to model the nonlinear behavior of the system.

As discussed above, a number of accuracy concerns dictated that we calibrate our system. In order to calibrate, we used 31 known resistor values between 56 Ohms and 5.6M Ohms. Since the current source has 4 different potential values, (0, 3, 2, 1, from largest current to smallest), we tested and calibrated each current source separately with resistors that would fall into that current level during operation. Figure 17 shows the calibration data along with the fitted curves and equations implemented in the software.