Resetschleife bei intensiver Nutzung der Seriellen Schnittstelle am Arduino Mega

anon64768891 · February 19, 2023, 5:11pm

Moin zusammen.

Ich brauch mal wieder eure Hilfe. Ich habe ein Sketch geschrieben, bei dem ich im Helbduplex Daten mit einem Gerät austausche. Hierbei kam es zu dem Phänomen, dass sich der Arduino zyklisch zurückzusetzen scheint. Nun habe ich das ganze eingedampft auf das pure Abholen der Daten. Bis zu einem gewissen Punkt hat das auch gut funktioniert, bis ich die letzte Funktion hinzugefügt habe. Danach begannen die Resteschleifen von neum.

Das, für mich, Kuriose daran ist, dass jede einzelne Funktion macht, was sie soll. Kommentiere ich die letzte aus, geht es wieder. Lasse ich die letzte drin und kommentiere z.B. getMode aus, geht es auch.

Was übersehe ich denn hier bloß?

Ich füge hier mal den kompletten Test-Code an. Ungeschminkt. Das Verhalten zeigt sich auch ohne Gegenstelle, die Ausführungszeiten sind dann bloß länger. Wie erwähnt, ist dies nur ein Teil des Ganzen und es sollten eigentlich auch noch weitere Abfragen dazu kommen.

Über meine stümperhaften Programmierkenntnisse bitte ich wohlwollend hinweg zu sehen.


#define CIVSerial Serial2
#define BAUD_RATE 19200     // CI-V speed

// Define band edges, some out of band allowed for antenna SWR curves
#define High4 (70500)
#define Low4 (69999)
#define High6 (52000)
#define Low6 (49999)
#define High10 (29700)
#define Low10 (27999)
#define High12 (24990)
#define Low12 (24889)
#define High15 (21450)
#define Low15 (20999)
#define High17 (18168)
#define Low17 (18067)
#define High20 (14350)
#define Low20 (13999)
#define High30 (10150)
#define Low30 (10099)
#define High40 (7200)
#define Low40 (6999)
#define High60 (5367)
#define Low60 (5350)
#define High80 (3800)
#define Low80 (3499)
#define High160 (2000)
#define Low160 (1799)
#define High630 (479)
#define Low630 (471)

//#define CIV_delay 550

byte TRX_address = 0x94; // HEX 0xA2 = Icom IC-9700 , 0x70 = Icom IC-7000, 0x94 = Icom IC-7300

int unsigned long QRG = 0;
int unsigned long oldQRG = 0;

byte Po; // Eingestellte Ausgangsleistung
int BAND = (0); // das derzeitige Band
String BandString; // Klartext des Bandnamens
bool NoiseBlanker = 0; //Status des Noise Blankers
bool NoiseReduction = 0; //Status des Noise Blankers
byte SWert = 0; // S-Meter Wert
byte Mode = 0;  // Eingestellter Mode
byte MicGain = 0; // Speichervariable für Mic Gain

////////////////////////////////////////////////////////////

void setup() {

	//// Serial Test
	Serial.begin(115200);

	CIVSerial.begin(BAUD_RATE); // CAT Geschwindigkeit

}

////////////////////////////////////////////////////////////

void loop() {

	byte Po; // Eingestellte Ausgangsleistung
	int BAND = (0); // das derzeitige Band
	String BandString; // Klartext des Bandnamens
	bool NoiseBlanker = 0; //Status des Noise Blankers
	bool NoiseReduction = 0; //Status des Noise Blankers
	byte SWert = 0; // S-Meter Wert
	byte Mode = 0;  // Eingestellter Mode
	byte MicGain = 0; // Speichervariable für Mic Gain

	int unsigned long LoopTime = millis(); // Messtimer

	getQRG(QRG);
	getQRGBand(QRG, BAND, BandString);
	getRFPower(Po);
	getNoiseBlanker(NoiseBlanker);
	getNoiseReduction(NoiseReduction);
	getSWert(SWert);
	getMode(Mode);
	getMicGain(MicGain);

	Serial.print("QRG: ");
	Serial.println(QRG);
	Serial.print("Band: ");
	Serial.println(BAND);
	Serial.print("RF-Power: ");
	Serial.println(Po);
	Serial.print("Noise Blanker: ");
	Serial.println(NoiseBlanker);
	Serial.print("Noise Reduction: ");
	Serial.println(NoiseReduction);
	Serial.print("S-Wert: ");
	Serial.println(SWert);
	Serial.print("Mode: ");
	Serial.println(Mode);
	Serial.print("Mic Gain: ");
	Serial.println(MicGain);
//
	LoopTime = millis() - LoopTime;
	Serial.print("Loopdauer in ms: ");
	Serial.println(LoopTime);

}

