Matrisberäkningar med för STM32?

[Al_Bundy]

Ja och jag tror jag får välja annat än det.

GTK verkar svårt, men samtidigt finns det något som heter Glade som underlättar kodskrivandet till en nivå med JavaFX. Valet står mellan JavaFX och GTK.

C kommer alltid vara mer "orenare" än Java, men C kommer alltid vara snabbare än Java, groft sagt.

[Al_Bundy]

C-programmerare har en tendens att skriva kod som är helt obegriplig att läsa, för att koden ska vara så optimal som möjligt.

Ett omdöme om dej själv för det är du som programmerar i C nu hehe Så det måste ju vara helt sant

Har testat din kod. En utmaning att få den kompilerad, hade underlättat med Makefiler. Det kanske fanns i eclipse-projektet men att köra eclipse blir för mycket nytt att ta in. Ja men den verkar funka. Vet inte vad för resultat jag väntat mej.
Ser att du gjort om allt till "float" antagligen med tanke på mcun.

Det beror på hur du har tänkt att använda detta. Ska du ha in det i en mcu och köra detta i realtid i nån mening, så får du försöka skohorna in det. En processor som är mer lämplig. Strypa ner behovet av minne. Du kan använda pc-versionen för att jaga minne och testa. Nåt åt det hållet.

Ska det bara beräknas då och då så kan en Rpi eller en ncu kanske vara bättre. Då kan du kosta på dej störra matriser och räkna med dubbel precision.

Jag skriver inte optimerad kod Så den punkten är jag ärlig på. Istället vill jag skriva kod som är enkel att förstå för andra att läsa. Jag är grund i botten en MATLAB-programmerare.

Utmaning att få den kompilerad? Du länkar ju bara "-lm" och "Include". Sedan är det klart.

Mitt mål är att få in mitt bibliotek på uC, men med tanke på att jag kommer kräva mycket ramminne så kommer det inte fungera. Jag behöver alltså bättre datorer.

Jag funderar att antingen använda JavaFX med SceneBuilder eller GTK med Glade. GTK är skrivet i C och Glade är precis som SceneBuilder, man slipper skriva massa kod.
Jag har behov att programmet ska vara stabilt och snabbt, men samtidigt portablet. Java är portabelt, men inte direkt snabbaste. Men Java ska inte vara långt ifrån C i dagens läge.

[Shimonu]

Bundy du har mycket att lära dig om C. Det går att skriva förståelig kod och ha den effektiv. Det gäller bara att förstå vilka verktyg det finns i C för att göra det.

.

[Al_Bundy]

Klart det går. Jag förstår bara inte varför ingen gör det.

[AndLi]

Det är ändå ingen som har kört mitt bibliotek här på forumet, så vad spelar det för roll om koden ligger på GitHub?

För att med gitHub är det hanterbart att experimentera med alla dina versioner, man kan följa vad du ändrar.. Använda exakt samma filer osv...
Det kan ju vara så att "ingen" kör det för att det är för hög tröskel att meka runt med zipar hela tiden, man gör någon patch som sen din nästa zip skriver över, eller man glömmer fixa sin patch i din nästa version. Vem orkar hålla på så?

[AndLi]

Al_Bundy: Du kan fråga vilken kompilatortillverkar som helst där ute, alla kommer säga samma sak:
"Låt kompilatorn optimera koden, det kvittar om du slänger dit 25 extra lokala variabler och skriver formeln på 5 rader med mellanresultat i lokala variabler istället för en med tretielva parenteser."

Obskyra C konstruktioner är något vissa programmerare gillar för att de antingen vill show off:a eller skriva kod som ingen annan kan arbeta på som något försök att bli oumbärlig för arbetsgivaren.
Riktiga C-programmerare skriver tydlig kod, det finns som sagt ingen anledning att skriva kompat C-kod

Det är ju samma sak som att vissa kan inte måla en snygg tavla eller skriva en bra bok. Fast att de kan placera färg på en duk eller skriva kompletta meningar..

[Al_Bundy]

Al_Bundy: Du kan fråga vilken kompilatortillverkar som helst där ute, alla kommer säga samma sak:
"Låt kompilatorn optimera koden, det kvittar om du slänger dit 25 extra lokala variabler och skriver formeln på 5 rader med mellanresultat i lokala variabler istället för en med tretielva parenteser."

Obskyra C konstruktioner är något vissa programmerare gillar för att de antingen vill show off:a eller skriva kod som ingen annan kan arbeta på som något försök att bli oumbärlig för arbetsgivaren.
Riktiga C-programmerare skriver tydlig kod, det finns som sagt ingen anledning att skriva kompat C-kod

Det är ju samma sak som att vissa kan inte måla en snygg tavla eller skriva en bra bok. Fast att de kan placera färg på en duk eller skriva kompletta meningar..

