user.c

ADS-B接收机DIY全套资料

			// AGC-offset auslesen
            case READ_OFFSET:
                dataPacket._byte[2] = agc_mode;  	// 1= agc-on   0=agc-off
                dataPacket._byte[3] = agc_offset; 	// offset in mV
                counter=0x04;
                break;



			// DC einstellen
			// ist sinnlos, falls AGC laeuft
			case SYS_PWM2:
				// [2] - lower 8 bit
				// [3] - upper 2 bit
				pwm_dutycycle =   dataPacket._byte[3];
				pwm_dutycycle <<= 8;
				pwm_dutycycle |=  dataPacket._byte[2];
				SetDCPWM2(pwm_dutycycle);  // 10 Bit
   				break;


			case SYS_ADC:
				switch (dataPacket._byte[1])
				{
					case 0:
						ADCON0 = 0x01;				// AN0, idle, enabled (Referenz)
						break;
					case 1:
						ADCON0 = 0x05;				// AN1, idle, enabled  (HF-Pegel)
						break;
				}
                counter=0x16;
				break;


			case RD_ADC:
				ADCON0bits.GO = 1;              // Start AD conversion
   				while(ADCON0bits.NOT_DONE);     // Wait for conversion
                dataPacket._byte[2] = ADRESL;
                dataPacket._byte[3] = ADRESH;
                counter=16;
				break;


			case SYS_EEPROM:
				UP_EEPROM();
   				break;

            case RESET:
                //When resetting, make sure to drop the device off the bus
                //for a period of time. Helps when the device is suspended.
                UCONbits.USBEN = 0;
                big_counter = 0;		//word = 16 Bit
                while(--big_counter);
				SleepMs(250);
				SleepMs(250);

                Reset();
                break;
                
            default:
				dataPacket._byte[0] = 0xFF;		// Error, unbekannter Befehl
				counter = 16;
                break;
        }//end switch()




		#ifdef NO_CDC		//senden mit microchip custom driver
		if(counter != 0)
		{
			if(!mUSBGenTxIsBusy())
				USBGenWrite((byte*)&dataPacket,counter);
		}
		#endif

		#ifdef CDC_ASCII		//senden mit CDC-Treiber im ASCII-code
		if(counter != 0)
		{
			if (!send_RAW) HexToAsciiParser();	//wandlung in ASCII-String
			send_RAW = false;
			if(mUSBUSARTIsTxTrfReady())
				mUSBUSARTTxRam((byte*)&input_buffer,counter);
		}
		#endif	//CDC_ASCII

		#ifdef CDC_HEX		//senden mit CDC-Treiber im HEX-Format (nonsens)
		if(counter != 0)
		{
			if(mUSBUSARTIsTxTrfReady())
				mUSBUSARTTxRam((byte*)&dataPacket,counter);
		}
		#endif	//CDC_HEX




    }	//end if wurde via USB entwas empfangen 


	// folgende Routinen werden bei jedem Schleifendurchlauf durchlaufen

	// die oberen 16 Bit der 32-Bit Zeitmarke aktualisieren
	Time._byte = TMR0L;			// triggert das lesen von TMR0H
	Time._byte = TMR0H;
	if (Time.b7 != Time2.b0) 	// wurde MSB von TMR0H veraendert?
	{
		Time2._byte++;
		if (!Time2._byte) Time3._byte++;
	}


	// alle 1,3 sec 
    if (INTCONbits.TMR0IF)
	{
		INTCONbits.TMR0IF = 0;
		// referenzpegel einstellen
		if (agc_mode) pwm_avr();
	}



	counter2 = 0;

	//DF17 = RB3 = 08		0: DF17
	//CRC  = RB2 = 04		0: DF7 & CRC
	//AGC  = RB1 = 02		0: AGC ein
	//rem  = RB0 = 01		0: switches ignorieren

	if (Switch0) 	// keine Fernsteuerung
	{
		ADSB_Mode=2;						// alles senden
		if (Switch_df17==0) ADSB_Mode=3;    // nur DF17 18 19
		if (Switch_crc ==0) ADSB_Mode=4;    // nur DF17 18 19 mit CRC
	}

	switch (ADSB_Mode)
	{
		case 1:
			adsbLoopH = 255;	// 100 = 15 ms    255 = 40 ms;
			adsbLoopL = 0;
			dataPacket._byte[2] = 2;	// fehler

			LATBbits.LATB7 = 1;			// LED an
  			if (!adsb_in())
			{
				dataPacket._byte[2] = Lang;
				for (counter=0; counter<14; counter++)   dataPacket._byte[counter+3] = adsb[counter];
				counter2 = 17;
			}
			LATBbits.LATB7 = 0;			// LED aus
			break;

		case 2:		// *...;  Format
			adsbLoopH = 255;	// 100 = 15 ms    255 = 40 ms;
			adsbLoopL = 0;
			LATBbits.LATB7 = 1;			// LED an
  			if (!adsb_in()) adsb_StringOut();
			LATBbits.LATB7 = 0;			// LED aus
			break;

		case 3:		//DF=17		*...;  Format
			adsbLoopH = 255;	// 100 = 15 ms    255 = 40 ms;
			adsbLoopL = 0;
			LATBbits.LATB7 = 1;			// LED an
  			if (!adsb_in())
			{
				if (adsb_DF() == 17) adsb_StringOut();
				if (adsb_DF() == 18) adsb_StringOut();
				if (adsb_DF() == 19) adsb_StringOut();
			}
			LATBbits.LATB7 = 0;			// LED aus
			break;

		case 4:		//DF=17		*...;  Format    CRC
			adsbLoopH = 255;	// 100 = 15 ms    255 = 40 ms;
			adsbLoopL = 0;
			LATBbits.LATB7 = 1;			// LED an
  			if (!adsb_in())
			{
				if ((adsb_DF() == 17) || (adsb_DF() == 18) || (adsb_DF() == 19))
				{
					if (adsb_CRC_OK()) adsb_StringOut();
				}
			}
			LATBbits.LATB7 = 0;			// LED aus
			break;
	}


	#ifdef CDC_ASCII		//senden mit CDC-Treiber im ASCII-code
	if(counter2 != 0)
	{
		if (send_RAW == 0) 
		{
			counter=counter2;
			HexToAsciiParser();	//wandlung in ASCII-String
			counter2=counter;
			counter=0;
			if(mUSBUSARTIsTxTrfReady())
				mUSBUSARTTxRam((byte*)&input_buffer,counter2);
		}
		else
		{
			send_RAW = 0;
			if(mUSBUSARTIsTxTrfReady())
				mUSBUSARTTxRam((byte*)&dataPacket,counter2);
		}

		LATCbits.LATC7 = 0;			// Frame_LED aus
	}
	#endif	//CDC_ASCII


}//end ServiceRequests




