Matrisberäkningar med för STM32?

[sodjan]

Men, vad är det som "styr" processen under den första tiden? Indata från den tiden kan väl vara helt åt skogen, beroende på hur processen (alltså det som "styrs") startar upp, vilket läge det befinner sig i? Hur säkrar man upp att inte styrsystemet får en helt felaktig bild av processen och gör något potentiellt farligt? Min bild är att en "systemidentifiering" betyder att man måste testa att styra processen för att kunna läsa av hur det reagerar. Eller hur mycket vet styrsystemet om processen från början? Det känns som att "processtekniken" från Teknis på 70 talet inte riktigt hänger med här...

[AndLi]

Men det blir nog en Raspberry Pi 3 B+ som har en CPU-kraft på 4 x 1.4 GHz

När blev din kod multithreadad?
Eller hur tänker du utnyttja de fyra kärnorna?

[Al_Bundy]

Men det blir nog en Raspberry Pi 3 B+ som har en CPU-kraft på 4 x 1.4 GHz

När blev din kod multithreadad?
Eller hur tänker du utnyttja de fyra kärnorna?

Den är inte trådad. Men jag kommer skriva ett program som använder sig av C's trådfunktioner.

Men, vad är det som "styr" processen under den första tiden?

Ett vanligt C-program förstås.

Indata från den tiden kan väl vara helt åt skogen, beroende på hur processen (alltså det som "styrs") startar upp, vilket läge det befinner sig i?

Datat kan vara åt skogen, vilket resulterar en dålig modell, vilket resulterar ostabil process, vilket resulterar volatilitiv data, vilket skapar förutsättningar till en bra modell

Hur säkrar man upp att inte styrsystemet får en helt felaktig bild av processen och gör något potentiellt farligt?

Man börjar med min te-kokare Faktiskt så har jag inget svar för denna fråga.

Min bild är att en "systemidentifiering" betyder att man måste testa att styra processen för att kunna läsa av hur det reagerar. Eller hur mycket vet styrsystemet om processen från början? Det känns som att "processtekniken" från Teknis på 70 talet inte riktigt hänger med här...

Systemidentifiering handlar bara om att behandla mätdata och estimera modeller av systemet. Innan 90-talet så var det gamla klassiska överföringsfunktioner som man använde. Då var man låst till ett specifikt beteende hos en process. Men sedan 90-talet kom man på att man kunde använda den linjära algebran för att räkna på datan. Helt plötsligt blev man befriad från alla krånglig teori och onödiga ekvationer.

Tycker synd om alla professorer som har fått sin teori förkastad av den yngre generationen som uppfann modernare tekniker, som vad dock mer avancerade, men ändå lättare att tillämpa numeriskt. Allt som krävdes var bara bättre datorer.

[Al_Bundy]

Till att verkligen börja med så tror jag lägger Pajen på sidan ett tag och kör på min nuvarande dator. Jag vet att det är mer som kan krångla med en vanlig PC, men jag vill först få allt fungera. En PC har dock ingen I/O modul, så jag tänkte använda då mitt STM32 kort I/O modul. Där efter när jag vet att allt fungerar, då kan jag börja finslipa lite på att optimera för realtidssystem.

[bearing]

Det är inget svårt att skriva till en array

Låt oss säga att vid tiden 0, dvs uppstart, så är utsignalen full PWM. Vi säger att samplingsintervallet är 1 sekund, då betyder det att efter 144 sekunder så kommer en initial modell byggas och sedan byts det ut insignal och utsignal hela tiden.

Edit:
Nu har man börjat kompilera PiGpio
http://abyz.me.uk/rpi/pigpio/download.html

Det verkar ta en stund.

Så efter 145 sekunder kommer arrayens äldsta mätvärde kastas, och ett nytt mätvärde sparas? Och sedan körs algoritmen för en andra gång? Och så vidare. Jo men det var det jag misstänkte.

Andra frågan gäller varför en 144x144- matris måste skapas i nästa steg? Den måste vara kvadratisk? Vad fylls 99% av matrisen med? Löses ett ekvationssystem med 144 okända?

Varför behöver matrisen ha så många rader?