Så det är GCC's fel att min kod är ooptimerad? Jag kan ge ett försök på att köpa in en bättre uC. Ge mig bara en länk så betalar jag. Men skulle helst vilja veta om min C kod fungerar för uC.
Sedan kan jag försöka titta lite närmare på mina C-kodsexempel.

Målet är som sagt att få in matrisberäkningar på en uC och jag har inte gett upp än, trots att jag försöker smida andra planer.

[hummel]

För 20-30 år sedan var man tvungen att skriva sin C-kod och sedan inspektera assemblerkoden för att avgöra hur "bra optimerad" kod det blev. Jag fick helt enkelt lära mig vad kompilatorn var bra eller dålig på. Då vi hade prestandakrav skrevs C-koden så att den genererade effektiv kod och kanske inte så läsbar kod i vissa fall. Som tur är det ett minne blott. NU räcker det att skriva högnivåkoden så den är lättläst och vi låter kompilatorn sköta optimeringen.

Bästa optimering är oftast att välja rätt algoritm.

[Al_Bundy]

Jo. Men i detta fall handlade det om att återanvända matriser. Ur ett MATLAB-perspektiv så är det inte direkt det bästa för matematiken är nog svår, speciellt när det handlar om linjär algebra.

Jag kan göra det, men frågan om det räcker med 1 mb RAM trots att jag återanvänder matriser.

Någon som kan testa om mitt C-bibliotek fungerar för andra uC-system?

[guckrum]

Öppna frågor, tyckande och troende. Får jag i all välmening föreslå lite (vetenskaplig) metodik? Ställ upp en hypotes, och förkasta eller bekräfta denna genom att tex testa, tänka eller räkna.

Exempel: Antag att du har 1MB (OBS stavning) minne. 1MB räcker till 262144 matriselement om du har reella 32-bitars floats. Detta motsvarar till exempel en 512x512-matris eller 256 styck 32x32-matriser. Skulle detta räcka åt dig? Ja, det beror ju på din applikation, och den har du inte sagt så mycket konkret om. (Kanske har jag missat det, tråden är 50+ sidor.) Eller vill du lösa generella problem? Utan att hantera komplexa tal eller illa konditionerade matriser? Hmm...

[Al_Bundy]

Nu har jag "optimerat" min matriskod. Nu åternavänder jag matriserna. För mig är det en enda röra.

Finns det något sätt för att analysera hur mycket ram detta program tar?
Jag lägger upp senaste uppdateringen på EmbeddedLapack.

Kod: Markera allt

#include <time.h>

#include "LinearAlgebra/declareFunctions.h"