/** E E P R O M **************************************************************************/

// EEPROM, der interne EEPROM des PIC
// 0 - 
// 1 - 
// 2 - schreiben
// 3 - lesen
// 4 - Block schreiben
// 5 - Block lesen

// 0 - Klasse
// 1 - Befehl 2,3
// 2 - Adresse
// 3 - Daten

// 0 - Klasse
// 1 - Befehl 4,5
// 2 - Adresse
// 3 - Laenge
// 4..7 - Daten
void UP_EEPROM(void)
{
	byte	Nummer;
	word	Adresse;
	word	Ende;
	switch (dataPacket._byte[1])
	{
		case 2:
			EECON1bits.EEPGD = 0;				/* WRITE step #1 */
			EECON1bits.CFGS  = 0;
			EECON1bits.WREN = 1;				/* WRITE step #2 */
			EEADR  = dataPacket._byte[2];		/* WRITE step #3 */
			EEDATA = dataPacket._byte[3];		/* WRITE step #4 */
			EECON2 = 0x55;						/* WRITE step #5 */
			EECON2 = 0xaa;						/* WRITE step #6 */
			EECON1bits.WR = 1;					/* WRITE step #7 */
			while (!PIR2bits.EEIF);				/* WRITE step #8 */
			PIR2bits.EEIF = 0;					/* WRITE step #9 */
			break;
		case 3:
			EECON1bits.EEPGD = 0;				/* READ step #1 */
			EECON1bits.CFGS  = 0;
			EEADR = dataPacket._byte[2];		/* READ step #2 */
			EECON1bits.RD = 1;					/* READ step #3 */
			dataPacket._byte[3] = EEDATA;		/* READ step #4 */
			break;
		case 4:
			Nummer = 4;
			Ende   = dataPacket._byte[2];
			Ende  += dataPacket._byte[3];
			for (Adresse=dataPacket._byte[2]; Adresse<Ende; Adresse++)
			{
				EECON1bits.EEPGD = 0;				/* WRITE step #1 */
				EECON1bits.CFGS  = 0;
				EECON1bits.WREN = 1;				/* WRITE step #2 */
				EEADR = Adresse;					/* WRITE step #3 */
				EEDATA = dataPacket._byte[Nummer];	/* WRITE step #4 */
				EECON2 = 0x55;						/* WRITE step #5 */
				EECON2 = 0xaa;						/* WRITE step #6 */
				EECON1bits.WR = 1;					/* WRITE step #7 */
				while (!PIR2bits.EEIF);				/* WRITE step #8 */
				PIR2bits.EEIF = 0;					/* WRITE step #9 */
				Nummer+=1;
			}
			break;
		case 5:
			Nummer = 4;
			Ende   = dataPacket._byte[2];
			Ende  += dataPacket._byte[3];
			for (Adresse=dataPacket._byte[2]; Adresse<Ende; Adresse++)
			{
				EECON1bits.EEPGD = 0;				/* READ step #1 */
				EECON1bits.CFGS  = 0;
				EEADR = Adresse;					/* READ step #2 */
				EECON1bits.RD = 1;					/* READ step #3 */
				dataPacket._byte[Nummer] = EEDATA;	/* READ step #4 */
				Nummer += 1;
			}
			break;
	}
	counter = 16;
} // UP_EEPROM