//>>>>>>>>>>>>>> SUBROUTINEN <<<<<<<<<<<<<<<<<

///////////////////////////////////////////////////////////////////////

byte DecToBcd(byte val) {

	return ((val / 10 * 16) + (val % 10));
}

///////////////////////////////////////////////////////////////////////

byte BcdToDec(byte val) {

	return ((val / 16 * 10) + (val % 16));
}

///////////////////////////////////////////////////////////////////////

void getQRG(unsigned long int &QRG) {

//	if (TX == true)
//		TXloop();
//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	int incoming;

	byte MHz2 = 0;
	byte MHz = 0;
	byte kHz = 0;
	byte Hz2 = 0;
	byte Hz = 0;

//	int unsigned long Freq;
//	int unsigned long QRGcomp = 0; // Frequenz - Band Vergleich
//	int BAND = (0); // das derzeitige Band

//////////////////////////////// sende Abfrage der Sendefrequenz

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x25); // Read the transmit frequency , command 25 00
		CIVSerial.write(byte(00)); // Read the transmit frequency , command 25 00
		CIVSerial.write(0xFD); // end sequence
	}

//////////////////////////////// Frequenzauswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delayMicroseconds(1000); // 1ms NICHT ENTFERNEN !!
		delay(1);

//		Serial.print("Durchlauf: ");
//		Serial.println(Durchlauf);
//		Serial.print("Schritt: ");
//		Serial.println(Schritt);

		incoming = CIVSerial.read();
//		Serial.print("Incomming: ");
//		Serial.println(incoming, HEX);

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x25) {
				Schritt++; // Read the transmit frequency , command 25 00
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			if (incoming == byte(00)) {
				Schritt++; // Read the transmit frequency , command 25 00
			} else {
				Schritt = 1;
			}

			break;

		case 7:
			Hz = incoming; // load QRG byte
			Schritt++;

			break;

		case 8:
			Hz2 = incoming; // load QRG byte
			Schritt++;

			break;

		case 9:
			kHz = incoming; // load QRG byte
			Schritt++;

			break;

		case 10:
			MHz = incoming; // load QRG byte
			Schritt++;

			break;

		case 11:
			MHz2 = incoming; // load QRG byte
			Schritt++;

			break;

		case 12:
			if (incoming == 0xFD) {
				Schritt++; // PWR
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

//	} while (Schritt < 10 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt
	} while (Schritt < 13 && Durchlauf < 30); // Lausche, bis das richtige Packet vorbei kommt

	MHz2 = BcdToDec(MHz2);
	MHz = BcdToDec(MHz);
	kHz = BcdToDec(kHz);
	Hz2 = BcdToDec(Hz2);
	Hz = BcdToDec(Hz);

//Serial.println(MHz2);
//Serial.println(MHz);
//Serial.println(kHz);
//Serial.println(Hz2);
//Serial.println(Hz);

////////////////////////////////////////////////////////////////////////////////////////////

	QRG = ((MHz * 1000) + (kHz * 10) + (Hz2 / 10)); // QRG variable stores frequency in MMkkkH format
//	Serial.println(QRG);

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getQRG-Loopdauer in ms: ");
//	Serial.println(SubLoopTime);
}

////////////////////////////////////////////////////////////////////////////////////////////