EDIT: Okej, jag har läst igenom ditt program på förra sidan lite noggrannare, och har väl fått ett litet hum om hur vissa bitar kan kan tänkas fungera.
Vektorn u brukar väl beteckna systemets tillstånd? Så då antar jag att u är systemets tillstånd även i denna kod. Du skapar alltså en kvadratisk matris baserad på u, som har data i diagonalen. Sedan tar du inversen av denna matris, och multiplicerar med y (indatan). Innebär detta att du löser ett ekvationssystem?
Sen fortsätter det med denna singular value decomposition som du nämnt, men som jag inte förstått. Och härifrån är jag inte med på vad som händer.

Men varför skrivs aldrig någonting tillbaka till u? Behöver inte tillståndet uppdateras inför nästa cykel?

[Al_Bundy]

Så efter 145 sekunder kommer arrayens äldsta mätvärde kastas, och ett nytt mätvärde sparas? Och sedan körs algoritmen för en andra gång? Och så vidare. Jo men det var det jag misstänkte.

Andra frågan gäller varför en 144x144- matris måste skapas i nästa steg? Den måste vara kvadratisk? Vad fylls 99% av matrisen med? Löses ett ekvationssystem med 144 okända?

Varför behöver matrisen ha så många rader?

För matrisen behöver ha så många rader. Alltså va? Jag förstår inte dina frågor. Tyvärr.

EDIT: Okej, jag har läst igenom ditt program på förra sidan lite noggrannare, och har väl fått ett litet hum om hur vissa bitar kan kan tänkas fungera.
Vektorn u brukar väl beteckna systemets tillstånd? Så då antar jag att u är systemets tillstånd även i denna kod. Du skapar alltså en kvadratisk matris baserad på u, som har data i diagonalen. Sedan tar du inversen av denna matris, och multiplicerar med y (indatan). Innebär detta att du löser ett ekvationssystem?
Sen fortsätter det med denna singular value decomposition som du nämnt, men som jag inte förstått. Och härifrån är jag inte med på vad som händer.

Men varför skrivs aldrig någonting tillbaka till u? Behöver inte tillståndet uppdateras inför nästa cykel?

Så här är det. Lyssna här allihop!

Steg 1:
Sampla på dig data från insignal och utsignal till ett dynamiskt valfritt system.

Steg 2:
Gör om denna insignal och utsignal till en impulssignal

Steg 3:
Med impulssignalen så kan vi räkna ut en matematisk modell av systemet. Det är viktigt att det måste vara en impulssignal för det har med hur prediktiva tillståndsmodeller är uppbyggda.

Steg 4:
Nu har vi våran matematiska modell. Nu kan vi förutspå framtiden hur systemet kommer bete sig om t.ex. 10 sekunder. Då räknar vi ut våran bästa insignal som vi har behov av för att komma till vårat börvärde. Det är alltså inget snack om derivering eller integrering eller hitta någon förstärkning. Allt handlar om att minimera en kostfunktion.

Steg 5:
Repetera från steg 1 igen och läs denna
https://www.ethz.ch/content/dam/ethz/sp ... A_2013.pdf

Singular Value Decompotistion är bara ett sätt för att lösa en en optimal lösning för ett system, utan att ens behöva beskriva någon form. Med andra ord, minstakvadratmetoden på ett bättre sätt utan form.

[bearing]

Eftersom att jag inte har den rätta matematiska bakgrunden är det svårt för mig att förstå exakt vad din metod gör, samt att förmedla vad jag undrar, eller ser som problematiskt.

Men det som jag främst ser som problematiskt är att du behöver dessa 144 samples.

Jag har jobbat litegrann med att implementera matrismatematik (inte min matematik) på en mikrocontroller. Då har det handlat om att från början (innan implementering) välja en matematisk modell av systemet (inte gjort av mig). Modellen är alltså fast, men har ett antal parametrar som kan förändras under programmets gång. Och dom beräknas genom en "observer", några "states", och lite matrismatematik (inte gjort av mig).

Programmets gång har varit ungefär:
Ta in ett (1) mätvärde (sample) av varje intressant signal
Kör in dessa i modellen/"observern"?
Jämför modellens utsignal med verkligheten och kör lite matematik i syfte att utifrån brusig indata och (möjligt) felaktiga parametrar kunna avgöra vad som behöver justeras
Uppdatera systemets states och parametrar (som förhoppningsvis hamnar en aning närmare verkligheten för varje iteration)
Skicka utsignaler
Vänta på nästa samling mätvärden och gör nästa iteration

Programmet behöver alltså bara ett enda mätvärde (av varje signal som mäts) för varje beräkning. Därför att hela historiken (allt som har hänt innan) sammanfattas av systemets states (tillstånd).

