Glove touch detection for touch devices

Apparatuses and methods of glove touch detection are described. One method performs a first scan to detect an object proximate to a sense array. The first scan comprises a first sensitivity parameter. The method compares touch data from the first scan against a plurality of thresholds. The method performs a second scan to detect a touch event when the first scan's touch data exceeds a glove saturation threshold of the plurality of thresholds. The second scan comprising a second sensitivity parameter that is different than the first sensitivity parameter. The method reports a glove touch event when the first scan's touch data does not exceed the glove saturation threshold and exceeds a glove-reporting threshold of the plurality of thresholds.

TECHNICAL FIELD

The present disclosure relates generally to sensing systems, and more particularly to capacitance-sensing systems configurable to glove touch detection on the capacitive-sensing systems.

BACKGROUND

Capacitance sensing systems can sense electrical signals generated on electrodes that reflect changes in capacitance. Such changes in capacitance can indicate a touch event (i.e., the proximity of an object to particular electrodes). Capacitive sense elements may be used to replace mechanical buttons, knobs and other similar mechanical user interface controls. The use of a capacitive sense element allows for the elimination of complicated mechanical switches and buttons, providing reliable operation under harsh conditions. In addition, capacitive sense elements are widely used in modern customer applications, providing new user interface options in existing products. Capacitive sense elements can range from a single button to a large number arranged in the form of a capacitive sense array for a touch-sensing surface.

Transparent touch screens that utilize capacitive sense arrays are ubiquitous in today's industrial and consumer markets. They can be found on cellular phones, GPS devices, set-top boxes, cameras, computer screens, MP3 players, digital tablets, and the like. The capacitive sense arrays work by measuring the capacitance of a capacitive sense element, and looking for a delta in capacitance indicating a touch or presence of a conductive object. When a conductive object (e.g., a finger, hand, or other object) comes into contact or close proximity with a capacitive sense element, the capacitance changes and the conductive object is detected. The capacitance changes of the capacitive touch sense elements can be measured by an electrical circuit. The electrical circuit converts the measured capacitances of the capacitive sense elements into digital values.

There are two typical types of capacitance: 1) mutual capacitance where the capacitance-sensing circuit has access to both electrodes of the capacitor; 2) self-capacitance where the capacitance-sensing circuit has only access to one electrode of the capacitor where the second electrode is tied to a DC voltage level or is parasitically coupled to Earth Ground. A touch panel has a distributed load of capacitance of both types (1) and (2) and Cypress' touch solutions sense both capacitances either uniquely or in hybrid form with its various sense modes.

DETAILED DESCRIPTION

In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be evident, however, to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known circuits, structures, and techniques are not shown in detail, but rather in a block diagram in order to avoid unnecessarily obscuring an understanding of this description.

Reference in the description to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the invention. The phrase “in one embodiment” located in various places in this description does not necessarily refer to the same embodiment.

One method performs a first scan to detect an object proximate to a sense array. The first scan comprises a first sensitivity parameter. The method compares touch data from the first scan against multiple thresholds. The method performs a second scan to detect a touch event when the first scan's touch data exceeds a glove saturation threshold. The second scan comprising a second sensitivity parameter that is different than the first sensitivity parameter. The method reports a glove touch event when the first scan's touch data does not exceed the glove saturation threshold and exceeds the gloved-finger reporting threshold.

The embodiments described herein are directed to glove touch detection. A glove touch is considered a touch of a conductive object proximate to a touch sensitive device where the conductive object, such as a finger, is covered by a glove. A glove is a covering for hands. Gloves can be used by a person for protection or for warmth. Gloves, as used herein, should refer to gloves with individual fingers or mittens that cover more than one finger. Touches by gloved fingers may not have a definitive description, but the embodiments described herein can be configured to detect most available gloves. However, it is expected that some types of gloves, like boxing gloves, may not be detectable by some of the embodiments, but other types such as line thin wool gloves, leather gloves, thick wool gloves, thin ski gloves, padded leather gloves, or wool-lined mittens would be expected to be detectable.

FIG. 1is a block diagram illustrating one embodiment of an electronic system100having a processing device110including glove touch detection tool120. Details regarding the glove touch detection tool120are described in more detail with respect toFIGS. 2-9. The processing device110is configured to detect one or more touches on a touch-sensing device, such as the capacitive sense array125. The processing device can detect conductive objects, such as touch objects140(fingers or passive styluses), an active stylus130, or any combination thereof. The capacitance-sensing circuit101can measure touch data on the capacitive sense array125. The touch data may be represented as multiple cells, each cell representing an intersection of sense elements (e.g., electrodes) of the capacitive sense array125. In another embodiment, the touch data is a 2D capacitive image of the capacitive sense array125. In one embodiment, when the capacitance-sensing circuit101measures mutual capacitance of the touch-sensing device (e.g., capacitive sense array125), the capacitance-sensing circuit101obtains a 2D capacitive image of the touch-sensing device and processes the data for peaks and positional information. In another embodiment, the processing device110is a microcontroller that obtains a capacitance touch signal data set, such as from a sense array, and finger detection firmware executing on the microcontroller identifies data set areas that indicate touches, detects and processes peaks, calculates the coordinates, or any combination therefore. The firmware identifies the peaks using the embodiments described herein. The firmware can calculate a precise coordinate for the resulting peaks. In one embodiment, the firmware can calculate the precise coordinates for the resulting peaks using a centroid algorithm, which calculates a centroid of the touch, the centroid being a center of mass of the touch. The centroid may be an X/Y coordinate of the touch. Alternatively, other coordinate interpolation algorithms may be used to determine the coordinates of the resulting peaks. The microcontroller can report the precise coordinates to a host processor, as well as other information.

A user wearing gloves cannot use a touchscreen device without removing their gloves. The glove touch detection tool120is used to allow a user to interact with a touch sensitive device without the need to remove gloves. Taking off and putting on gloves is time consuming and can be annoying. For time-critical responses, a user wearing gloves can miss important information; for example, responding to an incoming phone call. This glove touch detection tool120can be used to allow time-critical events to be met. For example, a user can respond to an incoming phone call on a touch screen of a mobile phone without removing their gloves to do so. Also, the glove touch detection tool120can be used to use other features of other types of devices than answering a call on a mobile phone. Conventional solutions to detect gloved touches used self-capacitance sensing and a glove filter to remove hovering events and approaching fingers. These conventional solutions resulted in frequent false detections (glove touch detected when it was just a non-gloved touch hovering) and could only be used for single finger detection, not multiple touches. Further, these conventional solutions had low accuracy and could not be used at the same time as finger or stylus detection.

The embodiments of the glove touch detection tool120, as described herein, can allow time-critical responses without requiring the user to remove their gloves. For example, a user can answer, ignore or end a phone call on a touchscreen of the mobile phone. For another example, a user can dismiss alerts on a navigation system (or other types of devices). The glove touch detection tool120can function alongside finger touch detection and stylus detection. The glove touch detection tool120can auto-detect the input without help from a host device. The glove touch detection tool120can maintain the existing performance of the other input systems. For example, a finger touch performs equally well with and without the presence of a gloved touch detection. That is the accuracy of finger touch detection is not impacted by the glove touch detection tool120. Also, there are no false touch detections when there is an approaching finger or hovering finger. Similarly, the stylus detection performs equally well with and without the presence of the glove touch detection tool120. For example, the detection performance supports fast movement and tapping and the accuracy of stylus detection is equal to that of a finger. The glove touch detection tool120can be used to allow full use of a device with a touch sensitive input (e.g., touchscreen) while gloves are being worn. For example, the user can write a note or text message, add or edit a contact, select menus and enter data on a navigation or in-vehicle entertainment or information system, draw rudimentary pictures, and the like, without removing their gloves. The operations of glove touch detection tool120are described below with respect toFIGS. 2-9.

