ఆర్డునో ఉపయోగించి సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్

సెగ్వే నుండి RYNO మోటార్లు మరియు ఇతర సెల్ఫ్ బ్యాలెన్సింగ్ స్కూటర్లచే ప్రేరణ పొందిన తరువాత, నేను ఎల్లప్పుడూ నా స్వంత Arduino Segway Robot ను నిర్మించాలనుకుంటున్నాను. కాసేపు ఆలోచిస్తూ, ఆర్డునో ఉపయోగించి సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ నిర్మించాలని నిర్ణయించుకున్నాను. ఈ విధంగా నేను ఈ స్కూటర్ల వెనుక ఉన్న అంతర్లీన భావనను గ్రహించగలను మరియు PID అల్గోరిథం ఎలా పనిచేస్తుందో కూడా తెలుసుకోగలను.

నేను నిర్మించడం ప్రారంభించిన తర్వాత, ఈ బోట్ నిర్మించడం కొంచెం సవాలుగా ఉందని నేను గ్రహించాను. ఎంచుకోవడానికి చాలా ఎంపికలు ఉన్నాయి మరియు అందువల్ల గందరగోళాలు మోటార్లు ఎంచుకునే సరైన రూపాన్ని ప్రారంభిస్తాయి మరియు PID విలువలను ట్యూన్ చేసే వరకు ఉంటాయి. మరియు బ్యాటరీ రకం, బ్యాటరీ యొక్క స్థానం, చక్రాల పట్టు, మోటారు డ్రైవర్ రకం, CoG (గురుత్వాకర్షణ కేంద్రం) ను నిర్వహించడం మరియు మరెన్నో వంటివి చాలా ఉన్నాయి.

కానీ నేను దానిని మీకు విడదీయనివ్వండి, మీరు దాన్ని నిర్మించిన తర్వాత అది అంత కష్టం కాదని మీరు అంగీకరిస్తారు. కాబట్టి దీనిని ఎదుర్కొందాం, ఈ ట్యుటోరియల్‌లో సెల్ఫ్ బ్యాలెన్సింగ్ రోబోను నిర్మించడంలో నా అనుభవాన్ని డాక్యుమెంట్ చేస్తాను. మీరు ఇప్పుడే ప్రారంభిస్తున్న సంపూర్ణ అనుభవశూన్యుడు కావచ్చు లేదా మీ బోట్ పని చేయకపోవడంపై చాలా నిరాశకు గురైన తర్వాత ఇక్కడకు దిగి ఉండవచ్చు. ఈ స్థలం మీ తుది గమ్యస్థానంగా ఉండాలని లక్ష్యంగా పెట్టుకుంది. కాబట్టి ప్రారంభిద్దాం……

సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ కోసం భాగాలను ఎంచుకోవడం

బోట్ నిర్మించడానికి అన్ని ఎంపికలను నేను మీకు చెప్పే ముందు ఈ సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ ప్రాజెక్ట్‌లో నేను ఉపయోగించిన వస్తువులను జాబితా చేయనివ్వండి

• ఆర్డునో UNO
• గేర్డ్ DC మోటార్లు (పసుపు రంగు) - 2 సంఖ్యలు
• L298N మోటార్ డ్రైవర్ మాడ్యూల్
• MPU6050
• ఒక జత చక్రాలు
• 7.4 వి లి-అయాన్ బ్యాటరీ
• వైర్లను కనెక్ట్ చేస్తోంది
• 3 డి ప్రింటెడ్ బాడీ

మీ స్వంత స్వీయ బ్యాలెన్సింగ్ రోబోట్ కిట్‌ను తయారు చేయడానికి లభ్యత ఆధారంగా పై భాగాలలో దేనినైనా మీరు కలపవచ్చు మరియు ఎంచుకోవచ్చు, భాగాలు ఈ క్రింది ప్రమాణాలకు సరిపోయేలా చూసుకోండి.

నియంత్రిక: నేను ఇక్కడ ఉపయోగించిన నియంత్రిక Arduino UNO, ఎందుకు ఉపయోగించడం సులభం కనుక. మీరు ఆర్డునో నానో లేదా ఆర్డునో మినీని కూడా ఉపయోగించవచ్చు, కాని యుఎన్‌ఓతో కలిసి ఉండాలని నేను మీకు సిఫారసు చేస్తాను ఎందుకంటే మనం దీన్ని బాహ్య హార్డ్‌వేర్ లేకుండా నేరుగా ప్రోగ్రామ్ చేయవచ్చు.

