ರೊಬೊಟಿಕ್ಸ್ ಮತ್ತು ಚಲನೆಯ ನಿಯಂತ್ರಣದಲ್ಲಿ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ

ಲಾಭಗಳು:

• AI ಸಹಾಯದಿಂದ ಫಾರ್ವರ್ಡ್/ಇನ್ವರ್ಸ್ ಚಲನಶಾಸ್ತ್ರ ಮತ್ತು ಪಥದ ಯೋಜನೆ ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿಸುವ ಮತ್ತು ಪರಿಹರಿಸುವ ಸಾಮರ್ಥ್ಯ
• ರೋಬೋಟ್ ಜಂಟಿ ಮಿತಿಗಳು, ವೇಗ ಮತ್ತು ವೇಗವರ್ಧನೆಯ ನಿರ್ಬಂಧಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್‌ಗೆ ಸಂದರ್ಭವಾಗಿ ನೀಡುವ ಮೂಲಕ ಸುರಕ್ಷಿತ ಕಕ್ಷೆಯನ್ನು ಉತ್ಪಾದಿಸುವ ಸಾಮರ್ಥ್ಯ
• AI ನಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಚಲನಶಾಸ್ತ್ರ ಮತ್ತು ಪಥದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಮತ್ತು ಭೌತಿಕವಾಗಿ ಪರಿಶೀಲಿಸುವ ಸಾಮರ್ಥ್ಯ

ರೋಬೋಟ್ ತೋಳಿನ ಕೊನೆಯಲ್ಲಿ ಗ್ರಿಪ್ಪರ್ ಅನ್ನು ಒಂದು ನಿರ್ದಿಷ್ಟ ದೃಷ್ಟಿಕೋನದಲ್ಲಿ ಬಾಹ್ಯಾಕಾಶದಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಬಿಂದುವಿಗೆ ತರುವುದು; ಇದು ಸರಳವೆಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಅದರ ಹಿಂದೆ ಚಲನಶಾಸ್ತ್ರದ ಸಮೀಕರಣಗಳು, ಜಂಟಿ ಮಿತಿಗಳು, ಏಕವಚನಗಳು ಮತ್ತು ಪಥದ ಯೋಜನೆಗಳಿವೆ. ಇಲ್ಲಿ, ಮೆಕಾಟ್ರಾನಿಕ್ಸ್ ಎಂಜಿನಿಯರ್ ತ್ರಿಕೋನಮಿತಿ, ರೇಖೀಯ ಬೀಜಗಣಿತ ಮತ್ತು ನಿಯಂತ್ರಣ ಸಿದ್ಧಾಂತವನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸುತ್ತಾರೆ. ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯು ಪ್ರಬಲವಾದ ಸಹಾಯವಾಗಿದೆ: ಇದು ಫಾರ್ವರ್ಡ್ ಚಲನಶಾಸ್ತ್ರದ ಸಮೀಕರಣಗಳನ್ನು ಸ್ಥಾಪಿಸಬಹುದು, ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರಕ್ಕೆ ಪರಿಹಾರ ವಿಧಾನಗಳನ್ನು ಸೂಚಿಸಬಹುದು, ವೇಗ/ವೇಗವರ್ಧನೆಯ ನಿರ್ಬಂಧಗಳ ಪ್ರಕಾರ ಪಥವನ್ನು ನಿಯತಾಂಕಗೊಳಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ರೊಬೊಟಿಕ್ಸ್ ಮೆಕಾಟ್ರಾನಿಕ್ಸ್‌ನಲ್ಲಿ ಹೆಚ್ಚಿನ ದೈಹಿಕ ಅಪಾಯವನ್ನು ಹೊಂದಿರುವ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ; AI ನಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಕೋನದ ಅನುಕ್ರಮವನ್ನು ಪರಿಶೀಲನೆಯಿಲ್ಲದೆ ರೋಬೋಟ್‌ಗೆ ಕಳುಹಿಸಿದರೆ, ತೋಳು ಸ್ವತಃ, ಪರಿಸರ ಅಥವಾ ಆಪರೇಟರ್‌ಗೆ ಹೊಡೆಯಬಹುದು. ಈ ಘಟಕದಲ್ಲಿ AI ನೊಂದಿಗೆ ಚಲನಶಾಸ್ತ್ರ ಮತ್ತು ಪಥದ ಯೋಜನೆಯನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು ಮತ್ತು ಪರಿಶೀಲಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

