Arduino Tekrarlayıcı Kontrol Cihazı

Yorum yapılmamış

ARC-01’in beta sürüm yükseltmesi, Arduino Nano’nun radyo yayını için tekrarlayıcı kontrolü.

PTT, ses sinyalini (COS) tamamlayabilir veya dijital DC sinyalini başka bir (SQ/O) göstergesine aktarabilir ve aynı zamanda bir programla (program aracılığıyla) birkaç bit arasında bağlantı kurabilir.

İlk önce geleneksel bir deneyime sahip olmak için bir şeyler yapmaya çalışın . Çalıştırma işlemi , “PTT’yi kullanarak” kısa bir süre içinde (COS ile) başka bir DC ses sinyali bileşeninin (Baofeng) kullanımıyla ilgili bir gösterge olarak kullanılabilir .

Ses sinyali FET’e aittir; programı başlatmak için radyoyu açın. FET, 5 V’ye kadar bir değere sahiptir (isteğe bağlı). mantıksal “1”.

Ayrıca, en az miktarda ses kaydı yapma olanağınız var ve ayrıca rezervasyon yaptırmanız gerekiyorsa, ARC-01’de aynı düzeltmeyi de yapabilirsiniz. Mikrofonlar, mV’nin mV RMS ile aynı şekilde olmasını sağlamak için bir sinyal üretir. Bu, VOX’un bu şekilde işlenmesini sağlar .

Povezivanje’nin radyo yayını, yeni bir konektora için uygun bir sistemdir. İkili bir şekilde veya başka bir şekilde anten almak istiyorsanız, CEO’nuz VF’nin yeni bir proje için güzel bir tema (krajnje važna) oluşturacağını düşünüyor . Podrazumeva, NF kablosunun, VF bağlantılarının ve anten bağlantısının yanı sıra daha fazla veri aktarımı için de aynı kontrole sahiptir.

ARC-01 9…12 V DC’de çalışıyor. 8V…14V ile farklı bağlantı seçenekleri mevcuttur krajnosti. Güç kaynağı 40 mA’dir. Bu, hem çok kaliteli hem de hazır bir USB bağlantısının temel ilkesidir .

Kontrol (tekrarlayıcı) – radi, testrane funkcije, mada ćemo se tek grati. COS, Baofeng UV5R, UVB5 ve UV-82’yi test etmiştir. Opsiyonel seçenekler, SQO, bir ürün ve hizmet modeli olarak kabul edilir ve bu, birkaç tane daha satın alınması gereken bir şeydir.

Programınız, tekrarlanan parametrelerle ilgili olarak çok çeşitlidir: CW tanımlayıcı periyodik olarak, maksimum düzeyde maksimum seviye ve ön yükleme veya ön yükleme için “bip” sesi duyulur. Program, yorum yapmak ve eklemek için kullanılır.

#include <EEPROM.h>

const byte ON = HIGH; //1
const byte OFF = LOW; //0
const byte COS = A0;
const byte SQO = 3;
const int ADC_LIMIT = 550;

//PODESAVANJA, PARAMETRI:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned long ID_PERIOD_LNG = 1800;// 'A' Period izmedju emitovanja neizazvane identifikacije. U SEKUNDAMA.
unsigned long ID_ANSWER_LNG = 900; // 'B' Minimalno trajanje perioda zatvorenog skvelca posle koga repetitor na sledece okidanje odgovara identifikacijom. U SEKUNDAMA.
unsigned long ID_COURTESY_LNG = 10; // 'C' Minimalno vreme od poslednje emisije do emitovanja periodicne identifikacije. U SEKUNDAMA.
unsigned long SQUELCH_TAIL_LNG = 1400; // 'D' Vreme od zatvaranja skvelca do otpustanja PTT. U MILISEKUNDAMA!
unsigned long MAX_AIR_TIME_LNG = 180; // 'E' Maksimalno trajanje perioda na predaji. U SEKUNDAMA.
unsigned long MINIMUM_BREAK_1_LNG = 5; // 'F' Minimalno trajanje prekida izmedju emisija koji resetuje brojac MAX_AIR_TIME_LNG. U SEKUNDAMA.
unsigned long COOLING_OFF_LNG = 300; // 'G' Period zastite posle iskljucenja po isteku MAX_AIR_TIME_LNG. U SEKUNDAMA.
unsigned long MINIMUM_BREAK_2_LNG = 5; // 'H' Minimalno trajanje perioda zatvorenog skvelca pre nastavka rada posle perioda zastite. U SEKUNDAMA.
int SQL_SENSE_MIN_LNG = 50; // 'I' Za "okidanje" i "drzanje" repetitora nebitne su promene stanja skvelca koje traju krace od SQL_SENSE_MIN_LNG. U MILISEKUNDAMA!
byte BEEP_ENABLED = OFF; // 'J' Bip na kraju relacije