The glove touch detection tool120can be used in connection with other position detection and gesture recognition units. These units may obtain a capacitive image of a capacitive sense array125. The capacitive image includes multiple cells each with a capacitance value of an intersection of sense elements of the sense array125. Alternatively, these units can receives the raw capacitance value measured by the capacitive-sensing circuit101and then compute a difference count, which is a difference between the raw capacitance value and a baseline capacitance value. Alternatively, the capacitance-sensing circuit101outputs the difference count to the glove touch detection tool120. The glove touch detection tool120can process the capacitive data received from the capacitance-sensing circuit101to determine if there is a gloved touch as described herein.

In one embodiment, the glove touch detection tool120is implemented in firmware of the processing device110. In another embodiment, the glove touch detection tool120is implemented in software, hardware, or any combination thereof. In another embodiment, the glove touch detection tool120is implemented as part of a gesture recognition tool that calculates and reports gestures. In another embodiment, the glove touch detection tool120can be implemented on the host, and the capacitive-sensing circuit101obtains the touch data and sends the touch data to the glove touch detection tool120on the host processor150. Alternatively, other configurations are possible as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure. It should also be noted that the touches, gloved touches, stylus touches can be reported to various applications executing on the host processor150.

Electronic system100includes processing device110, capacitive sense array125, stylus130, host processor150, embedded controller160, and non-capacitive sense elements170. The capacitive sense elements are electrodes of conductive material, such as copper. The sense elements may also be part of an ITO panel. The capacitive sense elements can be configurable to allow the capacitive-sensing circuit101to measure self capacitance, mutual capacitance, or any combination thereof. Self-capacitance scanning is a method of detecting the presence of a conductive object by measuring the relative capacitance to ground. For example, using self-capacitance scanning, every row and column is scanned individually resulting in R+C scans. Mutual-capacitance scanning is a method of detecting the presence of a conductive object by measuring the relative capacitance between two electrodes (transmit (TX) electrodes and receive (RX) electrodes). For example, using mutual-capacitance scanning, each intersection (TX/RX intersection) is scanned. However, in some cases, the RX electrodes can be grouped together, resulting in NumRXGroups*TX scans. In the depicted embodiment, the electronic system100includes the capacitive sense array125coupled to the processing device110via bus122. The capacitive sense array125may include a multi-dimension capacitive sense array. The multi-dimension sense array includes multiple sense elements, organized as rows and columns. In another embodiment, the capacitive sense array125operates as an all-points-addressable (“APA”) mutual capacitive sense array. In another embodiment, the capacitive sense array125operates as a coupled-charge receiver. In another embodiment, the capacitive sense array125is non-transparent capacitive sense array (e.g., PC touchpad). The capacitive sense array125may be disposed to have a flat surface profile. Alternatively, the capacitive sense array125may have non-flat surface profiles. Alternatively, other configurations of capacitive sense arrays may be used. For example, instead of vertical columns and horizontal rows, the capacitive sense array125may have a hexagon arrangement, or the like, as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure. In one embodiment, the capacitive sense array125may be included in an ITO panel or a touch screen panel.

The operations and configurations of the processing device110and the capacitive sense array125for detecting and tracking the touch object140and stylus130are described herein. In short, the processing device110is configurable to detect a presence of the touch object140, a presence of a stylus130on the capacitive sense array125, or any combination thereof. The processing device110may detect and track the stylus130and the touch object140individually on the capacitive sense array125. In one embodiment, the processing device110can detect and track both the stylus130and touch object140concurrently on the capacitive sense array125. If the touching object is an active stylus, in one embodiment, the active stylus130is configurable to operate as the timing “master,” and the processing device110adjusts the timing of the capacitive sense array125to match that of the active stylus130when the active stylus130is in use. In one embodiment, the capacitive sense array125capacitively couples with the active stylus130, as opposed to conventional inductive stylus applications. It should also be noted that the same assembly used for the capacitive sense array125, which is configurable to detect touch objects140, is also used to detect and track a stylus130without an additional PCB layer for inductively tracking the active stylus130.

In the depicted embodiment, the processing device110includes analog and/or digital general purpose input/output (“GPIO”) ports107. GPIO ports107may be programmable. GPIO ports107may be coupled to a Programmable Interconnect and Logic (“PIL”), which acts as an interconnect between GPIO ports107and a digital block array of the processing device110(not shown). The digital block array may be configurable to implement a variety of digital logic circuits (e.g., DACs, digital filters, or digital control systems) using, in one embodiment, configurable user modules (“UMs”). The digital block array may be coupled to a system bus. Processing device110may also include memory, such as random access memory (“RAM”)105and program flash104. RAM105may be static RAM (“SRAM”), and program flash104may be a non-volatile storage, which may be used to store firmware (e.g., control algorithms executable by processing core102to implement operations described herein). Processing device110may also include a memory controller unit (“MCU”)103coupled to memory and the processing core102. The processing core102is a processing element configured to execute instructions or perform operations. The processing device110may include other processing elements as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure. It should also be noted that the memory may be internal to the processing device or external to it. In the case of the memory being internal, the memory may be coupled to a processing element, such as the processing core102. In the case of the memory being external to the processing device, the processing device is coupled to the other device in which the memory resides as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure.

The processing device110may also include an analog block array (not shown). The analog block array is also coupled to the system bus. Analog block array may also be configurable to implement a variety of analog circuits (e.g., ADCs or analog filters) using, in one embodiment, configurable UMs. The analog block array may also be coupled to the GPIO107.