void getQRGBand(unsigned long int &QRG, int &BAND, String &BandString) {

//	int unsigned long SubLoopTime = micros(); // Messtimer
	// Which band ?

//	QRGcomp = Freq / 10;
//	Serial.println(QRG);
//	BAND = 0; // default band = will generate error
//
	if ((QRG < High4) and (QRG > Low4)) {
		BAND = 4;
		BandString = "  4m";
//		BandArrayPointer = 12;
	}
	if ((QRG < High6) and (QRG > Low6)) {
		BAND = 6;
		BandString = "  6m";
//		BandArrayPointer = 11;
	}
	if ((QRG < High10) and (QRG > Low10)) {
		BAND = 10;
		BandString = " 10m";
//		BandArrayPointer = 10;
	}
	if ((QRG < High12) and (QRG > Low12)) {
		BAND = 12;
		BandString = " 12m";
//		BandArrayPointer = 9;
	}
	if ((QRG < High15) and (QRG > Low15)) {
		BAND = 15;
		BandString = " 15m";
//		BandArrayPointer = 8;
	}
	if ((QRG < High17) and (QRG > Low17)) {
		BAND = 17;
		BandString = " 17m";
//		BandArrayPointer = 7;
	}
	if ((QRG < High20) and (QRG > Low20)) {
		BAND = 20;
		BandString = " 20m";
//		BandArrayPointer = 6;
	}
	if ((QRG < High30) and (QRG > Low30)) {
		BAND = 30;
		BandString = " 30m";
//		BandArrayPointer = 5;
	}
	if ((QRG < High40) and (QRG > Low40)) {
		BAND = 40;
		BandString = " 40m";
//		BandArrayPointer = 4;
	}
	if ((QRG < High60) and (QRG > Low60)) {
		BAND = 60;
		BandString = " 60m";
//		BandArrayPointer = 3;
	}
	if ((QRG < High80) and (QRG > Low80)) {
		BAND = 80;
		BandString = " 80m";
//		BandArrayPointer = 2;
	}
	if ((QRG < High160) and (QRG > Low160)) {
		BAND = 160;
		BandString = "160m";
//		BandArrayPointer = 1;
	}
	if ((QRG < High630) and (QRG > Low630)) {
		BAND = 630;
		BandString = "630m";
//		BandArrayPointer = 13;
	}
	if (BAND == 0) {
//		clearindicator(); // We are not on standard band, clear antenna's
		BandString = "    ";
//		BandArrayPointer = 0;
	}

//	Serial.print("RX-Band: ");
//	Serial.println(BandString);

//	SubLoopTime = micros() - SubLoopTime;
//	Serial.print("getBand-Loopdauer in µs: ");
//	Serial.println(SubLoopTime);

}

/////////////////////////////////////////////////////////////////////////

void getRFPower(byte &Po) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	byte byte1 = 0;
	byte byte2 = 0;

	int incoming;

//	byte Pout = oldPo;
//	byte Pout = 0;

	//////////////////////////////// sende Abfrage der Sendeleistung

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x14);
		CIVSerial.write(0x0A); // Read the transmit power , command 14 0A
		CIVSerial.write(0xFD); // end sequence
	}

	//////////////////////////////// Auswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delayMicroseconds(950); // 950µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x14) {
				Schritt++; // PWR
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			if (incoming == 0x0A) {
				Schritt++; // PWR
			} else {
				Schritt = 1;
			}

			break;

		case 7:
			byte1 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 8:
			byte2 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 9:
			if (incoming == 0xFD) {
				Schritt++; // PWR
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

//	} while (state < 10 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt
	} while (Schritt < 10 && Durchlauf < 25); // Lausche, bis das richtige Packet vorbei kommt

////////////////////////////////////////////////////////////////////////////////////////////

	byte TopByte = BcdToDec(byte1) * 100;
	byte LowByte = BcdToDec(byte2);

	Po = ((TopByte + LowByte) / 2.55); // Dezimal Umsetzung
//	Serial.println(Po);

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getRFPower-Loopdauer Ende in ms: ");
//	Serial.println(SubLoopTime);

//	return Pout;
//	Po = Pout;
}

//////////////////////////////////////////////////////////////////////

void getNoiseBlanker(bool &NoiseBlanker) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	byte byte1 = 0;
//	byte byte2 = 0;

	int incoming;

//	bool NoiseBlank = oldNoiseBlanker;

	//////////////////////////////// sende Abfrage von NB

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x16);
		CIVSerial.write(0x22); // Read the Noise Blanker, command 16 22
		CIVSerial.write(0xFD); // end sequence
	}

	//////////////////////////////// Auswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delayMicroseconds(950); // 950µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x16) {
				Schritt++;  // 16 22 => Noise Blanker
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			if (incoming == 0x22) {
				Schritt++;  // 16 22 => Noise Blanker
			} else {
				Schritt = 1;
			}

			break;

		case 7:
			byte1 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 8:
			if (incoming == 0xFD) {
				Schritt++; // Daten Ende
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

//	} while (state < 9 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt
	} while (Schritt < 9 && Durchlauf < 30); // Lausche, bis das richtige Packet vorbei kommt