మోటార్లు: మీరు స్వీయ బ్యాలెన్సింగ్ రోబోట్ కోసం ఉపయోగించగల మోటారు యొక్క ఉత్తమ ఎంపిక, సందేహం లేకుండా స్టెప్పర్ మోటర్. కానీ విషయాలు సరళంగా ఉంచడానికి నేను DC గేర్ మోటారును ఉపయోగించాను. అవును స్టెప్పర్ కలిగి ఉండటం తప్పనిసరి కాదు; చౌకగా లభించే ఈ పసుపు రంగు DC గేర్ మోటారులతో బోట్ బాగా పనిచేస్తుంది.

మోటారు డ్రైవర్: మీరు నా లాంటి DC గేర్ మోటార్లు ఎంచుకుంటే, మీరు నా లాంటి L298N డ్రైవర్ మాడ్యూల్‌ను ఉపయోగించవచ్చు, లేదా L293D కూడా బాగా పనిచేయాలి. L293D మరియు Arduino ఉపయోగించి DC మోటారును నియంత్రించడం గురించి మరింత తెలుసుకోండి.

చక్రాలు: ఈ కుర్రాళ్లను అంచనా వేయవద్దు; నా చక్రాలతో సమస్య ఉందని గుర్తించడానికి నాకు చాలా కష్టంగా ఉంది. కాబట్టి మీరు ఉపయోగిస్తున్న అంతస్తులో మీ చక్రాలకు మంచి పట్టు ఉందని నిర్ధారించుకోండి. నిశితంగా చూడండి, మీ పట్టు మీ చక్రాలను నేలపై దాటడానికి ఎప్పుడూ అనుమతించకూడదు.

యాక్సిలెరోమీటర్ మరియు గైరోస్కోప్: మీ బోట్ కోసం యాక్సిలెరోమీటర్ మరియు గైరోస్కోప్ యొక్క ఉత్తమ ఎంపిక MPU6050. కాబట్టి ADXL345 వంటి సాధారణ యాక్సిలెరోమీటర్‌తో లేదా అలాంటిదే నిర్మించటానికి ప్రయత్నించవద్దు, అది పనిచేయదు. ఈ వ్యాసం చివరలో ఎందుకు మీకు తెలుస్తుంది. Arduino తో MPU6050 ను ఉపయోగించడం గురించి మీరు మా ప్రత్యేక కథనాన్ని కూడా తనిఖీ చేయవచ్చు.

బ్యాటరీ: మనకు సాధ్యమైనంత తేలికైన బ్యాటరీ అవసరం మరియు ఆపరేటింగ్ వోల్టేజ్ 5V కన్నా ఎక్కువ ఉండాలి, తద్వారా బూస్ట్ మాడ్యూల్ లేకుండా మన ఆర్డునోను నేరుగా శక్తివంతం చేయవచ్చు. కాబట్టి ఆదర్శ ఎంపిక 7.4 వి లి-పాలిమర్ బ్యాటరీ అవుతుంది. ఇక్కడ, నా దగ్గర 7.4 వి లి-అయాన్ బ్యాటరీ అందుబాటులో ఉన్నందున నేను దానిని ఉపయోగించాను. లి-అయాన్ కంటే లి-పో ప్రయోజనకరంగా ఉంటుందని గుర్తుంచుకోండి.

చట్రం: మీరు రాజీ పడకూడని మరొక ప్రదేశం మీ బాట్ల చట్రంతో ఉంటుంది. మీకు మంచి కార్డ్బోర్డ్, కలప, ప్లాస్టిక్ ఏదైనా ఉపయోగించవచ్చు. కానీ, చట్రం ధృ dy నిర్మాణంగలని నిర్ధారించుకోండి మరియు బోట్ సమతుల్యత కోసం ప్రయత్నిస్తున్నప్పుడు విగ్లే చేయకూడదు. నేను ఇతర బాట్ల నుండి er హించిన సాలిడ్‌వర్క్‌లపై సొంత చట్రం ద్వారా రూపొందించాను మరియు 3D దానిని ముద్రించాను. మీకు ప్రింటర్ ఉంటే, మీరు డిజైన్‌ను కూడా ప్రింట్ చేయవచ్చు, డిజైన్ ఫైళ్లు రాబోయే శీర్షికలో జతచేయబడతాయి.

3 డి ప్రింటింగ్ మరియు అసెంబ్లింగ్ మా సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్

నా బోట్‌ను నిర్మించడానికి నేను ఉపయోగిస్తున్న అదే చట్రాన్ని 3 డి ప్రింట్ చేయాలని మీరు నిర్ణయించుకుంటే, అప్పుడు STL ఫైల్‌లను థింగ్‌వైర్స్ నుండి డౌన్‌లోడ్ చేసుకోవచ్చు. నేను దానితో పాటు డిజైన్ ఫైళ్ళను కూడా జోడించాను, కాబట్టి మీరు మీ సిబ్బంది ప్రాధాన్యత ప్రకారం దాన్ని కూడా సవరించవచ్చు.

