પાઠ ૨ માંથી ૧૦: રાસ્પબેરી પાઈ પીકો ૪ડબલ્યુડી સ્માર્ટ કાર કિટ ચલાવવા માટે મૂળભૂત પાયથોન

પાઠ ૨ માંથી ૧૦: રાસ્પબેરી પાઈ પીકો ૪ડબલ્યુડી સ્માર્ટ કાર કિટ ચલાવવા માટે મૂળભૂત પાયથોન

રોબોજેક્સ રાસ્પબેરી પાઈ પીકો 4WD સ્માર્ટ કાર કોર્સના આ બીજા પાઠમાં, આપણે મૂળભૂત પાયથોન પ્રોગ્રામિંગ ખ્યાલોમાં ઊંડાણપૂર્વક જઈએ છીએ જે તમને તમારા રોબોટને નિયંત્રિત કરવા માટે સક્ષમ બનાવશે. આ માર્ગદર્શિકા તમને શૂન્ય કોડિંગ અનુભવથી આત્મવિશ્વાસપૂર્વક હાર્ડવેરને નિયંત્રિત કરતી સ્ક્રિપ્ટ્સ લખવા સુધી લઈ જવા માટે રચાયેલ છે. માત્ર સિન્ટેક્સ યાદ રાખવાને બદલે, આપણે દરેક ખ્યાલ પાછળનું "કેમ" શોધીશું, જે તમને તમારા પોતાના પ્રોજેક્ટ્સ બનાવવા અને કસ્ટમાઇઝ કરવા માટે સાધનો આપશે. આ પાઠના અંત સુધીમાં, તમને ચલો, નિયંત્રણ પ્રવાહ, ફંક્શન્સ અને યાદીઓની નક્કર સમજ હશે—જે ભવિષ્યના તમામ પ્રોજેક્ટ્સ માટે મૂળભૂત બિલ્ડિંગ બ્લોક્સ છે.

આ જ્ઞાન માત્ર સ્માર્ટ કાર માટે નથી. તમે અહીં જે સિદ્ધાંતો શીખશો તે અસંખ્ય વાસ્તવિક-વિશ્વ એપ્લિકેશન્સમાં ઉપયોગમાં લેવાય છે. તમે આ કૌશલ્યો આ રીતે લાગુ કરી શકો છો:

• સેન્સર ડેટાના આધારે પંખા, પંપ અને લાઇટને નિયંત્રિત કરવા માટે ઘરના ગ્રીનહાઉસને સ્વચાલિત કરવું.
• કસ્ટમ સુરક્ષા સિસ્ટમ બનાવવી જે એલાર્મ ટ્રિગર કરે અથવા સૂચનાઓ મોકલે.
• ઇન્ટરેક્ટિવ આર્ટ ઇન્સ્ટોલેશન્સ બનાવવા જે પર્યાવરણને પ્રતિસાદ આપે.
• પૂર્વ-પ્રોગ્રામ કરેલા વર્તન ઉપરાંત તમારા પોતાના કસ્ટમ રોબોટ વર્તન વિકસાવવા.

હાર્ડવેર/ઘટકો

આ પાઠમાં હાર્ડવેર ઉદાહરણો સાથે અનુસરવા માટે, તમારે નીચેના ઘટકોની જરૂર પડશે. આ બધા સનફાઉન્ડર રાસ્પબેરી પાઈ પીકો 4WD સ્માર્ટ કાર કિટનો ભાગ છે, પરંતુ સ્વતંત્ર પ્રયોગો માટે વ્યક્તિગત રીતે ખરીદી શકાય છે.

• રાસ્પબેરી પાઈ પીકો: પ્રોજેક્ટનું માઇક્રોકંટ્રોલર મગજ.
• એક એલઇડી: ડિજિટલ આઉટપુટ નિયંત્રણ દર્શાવવા માટે વપરાય છે.
• એક રેઝિસ્ટર (150Ω - 330Ω): કરંટ મર્યાદિત કરવા અને એલઇડીને સુરક્ષિત કરવા માટે.
• જમ્પર વાયર: બ્રેડબોર્ડ પર જોડાણો બનાવવા માટે.
• એક બ્રેડબોર્ડ: તમારા સર્કિટનું પ્રોટોટાઇપિંગ કરવા માટે.

વાયરિંગ માર્ગદર્શિકા