////////////////////////////////////////////////////////////////////////////////////////////

	NoiseBlanker = byte1;

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getNoiseBlanker-Loopdauer in ms: ");
//	Serial.println(SubLoopTime);

}

//////////////////////////////////////////////////////////////////////

void getNoiseReduction(bool &NoiseReduction) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	byte byte1 = 0;
//	byte byte2 = 0;

	int incoming;

//	bool NoiseBlank = oldNoiseBlanker;

	//////////////////////////////// sende Abfrage von NB

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x16);
		CIVSerial.write(0x40); // Read the Noise Reduction, command 16 40
		CIVSerial.write(0xFD); // end sequence
	}

	//////////////////////////////// Auswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delayMicroseconds(950); // 950µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x16) {
				Schritt++;  // 16 40 => Noise Reduction
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			if (incoming == 0x40) {
				Schritt++;  // 16 40 => Noise Reduction
			} else {
				Schritt = 1;
			}

			break;

		case 7:
			byte1 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 8:
			if (incoming == 0xFD) {
				Schritt++; // Daten Ende
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

	} while (Schritt < 9 && Durchlauf < 30); // Lausche, bis das richtige Packet vorbei kommt
//} while (Schritt < 9 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt

////////////////////////////////////////////////////////////////////////////////////////////

//	NoiseBlank = byte1;
	NoiseReduction = byte1;

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getNoiseReduction-Loopdauer in ms: ");
//	Serial.println(SubLoopTime);

//	return NoiseBlank;

}

///////////////////////////////////////////////////////////////////////

void getSWert(byte &SWert) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte schritt = 1;

	byte byte1 = 0;
	byte byte2 = 0;

	int incoming;

//	byte SMeter = oldSWert;

	//////////////////////////////// sende Abfrage der Feldstärke

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x15);
		CIVSerial.write(0x02); // Read the Mig Gain, command 15 02
		CIVSerial.write(0xFD); // end sequence
	}

	//////////////////////////////// Auswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delay(1); // 1ms NICHT ENTFERNEN !!
//		delayMicroseconds(550); // 550µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();
//		Serial.print("Schritt: ");
//		Serial.println(schritt);
//		Serial.print("Byte: ");
//		Serial.println(incoming, HEX);

		switch (schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				schritt = 2;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				schritt = 3; // Preambel 2. FE
			} else {
				schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				schritt = 4; // Komando geht an Controller
			} else {
				schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				schritt = 5; // Komando kommt vom 7300
			} else {
				schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x15) {
				schritt = 6; // Read the Mig Gain, command 15 02
			} else {
				schritt = 1;
			}

			break;

		case 6:
			if (incoming == 0x02) {
				schritt = 7; // Read the Mig Gain, command 15 02
			} else {
				schritt = 1;
			}

			break;

		case 7:
			byte1 = incoming; // load byte1 with next characters
			schritt = 8;

			break;

		case 8:
			byte2 = incoming; // load byte2 with next characters
			schritt = 9;

			break;

		case 9:
			if (incoming == 0xFD) {
				schritt++; // Daten Ende
			} else {
				schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

	} while (schritt < 10 && Durchlauf < 100); // Lausche, bis das richtige Packet vorbei kommt
//} while (schritt < 10 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt

////////////////////////////////////////////////////////////////////////////////////////////

	float TopByte = ((byte1 / 16 * 10) + (byte1 % 16) * 100); // Dezimal Umsetzung
	float LowByte = ((byte2 / 16 * 10) + (byte2 % 16)); // Dezimal Umsetzung
	SWert = (TopByte + LowByte);

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getSMeter-Loopdauer in ms: ");
//	Serial.println(SubLoopTime);

}

//////////////////////////////////////////////////////////////

void getMode(byte &Mode) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	byte byte1 = 0;

	int incoming;

//	byte Mode = oldMD;

/////////////////////////////////////// sende Abfrage des Modus

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x04); // Read the operating mode
		CIVSerial.write(0xFD); // end sequence
	}