భాగాలకు ఓవర్‌హాంగింగ్ నిర్మాణాలు లేవు కాబట్టి మీరు వాటిని ఎటువంటి మద్దతు లేకుండా సులభంగా ముద్రించవచ్చు మరియు 25% నింపడం బాగా పనిచేస్తుంది. నమూనాలు చాలా సాదాసీదాగా ఉంటాయి మరియు ఏదైనా ప్రాథమిక ప్రింటర్ దీన్ని సులభంగా నిర్వహించగలగాలి. మోడల్‌ను ముక్కలు చేయడానికి నేను క్యూరా సాఫ్ట్‌వేర్‌ను ఉపయోగించాను మరియు నా టెవో టరాన్టులా ఉపయోగించి ముద్రించాను, ఈ సెట్టింగ్ క్రింద చూపబడింది.

మీరు శరీర భాగాన్ని అలాగే నాలుగు మోటారు మౌంటు భాగాలను ముద్రించాల్సి ఉంటుంది. సమీకరించడం చాలా సరళంగా ముందుకు ఉంటుంది; మోటారు మరియు బోర్డులను భద్రపరచడానికి 3 మిమీ గింజలు మరియు బోల్ట్‌లను ఉపయోగించండి. సమావేశమైన తరువాత ఇది క్రింది చిత్రంలో చూపిన విధంగా ఉండాలి.

వాస్తవ రూపకల్పనను దిగువ ర్యాక్‌లోని L298N డ్రైవ్ మాడ్యూల్‌తో పైన చూపిన విధంగా ఆర్డునో మరియు బ్యాటరీ పైన ప్లాన్ చేశారు. మీరు అదే క్రమాన్ని అనుసరిస్తుంటే, మీరు నేరుగా అందించిన రంధ్రాలను బోర్డు పతనంతో స్క్రూ చేయవచ్చు మరియు లి-పో బ్యాటరీ కోసం వైర్ ట్యాగ్‌ను ఉపయోగించవచ్చు. ఈ అమరిక కూడా పని చేయాలి, నేను తరువాత మార్చాల్సిన సూపర్ సాదా చక్రాలు తప్ప.

నా బోట్‌లో నేను ప్రోగ్రామింగ్ సౌలభ్యం కోసం బ్యాటరీ మరియు ఆర్డునో యుఎన్‌ఓ బోర్డు యొక్క స్థానాన్ని మార్చుకున్నాను మరియు కనెక్షన్‌లను పూర్తి చేయడానికి పెర్ఫ్ బోర్డును కూడా పరిచయం చేయాల్సి వచ్చింది. నేను ప్రారంభ దశలో ప్లాన్ చేసినట్లు నా బోట్ కనిపించలేదు. వైరింగ్ ప్రోగ్రామింగ్ పరీక్ష మరియు ప్రతిదీ పూర్తి చేసిన తరువాత, నా టూ వీల్ రోబోట్ చివరకు ఇలా కనిపిస్తుంది

సర్క్యూట్ రేఖాచిత్రం

ఈ ఆర్డునో బేస్డ్ సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ కోసం కనెక్షన్లు ఇవ్వడం చాలా సులభం. ఇది Arduino మరియు MPU6050 ను ఉపయోగించి స్వీయ బ్యాలెన్సింగ్ రోబోట్ కాబట్టి MPU6050 ను Arduino తో ఇంటర్‌ఫేస్ చేయడానికి మరియు మోటారు డ్రైవర్ మాడ్యూల్ అయినప్పటికీ మోటారులను కనెక్ట్ చేయడానికి మేము ప్రయత్నిస్తున్నాము. మొత్తం సెటప్ 7.4 వి లి-అయాన్ బ్యాటరీతో పనిచేస్తుంది. దాని కోసం సర్క్యూట్ రేఖాచిత్రం క్రింద చూపబడింది.

ఆర్డునో మరియు ఎల్ 298 ఎన్ మోటార్ డ్రైవర్ మాడ్యూల్ వరుసగా విన్ పిన్ మరియు 12 వి టెర్మినల్ ద్వారా శక్తిని పొందుతాయి. ఆర్డునో బోర్డ్‌లోని ఆన్-బోర్డ్ రెగ్యులేటర్ ఇన్‌పుట్ 7.4 విని 5 విగా మారుస్తుంది మరియు ఎటిమెగా ఐసి మరియు ఎంపియు 6050 దీని ద్వారా శక్తిని పొందుతాయి. DC మోటార్లు వోల్టేజ్ 5 వి నుండి 12 వి వరకు నడుస్తాయి. కానీ మేము 7.4 వి పాజిటివ్ వైర్‌ను బ్యాటరీ నుండి మోటారు డ్రైవర్ మాడ్యూల్ యొక్క 12 వి ఇన్‌పుట్ టెర్మినల్‌కు కనెక్ట్ చేస్తాము. దీనివల్ల మోటార్లు 7.4 వితో పనిచేస్తాయి. కింది పట్టికలో MPU6050 మరియు L298N మోటారు డ్రైవర్ మాడ్యూల్ Arduino తో ఎలా అనుసంధానించబడిందో జాబితా చేస్తుంది.