As illustrated, capacitance-sensing circuit101may be integrated into processing device110. Capacitance-sensing circuit101may include analog I/O for coupling to an external component, such as touch-sensor pad (not shown), capacitive sense array125, touch-sensor slider (not shown), touch-sensor buttons (not shown), and/or other devices. The capacitance-sensing circuit101may be configurable to measure capacitance using mutual-capacitance sensing techniques, self-capacitance sensing technique, charge coupling techniques or the like. In one embodiment, capacitance-sensing circuit101operates using a charge accumulation circuit, a capacitance modulation circuit, or other capacitance sensing methods known by those skilled in the art. In an embodiment, the capacitance-sensing circuit101is of the Cypress TMA-3xx, TMA-4xx, or TMA-xx families of touch screen controllers. Alternatively, other capacitance-sensing circuits may be used. The mutual capacitive sense arrays, or touch screens, as described herein, may include a transparent, conductive sense array disposed on, in, or under either a visual display itself (e.g. LCD monitor), or a transparent substrate in front of the display. In an embodiment, the TX and RX electrodes are configured in rows and columns, respectively. It should be noted that the rows and columns of electrodes can be configured as TX or RX electrodes by the capacitance-sensing circuit101in any chosen combination. In one embodiment, the TX and RX electrodes of the sense array125are configurable to operate as a TX and RX electrodes of a mutual capacitive sense array in a first mode to detect touch objects, and to operate as electrodes of a coupled-charge receiver in a second mode to detect a stylus on the same electrodes of the sense array. The stylus, which generates a stylus TX signal when activated, is used to couple charge to the capacitive sense array, instead of measuring a mutual capacitance at an intersection of a RX electrode and a TX electrode (a sense element) as done during mutual-capacitance sensing. An intersection between two sense elements may be understood as a location at which one sense electrode crosses over or overlaps another, while maintaining galvanic isolation from each other. The capacitance-sensing circuit101does not use mutual-capacitance or self-capacitance sensing to measure capacitances of the sense elements when performing a stylus sensing. Rather, the capacitance-sensing circuit101measures a charge that is capacitively coupled between the sense array125and the stylus as described herein. The capacitance associated with the intersection between a TX electrode and an RX electrode can be sensed by selecting every available combination of TX electrode and RX electrode. When a touch object, such as a finger, gloved finger or stylus, approaches the capacitive sense array125, the object causes a decrease in mutual capacitance between some of the TX/RX electrodes. In another embodiment, the presence of a finger increases the coupling capacitance of the electrodes. Thus, the location of the finger on the capacitive sense array125can be determined by identifying the RX electrode having a decreased coupling capacitance between the RX electrode and the TX electrode to which the TX signal was applied at the time the decreased capacitance was measured on the RX electrode. Therefore, by sequentially determining the capacitances associated with the intersection of electrodes, the locations of one or more inputs can be determined. It should be noted that the process can calibrate the sense elements (intersections of RX and TX electrodes) by determining baselines for the sense elements. It should also be noted that interpolation may be used to detect finger position at better resolutions than the row/column pitch as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure. In addition, various types of coordinate interpolation algorithms may be used to detect the center of the touch as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure.

In an embodiment, the electronic system100may also include non-capacitive sense elements170coupled to the processing device110via bus171and GPIO port107. The non-capacitive sense elements170may include buttons, light emitting diodes (“LEDs”), and other user interface devices, such as a mouse, a keyboard, or other functional keys that do not use capacitance sensing. In one embodiment, buses122, and171are embodied in a single bus. Alternatively, these buses may be configured into any combination of one or more separate buses.

Processing device110may include internal oscillator/clocks106and communication block (“COM”)108. In another embodiment, the processing device110includes a spread spectrum clock (not shown). The oscillator/clocks block106provides clock signals to one or more of the components of processing device110. Communication block108may be used to communicate with an external component, such as a host processor150, via host interface (“I/F”) line151. Alternatively, processing device110may also be coupled to embedded controller160to communicate with the external components, such as host processor150. In one embodiment, the processing device110is configurable to communicate with the embedded controller160or the host processor150to send and/or receive data.

Processing device110may reside on a common carrier substrate such as, for example, an integrated circuit (“IC”) die substrate, a multi-chip module substrate, or the like. Alternatively, the components of processing device110may be one or more separate integrated circuits and/or discrete components. In one exemplary embodiment, processing device110is the Programmable System on a Chip (PSoC®) processing device, developed by Cypress Semiconductor Corporation, San Jose, Calif. Alternatively, processing device110may be one or more other processing devices known by those of ordinary skill in the art, such as a microprocessor or central processing unit, a controller, special-purpose processor, digital signal processor (“DSP”), an application specific integrated circuit (“ASIC”), a field programmable gate array (“FPGA”), or the like.

It should also be noted that the embodiments described herein are not limited to having a configuration of a processing device coupled to a host, but may include a system that measures the capacitance on the sensing device and sends the raw data to a host computer where it is analyzed by an application. In effect, the processing that is done by processing device110may also be done in the host.

Capacitance-sensing circuit101may be integrated into the IC of the processing device110, or alternatively, in a separate IC. Alternatively, descriptions of capacitance-sensing circuit101may be generated and compiled for incorporation into other integrated circuits. For example, behavioral level code describing the capacitance-sensing circuit101, or portions thereof, may be generated using a hardware descriptive language, such as VHDL or Verilog, and stored to a machine-accessible medium (e.g., CD-ROM, hard disk, floppy disk, etc.). Furthermore, the behavioral level code can be compiled into register transfer level (“RTL”) code, a netlist, or even a circuit layout and stored to a machine-accessible medium. The behavioral level code, the RTL code, the netlist, and the circuit layout may represent various levels of abstraction to describe capacitance-sensing circuit101.

It should be noted that the components of electronic system100may include all the components described above. Alternatively, electronic system100may include some of the components described above.

In one embodiment, the electronic system100is used in a tablet computer. Alternatively, the electronic device may be used in other applications, such as a notebook computer, a mobile handset, a personal data assistant (“PDA”), a keyboard, a television, a remote control, a monitor, a handheld multi-media device, a handheld media (audio and/or video) player, a handheld gaming device, a signature input device for point of sale transactions, an eBook reader, global position system (“GPS”) or a control panel. The embodiments described herein are not limited to touch screens or touch-sensor pads for notebook implementations, but can be used in other capacitive sensing implementations, for example, the sensing device may be a touch-sensor slider (not shown) or touch-sensor buttons (e.g., capacitance sensing buttons). In one embodiment, these sensing devices include one or more capacitive sensors or other types of capacitance-sensing circuitry. The operations described herein are not limited to notebook pointer operations, but can include other operations, such as lighting control (dimmer), volume control, graphic equalizer control, speed control, or other control operations requiring gradual or discrete adjustments. It should also be noted that these embodiments of capacitive sensing implementations may be used in conjunction with non-capacitive sensing elements, including but not limited to pick buttons, sliders (ex. display brightness and contrast), scroll-wheels, multi-media control (ex. volume, track advance, etc.) handwriting recognition, and numeric keypad operation.

FIG. 2is a flow diagram of a method200of glove touch detection according to one embodiment. The method200may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), software (such as is run on a general purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In one embodiment, the processing device110performs the method200. In another embodiment, the glove touch detection tool120performs the method200. Alternatively, other components of the electronic system100perform some or all of the operations of method200.

Referring toFIG. 2, the method200begins with processing logic determining if a touch was detected on a last scan (block202). If there was a touch detected on the last scan, the processing logic scans for the same object type (block204) and if detected processes the object (block206) and the method200ends. However, if there was not a touch detected on the last scan at block202, the processing logic optionally determines if hover mode or stylus mode, or both, are enabled (block208). If these modes are enabled, the processing logic scans for hover events, stylus events, or both (block210) and determines if a hover object or a stylus object is detected (block212). If the hover object, stylus object, or both are detected at block212, the processing logic processes the touch object at block206and the method200ends. However, if the hover object, stylus object, or both are not detected at block212, the processing logic proceeds with glove touch detection. For glove touch detection, the processing logic determines if the glove touch detection (e.g.,120) is enabled (block214). If enabled, the processing logic scans for glove touches (block216) and determines if glove touches are detected (block218). If the glove touch is detected at block218, the processing logic proceeds to process the touch object at block206and the method200ends. However, if the glove touch is not detected at block218, the processing logic scans for finger touches (block220). When the processing logic determines that a finger touch is detected, the processing logic processes the touch object at block206and the method200ends. The method200can be repeated to track glove touches and finger touches, as well as optionally track hover touches or stylus touches.

In one embodiment, the processing logic can detect these different types of events according to a detection hierarchy. In one embodiment, the processing device may already have a detection hierarchy with both hover detection and stylus detection. The glove detection hierarchy can be implemented as another level in the existing hierarchy. In one embodiment, the detection hierarchy is implemented by first scanning for an object with a lowest expected signal. If that object is detected, scanning stops and the object is reported. If the object is not detected because of low signal, scanning stops. If the object is not detected due to excessive signal, then the next scan is for the object with the next lowest expected signal and so on. For example, the order of objects with the smallest to largest expected signals may be 1) Stylus or Hover detection using advanced scanning methods; 2) Glove detection using a sensitive mutual-capacitance scan; and 3) finger detection using a standard mutual-capacitance scan. If an object is detected, scanning for other objects stops until the current object is no longer detected. An object may be “not detected” if its signal strength drops below a specific (tuned) threshold. However, low signal objects (hover, stylus, and glove) can also be “not detected” if the signal strength increases above a specific (tuned) saturation threshold as described herein.

