Aproximace charakteristiky Atenuátoru

[Celeron]

Osmi ∏ článkovej Atenuátor. Chci ho co nejvíc útlumově vyrovnat podle vstupního kmitočtu. To znamená ho změřit v několika kmitočtech a udělat tabulku odchylek od ideálu a pak mezi body tabulky dělat výběr pomocí přímkový aproximace. To jsem už jednou v A51 dělal, takže vím jak na to.
Ale čím dál jsem přesvědčenej, že to nebude stačit, protože přeci při každým nastaveným útlumu Atenuátoru bude jiná odchylka.
Netušíte někdo, jak na to? Něco jako dvojtá aproximace? Nebo existuje něco jako 2D aproximace? Upozorňuji, že ani Open AI nevěděl jak na to, nejspís nepochopil co přesně chci.

[asdf]

Nevím, jestli jsem to správně pochopil, ale možná by to šlo nějak takhle (viz přiložené pdfko).
Ty determinanty se počítají takhle: https://cs.wikipedia.org/wiki/Determina ... %C3%A1du_3

[JirkaZ]

Podle mě to bude parametrická soustava charakteristik, resp.k nim inverzních korekčních křivek, kde parametrem bude zvolený útlum.

Takže změřit frekvenční charakteristiku atenuátoru při všech útlumech.

Aproximační funkci z tabulky hodnot umí určit třeba LibreOffice Calc (a předpokládám, že něco jiného podobného taky).

[Celeron]

Nojo, pole neoraný. Musím si o tom něco přečíst. Díky za odkaz.
S tím vyměřováním bude problém, je to na dlouho a pokud s tím půjdu někam, kde na to mají vybavení, tak tam nebudu moct být libovolně dlouho.

Napadlo mě zjistit charakteristiku pro každej zapnutej samostatnej ∏ článek, pokud nebude moc zvlněnej, tak ho zapsat třeba na deseti různých kmitočtech a tak to udělat pro všech 8 ∏ článků.
Pak vzít při nastavování útlumu jen ty ∏ články, co jsou sepnutý, každej aproximovat pro vstupní kmitočet a ty odchylky od jednotlivých ∏ článků sečíst a nakonec nastavit podle odchylky "opravné" sepnutí ∏ článků. Samozřejmě se zase ta odchylka změní ale charakteristika by se měla víc přiblížit k "rovné čáře". Pokud by se to provedlo opakovaně třeba 3 x za sebou, tak by to mohlo dotáhnout útlum na blízkou hodnotu "rovný čáry". Aspoň si to myslím....
Ale jestli bude atenuátor při měření "hodně křivej" tak tohle asi nebude optimální řešení...

[asdf]

Díky za odkaz.

Což z toho odkazu použiješ jen ten jeden vzoreček. Spíš jde o to přiložené PDFko. Tam by měla být ta 2D aproximace. Snad je to to, co jsi myslel.

[asdf]

Ještě mě napadlo, že by pro Tebe mohl být čitelnější program v C.

Kód: Vybrat vše

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
	double x;
	double y;
	double z;
	
} POINT;

static double det3(
	double a11, double a12, double a13,
	double a21, double a22, double a23,
	double a31, double a32, double a33
)
{
	return a11*a22*a33 + a12*a23*a31 + a13*a21*a32 - a13*a22*a31 - a12*a21*a33 - a11*a23*a32;
}

int main(int argc, const char **argv)
{
	POINT values[] =
	{
		{ 0, 0, 1 },
		{ 1, 0, 2 },
		{ 0, 1, 3 }
	};
	double sx = 0, sy = 0, sz = 0, sx2 = 0, sy2 = 0, sxy = 0, sxz = 0, syz = 0;
	int n = sizeof(values) / sizeof(values[0]);
	int i;
	double a, b, c;
	
	for ( i = 0; i < n; i++ )
	{
		sx += values[i].x;
		sy += values[i].y;
		sz += values[i].z;
		sx2 += values[i].x * values[i].x;
		sy2 += values[i].y * values[i].y;
		sxy += values[i].x * values[i].y;
		sxz += values[i].x * values[i].z;
		syz += values[i].y * values[i].z;
	}
	
	a = det3(
		sxz, sxy, sx,
		syz, sy2, sy,
		sz,  sy,  n
	) / det3(
		sx2, sxy, sx,
		sxy, sy2, sy,
		sx,  sy,  n
	);
	
	b = det3(
		sx2, sxz, sx,
		sxy, syz, sy,
		sx,  sz,  n
	) / det3(
		sx2, sxy, sx,
		sxy, sy2, sy,
		sx,  sy,  n
	);
	
	c = det3(
		sx2, sxy, sxz,
		sxy, sy2, syz,
		sx,  sy,  sz
	) / det3(
		sx2, sxy, sx,
		sxy, sy2, sy,
		sx,  sy,  n
	);
	
	printf("a=%f\nb=%f\nc=%f\n\n", a, b, c);
	
	for ( i = 0; i < n; i++ )
	{
		printf("x=%f, y=%f, z=%f, z_approx=%f\n", values[i].x, values[i].y, values[i].z, a * values[i].x + b * values[i].y + c);
	}
	
	return 0;
}

[Celeron]

Díky, kouknu večer na to
Tohle mi sepsal OpenAI. Ještě jsem to neprocházel ale ta rovnice je stejná jako jsem kdysi použil u 80C51. Ale je to jen jednoduchá přímkovka.

Kód: Vybrat vše

// Pole s měřenými kmitočty
const float measuredFrequencies[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0}; // Nahraďte skutečnými kmitočty

// Pole s měřenými útlumy
const float measuredAttenuation[] = {0, 1, 2, 3, 4, 5}; // Nahraďte skutečnými hodnotami útlumu

// Počet měřených bodů
const int numMeasuredPoints = sizeof(measuredFrequencies) / sizeof(measuredFrequencies[0]);

// Funkce pro lineární interpolaci
float linearInterpolation(float x, float x0, float x1, float y0, float y1) {
  return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
}

// Funkce pro výpočet útlumu na základě kmitočtu
float calculateAttenuation(float frequency) {
  int i;

  // Hledání intervalu pro interpolaci
  for (i = 0; i < numMeasuredPoints - 1; i++) {
    if (frequency >= measuredFrequencies[i] && frequency < measuredFrequencies[i + 1]) {
      break;
    }
  }

  // Lineární interpolace mezi dvěma měřenými body
  return linearInterpolation(frequency, measuredFrequencies[i], measuredFrequencies[i + 1], measuredAttenuation[i], measuredAttenuation[i + 1]);
}

void setup() {
  // Inicializace sériové komunikace
  Serial.begin(9600);

  // Výpočet útlumu pro vybraný kmitočet (např. 3.5 MHz)
  float frequency = 3.5; // Nahraďte skutečným kmitočtem
  float attenuation = calculateAttenuation(frequency);

  // Výpis vypočteného útlumu
  Serial.print("Frekvence: ");
  Serial.print(frequency);
  Serial.print(" MHz, Utlum: ");
  Serial.print(attenuation);
  Serial.println(" dB");
}

void loop() {
  // Vaše další kódová logika
}

Jestli to bude funkční, tak je šikovnej.

[asdf]

Aha. Ty to nechceš nahradit jednou přímkou, ale lomenou čárou. Tak to jo. Tak to je to moje k ničemu.