આ પાઠમાં હાર્ડવેર પ્રદર્શન માટે, આપણે રાસ્પબેરી પાઈ પીકો સાથે એલઇડી નિયંત્રિત કરવા માટે એક સરળ સર્કિટ બનાવીશું. વાયરિંગ સીધું છે અને ફિઝિકલ કમ્પ્યુટિંગમાં તે એક ક્લાસિક પ્રથમ પગલું છે. મુખ્ય વાત એ છે કે એલઇડીને બળી જતી અટકાવવા માટે કરંટ-લિમિટિંગ રેઝિસ્ટરનો ઉપયોગ કરવો. રેઝિસ્ટર એલઇડી સાથે શ્રેણીમાં જોડાયેલ છે. એલઇડીનો લાંબો પગ (એનોડ) હકારાત્મક જોડાણ છે, અને ટૂંકો પગ (કેથોડ) નકારાત્મક જોડાણ છે.

વિડિયોમાં, પ્રશિક્ષક ગ્રાઉન્ડ પિન અને એલઇડીના ટૂંકા પગ સાથે જોડાયેલ રેઝિસ્ટરનો ઉપયોગ કરે છે. લાંબો પગ GPIO પિન 22 સાથે જોડાયેલ છે. આ સેટઅપ પીકોને એલઇડી ચાલુ કરવા માટે પિન પર હાઇ (3.3V) સિગ્નલ અને તેને બંધ કરવા માટે લો (0V) સિગ્નલ મોકલવાની મંજૂરી આપે છે.

નોંધ: વાયરિંગ ડાયાગ્રામ વિડિયોમાં બતાવવામાં આવ્યો છે. ચોક્કસ સ્થાન માટે કૃપા કરીને વિઝ્યુઅલ માર્ગદર્શિકાનો સંદર્ભ લો.

કોડ સમજૂતી

આ પાઠ મુખ્ય પાયથોન સિન્ટેક્સ અને લોજિક પર ધ્યાન કેન્દ્રિત કરે છે, જે તમારા રોબોટને નિયંત્રિત કરવા માટે આવશ્યક છે. ચાલો વિડિયોમાં આવરી લેવામાં આવેલા મુખ્ય ખ્યાલોને તોડીએ. કોડ ઉદાહરણો માઇક્રોપાયથોનમાં લખેલા છે, જે રાસ્પબેરી પાઈ પીકો જેવા માઇક્રોકંટ્રોલર્સ પર ચાલવા માટે રચાયેલ પાયથોનનું સંસ્કરણ છે.

ચલો અને ડેટા પ્રકારો

ચલો લેબલવાળા બોક્સ જેવા છે જ્યાં તમે માહિતી સંગ્રહિત કરો છો. પાયથોનમાં, તમારે ચલનો પ્રકાર જાહેર કરવાની જરૂર નથી; તે તમે સોંપેલ મૂલ્ય પરથી અનુમાનિત થાય છે. (વિડિયોમાં 03:33 પર)

age = 23  # આ પૂર્ણાંક છે
name = "Ahmad"  # આ સ્ટ્રિંગ છે (ટેક્સ્ટ)
pi = 3.14  # આ ફ્લોટ છે (દશાંશ)

તમે આ ચલોનો ગણતરીમાં ઉપયોગ કરી શકો છો અને તેમની કિંમતો છાપી શકો છો. ઉદાહરણ તરીકે, આપેલી ઉંમરમાં દિવસોની સંખ્યા ગણવા માટે, તમે days = age * 365 નો ઉપયોગ કરી શકો છો. print() ફંક્શન કન્સોલ પર આઉટપુટ દર્શાવવા માટે વપરાય છે.

શરતી વિધાનો (ઇફ/એલ્સ)

શરતી વિધાનો તમારા કોડને નિર્ણય લેવાની મંજૂરી આપે છે. રોબોટ માટે તેના પર્યાવરણ પ્રત્યે પ્રતિક્રિયા આપવા માટે આ નિર્ણાયક છે, જેમ કે અવરોધ શોધે ત્યારે અટકવું. (વિડિયોમાં 07:39 પર)

age = 16
if age >= 17:
    print("તમે ડ્રાઇવ કરી શકો છો")
else:
    print("ડ્રાઇવ કરવા માટે ખૂબ નાના છો")

if વિધાન એક શરત તપાસે છે. જો શરત True હોય, તો તેની નીચેનો ઇન્ડેન્ટેડ કોડ બ્લોક ચાલે છે. જો તે False હોય, તો else વિધાન હેઠળનો કોડ ચાલે છે. પાયથોનમાં ઇન્ડેન્ટેશન (લીટીની શરૂઆતમાં જગ્યાઓ) નિર્ણાયક છે; તે વ્યાખ્યાયિત કરે છે કે કયો કોડ કયા બ્લોકનો છે.

લૂપ્સ (ફોર અને વ્હાઇલ)