కాంపోనెంట్ పిన్	ఆర్డునో పిన్
MPU6050
విసిసి	+ 5 వి
గ్రౌండ్	Gnd
ఎస్సీఎల్	A5
SDA	ఎ 4
INT	డి 2
ఎల్ 298 ఎన్
IN1	డి 6
IN2	డి 9
IN3	డి 10
IN4	డి 11

MPU6050 I2C ఇంటర్ఫేస్ ద్వారా Arduino తో కమ్యూనికేట్ చేస్తుంది, కాబట్టి మేము Arduino యొక్క SPI పిన్స్ A4 మరియు A5 ను ఉపయోగిస్తాము. DC మోటార్లు వరుసగా PWM పిన్స్ D6, D9 D10 మరియు D11 లతో అనుసంధానించబడి ఉన్నాయి. మేము వాటిని పిడబ్ల్యుఎం పిన్‌లకు కనెక్ట్ చేయాలి ఎందుకంటే పిడబ్ల్యుఎం సిగ్నల్స్ యొక్క విధి చక్రంలో తేడా ఉండటం ద్వారా డిసి మోటారు వేగాన్ని నియంత్రిస్తాము. మీకు ఈ రెండు భాగాలు తెలియకపోతే MPU6050 ఇంటర్‌ఫేసింగ్ మరియు L298N మోటార్ డ్రైవర్ ట్యుటోరియల్ ద్వారా చదవమని సిఫార్సు చేయబడింది.

సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ కోడ్

ఇప్పుడు మేము రోబోట్‌ను సమతుల్యం చేయడానికి మా ఆర్డునో UNO బోర్డును ప్రోగ్రామ్ చేయాలి. అన్ని మాయాజాలం ఇక్కడే జరుగుతుంది; దాని వెనుక ఉన్న భావన చాలా సులభం. MPU6050 ను ఉపయోగించి బోట్ ముందు వైపు లేదా వెనుక వైపుకు వాలుతుందో లేదో మనం తనిఖీ చేయాలి మరియు అది ముందు వైపు వాలుతుంటే చక్రాలను ముందుకు దిశలో తిప్పాలి మరియు అది వెనుక వైపుకు వాలుతుంటే మనం చక్రాలను తిప్పాలి రివర్స్ దిశలో.

అదే సమయంలో మనం చక్రాలు తిరిగే వేగాన్ని కూడా నియంత్రించాలి, బోట్ సెంటర్ స్థానం నుండి కొద్దిగా దిగజారితే చక్రాలు నెమ్మదిగా తిరుగుతాయి మరియు సెంటర్ స్థానం నుండి మరింత దూరం కావడంతో వేగం పెరుగుతుంది. ఈ తర్కాన్ని సాధించడానికి మేము PID అల్గోరిథంను ఉపయోగిస్తాము, ఇది కేంద్ర స్థానం సెట్-పాయింట్ మరియు అవుట్పుట్ వలె అయోమయ స్థాయిని కలిగి ఉంటుంది.

బోట్ యొక్క ప్రస్తుత స్థితిని తెలుసుకోవడానికి మేము MPU6050 ను ఉపయోగిస్తాము, ఇది 6-యాక్సిస్ యాక్సిలెరోమీటర్ మరియు గైరోస్కోప్ సెన్సార్ కలిపి. సెన్సార్ నుండి స్థానం యొక్క నమ్మదగిన విలువను పొందడానికి మనం యాక్సిలెరోమీటర్ మరియు గైరోస్కోప్ రెండింటి విలువను ఉపయోగించాలి, ఎందుకంటే యాక్సిలెరోమీటర్ నుండి వచ్చే విలువలకు శబ్దం సమస్యలు ఉంటాయి మరియు గైరోస్కోప్ నుండి వచ్చే విలువలు కాలంతో మళ్లించబడతాయి. కాబట్టి మనం రెండింటినీ మిళితం చేసి, మన రోబోట్ యొక్క యా పిచ్ మరియు రోల్ యొక్క విలువను పొందాలి, వీటిలో మనం యా యొక్క విలువను మాత్రమే ఉపయోగిస్తాము.

