user.c

ADS-B接收机DIY全套资料

                dataPacket._byte[3] = MAJOR_VERSION; // Hardware-Version
                counter=0x04;
                break;













			//**********************************************************************//
			// IO, ADC, FRQin, I2C, SPI, LCD, TMR1-3, PWM1, PWM2, RS232, EEPROM, KEY, LED



			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)
		{
			HexToAsciiParser();	//wandlung in ASCII-String
			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

	//ASM_Test();
	adsb_in();
    
	adsb[0] = 0;
	adsb[1] = 1;
	ASM_Test();


}//end ServiceRequests





/*************

0 - System/Interface
1 - 0=aus/1=init/2=write/3=read/...
2 - daten
3 - daten
4 - daten
5 - daten
6 - daten
7 - daten

**************/








/** 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 *************************
// sollte mit CCP1 synchronisiert werden
void ReadADC(void)
{
	ADCON0bits.GO = 1;              // Start AD conversion
   	while(ADCON0bits.NOT_DONE);     // Wait for conversion
    return;
}//end ReadADC






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