/****  W A R T E S C H L E I F E N **************************************************************/

// verz鰃erungen bis max. 63 ms
// Resonator 20 MHz, CPU-Takt 48 MHz, Cycl. 12 MHz
// 1 us = 12 Zyklen
// 1 ms = 12*1000 Zyklen
// High-Teil x 3072
// Low Teil x 12
// die delay-Routinen vertragen als input nur  1..255
void SleepUs(unsigned int us)
{
	byte teilzeit;
	teilzeit = us & 0x00FF;
    if (teilzeit>0)
	{
		Delay10TCYx(teilzeit);		// 10 Zyklen ~ 1祍
	}
	teilzeit = us >> 8;			// 1/256
    if (teilzeit>0)
	{
		Delay1KTCYx(teilzeit);	// 3070 Zyklen ~258祍 ~0,25ms
		Delay1KTCYx(teilzeit);
		Delay1KTCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
		Delay10TCYx(teilzeit);
	}
} //SleepUs



// verz鰃erungen bis max. 255 ms
// Resonator 20 MHz, CPU-Takt 48 MHz, Cycl. 12 MHz
// 1 us = 12 Zyklen
// 1 ms = 12*1000 Zyklen
// 4 ms = 48x1000 Zyklen
// die delay-Routinen vertragen als input nur  1..255
void SleepMs(unsigned int ms)
{
    if (ms>0)
	{
		Delay10KTCYx(ms);
		Delay1KTCYx(ms);
		Delay1KTCYx(ms);
	}
} //SleepMs



/****  E E P R O M   F U N K T I O N E N  F U E R   S T E U E R P I C ********************/


//lesen von Daten aus dem EEPROM des Steuerpic
//0 - Befehl
//1 - Startadresse -low
//2 - Startadresse high = 0
//3 - Blockl鋘ge
void readEdata(void)
{
	byte	Nummer;
	word	Adresse;
	dataPacket._byte[0] = READ_EDATA;
	counter = 63;
	Nummer  = 4;
	for (Adresse=dataPacket._byte[1]; Adresse<dataPacket._byte[1]+dataPacket._byte[3]; Adresse++)
	{
		EECON1bits.EEPGD = 0;				/* READ step #1 */
		EEADR = Adresse;					/* READ step #2 */
		EECON1bits.RD    = 1;				/* READ step #3 */
		dataPacket._byte[Nummer] = EEDATA;	/* READ step #4 */
		Nummer += 1;
	}
}


//lesen von Daten aus dem EEPROM des Steuerpic
//0 - Befehl
//1 - Startadresse -low
//2 - Startadresse high = 0
//3 - Blockl鋘ge
//4 - 1. Datenbyte
void writeEdata(void)
{
	byte	Nummer;
	word	Adresse;
	counter = 0x01;
	dataPacket._byte[0] = WRITE_EDATA;
	Nummer = 4;
	for (Adresse=dataPacket._byte[1]; Adresse<dataPacket._byte[1]+dataPacket._byte[3]; Adresse++)
	{
		EECON1bits.EEPGD = 0;				/* WRITE step #1 */
		EECON1bits.WREN  = 1;				/* WRITE step #2 */
		EEADR = Adresse;					/* WRITE step #3 */
		EEDATA = dataPacket._byte[Nummer];	/* WRITE step #4 */
		EECON2 = 0x55;						/* WRITE step #5 */
		EECON2 = 0xaa;						/* WRITE step #6 */
		EECON1bits.WR = 1;					/* WRITE step #7 */
		while (!PIR2bits.EEIF)				/* WRITE step #8 */
			;
		PIR2bits.EEIF = 0;					/* WRITE step #9 */
		Nummer+=1;
	}
}



/****  A D C   F U N K T I O N E N  ********************************************************/

// Spannung an AN1 auslesen *************************
void ReadADC(void)
{
	ADCON0bits.GO = 1;              // Start AD conversion
   	while(ADCON0bits.NOT_DONE);     // Wait for conversion
    return;
}//end ReadADC






/** EOF user.c ***************************************************************/