తల తిరగడం సరిగ్గా అనిపిస్తుందా? చింతించకండి, ఆర్డునో కమ్యూనిటీకి ధన్యవాదాలు, పిఐడి లెక్కింపును చేయగల MPU6050 నుండి యా యొక్క విలువను పొందగలిగే లైబ్రరీలను మేము సులభంగా కలిగి ఉన్నాము. లైబ్రరీని వరుసగా br3ttb మరియు జ్రోబెర్గ్ అభివృద్ధి చేశారు. డౌన్‌లోడ్ చేయడానికి ముందు వారి లైబ్రరీలు ఈ క్రింది లింక్‌ను ఏర్పరుస్తాయి మరియు వాటిని మీ ఆర్డునో లిబ్ డైరెక్టరీకి జోడించండి.

github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h

github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

ఇప్పుడు, మన ఆర్డునో IDE కి లైబ్రరీలు జోడించబడ్డాయి. మన సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ కోసం ప్రోగ్రామింగ్ ప్రారంభిద్దాం. ఎప్పటిలాగే MPU6050 బ్యాలెన్సింగ్ రోబోట్ యొక్క పూర్తి కోడ్ ఈ పేజీ చివరిలో ఇవ్వబడింది, ఇక్కడ నేను కోడ్‌లోని అతి ముఖ్యమైన స్నిప్పెట్‌లను వివరిస్తున్నాను. ఇంతకుముందు చెప్పిన కోడ్ MPU6050 ఉదాహరణ కోడ్ పైన నిర్మించబడుతోంది, మన ప్రయోజనం కోసం కోడ్‌ను ఆప్టిమైజ్ చేయబోతున్నాం మరియు మా సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ కోసం PID మరియు కంట్రోల్ టెక్నిక్‌ని జోడించండి.

మొదట మేము ఈ ప్రోగ్రామ్ పనిచేయడానికి అవసరమైన లైబ్రరీలను చేర్చుతాము. వాటిలో మేము ఇప్పుడే డౌన్‌లోడ్ చేసిన అంతర్నిర్మిత I2C లైబ్రరీ, PID లైబ్రరీ మరియు MPU6050 లైబ్రరీ ఉన్నాయి.

# చేర్చండి "I2Cdev.h" # చేర్చండి // నుండి # చేర్చండి "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

అప్పుడు మేము MPU6050 సెన్సార్ నుండి డేటాను పొందడానికి అవసరమైన వేరియబుల్స్ను ప్రకటిస్తాము. మేము గురుత్వాకర్షణ వెక్టర్ మరియు క్వాటర్నియన్ విలువలు రెండింటినీ చదివి, ఆపై బోట్ యొక్క యా పిచ్ మరియు రోల్ విలువను లెక్కిస్తాము. ఫ్లోట్ శ్రేణి ypr తుది ఫలితం నొక్కి.

// MPU నియంత్రణ / స్థితి vars bool dmpReady = తప్పుడు; // DMP init విజయవంతమైతే నిజం సెట్ uint8_t mpuIntStatus; // MPU uint8_t devStatus నుండి వాస్తవ అంతరాయ స్థితి బైట్‌ను కలిగి ఉంది ; // ప్రతి పరికర ఆపరేషన్ తర్వాత తిరిగి వచ్చే స్థితి (0 = విజయం,! 0 = లోపం) uint16_t packetSize; // D హించిన DMP ప్యాకెట్ పరిమాణం (డిఫాల్ట్ 42 బైట్లు) uint16_t fifoCount; // ప్రస్తుతం FIFO uint8_t fifoBuffer లో ఉన్న అన్ని బైట్ల సంఖ్య; // FIFO నిల్వ బఫర్ // ధోరణి / మోషన్ వర్స్ క్వాటర్నియన్ q; // క్వాటర్నియన్ కంటైనర్ వెక్టర్ ఫ్లోట్ గురుత్వాకర్షణ; // గురుత్వాకర్షణ వెక్టర్ ఫ్లోట్ ypr; // యా / పిచ్ / రోల్ కంటైనర్ మరియు గ్రావిటీ వెక్టర్

తదుపరిది కోడ్ యొక్క చాలా ముఖ్యమైన విభాగం వస్తుంది మరియు సరైన విలువల కోసం మీరు ట్యూనింగ్‌లో ఎక్కువ సమయం గడుపుతారు. మీరు రోబోట్ చాలా మంచి గురుత్వాకర్షణ కేంద్రంతో నిర్మించబడితే మరియు భాగాలు సుష్టంగా అమర్చబడి ఉంటే (ఇది చాలా సందర్భాలలో కాదు) అప్పుడు మీ సెట్ పాయింట్ యొక్క విలువ 180 అవుతుంది. లేకపోతే మీ బోట్‌ను ఆర్డునో సీరియల్ మానిటర్‌కు కనెక్ట్ చేసి, దానిని వంచి మీరు మంచి బ్యాలెన్సింగ్ స్థానాన్ని కనుగొంటారు, సీరియల్ మానిటర్‌లో ప్రదర్శించబడే విలువను చదవండి మరియు ఇది మీ సెట్ పాయింట్ విలువ. మీ బోట్ ప్రకారం Kp, Kd మరియు Ki యొక్క విలువను ట్యూన్ చేయాలి. ఒకేలా ఉండే రెండు బాట్‌లకు Kp, Kd మరియు Ki యొక్క ఒకే విలువలు ఉండవు కాబట్టి దాని నుండి తప్పించుకునే అవకాశం లేదు. ఈ విలువలను ఎలా సర్దుబాటు చేయాలనే ఆలోచన పొందడానికి ఈ పేజీ చివరిలో వీడియో చూడండి.

/ ********* మీ BOT కోసం ఈ 4 విలువలను ట్యూన్ చేయండి ********* / డబుల్ సెట్ పాయింట్ = 176; // సీరియల్ మానిటర్ ఉపయోగించి బోట్ భూమికి లంబంగా ఉన్నప్పుడు విలువను సెట్ చేయండి . // ఈ విలువలను డబుల్ Kp = 21 ఎలా సెట్ చేయాలో తెలుసుకోవడానికి సర్క్యూట్ డైజెస్ట్.కామ్‌లోని ప్రాజెక్ట్ డాక్యుమెంటేషన్ చదవండి ; // ఈ మొదటి డబుల్ Kd = 0.8; // ఈ సెకండ్ డబుల్ కి = 140; // చివరగా దీన్ని సెట్ చేయండి / ****** విలువల సెట్టింగ్ ముగింపు ********* /

తరువాతి పంక్తిలో ఇన్పుట్ వేరియబుల్స్ ఇన్పుట్, అవుట్పుట్, సెట్ పాయింట్, కెపి, కి మరియు కెడిలను దాటడం ద్వారా మేము పిఐడి అల్గోరిథంను ప్రారంభిస్తాము. వీటిలో మనం ఇప్పటికే పైన పేర్కొన్న కోడ్ స్నిప్పెట్‌లో సెట్-పాయింట్ Kp, Ki మరియు Kd విలువలను సెట్ చేసాము. ఇన్పుట్ యొక్క విలువ MPU6050 సెన్సార్ నుండి చదివిన యా యొక్క ప్రస్తుత విలువ అవుతుంది మరియు అవుట్పుట్ విలువ PID అల్గోరిథం చేత లెక్కించబడిన విలువ అవుతుంది. కాబట్టి ప్రాథమికంగా PID అల్గోరిథం మాకు అవుట్పుట్ విలువను ఇస్తుంది, ఇది ఇన్పుట్ విలువను సెట్ పాయింట్కు దగ్గరగా ఉండటానికి సరిచేయాలి.

PID పిడ్ (& ఇన్పుట్, & అవుట్పుట్, & సెట్ పాయింట్, Kp, Ki, Kd, ​​DIRECT);

శూన్య సెటప్ ఫంక్షన్ లోపల మేము DMP (డిజిటల్ మోషన్ ప్రాసెసర్) ను కాన్ఫిగర్ చేయడం ద్వారా MPU6050 ను ప్రారంభిస్తాము. యాక్సిలెరోమీటర్ డేటాను గైరోస్కోప్ డేటాతో కలపడానికి మరియు యా, పిచ్ మరియు రోల్ యొక్క నమ్మకమైన విలువను అందించడానికి ఇది మాకు సహాయపడుతుంది. ఇది చాలా లోతుగా వెళ్ళదు ఎందుకంటే ఇది అంశానికి మించినది. ఏమైనప్పటికీ మీరు సెటప్ ఫంక్షన్‌లో చూడవలసిన కోడ్ యొక్క ఒక విభాగం గైరో ఆఫ్‌సెట్ విలువలు. ప్రతి MPU6050 సెన్సార్‌కు దాని స్వంత ఆఫ్‌సెట్ విలువలు ఉన్నాయి, మీరు మీ సెన్సార్ యొక్క ఆఫ్‌సెట్ విలువను లెక్కించడానికి మరియు మీ ప్రోగ్రామ్‌లో ఈ క్రింది పంక్తులను నవీకరించడానికి ఈ ఆర్డునో స్కెచ్‌ను ఉపయోగించవచ్చు.

// మీ స్వంత గైరో ఆఫ్‌సెట్‌లను ఇక్కడ సరఫరా చేయండి, కనిష్ట సున్నితత్వం కోసం స్కేల్ చేయబడింది mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