const char MESSAGE_ID [] = {0x1d, 0xc, 0x3f, 0x18, 0xc, 0x02}; //'YU0VUE'. Promeniti pozivni znak po zelji.
const char MESSAGE_RESET [] = {0x0a, 0x02, 0x08, 0x02, 0x03}; //'RESET'
const char MESSAGE_BK [] = {0x11, 0x0d}; //'BK', kad prekida rad po isteku MAX_AIR_TIME_LNG
const char MESSAGE_DE [] = {0x09, 0x02}; //'DE'
const char MESSAGE_R [] = {0x0a}; //'R'

//CW parametri:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int DIT = 95; //Za promenu brzine SAMO OVAJ RED treba menjati. Duza tacka - manja CW brzina, i obrnuto.
const int DAH = DIT * 3; //Trajanje crte
const int FREQ = 750; //Frekvencija CW tona
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Pinovi:
const byte _DCinVolts = A6; //Za dijagnostiku.
const byte _5VRailVolts = A7; //Za dijagnostiku.
const byte _IdToneOut = A5; //CW tonski izlaz, za ID i druge poruke
const byte _PttOut = A4; //Pin PTT za TX, izlaz, active HIGH
const byte _RxSqlLed = A3; //LED koja pokazuje kada je skvelc otvoren, izlaz
const byte _RxAudioToTx = A2; //Kad je LOW, RX audio spojen je na TX MIC. 
const byte _PullUpDown = 7;
const byte _ShifterVoltOut = 4; //Izlaz, bice suvisno u sledecoj verziji, jer ce se napon za konvertor nivoa uzimati iz DX-3
const byte _JumperEE = 8; //Dzamper. Ako se ne koristi dodatni GSM-uredjaj, ovaj dzamper neka UVEK bude POSTAVLJEN.

const byte _InPin = COS; //OVDE IZABRATI ulazni pin tj. nacin kako se indicira otvoren skvelc. COS: DC komponenta iz audio-signala. SQO: gotov DC signal, digitalno HIGH ili LOW.
byte SQUELCH_OPEN = LOW; //OVDE IZABRATI stanje na _InPin kada je skvelc otvoren. Za SQO moze biti HIGH ili LOW. Za COS ovo nema znacaja. 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////PODESAVANJA, PARAMETRI - KRAJ

#define _ptt_state digitalRead(_PttOut)

unsigned long id_period_start;
unsigned long id_answer_start;
unsigned long id_courtesy_start; 
unsigned long max_air_time_start; 
unsigned long minimum_break_1_start;
unsigned long squelch_open_start; 
unsigned long squelch_closed_start;

byte SQUELCH_CLOSED;
byte answer_with_id_now;
byte sql_prev_state;
byte sql_now_open;
byte last_isr_result;