લૂપ્સનો ઉપયોગ કોડના બ્લોકને પુનરાવર્તિત કરવા માટે થાય છે. સેન્સર મૂલ્યો સ્કેન કરવા અથવા મોટરને પગલાંઓના ક્રમ દ્વારા ખસેડવા જેવા કાર્યો માટે આ આદર્શ છે. (વિડિયોમાં 09:04 પર)

ફોર લૂપ: આ લૂપ ચોક્કસ સંખ્યામાં પુનરાવર્તન કરે છે.

for x in range(5):  # x એ 0, 1, 2, 3, 4 હશે
    print(x)

વ્હાઇલ લૂપ: આ લૂપ ત્યાં સુધી ચાલુ રહે છે જ્યાં સુધી શરત સાચી હોય. મુખ્ય પ્રોગ્રામ લૂપ બનાવવા માટે આ ઉપયોગી છે જે ચોક્કસ ઘટના ન થાય ત્યાં સુધી કાયમ ચાલે છે. (વિડિયોમાં 12:13 પર)

x = 9
while x > 5:
    print("x ની કિંમત છે:", x)
    x = x - 1  # x ઘટાડો
print("લૂપ સમાપ્ત")

while True: લૂપ્સ સાથે સાવચેત રહો. જ્યાં સુધી તમે લૂપમાંથી બહાર નીકળવા માટે break વિધાનનો ઉપયોગ ન કરો અથવા પ્રોગ્રામ બંધ ન કરો ત્યાં સુધી તે કાયમ ચાલશે.

ફંક્શન્સ

ફંક્શન્સ પુનઃઉપયોગી કોડ બ્લોક્સ છે જે ચોક્કસ કાર્ય કરે છે. તે તમારા કોડને વ્યવસ્થિત રાખવામાં અને પુનરાવર્તન અટકાવવામાં મદદ કરે છે. (વિડિયોમાં 14:52 પર)

def calculate_days(years):
    days = years * 365
    return days

# હવે આપણે આ ફંક્શનનો ઘણી વખત ઉપયોગ કરી શકીએ છીએ
days_in_10_years = calculate_days(10)
print("10 વર્ષમાં દિવસો:", days_in_10_years)

અહીં, calculate_days એક ફંક્શન છે જે એક આર્ગ્યુમેન્ટ (years) લે છે અને એક મૂલ્ય પરત કરે છે. આ સમાન ગણતરીને વારંવાર લખવા કરતાં વધુ કાર્યક્ષમ છે. વિડિયો એ પણ દર્શાવે છે કે કેવી રીતે એક ફંક્શન બીજાને કૉલ કરી શકે છે, જે તમને સરળ, પરીક્ષણ કરી શકાય તેવા ભાગોમાંથી જટિલ કામગીરી બનાવવાની મંજૂરી આપે છે.

લિસ્ટ્સ

લિસ્ટ્સનો ઉપયોગ વસ્તુઓના ક્રમબદ્ધ સંગ્રહને સંગ્રહિત કરવા માટે થાય છે. આ તમારા રોબોટ માટે આદેશોનો ક્રમ સંગ્રહિત કરવા માટે યોગ્ય છે, જેમ કે "આગળ", "પાછળ", "ડાબે" અને "જમણે". (વિડિયોમાં 19:15 પર)

move = ["આગળ", "પાછળ", "ડાબે", "જમણે", "રોકો"]
print(len(move))  # લિસ્ટમાં વસ્તુઓની સંખ્યા છાપે છે (5)
print(move[0]) # પ્રથમ વસ્તુ છાપે છે, "આગળ"

# તમે વસ્તુઓ ઉમેરી શકો છો
move.append("ક્લિફ")
# તમે વસ્તુઓ દૂર કરી શકો છો
move.pop()  # "ક્લિફ" દૂર કરે છે
# તમે વસ્તુઓ બદલી શકો છો
move[2] = "ઉડાન"  # ત્રીજી વસ્તુને "ઉડાન" માં બદલે છે

લિસ્ટ્સ શૂન્ય-ઇન્ડેક્સ્ડ છે, એટલે કે પ્રથમ વસ્તુ ઇન્ડેક્સ 0 પર છે. len() ફંક્શન તમને લિસ્ટની લંબાઈ આપે છે, અને તમે બધી વસ્તુઓમાંથી પસાર થવા માટે for લૂપનો ઉપયોગ કરી શકો છો. enumerate() ફંક્શન પણ રજૂ કરવામાં આવ્યું છે, જે લૂપ દરમિયાન તમને ઇન્ડેક્સ અને મૂલ્ય બંને આપે છે, જે બહુવિધ પિન અથવા સેન્સર સાથે કામ કરવા માટે ઉપયોગી છે.