int main() {

	/*
	 * G(s) = 1/(s^2 + 1s + 3)  - Model
	 * y = measured output values
	 * u = measured input values
	 */

	clock_t start, end;
	float cpu_time_used;
	start = clock();

	float y[144] = { 0.00000, 0.49525, 1.43863, 2.13779, 2.30516, 2.05713,
			1.69220, 1.45608, 1.42777, 1.54146, 1.67927, 1.75624, 1.75400,
			1.70478, 1.65394, 1.62996, 1.63549, 1.65594, 1.67426, 1.68125,
			1.67752, 1.66930, 1.66285, 1.66102, 1.66300, 1.66621, 1.66842,
			1.66880, 1.66786, 1.66664, 1.66591, 1.66588, 1.66629, 1.66675,
			1.66698, 1.66695, 1.66678, 1.66661, 1.66654, 1.66657, 1.66664,
			1.66670, 1.66672, 1.66670, 1.66667, 1.66665, 1.66665, 1.66666,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66666, 1.66666,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667, 1.66667,
			1.66667, 1.66667, 1.66667, 1.66667, 1.66667 };

	float u[144] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5 };

	// Toeplitz matrix
	float toe[144 * 144];
	toeplitz(u, toe, 144);

	// Upper triangular
	float tru[144 * 144];
	triu(toe, tru, 0, 144, 144);

	// inverse
	inv(tru, 144);

	// Multiplication
	//float u[144]; // Ersatt g med u
	mul(y, tru, false, u, 1, 144, 144);

	// Create hankel
	float H0[144 * 144];
	hankel(u, H0, 144, 1);

	// Cut hankel into half
	float H0_half[72 * 72];
	cut(H0, 144, 144, H0_half, 0, 71, 0, 71);

	// Do SVD
	float U[72 * 72];
	float S[72 * 72];
	float V[72 * 72];
	svd(H0_half, U, S, V, 72, 72);

	//float H0[144 * 144]; // Ersat H1 med H0
	//float H0_half[72 * 72]; // Ersatt H1_half med H0_half
	hankel(u, H0, 144, 2);
	cut(H0, 144, 144, H0_half, 0, 71, 0, 71);


	// Model reduction to second order model
	//float u[72 * 2]; // Ersatt Un med u
	float Ad[2 * 2];
	//float y[72 * 2]; // Ersatt Vn med y
	cut(U, 72, 72, u, 0, 71, 0, 1);
	cut(S, 72, 72, Ad, 0, 1, 0, 1);
	cut(V, 72, 72, y, 0, 71, 0, 1);

	// Create A, B, C
	float Sn_sqrt_negative[2 * 2]; // -- Sn_sqrt_negative kan vara exakt samma som Sn_sqrt_positive
	float Sn_sqrt_positive[2 * 2];
	copy(Ad, Sn_sqrt_negative, 2,2);
	copy(Ad, Sn_sqrt_positive, 2,2);
	powdiag(Sn_sqrt_negative, -0.5, 2, 2);
	powdiag(Sn_sqrt_positive, 0.5, 2, 2);

	/*
	 * C = Un*En^(1/2);
	 * Cd = C(1, 1:2)
	 */
	float C[72 * 2];
	float Cd[1 * 2];
	mul(u, Sn_sqrt_positive, false, C, 72, 2, 2);
	cut(C, 72, 2, Cd, 0, 0, 0, 1);

	/*
	 * Ad = Sn^(-1/2)*Un'*H1*Vn*Sn^(-1/2);
	 */
	//float C[72 * 2]; // Ersatt A med C
	//float A1[72 * 2];  // Ersatt A1 med y
	//float Sn[2 * 2]; // Ersatt Ad med Sn
	float Ad1[2 * 2];
	mul(y, Sn_sqrt_negative, false, C, 72, 2, 2);
	mul(H0_half, C, false, y, 72, 72, 2);
	tran(u, 72, 2);
	mul(u, y, false, Ad1, 2, 72, 2);
	mul(Sn_sqrt_negative, Ad1, false, Ad, 2, 2, 2);

	/*
	 * B = En^(1/2)*Vn'
	 * Bd = B(:, 1);
	 */
	//float C[2 * 72]; // A ersatt med C
	float Bd[2 * 1];
	tran(y, 72, 2);
	mul(Sn_sqrt_positive, y, false, C, 2, 2, 72);
	cut(C, 2, 72, Bd, 0, 1, 0, 0);

	/*
	 * Print A, B, C
	 */
	printf("A Matrix: \n");
	print(Ad, 2, 2);

	printf("B Matrix: \n");
	print(Bd, 2, 1);

	printf("C Matrix: \n");
	print(Cd, 1, 2);

	end = clock();

	cpu_time_used = ((float) (end - start)) / CLOCKS_PER_SEC;
	printf("\nTotal speed  was %f,", cpu_time_used);

	return 0;
}

[Al_Bundy]

Öppna frågor, tyckande och troende. Får jag i all välmening föreslå lite (vetenskaplig) metodik? Ställ upp en hypotes, och förkasta eller bekräfta denna genom att tex testa, tänka eller räkna.

Om det inte räcker så får jag helt enkelt anpassa mig efter dessa begränsningar. Det vore tråkigt att gå över till operativsystem för det är inte samma sak som att köra rent C på en uC som att köra massa bibliotek på ett Linux OS.

Se ovan, där jag har gjort en liten uppdatering.

Exempel: Antag att du har 1MB (OBS stavning) minne. 1MB räcker till 262144 matriselement om du har reella 32-bitars floats. Detta motsvarar till exempel en 512x512-matris eller 256 styck 32x32-matriser. Skulle detta räcka åt dig? Ja, det beror ju på din applikation, och den har du inte sagt så mycket konkret om. (Kanske har jag missat det, tråden är 50+ sidor.) Eller vill du lösa generella problem? Utan att hantera komplexa tal eller illa konditionerade matriser? Hmm...

256 stycken 32*32 matriser lär räcka. Fast jag skulle helst vilja ha 64x64 matriser som maximum. Då skulle jag klara mig säkert.

[sodjan]

De flesta map filer (länkarens rapport av vad den har gjort)
brukar ha rapporter över förbrukat minne.

[Al_Bundy]

Jag vet inte varför han har gjort detta. Troligtvis för att han inte vet hur man gör.

[mrfrenzy]

Att hitta en mikrokontroller med rejält med minne är inte svårt.
Ta en raspberry pi zero som exempel.
512MB ram
1GHz klocka
Hårdvarustöd för flyttalsberäkning
Kostar ca 100kr färdigmonterad men om du kan löda bga går det såklart köpa armchippet löst.

Instruktioner hur man programmerar direkt på hårdvaran utan OS:
https://www.raspberrypi.org/forums/viewforum.php?f=72