void setup() {

	DDRB = 0x00;
	PORTB = 0xFF;
	DDRD = 0x00;
	PORTD = 0xFF;
	DDRC = 0x00;
	PORTC = 0b000010; 

	delay(500);

	pinMode(_PttOut, OUTPUT);

	digitalWrite(_RxSqlLed, LOW);	
	pinMode(_RxSqlLed, OUTPUT);

	digitalWrite(_ShifterVoltOut, LOW);
	pinMode(_ShifterVoltOut, OUTPUT);

	PassRXAudio(); //Postavi pin u pocetno stanje

	//ADC malo ubrzan:
	bitSet(ADCSRA,ADPS2);
	bitSet(ADCSRA,ADPS1);
	bitClear(ADCSRA, ADPS0); // delitelj /64  250kHz
	analogReference (INTERNAL);
	for (int i=0; i<10; i++) {
		int ii = analogRead(COS);
	}

	if (_InPin == SQO) { //Ako se se koristi gotov DC signal koji indicira otvoren skvelc (SQO)
		digitalWrite(_InPin, LOW); //Iskljuci pull-up na _InPin
		pinMode(_PullUpDown, OUTPUT);
		digitalWrite(_PullUpDown, !SQUELCH_OPEN);  //Ako je SQUELCH_OPEN HIGH, tj. ako je aktivno stanje HIGH, pin _PullUpDown davace pull-down, i obrnuto
	}

	SQUELCH_CLOSED = !SQUELCH_OPEN;
	sql_prev_state = 0;
	sql_now_open = 0;

	
	//Prijem s USARTa, makar pokusaj: 
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	char param_str[8]; 
	char ALL_LETTERS [10] = {0x06, 0x11, 0x15, 0x09, 0x02, 0x14, 0x0b, 0x10, 0x04, 0x1e}; //Morze kodovi za oznake parametara, od 'A' do 'J'
	char starting_letter[1];
	unsigned long starting_serial_time = millis();

	Serial.begin(19200); 
	digitalWrite(_ShifterVoltOut, HIGH); //Napon za konvertor nivoa, bice suvisno u sledecoj verziji
	Serial.println("k");

	starting_letter[0] = 0;
	byte char_pos = 0;
	
	while ((millis() - starting_serial_time < 50) && (starting_letter[0] < '0')) { 
		while (Serial.available()) {
	    	param_str[char_pos] = Serial.read(); //Cita bajt po bajt
	    	
	    	if (param_str[char_pos] == '#') { 
	    		param_str[char_pos] = '\0';
	            starting_letter[0] = param_str[0]; //Prvo slovo stringa s porta, oznaka parametra
	            if (starting_letter[0] >= 'A')  { //Ako je ovo reset s promenom parametara, ako je prvo slovo 'A', 'B'...
	            	param_str[0] = '0'; // Zbog kasnijeg pretvaranja stringa u int
	    			param_str[1] = '0'; //  			
	    		}
	    		break;
	    	}	
	    	else char_pos++;		
	    }
	}

	digitalWrite(_ShifterVoltOut, LOW); 

	InitParametersAndList(starting_letter[0], param_str); 

	Serial.end();
	//////////////////////////////////////////////////////////////////////////////////////////////Prijem s USARTa i odgovor listom parametara - KRAJ

	
	//Da bi na dalje sve bilo u milisekundama, zbog millis():
	ID_PERIOD_LNG *= 1000;
	ID_ANSWER_LNG *= 1000;
	ID_COURTESY_LNG *=1000;
	MAX_AIR_TIME_LNG *=1000; 
	MINIMUM_BREAK_1_LNG *=1000;
	COOLING_OFF_LNG *=1000;
	MINIMUM_BREAK_2_LNG *= 1000;
	
	max_air_time_start = millis();
	answer_with_id_now = OFF;

	StopRXAudio();
	GoTransmit();  

	if (starting_letter[0] >= 'A') { //Ako je menjan parametar SMS-porukom 
		starting_letter[0] = ALL_LETTERS[starting_letter[0] - 'A']; //Kod za CW
		PlayMessage (MESSAGE_R, sizeof(MESSAGE_R));
		PlayMessage (starting_letter, sizeof(starting_letter)); 
	}	
	else { // Ako NIJE menjan parametar SMS-porukom
		PlayMessage(MESSAGE_DE, sizeof(MESSAGE_DE));
		PlayMessage(MESSAGE_ID, sizeof(MESSAGE_ID));
		PlayMessage(MESSAGE_RESET, sizeof(MESSAGE_RESET));
	}

	delay(SQUELCH_TAIL_LNG);
	GoReceive();
	PassRXAudio(); //Na ulaz MIC predajnika od sada je spojen i audio iz prijemnika.

	id_period_start = millis();

    //TIMER1:
    ////////////////////////////////
  	TCCR1A = 0x00;
  	TCCR1B = 0x00;
   	bitSet (TCCR1B, CS11); //delitelj 8, period 33ms
   	bitSet(TIMSK1, TOIE1);
  	////////////////////////////////

}