પિન અને સમય સાથે કામ કરવું

આ તે છે જ્યાં તમે પાયથોન લોજિકને ભૌતિક વિશ્વ સાથે જોડો છો. તમે પિકોના GPIO પિનને નિયંત્રિત કરવા માટે machine લાઇબ્રેરીનો ઉપયોગ કરો છો. (વિડિયોમાં 25:16 પર)

from machine import Pin
import time

# પિન 22 ને આઉટપુટ તરીકે સેટ કરો
led = Pin(22, Pin.OUT)

# LED ચાલુ અને બંધ કરો
led.on()
time.sleep(1)
led.off()
time.sleep(1)

તમે Pin(2, Pin.IN) સાથે તેને ઇનપુટ તરીકે સેટ કરીને પિનમાંથી પણ વાંચી શકો છો. time લાઇબ્રેરી વિલંબ ઉમેરવા (time.sleep()) અને time.ticks_ms() નો ઉપયોગ કરીને વીતેલા સમયને માપવા અથવા time.localtime() અને time.mktime() સાથે સમય ફોર્મેટ વચ્ચે રૂપાંતર કરવા માટે આવશ્યક છે. આ સમય-આધારિત લોજિક માટે નિર્ણાયક છે, જેમ કે મોટર ઝડપને નિયંત્રિત કરવા માટે પલ્સ-વિડ્થ મોડ્યુલેશન (PWM) સિગ્નલ બનાવવું.

લાઇવ પ્રોજેક્ટ/પ્રદર્શન

વિડિયોમાં, પ્રશિક્ષક આ વિભાવનાઓનું લાઇવ પ્રદર્શન આપે છે. તે પાયથોન ઇન્ટરપ્રિટરમાં સરળ print() સ્ટેટમેન્ટ્સ અને ચલ સોંપણીઓ બતાવીને શરૂ કરે છે. પછી તે વધુ જટિલ ઉદાહરણો તરફ આગળ વધે છે, દૃષ્ટિની રીતે બતાવે છે કે કેવી રીતે if સ્ટેટમેન્ટ્સ ચલના મૂલ્યના આધારે પ્રોગ્રામનો પ્રવાહ બદલે છે.

પ્રશિક્ષક પછી રાસ્પબેરી પાઇ પિકો સાથે LED જોડીને વ્યવહારુ હાર્ડવેર ઉદાહરણ દર્શાવે છે. તે એક સરળ માઇક્રોપાયથોન સ્ક્રિપ્ટ લખે છે જે LED ને એક-સેકન્ડના વિલંબ સાથે ચાલુ અને બંધ કરે છે, જે કોડ સાથે ભૌતિક આઉટપુટને નિયંત્રિત કરવાનું સીધું પરિણામ દર્શાવે છે. આ હેન્ડ્સ-ઓન ઉદાહરણ પ્રોગ્રામિંગ લોજિક અને વાસ્તવિક-વિશ્વ ક્રિયા વચ્ચેનું જોડાણ મજબૂત કરે છે. પાઠ બહુવિધ પિનને સંચાલિત કરવા માટે enumerate નો ઉપયોગ કેવી રીતે કરવો અને વધુ અદ્યતન સમય અને શેડ્યુલિંગ કામગીરી માટે time મોડ્યુલનો ઉપયોગ કેવી રીતે કરવો તે બતાવીને સમાપ્ત થાય છે.

પ્રકરણો

• [00:00] રાસ્પબેરી પાઇ પિકો સ્માર્ટ કાર કોર્સનો પરિચય
• [01:31] કોર્સ ઝાંખી અને કિટ ક્ષમતાઓ
• [03:33] પાયથોનમાં ચલો અને ડેટા પ્રકારો
• [07:39] શરતી સ્ટેટમેન્ટ્સ (If/Else)
• [09:04] ફોર લૂપ્સ સમજવું
• [12:13] વ્હાઇલ લૂપ્સ શોધવું
• [14:52] ફંક્શન્સ વ્યાખ્યાયિત અને ઉપયોગ કરવું
• [19:15] લિસ્ટ્સ અને ડેટા સ્ટ્રક્ચર્સ સાથે કામ કરવું
• [25:16] માઇક્રોપાયથોન સાથે GPIO પિન નિયંત્રિત કરવું
• [29:54] વ્યવહારુ ઉદાહરણ: LED ઝબકાવવું
• [31:15] એન્યુમેરેટ સાથે અદ્યતન પિન નિયંત્રણ
• [31:24] સમય ફંક્શન્સ સાથે કામ કરવું