The following table illustrates one current scanning hierarchy without glove detection.

The following table illustrates another scanning hierarchy with glove detection enabled.

In one embodiment at blocks204,210,216or220, the processing logic collects a capacitive image of measured values. The capacitive image may include multiple cell values representing the capacitances of the intersections of a capacitive sense array. In one embodiment, the processing logic calculates the difference counts, which are the differences between the raw counts of the intersections and the baselines of the intersections. In another embodiment, the processing logic receives the difference counts from a different circuit or routine executing on the processing device.

In a further embodiment, the sense array is a capacitive sense array, and each of the multiple cells includes a capacitance value of an intersection of sense elements in the capacitive sense array. In another embodiment, the sense array is an optical sense array, and the cell values represent the values measured by an optical sensing device. Alternatively, the glove touch detection embodiments described herein may be used in other sensing systems, such as, for example, a system that creates a digitized heat map using reflected light.

The methods described above regarding glove touch detection can be implemented by the glove touch detection tool120, which may be implemented in a capacitive touch screen controller. In one embodiment, the capacitive touch screen controller is one of the TrueTouch® capacitive touchscreen controllers, such as the CY8CTMA3xx family of TrueTouch® Multi-Touch All-Points touchscreen controllers, developed by Cypress Semiconductor Corporation of San Jose, Calif. The TrueTouch® capacitive touchscreen controller sensing technology to resolve touch locations of multiple fingers and a stylus on the touch-screens, supports leading operating systems, and is optimized for low-power multi-touch gesture and all-point touchscreen functionality. Alternatively, the touch position calculation features and glove touch position calculation features may be implemented in other touchscreen controllers, or other touch controllers of touch-sensing devices. In one embodiment, the touch position calculation features and glove touch position calculation features may be implemented with other touch filtering algorithms as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure.

The embodiments described herein may be used in various designs of mutual-capacitance sensing arrays of the capacitance sensing system, or in self-capacitance sensing arrays. In one embodiment, the capacitance sensing system detects multiple sense elements that are activated in the array, and can analyze a signal pattern on the neighboring sense elements to separate noise from actual signal. The embodiments described herein are not tied to a particular capacitive sensing solution and can be used as well with other sensing solutions, including optical sensing solutions, as would be appreciated by one of ordinary skill in the art having the benefit of this disclosure.

In another embodiment, the processing logic performs a first scan to detect an object proximate to a sense array. The object may be a hover type object, a stylus type object, a glove type object or a finger type object. The first scan uses a first sensitivity parameter. The processing logic compares touch data from the first scan against multiple thresholds. The processing logic performs a second scan to detect a touch event when the first scan's touch data exceeds a glove saturation threshold. The glove saturation threshold can be considered a saturation threshold of the first scan for low signal touch objects, such as hover, stylus or glove touches. The second scan uses a second sensitivity parameter that is different than the first sensitivity parameter. The sensitivity parameter may be one or more parameters that may be thresholds, scan configuration parameters, or the like. The processing logic reports a glove touch event when the first scan's touch data does not exceed the glove saturation threshold and exceeds a the gloved-finger reporting threshold. Examples of the thresholds are illustrated and described with respect toFIG. 4B.

In a further embodiment, the processing logic reports no-touch event when the first scan's touch data does not exceed gloved-finger reporting threshold. Alternatively, post-processing can be used to identify the object profile as not a glove touch. For example, pressure indicators or acceleration indicators or other hysteresis data can be used to distinguish between touch types.

In one embodiment, the first scan is a mutual-capacitance scan in a mutual-capacitance mode. In another embodiment, the first scan is a mutual-capacitance scan in a mixed mode that includes a mutual-capacitance scan and a self-capacitance scan. The mutual-capacitance scan can be used for accuracy of the positions of the glove touch, where the self-capacitance scan can be used to determine a distance metric, as described herein.

In a further embodiment, the processing logic performs a higher sensitivity scan before the glove detection scan to detect at least one of a hover event or a stylus event by the object. For example, the processing logic can scan for the same object type if a touch was detected in the last scan. The touch here could be a glove touch, a hover touch, a stylus touch, or a finger touch. The processing logic can continue detecting the same object type until the same object type is no longer detected. This may be according to the scanning hierarchy described herein.

In a further embodiment, the processing logic performs a third scan after the second scan to detect the object proximate to the sense array. The third scan uses scan parameters and threshold parameters resulting in a less sensitive scan. This may be according to the scanning hierarchy described herein.

In one embodiment, the processing logic reports the glove touch event when the first scan's touch data does not exceed the glove saturation threshold, exceeds an initial detection threshold and exceeds the gloved-finger reporting threshold. Hysteresis is involved in the glove touch detection and finger detection as described below with respect toFIG. 9. The glove saturation threshold can operate as a maximum threshold for gloved touches and the gloved-finger reporting threshold can operate as a minimum threshold for gloved touches.

In some embodiments, the processing logic detects more than one touch object during the first scan. The processing logic can perform multi-touch scanning using mutual-capacitance scans as described herein.

In another embodiment, the processing logic scans for at least one of a hover type object or a stylus type object proximate to a sense array by a touch controller in a first scan. The processing logic scans for a glove type object proximate to the sense array by the touch controller in a second scan. The second scan provides a more sensitive scan than the first scan by using one or more of: a different scan method, different scan parameters, and different thresholds. The processing logic scans for a finger type object proximate to the sense array by the touch controller in a third scan. The third scan provides a more sensitive scan than the second scan by using one or more of: a different scan method, different scan parameters, and different thresholds.

In a further embodiment, the processing logic determines an object type from a previous scan. The object type is at least one of the hover type object, stylus type object, glove type object, or finger type object. The previous scan may be at least one of the first scan, second scan, or third scan. The processing logic scans for an object of a same object type in one or more subsequent scans until the object of the same object type is no longer detected.

In other embodiments, the processing logic detects multiple touches during any of the multiple scans.

In a further embodiment, the processing logic detects the glove type object in the second scan and activates a function of a device in which the touch controller resides, in response to the detecting the glove type object in the second scan. In one embodiment, the glove type object is detected by comparing touch data on the sense array against multiple thresholds. The processing logic determines that the first scan's touch data exceeds the gloved-finger reporting threshold and does not exceed the glove saturation threshold to detect the glove type object.

In one embodiment, the processing logic performs a mutual-capacitance scan in a mutual-capacitance mode in the second scan. In another embodiment, the processing logic performs a mutual-capacitance scan and a self-capacitance scan in a mixed mode in the second scan.

In another embodiment, the processing logic receives a pressure indicator from a pressure sensor disposed in relation to the sense array. The processing logic determines a presence of at least one of the hover type object, stylus type object, glove type object, or finger type object when the pressure indicator exceeds or does not exceed a pressure threshold.

In another embodiment, the processing logic receives an acceleration indicator from an accelerometer disposed in relation to the sense array. The processing logic determines a presence of at least one of the hover type object, stylus type object, glove type object, or finger type object when the acceleration indicator exceeds or does not exceed an acceleration threshold.

In another embodiment of the method, the processing logic measures a first set of touch data on a sense array. The processing logic determines that the touch data represents one or more touches proximate to the sense array. In one embodiment, the sense array is a capacitive sense array. Each of the cells of the capacitive sense array includes a capacitance value of an intersection of sense elements in the capacitive sense array. In a further embodiment, the first set of touch data is represented as multiple cells that each correspond to the intersections of the capacitive sense array. In a further embodiment, at least two of the two or more touches overlap on at least one of the intersections. In another embodiment of the method, the processing logic obtains a capacitive image of a capacitive sense array. The capacitive image includes multiple cells each with a capacitance value of an intersection of sense elements of the capacitive sense array. The processing logic identifies one or more touches proximate to the capacitive sense array based on the capacitive image.

The embodiments described above are discussed in scenarios where there are two touches detected on the sense array, however, the embodiments may also be used in scenarios where there is one touch, as well as three or more touches. Also, the scanning techniques may be used when the two or more touches are close together, such as when at least two touches overlap at least one sense element, as well as when the two or more touches are farther apart. Also, the embodiments described herein can be used when one or more touches are at the edge of the sensor array. For example, a partial touch may be detected at the edge of the sense array and the scanning techniques described herein can be used to determine the touch positions and the like.

In another embodiment, glove touch detection can be implemented as a device mode for a touchscreen controller, such as a touchscreen controller that already supports hover and stylus modes as described herein. In one embodiment, these modes can be enabled at blocks208and214using a system information mode field. The glove touch detection feature may be enabled or disabled independently of both the stylus detection feature and the hover detection feature. It should be noted that in some embodiments, the stylus mode described here is the high-accuracy stylus mode. The low-accuracy stylus detection that is part of the glove feature cannot be enabled or disabled independently of the glove feature at this time. The ability to independently configure the low-accuracy stylus detection is not precluded by this feature, and may be implemented together in other embodiments.

It should also be noted that, for the low signal objects such as hover type objects, stylus type objects and glove type objects (as contrasted with high signal objects such as finger type objects), an object's detection can fail if the signal detected is too large as well as too small as described and illustrated with respect toFIGS. 3, 4A, 4B.

FIG. 3illustrates four finger events including a gloved finger event detectable by the processing device ofFIG. 1according to one embodiment. The finger event302is when a finger is approaching or departing from the sense array. The finger event304is when a finger is detected proximate to the sense array and when the detected finger is moving parallel to, but not in contact with, a touch surface. The finger event306is when a finger is hovering above the sense array. The sensitivity of the sense array can detect a presence of a finger that is not touching the touch surface. A hover touch is when a finger is not actually touching the touch surface but is still detectable by the sense array. The finger event308is when a gloved finger is detected. That is the finger is covered by a glove. The gloved finger can also be detected moving along the touch surface. The embodiments of the glove touch detection do not report the finger events302,304and306. That is a glove touch is not reported when a finger is approaching or departing from the sense array (represented as a capacitor) as illustrated in the finger event302. A glove touch is not reported when a finger is moving parallel to, but not in contact with, the touch surface as illustrated in the finger event304. A glove touch is not reported when a finger is hovering as illustrated in the finger event306. A glove touch is reported when a gloved finger is on the touch surface (e.g., touch surface of a touchscreen). It should be noted that a false detection is far less acceptable than not detecting a real gloved touch. The finger events302,304,306and308can be detected in a first scan. The first scan may be a sensitive scan that precedes a second scan. The first scan may use a first sensitivity parameter that is more sensitive than a second sensitivity parameter of the second scan. The first scan may be considered a sensitive scan and the second scan may be considered a standard scan. The first scan can be used to detect a glove touch, whereas the second scan can be used to detect a finger touch. The first sensitivity parameter can be used to make the sense array more sensitive to touch objects that may be a greater distance from the touch surface. The first sensitivity parameter of the first scan can be used to detect a low signal object, such as the glove touch, and the second sensitivity parameter of the second scan can be used to detect a high signal object, such as a finger touch.

FIG. 4Aillustrates detection and reporting thresholds during a standard scan400of a touchscreen410according to one implementation. During the standard scan400, the touchscreen controller is configured such that a finger402is only reported after the detected signal passes a configurable threshold, called a finger reporting threshold430. The touchscreen controller is able to detect an object's presence at much further distance (i.e., initial detection threshold420) than the reporting distance (i.e., finger reporting threshold430). The finger reporting threshold430is usually configured to represent when a small finger makes a light touch on the touchscreen410as illustrated inFIG. 4A. The touchscreen controller can also be configured such that a finger402can be detected after the detected signal passes an initial detection threshold420; but, the finger402is reported after the detected signal passes the finger reporting threshold430. These two thresholds of the standard scan400can be set during a tuning phase. These thresholds may be programmable before runtime such as when compiled or during run-time.

FIG. 4Billustrates a detection threshold, a gloved-finger reporting threshold and a glove saturation threshold in a sensitive scan450of a touchscreen according to one embodiment. During the sensitive scan450, the touchscreen controller is configured such that a gloved finger452, which is a finger covered by a glove454, is only reported after the detected signal passes a first configurable threshold, called a gloved-finger reporting threshold470, but does not pass a second configurable threshold, called a glove saturation threshold480. The glove saturation threshold480represents when the touch object is a finger touch. The glove saturation threshold480is where the signal detected is too large to provide good data to calculate a location of a gloved touch. Therefore, at the saturation level, the scanning method can change to the standard mutual-capacitance scan. For example, when the detected signal passes the glove saturation threshold480, a standard scan can be performed to detect the finger touch as illustrated inFIG. 4A. The touchscreen controller is able to detect a gloved finger's452presence at much further distance (i.e., initial detection threshold460) than the reporting distance (i.e., gloved-finger reporting threshold470). The gloved-finger reporting threshold470can be set to represent when a gloved finger is proximate to the touchscreen410. That is the glove454may be touching the touchscreen410, but the finger within the glove454is not touching the touchscreen410because of the glove454as illustrated inFIG. 4B. Like above, the touchscreen controller can also be configured such that a gloved finger452can be detected after the detected signal passes an initial detection threshold460; but, the gloved finger452is reported after the detected signal passes the gloved-finger reporting threshold470. These three thresholds of the sensitive scan450can be set during a tuning phase. These thresholds may be programmable before runtime such as when compiled or during run-time. In one embodiment, the sensitive mutual-capacitance saturation threshold480is set to be when the finger is closer to the touchscreen410than where the mutual-capacitance finger reporting threshold430is set in order to provide a smooth transition; this provides some hysteresis between the two distances.

The standard scan400and the sensitive scan450are mutual capacitive scans. In another embodiments, the sensitive scan450can include a mutual capacitive scan and a self-capacitive scan as described herein.

FIG. 4Balso shows three typical scenarios of objects that may be detected by the sensitive scan450. The gloved finger452is one scenario described above. During the sensitive scan450, the touchscreen controller can detect a finger462approaching the touchscreen410and a finger472hovering above the touchscreen410. As described above, a touch should not be reported when a finger462is approaching or when a finger472hovering, and should report when a gloved finger452is on the touchscreen410. The non-reported events462,472are distinguished from the reported event452by one or more hardware and software algorithms.

As described above, the touchscreen controller can be configured at both compile and run-time with configuration parameters. The configuration parameters may include the following: 1) The sensitive scan450can include the standard scan's400tuning parameters, such as prescaler, TX cycles, sub-conversions, baseline configuration, reporting threshold, etc.; 2) Sensitive mutual-capacitance saturation threshold480, and the sensitive mutual-capacitance reporting threshold470; 3) Glove feature enabled at startup.

In some embodiments, the glove touch detection can use scanning data accumulation as described below in a high-level post-processing algorithm. The post-processing algorithm allows detecting a gloved finger operation without any changes in the scanning procedure by means of using the scanning data accumulation. The post-processing algorithm can be used after a centroid calculation that determines an approximate coordinate of a center of an object proximate to the sense array. In one implementation, at least three gloved finger touches can be detected using 256 bytes of memory (e.g., RAM).

When using gloved fingers to operate a touchscreen, there is signal deterioration in the mutual-capacitance scanning results, as compared to when using non-gloved fingers. This is because the surface of the finger is remote from the sense array at least the glove's material thickness. This may be equivalent to increasing an overlay thickness disposed to cover the sense array by the material thickness. As a result, during a gloved finger operation, the algorithm for finding local maximums cannot detect any local maximums, because they are lower than the FingerTheshold value (e.g., finger reporting threshold430). The difference data examples for gloved fingers552and ungloved fingers502are shown inFIGS. 5A and 5B.

FIG. 5Aillustrates a visual representation of difference data500of a mutual-capacitance scan of a touchscreen representing four ungloved fingers502according to one embodiment.FIG. 5Billustrates a visual representation of difference data550of a mutual-capacitance scan of a touchscreen representing four gloved fingers552according to one embodiment. As described above, the gloved fingers552are not detected as touches as their difference data does not exceed the finger reporting threshold. Using the glove touch detection embodiments described herein, the gloved fingers552can be detected as glove touch events. As a result, operations can be performed on the touchscreen without the user removing the glove to interact with the touchscreen.

The glove touch detection embodiments, by way of the sensitive scan, separate any low reaction of the measuring channels from continual in time gloved finger operations and short-time unstable reactions, such as those resulting from external noise reactions. At the same time, the ungloved finger operation characteristics stay the same as measured in standard scans.

As the base for gloved finger operation detection, the touchscreen controller can use the difference values after the baseline calculation. It can be D matrix of the difference values for all intersections of a sense array, such as sensors of Nrows*Mcolumnssensors panel. One way the touchscreen controller detects a gloved finger touch is to amplify the processing signal D to reach the FingerTheshold processing level. We can calculate an extra sensitive Dg gloved finger differences matrix as in the following equation (1):
Dg=G*D,(1)
where G is gain. In this case, the touchscreen controller receives the noises multiplied by G too. It may be better to use the running sum of G last scanning frames of D matrix to calculate Dg as in the following equation (2):

In this case, the touchscreen controller can obtain the same multiplying factor G for the signal, but with lower noise dependence. To collect all necessary data for Dg calculation, the touchscreen controller uses N*N*G words of the memory. The touchscreen controller can also change the FIR signal filtration in equation (2) for IIR filtration to reduce the used memory size as in the following equation (3):
Dgi=α*Dgi-1+(1−α)*(G*Di), 1>α>0.5,  (3)
where α is the filter time constant. To calculate the current Dgimatrix, the touchscreen controller needs the previous scanning frame Dgi-1matrix and current Dimatrix. The choice of G and α values may depend on the glove's material thickness, SNR of the signal, and operating stability expectation. The equation (3) with a fixed data point can be written as in the following equation (4):

Dgi=α*Dgi-1+(A-α)*(G*Di)A.(4)
where A=2n, 2n-1<α<2n. Hence, the touchscreen control can use a traditional algorithm for finding local maximums and centroid algorithms for Dg matrix, then gloved finger touches can be detected. Therefore, the touchscreen controller can calculate Dg matrix and try to detect any gloved finger touches if a normal finger activity is not present.

In one embodiment, to control switching between normal mode operations (e.g., standard scanning) and glove mode operations, a state machine can be used to transition between the modes. Timeouts can be used to switch between the modes. These timeout values can be tunable as configurable parameters. An example of one state machine is illustrated and described with respect toFIG. 6.

FIG. 6is a state machine600to control touch detection according to another embodiment. The state machine600starts at state602and moves into “gloves off” state604. At gloves off state604, the touchscreen controller operates in a normal scanning mode. In “gloves off” state604, the gloved finger detection procedure does not work and Dg matrix is not calculated. During this state, if there is no normal finger touch detected within a first timeout period601, the state machine600transitions to the “gloves listen” state606. For example, if there is no activity on the sense array during 1 second, the first timeout period, the state switches to the “gloves listen” state606. During the “gloves listen” state606, the touchscreen controller uses the gloved finger detection procedures and calculates the Dg matrix. In this state606, the touchscreen controller does not report gloved touches if they are detected, but switches to the “gloves off” state604if a normal touch appears603in the “gloves listen” state606. The normal touch can be reported immediately. If at state606, if one or more gloved touches are present continuously during a second timeout period605(e.g., 0.1 seconds), the state switches to “gloves operation” state608.

In the “gloves operation” state608, the touchscreen controller utilizes the gloved finger detection procedures and calculates the Dg matrix. The touchscreen controller reports gloved touches if they are detected. The state switches to “gloves wait” state610if a normal touch appears609or to “gloves listen” state606if no activity is present during a third timeout607(e.g., 60 seconds).

In the “gloves wait” state610, the touchscreen controller detects and reports normal touches as the normal touches are present during a fourth timeout period612(e.g., 0.1 seconds) and transitions to the “gloves off” state604. The state switches to the “gloves operation” state608if the normal touch disappears611before the fourth timeout period612.

FIG. 7is a flow diagram of a method700of glove touch detection algorithm according to another embodiment. The method700may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), software (such as is run on a general purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In one embodiment, the processing device110performs the method700. In another embodiment, the glove touch detection tool120performs the method700. Alternatively, other components of the electronic system100perform some or all of the operations of method700.

Referring toFIG. 7, the method700begins with processing logic with a panel scan, a baseline calculation and a centroid calculation (block702), and increments a counter (block704). The processing logic determines if the touch counter is greater than 1 (TouchCount>1) (block706). If the touch counter is greater than 1 at block706, the processing logic determines if the state is in the “gloves operation” state (block708). If yes at block708, the processing logic sets a gloves frames counter (factor G in equation (2)) to zero and puts the state into “gloves wait” state (block710); otherwise, if no at block708, the processing logic skips the operation at block710. At block712, the processing logic determines if the counter is greater than a timeout associated with the “gloves wait” state and the state is in the “gloves wait” state (block712). If yes at block712, the processing logic sets the state to “gloves off” state (block714), and the processing logic determines if the state is set to “gloves off” state (block716). If no at block712, the processing logic determines if the state is in the “gloves listen” state (block720). If yes at block720, the processing logic returns to block714to set the state to “gloves off” state; otherwise, the processing logic proceeds to block722in which the Dg matrix is calculated and a centroid is calculated using the Dg matrix. Also, if no at block716, the processing logic proceeds to block722; otherwise, the processing logic sets the counter to zero (block718) and proceeds to block724. At block724, the processing logic can perform finger identification algorithms, XY filtering, and host communication operations. From block724, the processing logic returns to block702.

If the processing logic determines that the touch counter is not greater than 1, the processing logic determines if the state is in “gloves wait” state (block726). If yes at block726, the processing logic sets the gloves frames counter to zero and sets the state to “gloves operation” state (block728) and proceeds to block722). If at block726the processing logic determines that the state is not set to “gloves wait” state, the processing logic determines if the state is set to “gloves off” state (block730). If not at block730, the processing logic proceeds to block722; otherwise, the processing logic determines if the counter is greater than a timeout period in which there is no normal activity detected (block732). If yes at block732, the processing logic sets the gloves frames counter to zero and sets the state to “gloves listen” state (block734) and proceeds to block722. If at block732the processing logic determines that the counter is not greater than the timeout period in which there is no normal activity detected, the processing logic proceeds to block724.

At block722, the processing logic calculates the Dg matrix and calculates a centroid calculation using the Dg matrix. The processing logic determines if the touch counter is greater than one (block736). If yes at block736, the processing logic determines if the state is “gloves listen” state (block738). If yes at block738, the processing logic determines if the counter is less than a timeout period associated with the “gloves listen” state (block740). If at block738the processing logic determines that the state is not in the “gloves listen” state, the processing logic sets the counter to zero (block742) and proceeds to block724. If at block740the processing logic determines that the counter is less than the timeout period, the processing logic sets the touch counter to zero (block744) and proceeds to block724. If at block740the processing logic determines that the counter is not less than the timeout period, the processing logic sets the state to the “gloves operation” state and sets the counter to zero (block746) and proceeds to block724.

If at block736the processing logic determines that the touch counter is greater than one, the processing logic determines if the state is set to “gloves operation” state (block748). If yes at block748, the processing logic determines if the counter is greater than a timeout period in which there is no glove activity (block750). If yes at block750, the processing logic sets the state to “gloves listen” state and sets the counter to zero (block752) and proceeds to block724. If at block750the processing logic determines that the counter is not greater than the timeout period, the processing logic proceeds to block724without performing the operation at block752. If the processing logic at block748determines that the state is not set to “gloves operation” state, the processing logic determines if the state is set to “gloves listen” state (block754). If yes at block754, the processing logic sets the counter to zero (block756) and proceeds to block724; otherwise, if at block754the processing logic determines that the state is not set to “gloves listen” the processing logic proceeds to block724.

In one embodiment, the touchscreen controller can use M*N*2 bytes of RAM to collect and calculate Dg matrix. For example, if the touchscreen controller uses 22×28 scanning matrix, the touchscreen controller needs 1232 bytes RAM (E.g., 22*28*2=1232 bytes) to store Dg matrix. Usually all the cells of D matrix contain Zero value, except several cells with non-zero values if fingers are present on the panel (seeFIGS. 5A and 5B). So it is not necessary to store all the cells of Dg matrix, but only non-zero values. One gloved finger touch can affect changes to 10-20 sensors cells (seeFIG. 5B). So, a 64 cell array may be enough for Dg matrix to store differences data of at least 3 gloved finger touches. The touchscreen controller can use a 2*64 cell table to store Dg. The first column of the table can contain non-zero values of Dg, the second column can contain the index of a corresponding cell in D matrix. Thus, to store Dg differences data of at least 3 gloved finger touches only uses 256 bytes (e.g., 64 cells*2 columns*2 bytes=256 byte).FIG. 8illustrates a difference matrix800and an indexed array802according to one embodiment. The different matrix800is a 7×5 matrix and can be presented as the indexed array802.

In one embodiment, the touchscreen controller copies the values from an indexed array, which contains Dg values, to an array which represents D matrix in the project in order to run a standard centroid algorithm using a calculated Dg matrix. Then it is possible to run the standard Centroid algorithm. In one implementation, the algorithm can take about 1.3 ms in the “gloves listening” state, 3 ms in the “gloves operations” state and does not take any time if normal touches are detected. Alternatively, other processing time periods may be incurred.

In another embodiment, a part of the algorithm can be integrated into the Centroid algorithm. In this embodiment, the total gloves data processing (including the part in the Centroid algorithm) takes 0.4 ms in the “gloves listening” state, 2 ms in the “gloves operations” state and takes no time if normal touches are detected.

It should be noted that detection of fingers in thin gloves may results in difference values close to the finger reporting threshold, FingerTheshold value, and could be detected as a normal touch, but depends on the finger pressure. By adding the “gloves wait” state as described above, this may be resolved. If a gloved finger is detected, the FingerTheshold value for normal touches detection can be increased.

FIG. 9is a graph900illustrating sensitivity of a sensitive scan and a standard scan according to one embodiment. The graph900represents the percentage of the maximum signal of the sensitive scan and the standard scan in the y-axis and estimated object distance from the touchscreen and object contact size in the x-axis. More specifically, the estimated object distance is to the left of a touch902and the object contact size is to the right of the touch902. During a sensitive scan, a measured signal904is compared to a sensitive scan threshold906that represents a saturation level of the sensitive scan. During the sensitive scan, any measured signal904that goes above the sensitive scan threshold906(e.g., 90% of maximum), causes the current scan method to change from sensitive scan to standard scan. Similar, during a standard scan, any measured signal908that goes below a standard scan threshold910(e.g., 14% of maximum), causes the current scan method to change from standard scan to sensitive scan.

In some embodiments, a measured signal904,908in either the glove range or in the finger range are not automatically detected as touches and other detection criteria can also be used to detect them as touches. For example, one of the detection criteria may be hysteresis so as to prevent toggling between the sensitive scan and standard scan. Also, the transition from standard scan to sensitive scan could be prevented in software, since the use case for a real finger turning into a gloved touch so rapidly may not be possible.

The embodiments described herein may provide one or more benefits to the conventional solutions. For example, the embodiments described herein may result in significantly fewer false glove detections with approaching or hovering fingers and may result in significantly higher accuracy. The embodiments described herein can also provide interoperability with the low-accuracy stylus detection, as well as provide multi-touch support for both fingers and gloved fingers.

In embodiments where the touchscreen controller currently supports hierarchical scanning, as described herein, the addition of glove scanning could be added with the addition some additional storage for the glove tuning parameters.

In some embodiments, the algorithm described herein can be used to detect gloved finger operation for gloves with thickness up to 1.8 mm. The use of these gloved finger techniques does not affect the detection of ungloved touches. That is during the algorithm for gloved finger detection, there is no operation degradation of operating parameters.

As described herein, the embodiments of glove touch detection allow a user to perform time-critical operations with their devices without panicking to remove their gloves. For example, receiving a phone call while wearing gloves would almost always result in the call being missed. Now, using the glove touch detection embodiments, the user can receive the phone call while wearing gloves, as well as many other user interactions with the touchscreen. The embodiments may also allow a user full access to their device while wearing gloves, not just time-critical operations. This would be particularly attractive during activities where gloves are constantly worn; for example, driving, skiing, walking, etc. An in-car control system (entertainment or information system) with a touchscreen would be practically useless to a driver that wears gloves. Using the embodiments described herein, the driver that wears gloves could interact with the in-car control system.

As described above, a sensitive mutual-capacitance scan can be used to detect a finger even through a glove. An extra layer in the scanning hierarchy can be used to add the sensitive mutual-capacitance scan. Adding the extra layer in the scanning hierarchy may allow the performance of the other scanning methods to be unaffected by the addition of the sensitive mutual-capacitance scan for glove touch detection. Using mutual-capacitance scanning for the sensitive scan can allow for higher accuracy and multi-touch support.

In addition to the additional sensitive scan, additional processing may be used to improve the glove touch detection feature. For example, the glove touch data can be filtered to provide more robust rejection of false glove detections. In another embodiment, self-capacitance scan (or other advanced scanning methods) can be performed and the self-capacitance scan data can be used along with the sensitive mutual-capacitance scan to more accurately detect if a gloved touch is present.

The glove touch detection feature as described herein uses a scanning hierarchy to produce a similar range of data from all hierarchical levels. The tuning for each of the hierarchical levels is defined at the panel's design-time, and do not change thereafter. In another embodiment, the scanning method can be changed to dynamically adapt the scanning parameters, also called tuning parameters, such as prescaler, TX cycles, sub-conversions, thresholds, etc. Using this method, the scanning parameters would gravitate to a sensitive scan setting when no touches were detected. This would allow the detection of low signal objects like a stylus or a gloved touch. When a real finger touches the panel, the scan data would saturate and the scanning parameters would be updated to provide a less sensitive scan. In another embodiment, the scanning method can be configured to detect a wider range of input. This would allow the detection of low signal objects with the same scan as high signal objects. To preserve signal-to-noise (SNR), a much larger output range would also be necessary. A larger output range could be provided by one of the following: 1) Change the raw data from bytes (8-bit) to words (16-bit) or even double-words (32-bit). This would allow the detection of the sensitive scan data even when a large finger is pressed to the panel producing very large signals. 2) Change the processing of the data to provide a dynamic offset. If only small signals are detected, the offset is small. If large signals are detected the offset would be large and the small signals would be ignored. This is basically a simplification of the previous method, by using a sliding and possibly stretching window.

In another embodiment, the sensitive mutual-capacitance scan can be combined with a self-capacitance scan (or other scanning method) to produce useful information to more accurately detect the presence of a glove touch. In another embodiment, the pressure on the touchscreen could be detected. When combined with the lack of a capacitive signal, a gloved touch could be inferred. However, false touches could be a big problem with this method, for example from pocket litter. The pressure on the touchscreen could be measured by a pressure sensor that provides a pressure indicator to the touchscreen controller as one of the inputs to the algorithm. In one embodiment, the touchscreen controller receives a pressure indicator from a pressure sensor disposed in relation to the sense array and determines a presence of at least one of the hover type object, stylus type object, glove type object, or finger type object when the pressure indicator exceeds or does not exceed a pressure threshold.

In another embodiment, an accelerometer can be used to detect the “jolt” when the touchscreen is touched. However this method would incur the same false detection problems as with the pressure method above. The acceleration on the touchscreen could be measured by a sensor that provides an acceleration indicator to the touchscreen controller as one of the inputs to the algorithm. In one embodiment, the touchscreen controller receives an acceleration indicator from an accelerometer disposed in relation to the sense array and determines a presence of at least one of the hover type object, stylus type object, glove type object, or finger type object when the acceleration indicator exceeds or does not exceed an acceleration threshold.

It should also be noted that if only a subset of thin gloves is required, then the sensitive scan tuning could be much tighter resulting in a far more robust solution. If the subset was reduced enough, then only one “slight more sensitive” scan could be used to detect both finger touches and gloved touches. This could result in a poorer user experience for finger touches, as the finger would be detected before it touched the panel. A solution using two reporting thresholds could be used instead, but then a filter could be used on the lower threshold to reject approaching and hovering fingers.

FIG. 10is a diagram of one embodiment of a computer system for glove touch detection. Within the computer system1000is a set of instructions for causing the machine to perform any one or more of the methodologies discussed herein. In alternative embodiments, the machine may be connected (e.g., networked) to other machines in a LAN, an intranet, an extranet, or the Internet. The machine can be a host in a cloud, a cloud provider system, a cloud controller or any other machine. The machine can operate in the capacity of a server or a client machine in a client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a console device or set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a server, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term “machine” shall also be taken to include any collection of machines (e.g., computers) that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

The exemplary computer system1000includes a processing device1002(e.g., host processor150or processing device110ofFIG. 1), a main memory1004(e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or DRAM (RDRAM), etc.), a static memory1006(e.g., flash memory, static random access memory (SRAM), etc.), and a secondary memory1018(e.g., a data storage device in the form of a drive unit, which may include fixed or removable computer-readable storage medium), which communicate with each other via a bus1030.

The computer system1000may further include a network interface device1022. The computer system1000also may include a video display unit1010(e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)) connected to the computer system through a graphics port and graphics chipset, an alphanumeric input device1012(e.g., a keyboard), a cursor control device1014(e.g., a mouse), and a signal generation device1020(e.g., a speaker).

The secondary memory1018may include a machine-readable storage medium (or more specifically a computer-readable storage medium)1024on which is stored one or more sets of instructions1026embodying any one or more of the methodologies or functions described herein. In one embodiment, the instructions1026include instructions for the glove touch detection tool120. The instructions1026may also reside, completely or at least partially, within the main memory1004and/or within the processing device1002during execution thereof by the computer system1000, the main memory1004and the processing device1002also constituting machine-readable storage media.

The instructions1026, components and other features described herein can be implemented as discrete hardware components or integrated in the functionality of hardware components such as ASICS, FPGAs, DSPs or similar devices. In addition, the instructions1026can be implemented as firmware or functional circuitry within hardware devices. Further, the instructions1026can be implemented in any combination of hardware devices and software components.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the above discussion, it is appreciated that throughout the description, discussions utilizing terms such as “encrypting,” “decrypting,” “storing,” “providing,” “deriving,” “obtaining,” “receiving,” “authenticating,” “deleting,” “executing,” “requesting,” “communicating,” or the like, refer to the actions and processes of a computing system, or similar electronic computing device, that manipulates and transforms data represented as physical (e.g., electronic) quantities within the computing system's registers and memories into other data similarly represented as physical quantities within the computing system memories or registers or other such information storage, transmission or display devices.

Embodiments descried herein may also relate to an apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a non-transitory computer-readable storage medium, such as, but not limited to, any type of disk including floppy disks, optical disks, CD-ROMs and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, flash memory, or any type of media suitable for storing electronic instructions. The term “computer-readable storage medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database and/or associated caches and servers) that store one or more sets of instructions. The term “computer-readable medium” shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that causes the machine to perform any one or more of the methodologies of the present embodiments. The term “computer-readable storage medium” shall accordingly be taken to include, but not be limited to, solid-state memories, optical media, magnetic media, any medium that is capable of storing a set of instructions for execution by the machine and that causes the machine to perform any one or more of the methodologies of the present embodiments.