Så jag försöker bara kolla med dig varför dessa 144 mätvärden behövs inför varje beräkning? Beror det på att din metod (machine learning) är väldigt olik den ovan beskrivna?

Ursäkta om detta är dumma frågor, men det är något som (intuitivt) bekymrar mig här, och jag kan nog inte själv komma på vad det är, pga begränsade mattekunskaper.

[Al_Bundy]

Det behövs 144 värden för 1 värde räcker inte. Du kan inte kurvanpassa med en punkt.

[guckrum]

bearing:

Du beskriver precis hur återkopplade adaptiva system fungerar:
Man skapar en "felsignal" som skillnaden mellan systemets
utsignal och modellens dito. Denna felsignal använder man sedan
för att justera modellen. Såhär funkar reglerteknik, adaptiva
filter, träning av neuralnät osv osv osv...

Som jag förstår TS (men jag kan ha fel och jag är oklar över vad
applikationen är) så skapar han en ren blackbox-modell som
skattar systemets impulssvar genom att titta på en
insignalsekvens och motsvarande utsignalfrekvens. Om insignalen
skulle vara en impuls blir ju utsignalen impulssvaret, och man är
klar. Men i allmänhet är insignalen mera komplex, så man
får "avfalta" med lite matte. Finns många sätt, varav det som är
aktuellt här beskrivs i den eleganta presentationen TS länkade
till.

Om man tittar förbi den teoretiska matematiken ser jag ett antal
praktiska problem som behöver adresseras, förutom att det
beräkningsmässigt är väldigt kostsamt. En fråga är hur modellen
förbättras över tid på bästa sätt, andra relaterar till
robusthet, noggranhet och stabilitet. Och hur väljer man
storleken på systemet så att den matchar impulssvaret när man
inte känner just impulssvaret? Detta är ett klassiskt problem.
Om till exempel impulssvaret är längre än sekvensen som man
räknar på blir det ju "klippt", men beräkningarna strävar efter
att hitta ett sätt att skapa utsignal från insignal, med
konsekvens att de skattade koefficienterna blir degraderade. Om,
å andra sidan impulssvaret är kortare skall ett antal nollor
estimeras, och dessa estimat "tar noggranhet" från de faktiska
tapparna samtidigt som att de i sig själva kommer att försämra
modellen.

Man kan såklart göra fantastiska saker med sådana här metoder.
Men som vanligt gäller att man måste veta vad man gör.

[Al_Bundy]

Man får utgå från att man har aldrig en korrekt modell. Folk som talar om robusthet/optimalhet är teoretiker. Noggrannhet kan jag köpa. Allt bygger på hur bra modell man har. Dålig modell så spelar det ingen roll vilken regulator man har.

Själv så föredrar jag prediktiva regulatorer för långsamma system t.ex. värme och vatten. Det har med att man kan ju inte minska en vattenivån ute hos en fabrik och man kan inte heller kyla.
Jag rekommenderar sedan PID regulatorer för snabba system t.ex. servosystem. Eventuellt om man har flera saker att hålla koll på t.ex. två servomotorer, så rekommenderar jag LQR. Det är i praktiken en multivariabel PD-regulator.

Det finns ju LQI också om man känner för det. I:et står för integral. Men integralen rekommenderar jag inte för snabba system. LQR duger fint! Men den är också modellbaserad. Så allt bygger på om man har en bra beskrivning av systemet.

För att kunna tillämpa LQR så krävs det matematisk modellbygge med papper och penna och sedan mätdata för att kurvanpassa, vilket kan ta lång tid. Då är en PID mycket bättre om man har en insignal och en utsignal. Men så fort man jobbar med två variabler så är det LQR som är bättre än PID:en.

[bearing]

Det behövs 144 värden för 1 värde räcker inte. Du kan inte kurvanpassa med en punkt.

