Kunstmatige intelligentie in robotica en bewegingscontrole — Kunstmatige intelligentie in de mechatronica

Winst:

Vermogen om voorwaartse/inverse kinematica en trajectplanningsproblemen op te zetten en op te lossen met behulp van AI
Mogelijkheid om een veilige baan te creëren door robotgewrichtslimieten, snelheids- en acceleratiebeperkingen als context voor de prompt te geven
Mogelijkheid om de door de AI geproduceerde kinematische en trajectoutput numeriek en fysiek te verifiëren

De grijper aan het uiteinde van een robotarm naar een bepaald punt in de ruimte brengen, in een bepaalde oriëntatie; Het klinkt eenvoudig, maar er zitten kinematische vergelijkingen, gezamenlijke limieten, singulariteiten en trajectplanning achter. Hier gebruikt de mechatronica-ingenieur trigonometrie, lineaire algebra en regeltheorie samen. Kunstmatige intelligentie is een krachtig hulpmiddel in dit proces: het kan vergelijkingen voor de voorwaartse kinematica opstellen, oplossingsbenaderingen voor inverse kinematica voorstellen, en een traject parametriseren op basis van snelheids-/versnellingsbeperkingen. Robotica is echter een van de gebieden binnen de mechatronica met het grootste fysieke risico; Als een door de AI gegenereerde hoekreeks zonder verificatie naar de robot wordt gestuurd, kan de arm zichzelf, de omgeving of de operator raken. In deze unit zullen we zien hoe we kinematica en trajectplanning met AI kunnen opzetten en verifiëren.

Voorwaartse en inverse kinematica

Voorwaartse kinematica (FK): Het vinden van de positie en oriëntatie van de eindeffector als de gewrichtshoeken bekend zijn. Er is maar één oplossing: direct.

Inverse kinematica (IK): Als de gewenste positie van de eindfunctie bekend is, het vinden van de gewrichtshoeken die hiervoor zorgen. Het heeft meestal meer dan één oplossing (zoals elleboog omhoog/omlaag), soms heeft het geen oplossingen (onbereikbaar punt), soms heeft het oneindige oplossingen (singulariteit).

concept

invoer

uitgang

Aantal oplossingen

Voorwaartse kinematica

gezamenlijke hoeken

Extreme positie/oriëntatie

enkel

Inverse kinematica

Extreme positie/oriëntatie

gezamenlijke hoeken

Meerdere/geen/oneindig

Voor een planaire arm met twee gewrichten kan de inverse kinematica in de AI worden ingesteld en als volgt handmatig worden geverifieerd:

import numpy as npdef inverse_kinematik_2r(x, y, L1, L2): """IK voor planaire arm met 2 gewrichten. Retourneert hoeken in radialen (elleboog-omlaag-oplossing).""" r2 = x**2 + y**2 # Toegankelijkheidscontrole: is het punt in de werkruimte? if np.sqrt(r2) > (L1 + L2) of np.sqrt(r2) < abs(L1 - L2): raise ValueError("Punt ligt buiten de toegankelijke werkruimte") cos_t2 = (r2 - L1**2 - L2**2) / (2 * L1 * L2) cos_t2 = np.clip(cos_t2, -1.0, 1.0) # numerieke beveiliging t2 = np.arccos(cos_t2) # elleboog naar beneden t1 = np.arctan2(y, x) - np.arctan2(L2*np.sin(t2), L1 + L2*np.cos(t2)) return np.degrees(t1), np.degrees(t2)# Validatie: L1=L2=1, doel (1,1) -> verwachte t2=90 gradenafdruk(inverse_kinematik_2r(1.0, 1.0, 1.0, 1.0)) # ~ (0.0, 90.0)

De kritische regels hier zijn waar de AI vaak overslaat: bereikbaarheidscontrole (is het punt in de werkruimte) en `np.clip` (voorkomt dat arccos-invoer verder gaat dan ±1 vanwege afrondingsfouten). Zonder deze twee beveiligingen zal de code NaN produceren of op een ongeldig punt crashen.

Tip: Wanneer u om IK-resolutie vraagt, vertel dan duidelijk aan de AI dat hij "toegankelijkheidscontrole moet toevoegen en arccos-invoer moet beperken tot clip". Deze twee lijnen voorkomen de stille fouten die in het veld de meeste kopzorgen veroorzaken.

Gezamenlijke grenzen, singulariteit en meerdere oplossingen

Elk gewricht van een echte robot heeft een hoekbereik (bijvoorbeeld -170° tot +170°), een snelheidslimiet en een versnellingslimiet. Zelfs als IK een wiskundig geldige hoek geeft, kan deze niet worden gebruikt als die hoek buiten het fysieke bereik van de verbinding ligt. Bovendien vervalt de robot in sommige configuraties in singulariteit: twee assen zijn uitgelijnd, één vrijheidsgraad gaat verloren en de gewrichtssnelheden proberen naar het oneindige te gaan voor een kleine tipbeweging.

Daarom is een HR-oplossing alleen niet voldoende; Elke oplossing moet een aanvaardbaarheidsfilter doorstaan:

def oplossing_gecerli_mi(acilar_deg, limit_deg): """pijn: [t1,t2,...], limieten: [(min,max),...]""" voor pijn, (amin, amax) in zip(acilar_deg, limit_deg): indien niet (amine <= pijn <= amax): return False, f"Gezamenlijke limiet overschreden: {pain:.1f} deg ({amine},{amax}) behalve" return True, "OK"limits = [(-170, 170), (-120, 120)]print(cozum_valid_mi([0.0, 90.0], limieten)) # (Waar, 'OK')print(cozum_valid_mi([0.0, 150.0], limieten)) # (False, 'Gezamenlijke limiet overschreden...')

AI kan de "wiskundige" oplossing van IK geven; maar gezamenlijke limieten en het vermijden van singulariteit zijn specifiek voor uw systeem en moeten als context bij de prompt worden gegeven.

Baanplanning

Om de robot van punt A naar punt B te krijgen, gaat het niet om het tekenen van een rechte lijn tussen twee hoeken. Een plotselinge snelheidsverandering veroorzaakt mechanische schokken en trillingen. In plaats daarvan worden zachte profielen gebruikt: trapeziumvormig snelheidsprofiel (constante versnelling – constante snelheid – constante vertraging) of S-curve (soepeler, waarbij de versnelling ook beperkt is). Wanneer je de AI een traject laat genereren, moet je het doel, de duur en de beperkingen opgeven.

import numpy as npdef trapez_yorunge(q0, q1, v_max, a_max, dt=0.01): """Trapezoïdaal snelheidsprofiel voor een enkel gewricht. De positiearray wordt geretourneerd.""" distance = abs(q1 - q0) direction = np.sign(q1 - q0) t_speed = v_max / a_max distance_speed = 0.5 * a_max * t_snelheid**2 if 2 * distance_speed > distance: # driehoekig profiel (v_max niet bereikbaar) t_speed = np.sqrt(distance / a_max) t_constant = 0,0 v_peak = a_max * t_speed anders: t_constant = (distance - 2 * distance_speed) / v_max v_peak = v_max T = 2 * t_accelerate + t_constant t = np.arange(0, T, dt) # ... positieberekening voor elke t (gebaseerd op acceleratie-/constante/deceleratiefasen) return t, T, v_peak, Duration, vz = trapeziumvormig_traject(0,0, 90,0, v_max=60,0, a_max=120,0)print(f"Totale duur: {duration:.3f} s, pieksnelheid: {vz:.1f} graden/s")

De logische controle hier is deze: als de afstand kort is, zal de motor nooit v_max bereiken en zal het profiel van trapeziumvormig naar driehoekig veranderen. Als de AI deze voorwaarde mist, wordt voor korte bewegingen de verkeerde duur berekend. U kunt dit verifiëren door de code te testen met een bekende waarde (bijvoorbeeld een zeer korte afstand).

Zwakke prompt/sterke prompt

ZWAK: "Schrijf een traject dat de robotarm van A naar B brengt." (Geen beperking: snelheidslimiet? Acceleratie? Gewrichtsafstand? Blinde uitvoer.) STERK: "Genereer een punt-tot-punt traject in de gewrichtsruimte voor een robot met 6 assen. De snelheidslimiet voor elk gewricht is 90 graden/s, de versnellingslimiet is 180 graden/s^2, het hoekbereik staat in de tabel. Gebruik een trapeziumvormig snelheidsprofiel als de afstand gelijk is aan Kortom, val in een driehoekig profiel. De uitvoer van elk gewricht is Schrijf ook een verificatiefunctie die controleert of het de limieten van het gewricht niet overschrijdt: {{table}}"

Verificatie: van simulatie tot robot

Het door de AI gegenereerde traject wordt in deze volgorde geverifieerd voordat het naar de robot gaat:

Numeriek: Zijn de gewrichtshoek, snelheid en versnelling van elke stap binnen de limieten?
Botsing: Komt de arm tijdens het traject in botsing met zichzelf of de omgeving (visualiseren/simuleren indien mogelijk)?
Singulariteit: Gaat de baan door een singulariteitsgebied (benadert de Jacobiaanse determinant nul)?
Langzame hardwaretest: Bedien de robot op een lage snelheid (bijvoorbeeld 10%) en controleer deze visueel.
Geleidelijke snelheidsverhoging: Zodra alles is geverifieerd, wordt de snelheid stap voor stap verhoogd tot de nominale waarde.

Let op: Wanneer u een robot voor de eerste keer met een nieuw traject start, moet de snelheidsoverride altijd laag zijn en moet de E-stop beschikbaar zijn. Zelfs als de AI-uitvoer ‘wiskundig correct’ is, zal een offset, omgekeerde as of kabelprobleem in de fysieke opstelling alleen aan het licht komen bij langzaam testen.

Mini-hoesje

Automatiseringsingenieur Ece vraagt de AI om een trajectcode in de gezamenlijke ruimte voor een pick-and-place-applicatie. De AI produceert een trapeziumvormig profiel, maar wanneer Ece een beweging over korte afstand test, ziet ze dat de tijd negatief is: de code heeft het driehoekige profiel niet afgehandeld waarbij v_max niet kan worden bereikt. Ece corrigeert dit door de prompt te geven "als de afstand kort is, val dan in het driehoekige profiel". Vervolgens voert het de verbindingshoeken uit die door de AI via zijn validatiefunctie zijn gegeven tegen zijn eigen limiettabel en ontdekt dat verbinding 5 op een gegeven moment +125° wilde, terwijl de limiet +120° was. Hij plant het traject opnieuw en bewaakt het, deze keer laat hij de robot op 10% snelheid draaien. In de eerste ronde ziet hij dat de grijper te dicht bij de tafel komt en corrigeert hij de Z-offset. De AI stuurde binnen enkele minuten een werkschema terug; maar drie afzonderlijke validaties (driehoeksprofiel, gezamenlijke limiet, langzame test) brachten drie afzonderlijke echte problemen aan het licht.

Veelvoorkomende fouten

Gebruik van de IK-oplossing zonder gezamenlijke grenzen en toegankelijkheidscontrole.
Arccos/arcsin-invoeren worden niet afgekapt, maar NaN geproduceerd in geval van afrondingsfouten.
De baan aanvragen zonder de snelheid/versnelling te beperken en mechanische schokken te veroorzaken.
Het negeren van singulariteitszones en het laten stijgen van de gezamenlijke snelheden.
De trapezium-driehoekige profielovergang op korte afstand overslaan en de verkeerde tijd berekenen.
Het uitvoeren van de eerste orbitale test op volle snelheid en zonder noodstoptoegang.

Samengevat

Voorwaartse kinematica heeft één oplossing; inverse kinematica kan meerdere, niet-bestaande of oneindige oplossingen opleveren.
IK-oplossingen worden noodzakelijkerwijs gefilterd in termen van gezamenlijke grenzen, toegankelijkheid en singulariteit.
Trajectplanning; Het maakt gebruik van zachte, limiet-compatibele profielen zoals trapeziumvormige of S-curve.
Op korte afstand verandert het profiel van trapeziumvormig naar driehoekig; dit moet in de code worden afgehandeld.
AI versnelt wiskunde; De limieten en fysieke installatiecontext moeten in de prompt verschijnen.
Het nieuwe traject wordt voor de eerste keer altijd gereden met een lage snelheidsverhouding en een toegankelijke E-stop.

Applicatie taak

Selecteer een armmodel met twee of drie gewrichten (met echte of denkbeeldige schakellengtes en gewrichtslimieten). Laat de AI met deze context een inverse kinematica-functie en een trajectplanner genereren. Vervolgens: (1) verifieer handmatig de IK-uitvoer met een bekend doel (zet je de hoeken terug en keer terug naar hetzelfde punt als de FK), (2) test of de code ze vastlegt door ten minste één ontoegankelijk punt en één gezamenlijke limiet op te geven die het doel overschrijdt, (3) controleer of op korte afstand de omlooptijd redelijk blijkt te zijn. Schrijf op hoeveel validatieproblemen je hebt gevonden in de eerste versie van de code en welke laag ze allemaal heeft ondervonden.