ಫಾರ್ವರ್ಡ್ ಮತ್ತು ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರ

ಫಾರ್ವರ್ಡ್ ಚಲನಶಾಸ್ತ್ರ (FK): ಜಂಟಿ ಕೋನಗಳು ತಿಳಿದಿದ್ದರೆ ಅಂತ್ಯ-ಪರಿಣಾಮದ ಸ್ಥಾನ ಮತ್ತು ದೃಷ್ಟಿಕೋನವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು. ಒಂದೇ ಒಂದು ಪರಿಹಾರವಿದೆ, ಅದು ನೇರವಾಗಿರುತ್ತದೆ.

ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರ (IK): ಅಂತಿಮ ಕ್ರಿಯೆಯ ಅಪೇಕ್ಷಿತ ಸ್ಥಾನವು ತಿಳಿದಿದ್ದರೆ, ಇದನ್ನು ಒದಗಿಸುವ ಜಂಟಿ ಕೋನಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪರಿಹಾರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಮೊಣಕೈ ಮೇಲೆ/ಕೆಳಗೆ), ಕೆಲವೊಮ್ಮೆ ಇದು ಯಾವುದೇ ಪರಿಹಾರಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ (ಅನ್ರೀಚ್ ಪಾಯಿಂಟ್), ಕೆಲವೊಮ್ಮೆ ಇದು ಅನಂತ ಪರಿಹಾರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಏಕತ್ವ).

ಪರಿಕಲ್ಪನೆ

ಇನ್ಪುಟ್

ಔಟ್ಪುಟ್

ಪರಿಹಾರಗಳ ಸಂಖ್ಯೆ

ಫಾರ್ವರ್ಡ್ ಚಲನಶಾಸ್ತ್ರ

ಜಂಟಿ ಕೋನಗಳು

ವಿಪರೀತ ಸ್ಥಾನ / ದೃಷ್ಟಿಕೋನ

ಏಕ

ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರ

ವಿಪರೀತ ಸ್ಥಾನ / ದೃಷ್ಟಿಕೋನ

ಜಂಟಿ ಕೋನಗಳು

ಬಹು/ಯಾವುದೂ ಇಲ್ಲ/ಅನಂತ

ಎರಡು-ಜಂಟಿ ಸಮತಲ ತೋಳಿಗೆ, ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರವನ್ನು AI ನಲ್ಲಿ ಹೊಂದಿಸಬಹುದು ಮತ್ತು ಕೆಳಗಿನಂತೆ ಹಸ್ತಚಾಲಿತವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು:

npdef inverse_kinematik_2r(x, y, L1, L2) ನಂತೆ numpy ಅನ್ನು ಆಮದು ಮಾಡಿ: """2-ಜಾಯಿಂಟ್ ಪ್ಲ್ಯಾನರ್ ಆರ್ಮ್‌ಗಾಗಿ IK. ರೇಡಿಯನ್ಸ್‌ನಲ್ಲಿ ಕೋನಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ (ಮೊಣಕೈ-ಕೆಳಗಿನ ಪರಿಹಾರ).""" r2 = x**2 + y**2 # ಆಕ್ಸೆಸಿಬಿಲಿಟಿ ಚೆಕ್: ಕಾರ್ಯಸ್ಥಳದಲ್ಲಿರುವ ಬಿಂದುವೇ? np.sqrt(r2) > (L1 + L2) ಅಥವಾ np.sqrt(r2) < abs(L1 - L2): ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸಿದರೆ ("ಪಾಯಿಂಟ್ ಪ್ರವೇಶಿಸಬಹುದಾದ ಕೆಲಸದ ಸ್ಥಳದ ಹೊರಗಿದೆ") cos_t2 = (r2 - L1**2 - L2**2) / (2 * L1 * L2) cospt_ (2 * L1 * L2) cospt_ -1.0, 1.0) # ಸಂಖ್ಯಾತ್ಮಕ ಭದ್ರತೆ t2 = np.arccos(cos_t2) # ಮೊಣಕೈ ಕೆಳಗೆ t1 = np.arctan2(y, x) - np.arctan2(L2*np.sin(t2), L1 + L2*np.cos(np.cos(nt.2))grees(np.t.2) np.degrees(t2)# ಮೌಲ್ಯೀಕರಣ: L1=L2=1, ಗುರಿ (1,1) -> ನಿರೀಕ್ಷಿತ t2=90 ಡಿಗ್ರಿಸ್ಪ್ರಿಂಟ್(inverse_kinematik_2r(1.0, 1.0, 1.0, 1.0)) # ~ (0.0, 90.0)

ಇಲ್ಲಿ ವಿಮರ್ಶಾತ್ಮಕ ರೇಖೆಗಳು AI ಸಾಮಾನ್ಯವಾಗಿ ಬಿಟ್ಟುಬಿಡುತ್ತವೆ: ತಲುಪುವಿಕೆ ಪರಿಶೀಲನೆ (ಕಾರ್ಯಸ್ಥಳದಲ್ಲಿನ ಬಿಂದು) ಮತ್ತು `np.clip` (ರೌಂಡಿಂಗ್ ದೋಷದಿಂದಾಗಿ ಆರ್ಕೋಸ್ ಇನ್‌ಪುಟ್ ±1 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಹೋಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ). ಈ ಎರಡು ರಕ್ಷಣೆಗಳಿಲ್ಲದೆಯೇ, ಕೋಡ್ NaN ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಅಥವಾ ಅಮಾನ್ಯ ಹಂತದಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ಮಾಡುತ್ತದೆ.

ಸಲಹೆ: IK ರೆಸಲ್ಯೂಶನ್‌ಗಾಗಿ ಕೇಳುವಾಗ, "ಆಕ್ಸೆಸಿಬಿಲಿಟಿ ಕಂಟ್ರೋಲ್ ಅನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಕ್ಲಿಪ್‌ಗೆ ಆರ್ಕೋಸ್ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮಿತಿಗೊಳಿಸಿ" ಎಂದು AI ಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿ. ಈ ಎರಡು ಸಾಲುಗಳು ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೆಚ್ಚು ತಲೆನೋವನ್ನು ಉಂಟುಮಾಡುವ ಮೂಕ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

ಜಂಟಿ ಮಿತಿಗಳು, ಏಕತ್ವ ಮತ್ತು ಬಹು ಪರಿಹಾರಗಳು

ನಿಜವಾದ ರೋಬೋಟ್‌ನ ಪ್ರತಿಯೊಂದು ಜಾಯಿಂಟ್ ಕೋನ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಉದಾ. -170° ರಿಂದ +170°), ವೇಗದ ಮಿತಿ ಮತ್ತು ವೇಗೋತ್ಕರ್ಷದ ಮಿತಿ. IK ಗಣಿತದ ಮಾನ್ಯ ಕೋನವನ್ನು ನೀಡಿದರೂ, ಆ ಕೋನವು ಜಂಟಿ ಭೌತಿಕ ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿದ್ದರೆ ಅದನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ರೋಬೋಟ್ ಕೆಲವು ಸಂರಚನೆಗಳಲ್ಲಿ ಏಕತ್ವಕ್ಕೆ ಬೀಳುತ್ತದೆ: ಎರಡು ಅಕ್ಷಗಳು ಜೋಡಿಸಲ್ಪಟ್ಟಿವೆ, ಒಂದು ಡಿಗ್ರಿ ಸ್ವಾತಂತ್ರ್ಯ ಕಳೆದುಹೋಗುತ್ತದೆ ಮತ್ತು ಜಂಟಿ ವೇಗಗಳು ಸಣ್ಣ ತುದಿ ಚಲನೆಗಾಗಿ ಅನಂತತೆಗೆ ಹೋಗಲು ಪ್ರಯತ್ನಿಸುತ್ತವೆ.

ಅದಕ್ಕಾಗಿಯೇ ಮಾನವ ಸಂಪನ್ಮೂಲ ಪರಿಹಾರ ಮಾತ್ರ ಸಾಕಾಗುವುದಿಲ್ಲ; ಪ್ರತಿ ಪರಿಹಾರವು ಸ್ವೀಕಾರಾರ್ಹ ಫಿಲ್ಟರ್ ಅನ್ನು ರವಾನಿಸಬೇಕು:

def solution_gecerli_mi(acilar_deg, limits_deg): """ನೋವುಗಳು: [t1,t2,...], ಮಿತಿಗಳು: [(min,max),...]""" ನೋವಿಗೆ, (amin, amax) zip(acilar_deg, limits_deg): ಇಲ್ಲದಿದ್ದರೆ (ಅಮೈನ್ <= ನೋವು <= amax) ಮಿತಿ ಮೀರಿದೆ: {pain:.1f} deg ({amine},{amax}) ಹೊರತುಪಡಿಸಿ" ರಿಟರ್ನ್ ಟ್ರೂ, "ಸರಿ" ಮಿತಿಗಳು = [(-170, 170), (-120, 120)]ಪ್ರಿಂಟ್(cozum_valid_mi([0.0, 90.0], ಮಿತಿಗಳು)) # (True_'Okum')print. 150.0], ಮಿತಿಗಳು)) # (ತಪ್ಪು, 'ಜಂಟಿ ಮಿತಿ ಮೀರಿದೆ...')

AI IK ಯ "ಗಣಿತದ" ಪರಿಹಾರವನ್ನು ನೀಡಬಹುದು; ಆದರೆ ಜಂಟಿ ಮಿತಿಗಳು ಮತ್ತು ಏಕತ್ವವನ್ನು ತಪ್ಪಿಸುವುದು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿದೆ ಮತ್ತು ಪ್ರಾಂಪ್ಟ್‌ಗೆ ಸಂದರ್ಭವಾಗಿ ನೀಡಬೇಕು.

ಕಕ್ಷೆಯ ಯೋಜನೆ

ಎ ಬಿಂದುವಿನಿಂದ ಬಿ ಬಿಂದುವಿಗೆ ರೋಬೋಟ್ ಅನ್ನು ಪಡೆಯುವುದು ಎರಡು ಕೋನಗಳ ನಡುವೆ ನೇರ ರೇಖೆಯನ್ನು ಎಳೆಯುವುದರ ಬಗ್ಗೆ ಅಲ್ಲ. ಹಠಾತ್ ವೇಗ ಬದಲಾವಣೆಯು ಯಾಂತ್ರಿಕ ಆಘಾತ ಮತ್ತು ಕಂಪನವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಬದಲಾಗಿ, ಮೃದುವಾದ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ: ಟ್ರೆಪೆಜೋಡಲ್ ವೇಗದ ಪ್ರೊಫೈಲ್ (ಸ್ಥಿರ ವೇಗವರ್ಧನೆ-ಸ್ಥಿರ ವೇಗ-ಸ್ಥಿರವಾದ ಕುಸಿತ) ಅಥವಾ S-ಕರ್ವ್ (ನಯವಾದ, ವೇಗವರ್ಧನೆಯು ಸಹ ಸೀಮಿತವಾಗಿರುತ್ತದೆ). AI ಅನ್ನು ಪಥವನ್ನು ರಚಿಸುವಾಗ, ನೀವು ಗುರಿ, ಅವಧಿ ಮತ್ತು ನಿರ್ಬಂಧಗಳನ್ನು ನೀಡಬೇಕು.