మన మోటారులను కనెక్ట్ చేయడానికి మేము ఉపయోగిస్తున్న డిజిటల్ పిడబ్ల్యుఎం పిన్‌లను కూడా ప్రారంభించాలి. మా విషయంలో ఇది D6, D9, D10 మరియు D11. కాబట్టి మేము ఈ పిన్‌లను అవుట్పుట్ పిన్‌లు డిఫాల్ట్‌గా తక్కువగా చేస్తాము.

// మోటార్ అవుట్‌పు పిన్స్ పిన్‌మోడ్ (6, OUTPUT) ను ప్రారంభించండి; పిన్ మోడ్ (9, U ట్పుట్); పిన్ మోడ్ (10, U ట్పుట్); పిన్ మోడ్ (11, U ట్పుట్); // అప్రమేయంగా మోటార్లు అనలాగ్‌రైట్ (6, తక్కువ) రెండింటినీ ఆపివేయండి ; అనలాగ్‌రైట్ (9, తక్కువ); అనలాగ్‌రైట్ (10, తక్కువ); అనలాగ్‌రైట్ (11, తక్కువ);

ప్రధాన లూప్ ఫంక్షన్ లోపల MPU6050 నుండి డేటా చదవడానికి సిద్ధంగా ఉందా అని మేము తనిఖీ చేస్తాము. అవును అయితే, మేము PID విలువను లెక్కించడానికి దాన్ని ఉపయోగిస్తాము మరియు PID ఎలా స్పందిస్తుందో తనిఖీ చేయడానికి PID యొక్క ఇన్పుట్ మరియు అవుట్పుట్ విలువను సీరియల్ మానిటర్లో ప్రదర్శిస్తుంది. అప్పుడు అవుట్పుట్ విలువ ఆధారంగా బోట్ ముందుకు లేదా వెనుకకు కదలాలా లేదా నిలబడాలా అని మేము నిర్ణయిస్తాము.

బోట్ నిటారుగా ఉన్నప్పుడు MPU6050 180 తిరిగి వస్తుందని మేము అనుకుంటాము. బోట్ ముందు వైపు పడుతున్నప్పుడు మేము దిద్దుబాటు విలువలను సానుకూలంగా పొందుతాము మరియు బోట్ వెనుక వైపుకు పడిపోతే మనకు విలువలు ప్రతికూలంగా లభిస్తాయి. కాబట్టి మేము ఈ పరిస్థితిని తనిఖీ చేస్తాము మరియు బోట్ను ముందుకు లేదా వెనుక వార్డ్కు తరలించడానికి తగిన విధులను పిలుస్తాము.