//////////////////////////////////////// Modusauswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delay(1); // 1ms NICHT ENTFERNEN !!
//		delayMicroseconds(650); // 600µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x04) {
				Schritt++;  // 04 Mode
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			byte1 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 7:
			if (incoming == 0xFD) {
				Schritt++; // Daten Ende
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

	} while (Schritt < 8 && Durchlauf < 30); // Lausche, bis das richtige Packet vorbei kommt
//} while (Schritt < 8 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt

////////////////////////////////////////////////////////////////////////////////////////////

	Mode = byte1;

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getMode-Loopdauer in ms: ");
//	Serial.println(SubLoopTime);

}

///////////////////////////////////////////////////////////////////////

void getMicGain(byte &MicGain) {

//	if (TX == true)
//		TXloop();

//	int unsigned long SubLoopTime = millis(); // Messtimer

	byte Durchlauf = 1;

	byte Schritt = 1;

	byte byte1 = 0;
	byte byte2 = 0;

	int incoming;

//	byte MicGain = oldMG;

	//////////////////////////////// sende Abfrage des Mic Gain

	if ((CIVSerial.available() <= 0)) { // Wenn keine CI-V Daten kommen

		CIVSerial.write(0xFE);
		CIVSerial.write(0xFE);
		CIVSerial.write(TRX_address);
		CIVSerial.write(0xE0);
		CIVSerial.write(0x14);
		CIVSerial.write(0x0B); // Read the Mic Gain, command 14 0B
		CIVSerial.write(0xFD); // end sequence
	}

	//////////////////////////////// Auswertung

	delay(2); // 2ms Nicht entfernen!

	/////////////////////////////////////////////////////////////////////////
	do {

//		if (TX == true)
//			TXloop();

//		delayMicroseconds(750); // 750µs NICHT ENTFERNEN !!
		delay(1);

		incoming = CIVSerial.read();

		switch (Schritt) {
		case 1:
			if (incoming == 0xFE) { // Preambel 1. FE
				Schritt++;
			}

			break;

		case 2:
			if (incoming == 0xFE) {
				Schritt++; // Preambel 2. FE
			} else {
				Schritt = 1;
			}

			break;

		case 3:
			if (incoming == 0xE0) {
				Schritt++; // Komando geht an Controller
			} else {
				Schritt = 1;
			}

			break;

		case 4:
			if (incoming == TRX_address) {
				Schritt++; // Komando kommt vom 7300
			} else {
				Schritt = 1;
			}

			break;

		case 5:
			if (incoming == 0x14) {
				Schritt++; // Mic Gain
			} else {
				Schritt = 1;
			}

			break;

		case 6:
			if (incoming == 0x0B) {
				Schritt++; // Mic Gain
			} else {
				Schritt = 1;
			}

			break;

		case 7:
			byte1 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 8:
			byte2 = incoming; // load buffget with next 10 characters
			Schritt++;

			break;

		case 9:
			if (incoming == 0xFD) {
				Schritt++; // Daten Ende
			} else {
				Schritt = 1;
			}

			break;

		default:

			break;
		}

		Durchlauf++;

	} while (Schritt < 10 && Durchlauf < 80); // Lausche, bis das richtige Packet vorbei kommt
//} while (state < 11 && Durchlauf < 30 && pos == 0); // Lausche, bis das richtige Packet vorbei kommt

///////////////////////////////////////////////////////////////////////////////////////////

	byte TopByte = BcdToDec(byte1) * 100;
	byte LowByte = BcdToDec(byte2);
//
	MicGain = ((TopByte + LowByte) / 2.55); // Prozent Umsetzung

//	SubLoopTime = millis() - SubLoopTime;
//	Serial.print("getMicGain-SubLoopdauer in ms: ");
//	Serial.println(SubLoopTime);

}

Tommy56 · February 19, 2023, 5:28pm

Außer, dass Du zu viele nutzlose Leerzeilen im Code hast, die das Lesen erschweren, was sagt der Compiler zum Speicherverbrauch?

Gruß Tommy

anon64768891 · February 19, 2023, 5:33pm

Das kompilieren wirft folgendes aus:

section                     size      addr
.data                        202   8389120
.text                       7454         0
.bss                         337   8389322
.comment                      17         0
.note.gnu.avr.deviceinfo      64         0
.debug_aranges               304         0
.debug_info                17195         0
.debug_abbrev               4676         0
.debug_line                 5450         0
.debug_frame                1016         0
.debug_str                  2879         0
.debug_loc                  8596         0
.debug_ranges               1232         0
Total                      49422