Ja om man sitter vid skrivbordet ja. Och även i realtidssystem behövs tillräckligt med data för att finna en lösning så klart. Men man lägger upp det på ett annat sätt än på skrivbordet. I realtidssystem hittar man bl.a. metoder för att slippa använda så mycket minne. T.ex, låt säga att du vill ta reda på hur långt jag gått en dag. Då kan du instruera mig att, för varje steg, mäta hur långt steget var, samt anteckna varje steglängd i en lång lista i min mobiltelefon, och sedan maila denna lista till dig, så att du kan räkna ut hur långt jag gått. Alternativt, kan du instruera mig att för varje steg knappa in steglängden i min miniräknarapp, och trycka "M+". I slutet av dagen kommer jag direkt kunna ge dig en siffra på hur långt jag gått genom att trycka "MR". Dessutom, om du vill veta vid lunch hur långt jag gått, och sedan vid eftermiddagsfikat, osv, då behöver jag inte hålla på och Maila långa listor till dig hela tiden. Och du behöver inte hålla på och räkna hela tiden. Utan jag kan efter precis varje steg berätta hur det ligger till med det du undrar. (Berätta mitt tillstånd/state?)

Men kanske inte i den här algoritmen. Jag förstår den som sagt inte tyvärr. Så jag jag borde ju egentligen hålla tyst i min situation. Vet inte mycket om machine learning, och har läst för lite matte. Men i alla mattekurser jag läst har jag fått högsta betyg, så det var kanske dumt att sluta. Dom här frågorna är väl en kombination av att vilja lära mig mera, samt att kolla att du har koll på detta med realtidssystem. Jag tror ju att du har full koll på matten, och förmodligen även på resten. Det är bara något intuitivt som ligger och gnager som sagt...

Guckrum, tack för svaret. Jag verkar ju inte vara helt ute och cyklar i alla fall. Det känns som att jag borde göra ett försök att förstå mig på den presentationen. Var länkade TS till den?

Al, jag tror att du missförstått vad robust är. Robust och simpelt brukar gå hand i hand. En P-regulator är mycket mer robust än en PI, därför att man kan garantera att en P aldrig börjar bygga upp ett stort värde i integratorn vid speciella omständigheter under drift, som senare ger ett enormt översväng. För att göra sin PI mer robust kan man lägga in gränser för hur stora värden (positiva och negativa) integratorn får anta, och på så sätt hantera dessa speciella omständigheter / bli mer robust.

Hur kan man garantera att en adaptiv "Black box" aldrig förändras så mycket under speciella omständigheter att den aldrig hittar tillbaka?
Kanske fastnar den i ett "lokal minimum" i sin kostfunktion, som den aldrig tar sig ur, så att den aldrig hittar sitt "global minimum" där den tidigare, till synes robust, befann sig?

[Al_Bundy]

Ja om man sitter vid skrivbordet ja.

Nej. Hela tiden.

Och även i realtidssystem behövs tillräckligt med data för att finna en lösning så klart. Men man lägger upp det på ett annat sätt än på skrivbordet. I realtidssystem hittar man bl.a. metoder för att slippa använda så mycket minne. T.ex, låt säga att du vill ta reda på hur långt jag gått en dag. Då kan du instruera mig att, för varje steg, mäta hur långt steget var, samt anteckna varje steglängd i en lång lista i min mobiltelefon, och sedan maila denna lista till dig, så att du kan räkna ut hur långt jag gått. Alternativt, kan du instruera mig att för varje steg knappa in steglängden i min miniräknarapp, och trycka "M+". I slutet av dagen kommer jag direkt kunna ge dig en siffra på hur långt jag gått genom att trycka "MR". Dessutom, om du vill veta vid lunch hur långt jag gått, och sedan vid eftermiddagsfikat, osv, då behöver jag inte hålla på och Maila långa listor till dig hela tiden. Och du behöver inte hålla på och räkna hela tiden. Utan jag kan efter precis varje steg berätta hur det ligger till med det du undrar. (Berätta mitt tillstånd/state?)

Visa gärna hur man gör matrisberäkningar med subspaceindetifiering utan att använda så mycket minne. Då ska du få nobelpris i matematik.

Men kanske inte i den här algoritmen. Jag förstår den som sagt inte tyvärr. Så jag jag borde ju egentligen hålla tyst i min situation. Vet inte mycket om machine learning, och har läst för lite matte. Men i alla mattekurser jag läst har jag fått högsta betyg, så det var kanske dumt att sluta. Dom här frågorna är väl en kombination av att vilja lära mig mera, samt att kolla att du har koll på detta med realtidssystem. Jag tror ju att du har full koll på matten, och förmodligen även på resten. Det är bara något intuitivt som ligger och gnager som sagt...

Du borde vara tyst som en liten mus Jag skulle rekommendera att du läser på om algoritmen. Den är den enklaste av alla Många lär ut denna.

