આ ટ્યુટોરિયલમાં, આપણે ESP32 મોડ્યુલ સાથે ઇન્ફ્રારેડ અવરોધ ટાળવાની સેન્સરનો ઉપયોગ કરીને અવરોધો શોધવાનું શીખીશું. આ પ્રોજેક્ટ દર્શાવશે કે કેવી રીતે સેન્સર અવરોધ શોધાય ત્યારે બઝરને ટ્રિગર કરી શકે છે. આ સેટઅપ સીરિયલ મોનિટર પર શોધ સ્થિતિ પણ દર્શાવશે, જે સેન્સરની કાર્યક્ષમતાને અવલોકન કરવાની સ્પષ્ટ અને ઇન્ટરેક્ટિવ રીત પ્રદાન કરશે.
આપણે SunFounder ESP32 IoT લર્નિંગ કિટ સાથે કામ કરીશું, જેમાં Wi-Fi અને બ્લૂટૂથ ક્ષમતાઓ ધરાવતો ESP32 માઇક્રોકંટ્રોલર શામેલ છે. ઇન્ફ્રારેડ સેન્સર ઇન્ફ્રારેડ પ્રકાશ મોકલીને કામ કરે છે, જે નજીકના અવરોધો પરથી પ્રતિબિંબિત થશે. જ્યારે પ્રકાશ પાછો પ્રતિબિંબિત થાય છે, ત્યારે સેન્સર આઉટપુટ સિગ્નલ ટ્રિગર કરશે જે આપણે આપણા કોડમાં વાંચીશું. આપણે એક બઝર પણ શામેલ કરીશું જે અવરોધ શોધાય ત્યારે સક્રિય થાય છે, જે શ્રાવ્ય ચેતવણી પ્રદાન કરે છે.
હાર્ડવેર સમજાવ્યું
આ પ્રોજેક્ટના મુખ્ય ઘટકોમાં ESP32 મોડ્યુલ, ઇન્ફ્રારેડ અવરોધ ટાળવાની સેન્સર અને બઝર શામેલ છે. ESP32 મોડ્યુલ કેન્દ્રીય પ્રોસેસિંગ એકમ તરીકે સેવા આપે છે, સેન્સર ઇનપુટ્સ સંભાળે છે અને આઉટપુટ્સ નિયંત્રિત કરે છે. તેને લિથિયમ બેટરીનો ઉપયોગ કરીને પાવર કરી શકાય છે, જે તેને વિવિધ એપ્લિકેશનો માટે પોર્ટેબલ અને લવચીક બનાવે છે.
ઇન્ફ્રારેડ અવરોધ ટાળવાની સેન્સરમાં ટ્રાન્સમિટર અને રીસીવર શામેલ છે. ટ્રાન્સમિટર ઇન્ફ્રારેડ પ્રકાશ ઉત્સર્જિત કરે છે, જ્યારે રીસીવર નજીકના પદાર્થોમાંથી પ્રતિબિંબિત પ્રકાશ શોધે છે. જ્યારે અવરોધ હાજર હોય છે, ત્યારે સેન્સરનો આઉટપુટ પિન નીચો જાય છે, જે ESP32 ને ક્રિયા લેવાનો સંકેત આપે છે, જેમ કે બઝર ચાલુ કરવું.
ડેટાશીટ વિગતો
ઉત્પાદક
SunFounder
ભાગ નંબર
ઇન્ફ્રારેડ અવરોધ ટાળવાની સેન્સર
ઓપરેટિંગ વોલ્ટેજ
3.3 V - 5 V
આઉટપુટ પ્રકાર
ડિજિટલ (અવરોધ શોધાય ત્યારે નીચું)
શોધ શ્રેણી
20 સેમી સુધી
પ્રતિભાવ સમય
10 એમએસ કરતાં ઓછો
પેકેજ
મોડ્યુલ
પાવર સપ્લાય: ઓપરેશન માટે 3.3 V થી 5 V.
અવરોધ શોધાય ત્યારે આઉટપુટ સિગ્નલ નીચું જાય છે.
પોટેન્શિયોમીટર દ્વારા સંવેદનશીલતા ગોઠવી શકાય છે.
સામાન્ય શોધ શ્રેણી 20 સેમી સુધી છે.
10 એમએસ કરતાં ઓછો ઝડપી પ્રતિભાવ સમય.
વાયરિંગ સૂચનાઓ
ESP32-19-obstacle_voide-wiring
ઇન્ફ્રારેડ અવરોધ ટાળવાની સેન્સરને ESP32 સાથે વાયર કરવા માટે, સેન્સરના VCC પિનને ESP32 પરના 5V પિન સાથે જોડીને શરૂ કરો. આગળ, સેન્સરના GND પિનને ESP32 પરના એક GND પિન સાથે જોડો. છેલ્લે, સેન્સરના OUT પિનને ESP32 પરના GPIO પિન 14 સાથે જોડો.
બઝર માટે, નકારાત્મક ટર્મિનલને GND સાથે અને હકારાત્મક ટર્મિનલને GPIO પિન 27 સાથે જોડો. ખાતરી કરો કે બધા જોડાણો સુરક્ષિત છે અને સેન્સર યોગ્ય રીતે પાવર થયેલ છે. વાયરિંગ સીધું હોવું જોઈએ, કારણ કે સેન્સર અને બઝરને ફક્ત સરળ પાવર અને સિગ્નલ જોડાણોની જરૂર છે.
કોડ ઉદાહરણો અને વોકથ્રુ
કોડમાં, આપણે પહેલા અવરોધ ટાળવાની સેન્સર સાથે જોડાયેલ પિન વ્યાખ્યાયિત કરીએ છીએ. આ avoidPin ઓળખકર્તાનો ઉપયોગ કરીને 14 પર સેટ કરવામાં આવે છે. આપણે સેન્સરના આઉટપુટ સ્થિતિને પકડી રાખવા માટે avoidState ચલ પણ જાહેર કરીએ છીએ.
const int avoidPin = 14; // અવોઇડ મોડ્યુલ પિનનો નંબર
int avoidState = 0;
સેટઅપ ફંક્શનમાં, આપણે સીરિયલ કમ્યુનિકેશન શરૂ કરીએ છીએ અને avoidPin ને ઇનપુટ તરીકે સેટ કરીએ છીએ. આ ESP32 ને સેન્સરના આઉટપુટ સ્થિતિ વાંચવાની મંજૂરી આપે છે.
લૂપ ફંક્શનમાં, આપણે digitalRead(avoidPin) નો ઉપયોગ કરીને સેન્સરના આઉટપુટને સતત વાંચીએ છીએ અને પરિણામ avoidState માં સંગ્રહિત કરીએ છીએ. આ મૂલ્ય પછી સીરિયલ મોનિટર પર છાપવામાં આવે છે, જે આપણને જોવાની મંજૂરી આપે છે કે અવરોધ શોધાયો છે (આઉટપુટ 0 હશે) કે નહીં (આઉટપુટ 1 હશે).
જ્યારે સેટઅપ પૂર્ણ થાય અને કોડ અપલોડ થાય, ત્યારે તમારે સીરિયલ મોનિટર પર અવરોધ શોધાયો છે કે નહીં તેના આધારે 0 અથવા 1 પ્રદર્શિત થતું જોવું જોઈએ. જ્યારે અવરોધ શોધ શ્રેણીમાં હોય છે, ત્યારે આઉટપુટ 0 વાંચશે, અને બઝર વાગશે. જો અવરોધ દૂર કરવામાં આવે છે, તો આઉટપુટ 1 વાંચશે, અને બઝર બંધ થશે. આ કાર્યક્ષમતા વિડિઓમાં દર્શાવવામાં આવી છે (વિડિઓમાં 12:30 પર).
સામાન્ય સમસ્યાઓમાં ખોટી વાયરિંગ શામેલ હોઈ શકે છે, જે સેન્સરને યોગ્ય રીતે કાર્ય ન કરવા તરફ દોરી શકે છે, અથવા સીરિયલ મોનિટરમાં મેળ ખાતી ન હોય તેવી બૉડ રેટ, જે ડેટાને ચોક્કસ રીતે પ્રદર્શિત થતા અટકાવે છે. જો તમને સમસ્યાઓ આવે તો આ પાસાઓ તપાસવાની ખાતરી કરો.
વિડિઓ સમયસ્ટેમ્પ્સ
00:00 શરૂઆત
1:57 પ્રોજેક્ટ પરિચય
4:33 અવરોધ ટાળવાની વાયરિંગ
5:55 અવરોધ ટાળવા માટે આર્ડુઇનો કોડ
7:36 આર્ડુઇનો IDE પર ESP32 બોર્ડ અને COM પોર્ટ પસંદ કરવું
818-ESP32 Tutorial 19/55- Arduino code for obstacle avoidance module
ભાષા: C++
// set pin
const int avoidPin = 14; // the number of the avoid avoid module pin
// variable for storing the avoid status
int avoidState = 0;
void setup() {
Serial.begin(115200);
// initialize the avoid pin as an input
pinMode(avoidPin, INPUT);
}
void loop() {
// read the state of the avoid value
avoidState = digitalRead(avoidPin);
Serial.println(avoidState);
}