'Finished building target: 7300_EXT_V2'
' '

18:33:13 Build Finished. 0 errors, 0 warnings. (took 2s.267ms)

Und dies nach dem Schreiben:

avrdude: verifying ...
avrdude: 7656 bytes of flash verified

anon64768891 · February 19, 2023, 5:37pm

Sorry, ich sehe geade, dass die Formatierung des Kompileroutputs verloren gegangen ist

Tommy56 · February 19, 2023, 5:37pm

Das sieht aber nicht nach Arduino-IDE aus. Was nutzt Du?

Gruß Tommy

anon64768891 · February 19, 2023, 5:38pm

Ein Plugin für Eclipse.

fony · February 19, 2023, 5:38pm

Wen du das für Mega kompilierst dann kommen

Der Sketch verwendet 8260 Bytes (3%) des Programmspeicherplatzes. Das Maximum sind 253952 Bytes.
Globale Variablen verwenden 533 Bytes (6%) des dynamischen Speichers, 7659 Bytes für lokale Variablen verbleiben. Das Maximum sind 8192 Bytes.

raus

Tommy56 · February 19, 2023, 5:38pm

Setze es auch in Codetags. Das kannst Du auch nachträglich ändern.

Gruß Tommy

anon64768891 · February 19, 2023, 6:16pm

Liebe Leute, ich muss mich ganz herzlich bei euch für die gestohlene Zeit entschuldigen.
Ganz offenbar bin ich dem weißen Kaninchen gefolgt.

Ich habe eben den oben angefügten Code in die Arduino IDE stumpf hineinkopiert und in den Mega geladen.

Er funktioniert.

Dann habe ich das größere Gesamtprogramm in die IDE kopiert und von dort aus hoch geladen.

Funktioniert auch.

Ganz offenbar ist die von mir genutzte Entwicklungsumgebung die Wurzel.
Diese Erkenntnis hat mich zwei Tage gekostet.

Bitte seht es mir nach, dass ich das nicht schon eher ausprobiert habe, aber manchmal ist man einfach zu vernagelt. Solltet ihr trotzdem Verbesserungsvorschläge zu dem Code für einen Hobbybastler habe, wäre ich euch außerdem dankbar.

Mea culpa.

Gruß

Gunnar

noiasca · February 19, 2023, 7:16pm

erzähl mal was du da genau vorhast.

Das wäre "meine" Version von einer Leseroutine für CI-V + Banderkennung:

https://werner.rothschopf.net/microcontroller/202102_arduino_antennaswitch_en.htm

uwefed · February 19, 2023, 7:21pm

Unabhängig davon verwende die F() Makro bei allen print/println von Text.
zB
Serial.print(F("text"));
Das verhindert daß der Text zuerst ins RAM kopiert wird und dann erst augegeben.
Der von der IDE angegebene RAM-Verbrauch beinhaltet diese RAM-Verwendung nicht, da diese erst zur Laufzeit verwendet.

Grüße Uwe

michael_x · February 19, 2023, 10:27pm

Eher so:

Wenn du
Serial.print("ein ziemlich langer Text");
in deinem Code hast, und diesen Text zum Test noch verlängerst, siehst du das am steigenden RAM-Bedarf beim Übersetzen. (Der Flash-Bedarf erhöht sich natürlich auch.)
Dass der RAM-Bedarf sinkt, wenn du sinnvollerweise den F-Makro verwendest, kannst du auch sehen.

anon64768891 · February 20, 2023, 11:19am

Danke für den Tipp. Werde ich mir mal anschauen.

system · August 19, 2023, 11:19am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
RF433MHz some basic examles and traffic ligths one General Guidance	27	259	December 11, 2025
Variable in einem Inerrupt wird nicht verarbeitet Deutsch	23	167	March 2, 2026
Serial eine einfache Fehler Überprüfung Deutsch	65	791	November 3, 2024
Problem mit weiterer include-Datei Deutsch	25	249	October 20, 2025
Transmission NRF24l01 Français	47	354	February 22, 2026

Resetschleife bei intensiver Nutzung der Seriellen Schnittstelle am Arduino Mega

Related topics