Matemaik är överskattat. Det enda man behöver kunna är numeriska beräkningar. Klart! Det är praktisk matematik.

Al, jag tror att du missförstått vad robust är. Robust och simpelt brukar gå hand i hand. En P-regulator är mycket mer robust än en PI, därför att man kan garantera att en P aldrig börjar bygga upp ett stort värde i integratorn vid speciella omständigheter under drift, som senare ger ett enormt översväng. För att göra sin PI mer robust kan man lägga in gränser för hur stora värden (positiva och negativa) integratorn får anta, och på så sätt hantera dessa speciella omständigheter / bli mer robust.

Jösses! Robusthet handlar om att forma kretsförstärkningen! En P-regulator är robust? Nej. Så fort du för fördröjning i ett system t.ex digitalt diskret system, så kan det lätt svänga. Hört talas som Root-Locus? Lär dig den. Då kan du räkna ut vilket P du behöver innan det svänger.

Eller så kan du räkna på H_infinity och H2-metoderna om du vill tävla med de riktiga forskarna. Jag har försökt mig på att räkna lite på H_infinity och H2. Men det är så långt ifrån verkligheten som det kan komma. Matematiken är fin och elegant, men frågan om den verkligen fungerar. Få verkar intressera sig för robust reglering.

Hur kan man garantera att en adaptiv "Black box" aldrig förändras så mycket under speciella omständigheter att den aldrig hittar tillbaka?
Kanske fastnar den i ett "lokal minimum" i sin kostfunktion, som den aldrig tar sig ur, så att den aldrig hittar sitt "global minimum" där den tidigare, till synes robust, befann sig?

Märks att du inte förstår vad det handlar om Black box är en vanlig matematisk modell t.ex. en funktion som man har hittat sina parametrar och strukturen till.
Kostfunktionen är bara ett sätt för dig att bestämma ett gott värde som du vill använda. Typ som när du använder en tumstock.

[bearing]

Vid vilket P reglersystemet svänger är väl bland det första man lär sig i en reglerkurs?
Och det har väl inte främst med robusthet att göra, utan stabilitet. Så du verkar ju fortfarande vilja missförstå/undvika ämnet.
Men ok, det där om P/PI hittade jag på när jag skrev inlägget och kanske inte var ett helt bra exempel.

Förstod inte din liknelse. Alla som läst lite matte vet väl vad minsta kvadratmetoden är. Även viktade sådana. Men vad det har med en tumstock att göra undrar jag.

Är det inte så att du ökat till 144 mätvärden just för att undvika problem med "lokal minimum"? Dvs att med 36 punkter passar en viss modell jättebra. Men det visar sig att om du hade använt 72 punkter hittades en bättre modell, som även hade passat bättre med 36 punkter, och så vidare?

Som Guckrum undrade, hur väljer man storleken om man inte vet någonting om processen?

[Al_Bundy]

Här är ett praktiskt exempel på hur diskreta system, t.ex. mikrokontrollers kan ställa till detta för en.

Antag att vi har en överföringsfunktion och vi diskritiserar den för att köra in den på en mikrokontroller. Samplingstid är 0.5 sekunder. Då passar inte denna P-regulator med förstärkningen 3.3 bra.

Kod: Markera allt

>> G = tf(5, [1 3 2])
G =

  scalar structure containing the fields:

    num =  5
    den =

       1   3   2

    delay = 0
    tfnum =  5
    tfdash = -------------
    tfden =  s^2 + 3s + 2
    type = TF
    sampleTime = 0

>> Gd = c2d(G, 0.5) % Sampeltid 0.5
Gd =

  scalar structure containing the fields:

    num =

       0.38705   0.23475

    den =

       1.00000  -0.97441   0.22313

    delay = 0
    tfnum =  0.38705z + 0.23475
    tfdash = ------------------------
    tfden =  z^2 -0.97441z + 0.22313
    type = TF
    sampleTime =  0.50000

>> K = findmaxgain(Gd, 1000)
K =  3.4003
>> K = findmaxgain(Gd, 10)
K =  3.3093
>> K = findmaxgain(Gd, 5)
K =  3.3093
>> Gp = tf(3.3093, 1);
>> Gpd = c2d(Gp, 0.5);
>> Gdserie = series(Gpd, Gd)
Gdserie =

  scalar structure containing the fields:

    num =

       1.28085  -0.50397  -0.77687

    den =

       1.00000  -1.97441   1.19754  -0.22313

    delay = 0
    tfnum =  1.2808z^2 -0.50397z -0.77687
    tfdash = ----------------------------------
    tfden =  z^3 -1.9744z^2 + 1.1975z -0.22313
    type = TF
    sampleTime =  0.50000