అయితే (! mpuInterrupt && fifoCount <packetSize) { // mpu డేటా లేదు - PID లెక్కలు మరియు మోటారులకు అవుట్పుట్ చేయడం pid.Compute (); // ఇన్పుట్ మరియు అవుట్పుట్ యొక్క విలువను సీరియల్ మానిటర్లో ప్రింట్ చేయండి, ఇది ఎలా పనిచేస్తుందో తనిఖీ చేయండి. సీరియల్.ప్రింట్ (ఇన్పుట్); సీరియల్.ప్రింట్ ("=>"); సీరియల్.ప్రింట్ల్న్ (అవుట్పుట్); if (ఇన్పుట్> 150 && ఇన్పుట్ <200) {// బాట్ పడిపోతుంటే (అవుట్పుట్> 0) // ముందు వైపు పడటం ఫార్వర్డ్ (); // (అవుట్పుట్ <0) // వెనుక వైపు పడితే రివర్స్ (); // చక్రాలను వెనుకకు తిప్పండి } else // బొట్ పడకపోతే ఆపు (); // చక్రాలను ఇంకా పట్టుకోండి }

PID అవుట్పుట్ వేరియబుల్ మోటార్ భ్రమణం చేయడానికి ఉంది ఎంత వేగంగా నిర్ణయిస్తుంది. బోట్ పడిపోయేటప్పుడు, చక్రం నెమ్మదిగా తిప్పడం ద్వారా మేము చిన్న దిద్దుబాటు చేస్తాము. ఈ చిన్న దిద్దుబాటు పని చేస్తే మరియు బోట్ క్రింద పడిపోతుంటే మేము మోటారు వేగాన్ని పెంచుతాము. చక్రాలు ఎంత వేగంగా తిరుగుతాయో దాని విలువ PI అల్గోరిథం ద్వారా నిర్ణయించబడుతుంది. రివర్స్ ఫంక్షన్ కోసం మేము అవుట్పుట్ విలువను -1 తో గుణించాము, తద్వారా ప్రతికూల విలువను సానుకూలంగా మార్చగలము.

శూన్య ఫార్వర్డ్ () // చక్రం ముందుకు తిప్పడానికి కోడ్ { అనలాగ్‌రైట్ (6, అవుట్పుట్); అనలాగ్‌రైట్ (9,0); అనలాగ్‌రైట్ (10, అవుట్‌పుట్); అనలాగ్‌రైట్ (11,0); సీరియల్.ప్రింట్ ("ఎఫ్"); // డీబగ్గింగ్ సమాచారం } శూన్యమైన రివర్స్ () // చక్రం తిప్పడానికి కోడ్ వెనుకకు { అనలాగ్‌రైట్ (6,0); అనలాగ్‌రైట్ (9, అవుట్‌పుట్ * -1); అనలాగ్‌రైట్ (10,0); అనలాగ్‌రైట్ (11, అవుట్‌పుట్ * -1); సీరియల్.ప్రింట్ ("R"); } గర్జన ఆపు () // చక్రాలు రెండు ఆపడానికి కోడ్ { analogWrite (6,0); అనలాగ్‌రైట్ (9,0); అనలాగ్‌రైట్ (10,0); అనలాగ్‌రైట్ (11,0); సీరియల్.ప్రింట్ ("ఎస్"); }

ఆర్డునో సెల్ఫ్ బ్యాలెన్సింగ్ రోబోట్ యొక్క పని

మీరు హార్డ్‌వేర్‌తో సిద్ధమైన తర్వాత, మీరు కోడ్‌ను మీ ఆర్డునో బోర్డుకు అప్‌లోడ్ చేయవచ్చు. మేము లి-అయాన్ బ్యాటరీని ఉపయోగిస్తున్నందున కనెక్షన్లు సరైనవని నిర్ధారించుకోండి. కాబట్టి షార్ట్ సర్క్యూట్ల కోసం రెండుసార్లు తనిఖీ చేయండి మరియు మీ బోట్ కొన్ని చిన్న ప్రభావాలను ఎదుర్కొన్నప్పటికీ టెర్మినల్స్ పరిచయం లోకి రాకుండా చూసుకోండి. మీ మాడ్యూల్‌ను శక్తివంతం చేయండి మరియు మీ సీరియల్ మానిటర్‌ను తెరవండి, మీ ఆర్డునో MPU6050 తో విజయవంతంగా కమ్యూనికేట్ చేయగలిగితే మరియు ప్రతిదీ expected హించిన విధంగా పనిచేస్తుంటే మీరు ఈ క్రింది స్క్రీన్‌ను చూడాలి.

ఇక్కడ మనం PID అల్గోరిథం యొక్క ఇన్పుట్ మరియు అవుట్పుట్ విలువలను ఫార్మాట్ ఇన్పుట్ => అవుట్పుట్లో చూస్తాము . బోట్ సంతులనం అయితే అవుట్పుట్ విలువ 0 అవుతుంది. ఇన్పుట్ విలువ MPU6050 సెన్సార్ నుండి ప్రస్తుత విలువ. "F" అనే వర్ణమాల బోట్ ముందుకు కదులుతున్నట్లు సూచిస్తుంది మరియు "R" బోట్ రివర్స్ అని సూచిస్తుంది.

PID యొక్క ప్రారంభ దశలలో, మీ Arduino కేబుల్‌ను బోట్‌కు కనెక్ట్ చేయమని నేను సిఫార్సు చేస్తున్నాను, తద్వారా మీరు ఇన్పుట్ మరియు అవుట్పుట్ యొక్క విలువలను సులభంగా పర్యవేక్షించగలరు మరియు Kp, Ki మరియు Kd విలువల కోసం మీ ప్రోగ్రామ్‌ను సరిదిద్దడం మరియు అప్‌లోడ్ చేయడం కూడా సులభం అవుతుంది. ప్రదర్శనలు బాట్ యొక్క పూర్తి పని క్రింద వీడియో మీ PID విలువలు సరి ఎలా మరియు కూడా ప్రదర్శనలు.

మీకు పని చేయడంలో ఏమైనా సమస్య ఉంటే మీ స్వంత సెల్ఫ్ బ్యాలెన్సింగ్ రోబోను రూపొందించడానికి ఇది సహాయపడుతుందని ఆశిస్తున్నాము, ఆపై మీ ప్రశ్నలను క్రింది వ్యాఖ్య విభాగంలో ఉంచండి లేదా మరిన్ని సాంకేతిక ప్రశ్నల కోసం ఫోరమ్‌లను ఉపయోగించండి. మీకు మరింత సరదా కావాలంటే బంతి బ్యాలెన్సింగ్ రోబోను నిర్మించడానికి మీరు అదే లాజిక్‌ని కూడా ఉపయోగించవచ్చు.