Svenska ElektronikForumet

lillahuset skrev:Vad hade du tänkt att använda för datatyper för beräkningarna? Heltal, flyttal? Hur långa.

Hur många matematiska operationer blir det per loop?

Addition, subtraktion, multiplikation, division, annat?

Hur mycket data behandlar du per loop? Alltså hur många, låt oss kalla det "variabler", handlar det om? En matris MxN är MxN "variabler". Konstanter?

Edit: Jag förstår inte men det är ingen idé att du försöker förklara.

Greve Hamilton skrev:

Volvo740 skrev:Vänta lite. Hur menar du? Måste jag använda en diskret modell eller tidskontiunerlig modell?

Jag menar att din metod i ditt ursprungliga inlägg i princip är rätt, men att det du har kommit fram till faktiskt är en tidsdiskret modell.

Jag föreslår att du sätter dig och labbar med detta i Matlab/Octave/IPython eller liknande innan du implementerar det på en mcu.

lillahuset skrev:Och sedan i C på en PC om du ska implementera det i C på en MCU.

Jag har tänkt att använda korta flyttal. Max 3 decimaler.

Det blir en matematisk operation per loop. Filtret tar hand om bruset.

Det blir endast addition, subtraktion, multiplikation, transponat och invers(division i linjär algebra). Finns C++ bibliotek för detta.

Ja. \(F(t)\) är alltså \(NxN\) matris. Det kommer max bli \(10x10\) då \(6x6\) så han man behandla en hydraulisk cylinder med fjäder och tämpare + massa med fjäder och dämpare + balk med fjäder och dämpare. Alltså 3-DOF system = \(6x6\)

Du bör lära dig LQ-teknik om du vill hålla på med reglerteknik för flervariabla system. LQ-teknik används oftast inom robotik och rymdteknik. Men jag vill tillämpa detta i mitt egna hem då jag tycker PID-regulatorer är för mainstream.

Men frågan gäller:
Kan jag använda en tidskontinuerlig matematisk modell i en mikrokontroller?

Volvo740 skrev: Jag är pro-master på Octave och har byggt många LQG regulatorer igenom endast matrisberäkningar.

Men jag håller inte med att du anser att jag har byggt en diskret matematisk modell. För det första är detta en linjär tidskontinuerlig matematisk tillståndsmodell:

\(\dot{x}(t) = Ax(t) + Bu(t)\)
\(y(t) = Cx(t) + Du(t)\)

För att göra om denna modell till en diskret modell som görs följande:
\(F = e^{At} = I + At + \frac{A^2t^2}{2!} + \frac{A^3t^3}{3!} + \frac{A^3t^4}{4!} + ... = {\sum_{k = 0}^{\infty }\frac{A^kt^k}{k!}}\)

Där \(t\) bestäms som ett samplingsintervall \(h\) och därmed:
\(F = e^{Ah}\)

För insignalerna:

\(G = \int_0^h e^{At}Bdt\)

Volvo740 skrev: Och därmed blir den diskreta modellen följande:
\(\dot{x}(k + 1) = Fx(k) + Gu(k)\)
\(y(k) = Cx(k) + Du(k)\)

Det här är alltså en diskret matematisk linjär tillståndsmodell....

hawkan skrev:Du kan använda Arduino. Det är som en vanlig dator fast typ en miljon gånger långsammare för sådant här.

Vad är du specifikt ute efter när du nämner mikroprocessor? Vad är det för egenskap du är ute efter?

Vad jag fattar så är det en ODE-lösare du vill ha. Det finns till PC, börja där.

Börja med t ex octave och lös problemet där.

Gör om till C++ men håll dej på PC så länge. Funkar det bra, gå vidare.

Välj den snabbaste mikroprocessor med hårdvara för flyttal. Det är inte en Arduino Uno eller Mega.
Se om det går att få in ODE-lösaren och om den hinner med. Då är du nästan framme.

lillahuset skrev: Läs på om flyttal och återkom.

Låter som om det kan bli väldigt många instruktioner per loop.

Så hundra stycken alltså?

Det borde väl du kunna svara på som gillar och har läst reglerteknik. Jag har ingen aning.

Mr Andersson skrev:Körde just en test i atmels avr-simulator. En enda floating point multiplikation är strax över 160 instruktioner. En division är över 500 st.
Valfri ARM med hårdvaru-FPU skulle vara avsevärt mycket bättre än en arduino. De kostar inte heller speciellt många kronor mer.

Greve Hamilton skrev: Nja, ta bort pricken på x:et så är det rätt. Då har du samma form som jag skrev förut men med \(F(x_k,u_k) = Fx_k+Gu_k\). Varför är det fel menar du?

u = 10;
for(int i = 0; i < 100; i++)
{
       dx = A*x + B*u;
       y[i] = C*x;
       T[i] = t;
       x = x + dx*t; // Uppdatera nästa tillstånd
}

Volvo740 skrev:

Greve Hamilton skrev: Nja, ta bort pricken på x:et så är det rätt. Då har du samma form som jag skrev förut men med \(F(x_k,u_k) = Fx_k+Gu_k\). Varför är det fel menar du?

Glömde pricken. Jag kopierade bara.

Problemet är att jag vill inte använda en diskret matematisk modell då jag tycker det är onödigt och dåligt samt svårt. Varför ska man ha en diskret matematisk modell när man kan egentligen köra istället med mycket kort sampling t.ex. 0.0001 sekunder?

Många jag har pratat med uppmanar mig att välja diskreta modeller om jag ska implementera en regulator i en mikrokontroller, men de kan inte förklara varför jag måste ha en diskret modell. Det är som det vore en norm från 50-talet att använda diskreta modeller.

Jag kan simulera en tidskontinuerlig ODE (Ordinär Differentialekvation) med hjälp av en for-loop i C. Inga problem alls!

Kod: Markera allt

u = 10;
for(int i = 0; i < 100; i++)
{
       dx = A*x + B*u;
       y[i] = C*x;
       T[i] = t;
       x = x + dx*t; // Uppdatera nästa tillstånd
}

Där t är samplingstiden och y kan nu plottas över tiden T.

OK, jag tror att vi pratar förbi varandra. Jag fortsätter dock hävda att så fort ett dt är inblandat så har du att göra med ett tidsdiskret system. Oavsett hur litet det är. Ditt kodexempel implementerar på sista raden just den diskretisering jag beskrev först.

MEN, det är ju så att ju mindre dt desto mer likt blir det diskreta systemet det kontinuerliga. Så om du vill kalla din metod med litet dt för kontinuerlig så låt inte mig hindra dig.

lillahuset skrev:Volvo740: Sluta sprattla och bjud till istället.

Flyttal: https://en.wikipedia.org/wiki/IEEE_754
Arduino: Extremt långsam för flyttal.
PC: Endast avsedd för simulering och felsökning av algoritm.

Om du skulle gissa, dra till med något bara, hur många cykler i en AVR tror du att din ODE i inlägget ovanför tar att räkna? Ta i ordentligt.
Hur många instruktioner har du tillgängliga för varje sampel? Jo, i bästa fall 16E6 * 1E-4 = 16E2, dvs 1600. Nu är ju inte alla encykels så räkna med 1200.
Hur många blir det per loop?