/////////////////////////////////////  GLAVNA PETLJA  ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
void loop() {

	sql_now_open = TheVerdict();

	if (sql_now_open != sql_prev_state) {
		if (sql_now_open && !_ptt_state) squelch_open_start = millis(); //Ako je upravo otvoren skvelc 
		if (!sql_now_open && _ptt_state) squelch_closed_start = millis(); //Ako je upravo zatvoren skvelc 
	}

	else { //Ako je stanje skvelca nepromenjeno

		if (sql_now_open) {  //Ako skvelc stoji otvoren

			if ((millis() - squelch_open_start >= SQL_SENSE_MIN_LNG) && !_ptt_state) { //Ako je skvelc upravo dovoljno dugo bio otvoren da "okine" repetitor
				GoTransmit(); //Repetitor je "okinut", reemitovace se audio iz prijemnika
				if (millis() - id_answer_start >= ID_ANSWER_LNG)  answer_with_id_now = ON; //A mozda ce potom biti odgovoreno sa CW ID
			}

			if ((millis() - max_air_time_start >= MAX_AIR_TIME_LNG) && _ptt_state) {  //Ako je istekao period MAX_AIR_TIME_LNG 
				StopRXAudio();
				PlayMessage(MESSAGE_BK, sizeof (MESSAGE_BK)); //Kuca 'BK'
				GoReceive();
				PassRXAudio();
				delay(COOLING_OFF_LNG); //Repetitor ce biti van funkcije tokom ovog vremena

				for (unsigned long i = 0; i < MINIMUM_BREAK_2_LNG; i++) { //Posle perioda zastite COOLING_OFF_LNG, da skvelc obavezno bude zatvoren jos tokom perioda MINIMUM_BREAK_2_LNG
					sql_now_open = TheVerdict(); 
					if (sql_now_open) i = 0;
					delay(1);
				} 

			}
			
		}

		else { //Ako skvelc stoji zatvoren

			if (_ptt_state) { //Ako je na predaji	

				if (millis() - squelch_closed_start >= SQL_SENSE_MIN_LNG) { //Ako je skvelc upravo dovoljno dugo bio zatvoren...
					
					delay(SQUELCH_TAIL_LNG);
					if (BEEP_ENABLED) SoundBeep();
					
					id_answer_start = millis(); //Resetuje odbrojavanje do ID_ANSWER_LNG, za odziv identifikacijom
					GoReceive(); //Vrati se na prijem
				}
			}	  	

			else { //Ako je na prijemu

				if ((millis() - id_period_start >= ID_PERIOD_LNG) && (millis() - id_courtesy_start >= ID_COURTESY_LNG)) { 
					//CW ID: ako je isteklo vreme ID_PERIOD_LNG i ako je proslo dovoljno vremena od zadnje emisije (ID_COURTESY_LNG)
					GoTransmit();
					PlayMessage(MESSAGE_DE, sizeof(MESSAGE_DE)); 
					PlayMessage(MESSAGE_ID, sizeof(MESSAGE_ID));//Kuca CW ID repetitora
					delay(SQUELCH_TAIL_LNG); //I ovde ceka toliko pre nego sto dozvoli novo otvaranje skvelca
					GoReceive();
					
					id_period_start = millis(); //Resetuje tajmer/brojac
				}

			}
			
		}

	}

	sql_prev_state = sql_now_open;
} 
/////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////  GLAVNA PETLJA - KRAJ


void GoReceive() { //Prelazak na prijem
	if (answer_with_id_now == ON) { //Ako treba da odgovori identifikacijom
		AnswerWithID();
		answer_with_id_now = OFF;
	}
	minimum_break_1_start = millis();
	id_courtesy_start = millis();
	digitalWrite(_PttOut, LOW);
}

void GoTransmit() { //Prelazak na predaju
	digitalWrite(_PttOut, HIGH);
	if (millis() - minimum_break_1_start >= MINIMUM_BREAK_1_LNG) max_air_time_start = millis();
}

void SoundBeep() { //'Roger beep'
	tone(_IdToneOut, 600, 100);
	delay(200);
}  

void AnswerWithID() {
	delay(1500);
	PlayMessage(MESSAGE_DE, sizeof(MESSAGE_DE));
	PlayMessage(MESSAGE_ID, sizeof(MESSAGE_ID)); //Kuca CW ID repetitora
	id_period_start = millis();
	delay(SQUELCH_TAIL_LNG); 
}

void StopRXAudio() { //Hardver 1.0. Ne menjati.
	digitalWrite(_RxAudioToTx, HIGH); 
	pinMode(_RxAudioToTx, OUTPUT);
} 

void PassRXAudio() { //Hardver 1.0. Ne menjati.
	pinMode(_RxAudioToTx, INPUT); 
	digitalWrite(_RxAudioToTx, LOW); 
} 

