Capacitive Touch PIC16F886 მიკროკონტროლით: 3 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ამ სახელმძღვანელოში ჩვენ განვიხილავთ, თუ როგორ შეგიძლიათ გამოიყენოთ PIC16F886 მიკროკონტროლერი ტევადობის განსხვავებების გამოსავლენად, ეს მოგვიანებით შეიძლება გამოყენებულ იქნას იმის დასადგენად, არის თუ არა შეხების ბალიშზე დაჭერილი. კარგია იცოდეთ სურათის მიკროკონტროლერები ამ პროექტის განხორციელებამდე.

ნაბიჯი 1: შეაერთეთ თქვენი წრე

პირველი, დავიწყოთ სქემის გაყვანილობით ზემოთ სქემატური სქემის მიხედვით. სენსორული ბალიშის გასაკეთებლად შეგიძლიათ ალუმინის კილიტა კვადრატში მოათავსოთ და დააწებოთ მავთულზე. თქვენ შეგიძლიათ ექსპერიმენტი გააკეთოთ სხვადასხვა მნიშვნელობებით 100k რეზისტორისთვის, მე აღმოვაჩინე, რომ 100k კარგად მუშაობდა ჩემთვის.

RC4 პინი გამოიყენება შესაფასებელი ტევადობის დატენვის/დაცლის დასაწყებად. C12IN0 უკავშირდება შიდა შედარების მხარეს და C1IN პინი უკავშირდება იმავე შედარების + მხარეს. მიკროკონტროლი ხედავს, რომ ტევადობა სრულად არის დამუხტული, როდესაც C12IN0 ძაბვა აღწევს C1IN ძაბვის ზემოთ. რეზისტენტული ძაბვის გამყოფი დარწმუნებულია, რომ C1IN ახლოს არის 5 ვოლტთან.

მას შემდეგ, რაც სენსორული დაფა დამოკიდებულია იმაზე, რომ თქვენსა და მიკროსქემის მიწას შორის არის მნიშვნელოვანი ტევადობა, არსებობს შესაძლებლობა, რომ ბატარეა არ იმუშაოს.

ნაბიჯი 2: სათაურის ფაილი

დასრულდა ყველა კავშირი? კარგი, ჩვენ გავაგრძელებთ სათაურის ფაილს. ჩვენ ვიყენებთ XC8 შემდგენელს და როგორც სათაურიდან ჩანს, თქვენ ახლა შექმნით ახალ სათაურის ფაილს თქვენს პროექტში და დააკოპირეთ შემდეგი კოდი. თქვენ ასევე შეგიძლიათ კოპირება-ჩასმა თქვენს მთავარ კოდზე, ყოველგვარი სათაურის გარეშე.

#განსაზღვრეთ CALIBRATION_SAMPLE 20 #განსაზღვრეთ TOUCH_SAMPLE 10 #განსაზღვრეთ DISCHARGE_TIME 5

int დათვლა;

int calibrationValue, maxCalibrationValue, minCalibrationValue;

int getChargeTime () {

int timerCount = 0; int overflowCount = 0; // განისაზღვრება განმუხტვის ტევადობა RC4 = 0; _გადადება_წთ (DISCHARGE_TIME); // მიეცით საკმარისი შეფერხება სრულად (თითქმის სრულად რეალურად) "კონდენსატორის" ამოღების მიზნით // გაწმინდეთ ტაიმერის გადავსების დროშა T0IF = 0; // დაელოდეთ ტაიმერის ამოვსებას, დაიწყეთ დათვლა 0 – დან (! T0IF); T0IF = 0; // დატენვის მოცულობის გაზომვა RC4 = 1; // დაელოდეთ ტევადობის დასატენად რეფერენციულ ძაბვამდე (C1OUT) {timerCount = TMR0; if (T0IF) {overflowCount ++; T0IF = 0; }} რაოდენობა = (256 * overflowCount) + timerCount; // გადატვირთვა timerCount timerCount = 0; overflowCount = 0; დაბრუნების რაოდენობა; }

int isTouching (int ტოლერანტობა) {

// მრავალჯერადი ნიმუშის საშუალო ორმაგი საშუალო = 0; for (int i = 0; i calibrationValue+tolerance) საშუალო ++; } საშუალო /= TOUCH_SAMPLE; // საშუალო იქნება რიცხვი 0 -დან 1 -მდე, თუ (საშუალო> 0.2) დააბრუნებს 1; დაბრუნება 0; }

ბათილად დაკალიბრება () {

int საშუალო = 0; int ნიმუშები [CALIBRATION_SAMPLE]; // მიიღეთ საშუალო მნიშვნელობა (int i = 0; i <CALIBRATION_SAMPLE; i ++) {sample = getChargeTime (); საშუალო += ნიმუშები ; } საშუალო /= CALIBRATION_SAMPLE; calibrationValue = საშუალო; // მიიღეთ max/min მნიშვნელობები maxCalibrationValue = ნიმუშები [0]; minCalibrationValue = ნიმუშები [0]; for (int i = 0; i maxCalibrationValue) maxCalibrationValue = ნიმუშები ; თუ (ნიმუშები <minCalibrationValue) minCalibrationValue = ნიმუშები ; }}

void setupCapacitiveTouch () {

// დატენვის/განმუხტვის პინის დაყენება გამომავლად, ამ შემთხვევაში ეს არის RC4 TRISCbits. TRISC4 = 0; // ტაიმერის დაყენება 0 T0CS = 0; PSA = 1; // შედარების დაყენება C1CH0 = 0; C1CH1 = 0; C1R = 0; C1ON = 1; C1POL = 0; // გაწმენდის რაოდენობა ღირებულებების რაოდენობა = 0; // დაკალიბრების მნიშვნელობების გაწმენდა calibrationValue = 0; maxCalibrationValue = 0; minCalibrationValue = 0; // კალიბრაციის გაშვება დაწყების დაკალიბრებაზე (); }

ნაბიჯი 3: ძირითადი კოდის ჩაწერა

დაწყებული ძირითადი კოდით, თქვენ უნდა შეიტანოთ წინა საფეხურზე შექმნილი სათაურის ფაილი. შემდეგი კოდი არის მაგალითი იმისა, თუ როგორ შეგიძლიათ გამოიყენოთ isTouching ფუნქცია როგორც გადამრთველი. ჩემს შემთხვევაში სათაურს მივეცი სახელი capacitiveTouch.h.

#ჩართეთ

#მოიცავს "capacitiveTouch.h"

// ეს ცვლადი გვეუბნება, არის თუ არა ღილაკი დაჭერილი

int lastState = 0;

ბათილია მთავარი () {

// RC5- ის გამოყვანა TRISCbits. TRISC5 = 0; // თქვენ უნდა გამოიძახოთ ეს ფუნქცია პროგრამის setupCapacitiveTouch () დაწყებისთანავე; _გადადება_მმ (1000); // დაკალიბრება თქვენი ზუსტი დაყენების შემდეგ დაკალიბრება (); ხოლო (1) {// შემოწმება ხდება თუ არა ღილაკზე დაჭერილი თუ (isTouching (15) && lastState == 0) {if (RC5) RC5 = 0; სხვაგან RC5 = 1; lastState = 1; } // შემოწმება ხდება თუ არა ღილაკის გამოშვება სხვა შემთხვევაში (lastState == 1 &&! isTouching (15)) lastState = 0; _გადადება_მმ (20); }}

დაკალიბრება:

როდესაც ეს ფუნქცია ეწოდება ცვლადებს calibrationValue, maxCalibrationValue და minCalibrationValue განახლდება. calibrationValue გამოიყენება isTouching ფუნქციით. გაითვალისწინეთ, რომ სენსორული ბალიში დაკალიბრებისას მარტო უნდა დარჩეს.

setupCapacitiveTouch:

უნდა დარეკოთ თქვენი პროგრამის დასაწყისში. ის ადგენს საჭირო ბიტებს, რომლებიც გამოიყენება სხვა ფუნქციებისათვის. ასევე აწარმოებს კალიბრაციას. თუმცა მე უკეთესი შედეგი მივიღე წამით ლოდინით და კალიბრაცია კვლავ ცალკე გავუშვი.

isTouching:

ეს ფუნქცია აბრუნებს 1 -ს, თუ აღმოაჩენს C12IN0- ზე ტევადობის ზრდას და დააბრუნებს 0 -ს, თუ ტევადობა ახლოს არის კალიბრაციის დროს. მარტივად რომ ვთქვათ, თუ ვინმე შეეხება ბალიშს, isTouching ფუნქცია დაუბრუნდება 1. ფუნქციას ასევე უნდა პარამეტრი, როგორც შეყვანის, ეს არის ტოლერანტობა მისი გამოწვევისთვის. რაც უფრო მაღალია ტოლერანტობის მნიშვნელობა, მით უფრო მგრძნობიარე ხდება იგი. ჩემს კონფიგურაციაში აღმოვაჩინე, რომ 15 კარგად მუშაობს, მაგრამ რადგან ეს დამოკიდებულია ოცილატორის სიხშირეზე და იმაზე, თუ რამდენ ტევადობას ემატება მისი დაჭერისას, თქვენ უნდა გაიაროთ ექსპერიმენტი ამ მნიშვნელობით, სანამ არ იპოვით იმას, რაც თქვენთვის მუშაობს.

getChargeTime:

როდესაც გსურთ იცოდეთ რამდენი დრო დასჭირდება CVREF ძაბვის ტევადობის დატენვას, ეს ფუნქცია შეამოწმებს მას და დააბრუნებს მთელ რიცხვს. წამში დროის მისაღებად გამოიყენეთ ეს ფორმულა: (4 * getChargeTime) / oscillatorFrequency = chargeTimeInSeconds ეს ფორმულა ასევე შეიძლება გამოყენებულ იქნას isTouching ფუნქციის ტოლერანტობის შეყვანის წამებში.