npdef trapez_yorunge(q0, q1, v_max, a_max, dt=0.01) ಎಂದು ನಂಬಿ ಆಮದು ಮಾಡಿ: """ಒಂದೇ ಜಂಟಿಗಾಗಿ ಟ್ರೆಪೆಜೋಡಲ್ ವೇಗದ ಪ್ರೊಫೈಲ್. ಸ್ಥಾನ ರಚನೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ."" ದೂರ = abs(q1 - q0) ದಿಕ್ಕು = np.qpe (q1t_sign_) a_max ದೂರ_ವೇಗ = 0.5 * a_max * t_speed**2 ವೇಳೆ 2 * ದೂರ_ವೇಗ > ದೂರ: # ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್ (v_max ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ) t_speed = np.sqrt(ದೂರ / a_max) t_constant = 0.0 v_peaked = t_tmax_peaked else: 2 * ದೂರ_ವೇಗ) / v_max v_peak = v_max T = 2 * t_accelerate + t_constant t = np.arange(0, T, dt) # ... ಪ್ರತಿ t ಗಾಗಿ ಸ್ಥಾನದ ಲೆಕ್ಕಾಚಾರ (ವೇಗವರ್ಧನೆ/ಸ್ಥಿರ/ಕ್ಷೀಣತೆ ಹಂತಗಳ ಆಧಾರದ ಮೇಲೆ) t, T, v_peak, ಅವಧಿ, v_peak ಹಿಂತಿರುಗಿ trapezoidal_trajectory(0.0, 90.0, v_max=60.0, a_max=120.0)print(f"ಒಟ್ಟು ಅವಧಿ: {duration:.3f} s, ಗರಿಷ್ಠ ವೇಗ: {vz:.1f} deg/s")

ಇಲ್ಲಿ ತರ್ಕ ಪರಿಶೀಲನೆ ಹೀಗಿದೆ: ದೂರವು ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ಮೋಟಾರ್ ಎಂದಿಗೂ v_max ಅನ್ನು ತಲುಪುವುದಿಲ್ಲ ಮತ್ತು ಪ್ರೊಫೈಲ್ ಟ್ರೆಪೆಜೋಡಲ್ನಿಂದ ತ್ರಿಕೋನಕ್ಕೆ ತಿರುಗುತ್ತದೆ. AI ಈ ಸ್ಥಿತಿಯನ್ನು ತಪ್ಪಿಸಿಕೊಂಡರೆ, ಸಣ್ಣ ಚಲನೆಗಳಿಗೆ ತಪ್ಪಾದ ಅವಧಿಯನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ತಿಳಿದಿರುವ ಮೌಲ್ಯದೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವ ಮೂಲಕ ನೀವು ಇದನ್ನು ಪರಿಶೀಲಿಸಬಹುದು (ಉದಾಹರಣೆಗೆ, ಬಹಳ ಕಡಿಮೆ ದೂರ).

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ:"ರೋಬೋಟ್ ತೋಳನ್ನು A ನಿಂದ B ಗೆ ಕೊಂಡೊಯ್ಯುವ ಪಥವನ್ನು ಬರೆಯಿರಿ."(ಯಾವುದೇ ನಿರ್ಬಂಧವಿಲ್ಲ: ವೇಗದ ಮಿತಿ? ವೇಗವರ್ಧನೆ? ಜಂಟಿ ಅಂತರ? ಬ್ಲೈಂಡ್ ಔಟ್‌ಪುಟ್ ವ್ಯಾಪ್ತಿಯನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ ನೀಡಲಾಗಿದೆ, ದೂರವು ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್‌ಗೆ ಬೀಳುತ್ತದೆ, ಅದು ಜಂಟಿ ಮಿತಿಗಳನ್ನು ಮೀರುವುದಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸುವ ಪರಿಶೀಲನಾ ಕಾರ್ಯವನ್ನು ಬರೆಯಿರಿ.

ಪರಿಶೀಲನೆ: ಸಿಮ್ಯುಲೇಶನ್‌ನಿಂದ ರೋಬೋಟ್‌ಗೆ

ರೋಬೋಟ್‌ಗೆ ಹೋಗುವ ಮೊದಲು AI ನಿಂದ ರಚಿಸಲಾದ ಪಥವನ್ನು ಈ ಕ್ರಮದಲ್ಲಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ:

1. ಸಂಖ್ಯಾತ್ಮಕ: ಪ್ರತಿ ಹಂತದ ಜಂಟಿ ಕೋನ, ವೇಗ ಮತ್ತು ವೇಗವರ್ಧನೆಯು ಮಿತಿಯಲ್ಲಿದೆಯೇ?
2. ಘರ್ಷಣೆ: ಪಥದ ಉದ್ದಕ್ಕೂ, ತೋಳು ತನ್ನೊಂದಿಗೆ ಅಥವಾ ಪರಿಸರದೊಂದಿಗೆ ಡಿಕ್ಕಿ ಹೊಡೆಯುತ್ತದೆಯೇ (ಸಾಧ್ಯವಾದರೆ ದೃಶ್ಯೀಕರಿಸುವುದು/ಅನುಕರಿಸುವುದು)?
3. ಏಕತ್ವ: ಕಕ್ಷೆಯು ಏಕತೆಯ ಪ್ರದೇಶದ ಮೂಲಕ ಹಾದುಹೋಗುತ್ತದೆಯೇ (ಜಾಕೋಬಿಯನ್ ಡಿಟರ್ಮಿನಂಟ್ ಶೂನ್ಯವನ್ನು ತಲುಪುತ್ತದೆಯೇ)?
4. ನಿಧಾನ ಯಂತ್ರಾಂಶ ಪರೀಕ್ಷೆ: ರೋಬೋಟ್ ಅನ್ನು ಕಡಿಮೆ ವೇಗದಲ್ಲಿ ನಿರ್ವಹಿಸಿ (ಉದಾ. 10%) ಮತ್ತು ಅದನ್ನು ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.
5. ಕ್ರಮೇಣ ವೇಗ ಹೆಚ್ಚಳ: ಎಲ್ಲವನ್ನೂ ಪರಿಶೀಲಿಸಿದ ನಂತರ, ವೇಗವು ನಾಮಮಾತ್ರ ಮೌಲ್ಯಕ್ಕೆ ಹಂತ ಹಂತವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ.

ಎಚ್ಚರಿಕೆ: ಮೊದಲ ಬಾರಿಗೆ ಹೊಸ ಪಥದೊಂದಿಗೆ ರೋಬೋಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ವೇಗದ ಓವರ್‌ರೈಡ್ ಯಾವಾಗಲೂ ಕಡಿಮೆಯಿರಬೇಕು ಮತ್ತು ಇ-ಸ್ಟಾಪ್ ಲಭ್ಯವಿರಬೇಕು. AI ಔಟ್‌ಪುಟ್ "ಗಣಿತದ ಪ್ರಕಾರ ಸರಿಯಾಗಿದ್ದರೂ", ಭೌತಿಕ ಸೆಟಪ್‌ನಲ್ಲಿ ಆಫ್‌ಸೆಟ್, ರಿವರ್ಸ್ ಆಕ್ಸಿಸ್ ಅಥವಾ ಕೇಬಲ್ ಸ್ನ್ಯಾಗ್ ನಿಧಾನ ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ಮಾತ್ರ ಬಹಿರಂಗಗೊಳ್ಳುತ್ತದೆ.

ಮಿನಿ ಕೇಸ್

ಆಟೋಮೇಷನ್ ಇಂಜಿನಿಯರ್ Ece ಪಿಕ್ ಮತ್ತು ಪ್ಲೇಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಜಂಟಿ ಜಾಗದಲ್ಲಿ ಪಥದ ಕೋಡ್‌ಗಾಗಿ AI ಅನ್ನು ಕೇಳುತ್ತಾರೆ. AI ಟ್ರೆಪೆಜಾಯಿಡಲ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಆದರೆ Ece ಕಡಿಮೆ-ದೂರ ಚಲನೆಯನ್ನು ಪರೀಕ್ಷಿಸಿದಾಗ, ಸಮಯವು ಋಣಾತ್ಮಕವಾಗಿದೆ ಎಂದು ಅವಳು ನೋಡುತ್ತಾಳೆ: v_max ಅನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಾಗದ ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್ ಪ್ರಕರಣವನ್ನು ಕೋಡ್ ನಿಭಾಯಿಸಲಿಲ್ಲ. "ದೂರವು ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್‌ಗೆ ಬೀಳು" ಎಂಬ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಹೇಳುವ ಮೂಲಕ Ece ಇದನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ. ಇದು ನಂತರ AI ನೀಡಿದ ಜಂಟಿ ಕೋನಗಳನ್ನು ತನ್ನದೇ ಆದ ಮಿತಿಯ ಕೋಷ್ಟಕದ ವಿರುದ್ಧ ಅದರ ಮೌಲ್ಯೀಕರಣ ಕಾರ್ಯದ ಮೂಲಕ ರನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜಂಟಿ 5 ಒಂದು ಹಂತದಲ್ಲಿ +125 ° ಬಯಸಿದೆ ಎಂದು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಮಿತಿ +120 ° ಆಗಿತ್ತು. ಅವನು ಪಥವನ್ನು ಪುನಃ ಯೋಜಿಸುತ್ತಾನೆ ಮತ್ತು ಅದನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತಾನೆ, ಈ ಬಾರಿ ರೋಬೋಟ್ ಅನ್ನು 10% ವೇಗದಲ್ಲಿ ಓಡಿಸುತ್ತಾನೆ. ಮೊದಲ ಸುತ್ತಿನಲ್ಲಿ, ಗ್ರಿಪ್ಪರ್ ಟೇಬಲ್‌ಗೆ ತುಂಬಾ ಹತ್ತಿರವಾಗುತ್ತಿರುವುದನ್ನು ಅವನು ನೋಡುತ್ತಾನೆ ಮತ್ತು Z ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಸರಿಪಡಿಸುತ್ತಾನೆ. AI ನಿಮಿಷಗಳಲ್ಲಿ ಕೆಲಸದ ರೂಪರೇಖೆಯನ್ನು ಹಿಂದಿರುಗಿಸಿತು; ಆದರೆ ಮೂರು ಪ್ರತ್ಯೇಕ ಮೌಲ್ಯೀಕರಣಗಳು (ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್, ಜಂಟಿ ಮಿತಿ, ನಿಧಾನ ಪರೀಕ್ಷೆ) ಮೂರು ಪ್ರತ್ಯೇಕ ನೈಜ ಸಮಸ್ಯೆಗಳನ್ನು ಸೆಳೆಯಿತು.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಜಂಟಿ ಮಿತಿಗಳು ಮತ್ತು ಪ್ರವೇಶ ನಿಯಂತ್ರಣವಿಲ್ಲದೆ IK ಪರಿಹಾರವನ್ನು ಬಳಸುವುದು.
• ಆರ್ಕೋಸ್/ಆರ್ಕ್‌ಸಿನ್ ನಮೂದುಗಳನ್ನು ಕ್ಲಿಪ್ ಮಾಡುತ್ತಿಲ್ಲ ಆದರೆ ಪೂರ್ಣಾಂಕ ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ NaN ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.
• ವೇಗ/ವೇಗವರ್ಧನೆಯನ್ನು ಮಿತಿಗೊಳಿಸದೆ ಮತ್ತು ಯಾಂತ್ರಿಕ ಆಘಾತವನ್ನು ಸೃಷ್ಟಿಸದೆ ಕಕ್ಷೆಗೆ ವಿನಂತಿಸುವುದು.
• ಏಕತೆಯ ವಲಯಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಮತ್ತು ಜಂಟಿ ವೇಗವನ್ನು ಗಗನಕ್ಕೇರಲು ಬಿಡುವುದು.
• ಟ್ರೆಪೆಜೋಡಲ್-ತ್ರಿಕೋನ ಪ್ರೊಫೈಲ್ ಪರಿವರ್ತನೆಯನ್ನು ಸ್ವಲ್ಪ ದೂರದಲ್ಲಿ ಬಿಟ್ಟುಬಿಡುವುದು ಮತ್ತು ತಪ್ಪಾದ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.
• ಪೂರ್ಣ ವೇಗದಲ್ಲಿ ಮತ್ತು ಇ-ಸ್ಟಾಪ್ ಪ್ರವೇಶವಿಲ್ಲದೆ ಮೊದಲ ಕಕ್ಷೆಯ ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸುವುದು.

ಸಾರಾಂಶದಲ್ಲಿ

• ಫಾರ್ವರ್ಡ್ ಚಲನಶಾಸ್ತ್ರವು ಒಂದೇ ಪರಿಹಾರವನ್ನು ಹೊಂದಿದೆ; ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರವು ಬಹು, ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಅಥವಾ ಅನಂತ ಪರಿಹಾರಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು.
• IK ಪರಿಹಾರಗಳನ್ನು ಜಂಟಿ ಮಿತಿಗಳು, ಪ್ರವೇಶಿಸುವಿಕೆ ಮತ್ತು ಏಕತ್ವದ ಪರಿಭಾಷೆಯಲ್ಲಿ ಅಗತ್ಯವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತದೆ.
• ಪಥದ ಯೋಜನೆ; ಇದು ಟ್ರೆಪೆಜಾಯಿಡಲ್ ಅಥವಾ ಎಸ್-ಕರ್ವ್‌ನಂತಹ ಮೃದುವಾದ, ಮಿತಿ-ಹೊಂದಾಣಿಕೆಯ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.
• ಸ್ವಲ್ಪ ದೂರದಲ್ಲಿ ಪ್ರೊಫೈಲ್ ಟ್ರೆಪೆಜೋಡಲ್ನಿಂದ ತ್ರಿಕೋನಕ್ಕೆ ಬದಲಾಗುತ್ತದೆ; ಇದನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸಬೇಕು.
• AI ಗಣಿತದ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ; ಮಿತಿಗಳು ಮತ್ತು ಭೌತಿಕ ಅನುಸ್ಥಾಪನೆಯ ಸಂದರ್ಭವು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ನಮೂದಿಸಬೇಕು.
• ಹೊಸ ಪಥವನ್ನು ಯಾವಾಗಲೂ ಕಡಿಮೆ ವೇಗದ ಅನುಪಾತ ಮತ್ತು ಪ್ರವೇಶಿಸಬಹುದಾದ ಇ-ಸ್ಟಾಪ್‌ನೊಂದಿಗೆ ಮೊದಲ ಬಾರಿಗೆ ಚಾಲನೆ ಮಾಡಲಾಗುತ್ತದೆ.

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ಎರಡು ಅಥವಾ ಮೂರು-ಜಂಟಿ ತೋಳಿನ ಮಾದರಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ (ನೈಜ ಅಥವಾ ಕಾಲ್ಪನಿಕ ಲಿಂಕ್ ಉದ್ದಗಳು ಮತ್ತು ಜಂಟಿ ಮಿತಿಗಳೊಂದಿಗೆ). ಈ ಸಂದರ್ಭದೊಂದಿಗೆ AI ವಿಲೋಮ ಚಲನಶಾಸ್ತ್ರದ ಕಾರ್ಯವನ್ನು ಮತ್ತು ಪಥದ ಯೋಜಕವನ್ನು ಉತ್ಪಾದಿಸುವಂತೆ ಮಾಡಿ. ನಂತರ: (1) ತಿಳಿದಿರುವ ಗುರಿಯೊಂದಿಗೆ IK ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪರಿಶೀಲಿಸಿ (ನೀವು ಕೋನಗಳನ್ನು ಹಿಂದಕ್ಕೆ ಇರಿಸಿ ಮತ್ತು FK ಯಂತೆಯೇ ಅದೇ ಬಿಂದುವಿಗೆ ಹಿಂತಿರುಗುತ್ತೀರಾ), (2) ಕನಿಷ್ಠ ಒಂದು ಪ್ರವೇಶಿಸಲಾಗದ ಬಿಂದು ಮತ್ತು ಗುರಿಯನ್ನು ಮೀರಿದ ಒಂದು ಜಂಟಿ ಮಿತಿಯನ್ನು ನೀಡುವ ಮೂಲಕ ಕೋಡ್ ಅವುಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಿ, (3) ಸ್ವಲ್ಪ ದೂರದಲ್ಲಿ ಕಕ್ಷೆಯ ಸಮಯವು ಸಮಂಜಸವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಕೋಡ್‌ನ ಮೊದಲ ಆವೃತ್ತಿಯಲ್ಲಿ ನೀವು ಎಷ್ಟು ಊರ್ಜಿತಗೊಳಿಸುವಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೀರಿ ಮತ್ತು ಪ್ರತಿಯೊಂದನ್ನು ಯಾವ ಪದರವು ಸೆಳೆಯಿತು ಎಂಬುದನ್ನು ಬರೆಯಿರಿ.