>> M = tf(1,1);
>> Md = c2d(M, 0.5);
>> Gdfeedback = feedback(Gdserie, Md)
Gdfeedback =

  scalar structure containing the fields:

    num =

       1.28085  -4.31375   4.78494  -1.10750  -1.46243   0.99123  -0.17334

    den =

       1.00000  -3.66797   5.92845  -6.68356   6.38283  -4.31205   1.57543  -0.22313

    delay = 0
    tfnum =  1.2808z^6 -4.3137z^5 + 4.7849z^4 -1.1075z^3 -1.4624z^2 + 0.99123z -0.17334
    tfdash = ------------------------------------------------------------------------------
    tfden =  z^7 -3.668z^6 + 5.9285z^5 -6.6836z^4 + 6.3828z^3 -4.312z^2 + 1.5754z -0.22313
    type = TF
    sampleTime =  0.50000

>> step(Gdfeedback);
Time assumed to be 10 seconds
>> step(Gdfeedback, 20);
>> hold on
>> step(Gd, 20);
>>

Den röda visar vanligt stegsvar och den blåa visar återkopplat med för hög förstärkning.

Markering_016.png

Om jag istället antar en lägre förstärkning.

Kod: Markera allt

>> Gp = tf(1.3093, 1);
>> Gpd = c2d(Gp, 0.5);
>> Gdserie = series(Gpd, Gd)
Gdserie =

  scalar structure containing the fields:

    num =

       0.50676  -0.19939  -0.30736

    den =

       1.00000  -1.97441   1.19754  -0.22313

    delay = 0
    tfnum =  0.50676z^2 -0.19939z -0.30736
    tfdash = ----------------------------------
    tfden =  z^3 -1.9744z^2 + 1.1975z -0.22313
    type = TF
    sampleTime =  0.50000

>> Gdfeedback = feedback(Gdserie, Md)
Gdfeedback =

  scalar structure containing the fields:

    num =

       0.506758  -1.706701   1.893127  -0.438176  -0.578599   0.392173  -0.068582

    den =

       1.00000  -4.44206   8.53549  -9.57538   7.05216  -3.42822   0.97637  -0.11837

    delay = 0
    tfnum =  0.50676z^6 -1.7067z^5 + 1.8931z^4 -0.43818z^3 -0.5786z^2 + 0.39217z -0.068582
    tfdash = ---------------------------------------------------------------------------------
    tfden =  z^7 -4.4421z^6 + 8.5355z^5 -9.5754z^4 + 7.0522z^3 -3.4282z^2 + 0.97637z -0.11837
    type = TF
    sampleTime =  0.50000

>> step(Gdfeedback, 20);

Då ser vi detta. Den gula gungar in lugnt och fint.

Markering_017.png

Vid vilket P reglersystemet svänger är väl bland det första man lär sig i en reglerkurs?
Och det har väl inte främst med robusthet att göra, utan stabilitet. Så du verkar ju fortfarande vilja missförstå/undvika ämnet.
Men ok, det där om P/PI hittade jag på när jag skrev inlägget och kanske inte var ett helt bra exempel.

Förstod inte din liknelse. Alla som läst lite matte vet väl vad minsta kvadratmetoden är. Även viktade sådana. Men vad det har med en tumstock att göra undrar jag.

Är det inte så att du ökat till 144 mätvärden just för att undvika problem med "lokal minimum"? Dvs att med 36 punkter passar en viss modell jättebra. Men det visar sig att om du hade använt 72 punkter hittades en bättre modell, som även hade passat bättre med 36 punkter, och så vidare?

Som Guckrum undrade, hur väljer man storleken om man inte vet någonting om processen?

Jag vet att robusthet är att hur mycket den klarar yttre påfrestningar och stabilitet är hur bra dimensionerad den själva regulatorn är.

Jag samlar 144 värden och byter ut första värdet och fyller på ett ytterligare.

Lär dig SVD. Den kräver mycket data.

[Al_Bundy]

Nu har jag ett litet problem. Jag försöker ha USB kommunikation mellan en STM32, men jag får det inte att fungera. Jag har skrivit en C-kod med biblioteket libusb som är ett välbeprövat bibliotek och passar alla system. Dock krångligt. Därför tänkte jag om något förstår vad jag gör för fel.

Här är min C-kod. Ni kan i praktiken bara köra C-koden som den där. För att använda denna C-kod så måste ni ha libusb först installerat. I ubuntu så är det denna kommando man ska köra

sudo apt-get install libusb-1.0.0-dev libusb-1.0-0

Där efter så kör ni funktionen int getDevices(). Den kommer spotta ut vendor och product samt alla enheternas namn. Då skriver ni in dessa nummer i

libusb_open_device_with_vid_pid(CONTEXT, vendor, product);

Sedan kör ni funktionen int connectUSB() och sedan testfunktionen int writeUSB. Funktionen writeUSB (jag har inte skrivit writeUSB, endast övrig kod) både skriver och läser, men jag får det inte att fungera. Jag har min STM32 som ständigt spottar ut siffror till USB porten hela tiden. Men jag kan inte läsa dessa för jag får bara felmeddelanden. Vet ni vad jag ska göra?

Kod: Markera allt

#include <stdio.h>
#include <stdlib.h>
#include <libusb-1.0/libusb.h>
#include <string.h>

libusb_context *CONTEXT; //a libusb session
libusb_device_handle *DEVICEHANDLE; //a device handle
libusb_device * DEVICE_POINTER; // a pointer to a device
libusb_device **ARRAY_OF_POINTERS_TO_DEVICE; // an array of pointers to devices
ssize_t NUMBER_OF_USB_DEVICES; // Initial zero devices

#define BULK_EP_OUT     0x82
#define BULK_EP_IN      0x02

/*
 * Here we are going to read the USB
 */
int readUSB() {
	return 0;
}

/*
 * Here are we going to write to the USB
 */
int writeUSB() {
	unsigned char *my_string, *my_string1;
	    int transferred = 0;
	    int received = 0;
	    int i, e;
	    int nbytes = 64;
	    int length = 0;

	    my_string = (char *)malloc(nbytes + 1);
	    my_string1 = (char *)malloc(nbytes + 1);

	    memset(my_string, '\0', 64);
	    memset(my_string1, '\0', 64);

	    strcpy(my_string, "Prasad Divesd");
	    length = strlen(my_string);

	    printf("\nTo be sent: %s", my_string);

	    e = libusb_bulk_transfer(DEVICEHANDLE, BULK_EP_IN, my_string, length, &transferred, 0);
	    if(e == 0 && transferred == length)
	    {
	        printf("\nWrite successful!");
	        printf("\nSent %d bytes with string: %s\n", transferred, my_string);
	    }
	    else
	        printf("\nError in write! e = %d and transferred = %d\n", e, transferred);

	    sleep(3);
	    i = 0;

	    for(i = 0; i < length; i++)
	    {
	        e = libusb_bulk_transfer(DEVICEHANDLE, BULK_EP_OUT, my_string1, 64, &received, 0);  //64: Max Packet Length
	        if(e == 0)
	        {
	            printf("\nReceived: ");
	            printf("%s", my_string1[i]); //Will read a string from LPC2148
	            sleep(1);
	        }
	        else
	        {
	            printf("\nError in read! e = %d and received = %d\n", e, received);
	            return -1;
	        }
	    }

	    e = libusb_release_interface(DEVICEHANDLE, 0);

	    libusb_close(DEVICEHANDLE);
	    libusb_exit(NULL);
	return 0;
}

/*
 * This will connect to our USB device
 */
int connectUSB() {

	/*
	 * Initialize a USB
	 */
	int r = libusb_init(&CONTEXT); //initialize the library for the session we just declared
	if (r < 0) {
		printf("Init Error: %d\n", r);
		return -1;
	}

	/*
	 * Open and connect
	 */
	libusb_set_debug(CONTEXT, 3); //set verbosity level to 3, as suggested in the documentation
	DEVICEHANDLE = libusb_open_device_with_vid_pid(CONTEXT, 1155, 14155); //these are vendorID and productID I found for my usb device

	/*
	 * Check if there was any error
	 */
	if (DEVICEHANDLE == NULL) {
		printf("Cannot open device\n");
		return -1;
	} else {
		printf("Device Opend. DEVICEHANDLE = %d \n", DEVICEHANDLE);
		return 1;
	}
}

/*
 * This will show all the devices for USB and send it thru sockets
 */
int getDevices() {

	/*
	 * Special local device handle for only get the name of the USB device
	 */
	libusb_device_handle *DEVICEHANDLE_NULL; //a device handle

	/*
	 * Compute the number of USB
	 */
	int returnValue = libusb_init(NULL);
	NUMBER_OF_USB_DEVICES = libusb_get_device_list(NULL,
			&ARRAY_OF_POINTERS_TO_DEVICE);

	/*
	 * Create our list of Vendor, Product and device
	 * Vendor and product are important for connect the USB and device is important for the user to see which USB to connect
	 */
	uint16_t vendor[NUMBER_OF_USB_DEVICES];
	uint16_t product[NUMBER_OF_USB_DEVICES];
	char device[NUMBER_OF_USB_DEVICES][256 * 2];

	/*
	 * Loop thru all USB devices
	 */
	ssize_t deviceIndex = 0;
	while (deviceIndex < NUMBER_OF_USB_DEVICES) {

		/*
		 * Get the description of the USB device
		 */
		DEVICE_POINTER = ARRAY_OF_POINTERS_TO_DEVICE[deviceIndex];
		struct libusb_device_descriptor deviceDescriptor;
		returnValue = libusb_get_device_descriptor(DEVICE_POINTER,
				&deviceDescriptor);
		if (returnValue != LIBUSB_SUCCESS)
			break;

		/*
		 * Open the USB device with NULL. It's only because we want the name of the USB device
		 */
		DEVICEHANDLE_NULL = NULL;
		returnValue = libusb_open(DEVICE_POINTER, &DEVICEHANDLE_NULL);
		if (returnValue != LIBUSB_SUCCESS) {
			/*
			 * There was an error. Not success.
			 */

			if (DEVICEHANDLE_NULL != NULL) {
				libusb_close(DEVICEHANDLE_NULL);
				DEVICEHANDLE_NULL = NULL;
			}

			/*
			 * Write as there was no info at all to display
			 */
			product[deviceIndex] = 0;
			vendor[deviceIndex] = 0;
			memcpy(device[deviceIndex], "-", 256 * 2 * sizeof(char));
			deviceIndex++;
			continue;

		}

		/*
		 * Get the string associated with iManufacturer index.
		 */
		const int STRING_LENGTH = 256;
		unsigned char stringManufacturer[STRING_LENGTH];
		unsigned char stringProduct[STRING_LENGTH];
		char stringDeviceName[STRING_LENGTH * 2];
		if (DEVICEHANDLE_NULL != NULL && deviceDescriptor.iManufacturer > 0) {
			returnValue = libusb_get_string_descriptor_ascii(DEVICEHANDLE_NULL,
					deviceDescriptor.iManufacturer, stringManufacturer,
					STRING_LENGTH);
			if (returnValue < 0)
				break;
		}

		/*
		 * Get string associated with iProduct index.
		 */
		if (DEVICEHANDLE_NULL != NULL && deviceDescriptor.iProduct > 0) {
			returnValue = libusb_get_string_descriptor_ascii(DEVICEHANDLE_NULL,
					deviceDescriptor.iProduct, stringProduct, STRING_LENGTH);
			if (returnValue < 0)
				break;
		}

		/*
		 * Combine manufacturer and product
		 */
		strcpy(stringDeviceName, (char*) stringManufacturer);
		strcat(stringDeviceName, " "); // a space only
		strcat(stringDeviceName, (char*) stringProduct);
		//printf("%s\n", stringDeviceName);

		/*
		 * Save them all into arrays
		 */
		product[deviceIndex] = deviceDescriptor.idProduct;
		vendor[deviceIndex] = deviceDescriptor.idVendor;
		memcpy(device[deviceIndex], stringDeviceName, 256 * 2 * sizeof(char));

		/*
		 * Close and try next one.
		 */
		if (DEVICEHANDLE_NULL != NULL) {
			libusb_close(DEVICEHANDLE_NULL);
			DEVICEHANDLE_NULL = NULL;
		}

		/*
		 * Next USB device
		 */
		deviceIndex++;
	}

	/*
	 * Print our result what we found and send them to socket
	 */
	for (int i = 0; i < 11; i++) {
		printf("Name: %s\n", device[i]);
		printf("Vendor: %u\n", vendor[i]);
		printf("Product: %u\n\n", product[i]);
	}

	libusb_exit(NULL);

	return 0;
}