void EEWriteInt(int address, int value) {
	EEPROM.write(address, highByte(value));
	EEPROM.write(address + 1, lowByte(value));
}

int EEReadInt(int address) {
	int word = word(EEPROM.read(address), EEPROM.read(address + 1));
	return word;
}


ISR (TIMER1_OVF_vect) { //Traje duze oko 56us ako je COS
	if (_InPin == COS) last_isr_result = (analogRead(COS) > ADC_LIMIT);
	else last_isr_result = (digitalRead(_InPin) == SQUELCH_OPEN);

	digitalWrite(_RxSqlLed, last_isr_result);
}

byte TheVerdict() {
	byte result;
	if (_InPin == COS) result = last_isr_result;
	else result = (digitalRead(_InPin) == SQUELCH_OPEN); 
	return result;
}

void InitParametersAndList(byte starting_letter, char param_str []) {

	byte eeb;
	int eei;
	int ee_addr;
	byte sq;

	if (starting_letter >= 'A') { //Ako je ovo reset radi promene parametra
		ee_addr = (starting_letter - 'A') * 2; //Parametri su u EEPROMu od adrese 0, pocev od 'A', po dva bajta
		
		if (starting_letter == 'J') EEPROM.write(ee_addr, param_str[2] == 'D'); 
		else EEWriteInt(ee_addr, atoi(param_str));
	}

	if ((starting_letter >= '0') || digitalRead(_JumperEE)) { //Ako je povezan s DX-3 ili ako je uklonjen dzamper koristice vrednosti parametara iz EEPROMa (ako su validne).

		ee_addr = 0;//'A'
		eei = EEReadInt(ee_addr); 
		if ((eei >= 300) && (eei <= 3600)) ID_PERIOD_LNG = eei;
		else EEWriteInt(ee_addr, ID_PERIOD_LNG);
		
		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'B'
		if ((eei >= 300) && (eei <= 1800)) ID_ANSWER_LNG = eei;
		else EEWriteInt(ee_addr, ID_ANSWER_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'C'
		if ((eei >= 1) && (eei <= 300)) ID_COURTESY_LNG = eei;
		else EEWriteInt(ee_addr, ID_COURTESY_LNG);

		ee_addr +=2;	
		eei = EEReadInt(ee_addr); //'D'
		if ((eei >= 50) && (eei <= 5000)) SQUELCH_TAIL_LNG = eei;
		else EEWriteInt(ee_addr, SQUELCH_TAIL_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'E'
		if ((eei >= 60) && (eei <= 600)) MAX_AIR_TIME_LNG = eei;
		else EEWriteInt(ee_addr, MAX_AIR_TIME_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'F'
		if ((eei >= 1) && (eei <= 60)) MINIMUM_BREAK_1_LNG = eei;
		else EEWriteInt(ee_addr, MINIMUM_BREAK_1_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'G'
		if ((eei >= 60) && (eei <= 600)) COOLING_OFF_LNG = eei;
		else EEWriteInt(ee_addr, COOLING_OFF_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'H'
		if ((eei >= 2) && (eei <= 60)) MINIMUM_BREAK_2_LNG = eei;
		else EEWriteInt(ee_addr, MINIMUM_BREAK_2_LNG);

		ee_addr +=2;
		eei = EEReadInt(ee_addr); //'I'
		if ((eei >= 10) && (eei <= 300)) SQL_SENSE_MIN_LNG = eei;
		else EEWriteInt(ee_addr, SQL_SENSE_MIN_LNG);

		ee_addr +=2;
		eeb = EEPROM.read(ee_addr); //'J'
		if ((eeb == 0) || (eeb == 1)) BEEP_ENABLED = eeb;
		else EEPROM.write(ee_addr, BEEP_ENABLED);

	}

	if (starting_letter == '1') { //Ako je ovo po naredbi RESET
		Serial.println("Napajanje");
		Serial.print("DC ulaz ");
		float voltage = ((17.276 * (float(analogRead(_DCinVolts)) + 0.5)) / 1024) + 0.74; //delitelj 10k/680R, dioda M7, VREF = 1.1V
		Serial.print(voltage, 1);
		Serial.println(" V");

		Serial.print("Nano ");
		voltage = (6.4382 * (float(analogRead(_5VRailVolts)) + 0.5)) / 1024; //delitelj 3k3/680R, VREF = 1.1V
		Serial.print(voltage, 1);
		Serial.println(" V");
		Serial.println();

		if (_InPin == COS) {
			Serial.print ("A0 (COS) ");
			int a = analogRead(COS);
			voltage = (1.1 * (a + 0.5)) / 1024;
			if (a > 1020) {
				Serial.println(">= 1.10 V");	
			}
			else {
				Serial.print(voltage, 2);	
				Serial.println(" V");
			}
			sq = (a > ADC_LIMIT); //Da li je skvelc otvoren
		}
		else {
			Serial.print("D3 (SQO)  '");
			Serial.print(digitalRead(SQO));
			sq = (digitalRead(SQO) == SQUELCH_OPEN);
			Serial.println("'");
		}

		Serial.print("Skvelc ");
		if (sq) Serial.println("otvoren");
		else Serial.println("zatvoren");
		
		Serial.println();
		Serial.print("A2 (RXAudio)  '");
		Serial.print(digitalRead(_RxAudioToTx));
		Serial.println("'");
		Serial.print("#");
	}
	else {	
		//PARAMETRI za DX-3, OBAVEZNO u ovom formatu.
		//'A'...'I' - maksimalno po cetiri cifre:
		//////////////////////////////////////////
		Serial.print("A ");						//
		Serial.println(ID_PERIOD_LNG); 			//
		Serial.print("B ");	  					//
		Serial.println(ID_ANSWER_LNG); 			//
		Serial.print("C ");		 				//
		Serial.println(ID_COURTESY_LNG); 		//
		Serial.print("D ");						//
		Serial.println(SQUELCH_TAIL_LNG); 		//
		Serial.print("E ");						//
		Serial.println(MAX_AIR_TIME_LNG); 		//
		Serial.print("F ");						//
		Serial.println(MINIMUM_BREAK_1_LNG); 	//
		Serial.print("G ");						//
		Serial.println(COOLING_OFF_LNG); 		//
		Serial.print("H ");						//
		Serial.println(MINIMUM_BREAK_2_LNG); 	//
		Serial.print("I ");						//
		Serial.println(SQL_SENSE_MIN_LNG); 		//
		Serial.print("J ");						//
		Serial.print(BEEP_ENABLED); 			//
		Serial.print("#"); 			 			//
		//////////////////////////////////////////
	}

}


void PlayMessage(const char message [], size_t msg_length) {

	int character_pos; 
	char temp; 
	byte lsb;

	delay(DIT*4);

	for (character_pos = 0; character_pos < msg_length; character_pos ++) { 

		temp = message[character_pos]; //Uzimace temp, karakter po karakter

		for (int i = 0;  temp > 1 ; i++) { 
			lsb = bitRead(temp, 0); //Uzima nulti bit, tj. krajnji bit desno
			delay(DIT); //Pauza izmedju elemenata

			if (lsb) { //Ako je bit 1
				tone(_IdToneOut, FREQ, DAH); //kuca crtu
				delay(DAH); //Zato sto se tone() izvrsava asinhrono
			}

			else { //Ako je bit 0
				tone(_IdToneOut, FREQ, DIT); //kuca tacku
				delay(DIT);
			}
			
			temp = temp >> 1;  //Pomera u desno, tj. odseca krajnji bit desno
		}

		delay(DAH); //Pauza izmedju karaktera
	}

	delay(DAH);

}

/*
Kodovi Morzeovih znakova, za promenu sadrzaja poruka:

    0x06 	a
    0x11 	b
    0x15 	c
    0x09 	d
    0x02 	e
    0x14 	f
    0x0b 	g
    0x10 	h
    0x04 	i
    0x1e 	j
    0x0d 	k
    0x12 	l
    0x07 	m
    0x05 	n
    0x0f 	o
    0x16 	p
    0x1b 	q
    0x0a 	r
    0x08 	s
    0x03 	t
    0x0c 	u
    0x18 	v
    0x0e 	w
    0x19 	x
    0x1d 	y
    0x13 	z
    0x3f	0
    0x3e 	1
    0x3c 	2
    0x38 	3
    0x30 	4
    0x20 	5
    0x21 	6
    0x23 	7
    0x27 	8
    0x2f 	9
    0x29 	/
    0x68	SK
    0x2a	AR
    */

 

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir