Ejemplo n.º 1
0
/** Check to see if Busy Flag (BF) is HIGH
/   To read BF, set RS=Low, and R/W=High. Read through DB7
**/
uint8_t LCD_get_busy_flag(void)
{
    uint8_t bf_read;

    DB_PORT->DIR &= ~(1UL << 7);        // Set the direction as input (0) for DB7
    CONTROL_PORT->DATA &= ~(1UL << 4);  // Set RS (PA4) low
    CONTROL_PORT->DATA |= (1UL << 3);   // Set R/W (PA3) High
    CONTROL_PORT->DATA |= (1UL << 2);   // Start Read

    delay_timer(READ_DELAY);
    bf_read = (DB_PORT->DATA & (1UL << 7)) >> 7;  // Read Busy Flag through DB7

    return bf_read;
}
Ejemplo n.º 2
0
void main(void)
{
	unsigned char n;


	restart_hw();				// Hardware zuruecksetzen

	for (n=0;n<50;n++) {		// Warten bis Bus stabil, nach Busspannungswiederkehr
		TR0=0;					// Timer 0 anhalten
		TH0=eeprom[ADDRTAB+1];	// Timer 0 setzen mit phys. Adr. damit Geräte unterschiedlich beginnen zu senden
		TL0=eeprom[ADDRTAB+2];
		TF0=0;					// Überlauf-Flag zurücksetzen
		TR0=1;					// Timer 0 starten
		while(!TF0);
	}
	restart_app();				// Anwendungsspezifische Einstellungen zuruecksetzen


	do  {
		if(APPLICATION_RUN) {	// nur wenn run-mode gesetzt

			state_machine(g_objno);
		}

		if(tel_arrived) process_tel();		// empfangenes Telegramm abarbeiten

		if(RTCCON>=0x80) delay_timer();		// Realtime clock Ueberlauf


		// Watchdog!
		  EA = 0;
		  // feed the watchdog
		  WFEED1 = 0xA5;
		  WFEED2 = 0x5A;
		  // restore interrupts
		  EA=1;

		// Abfrage Programmier-Taster
		TASTER=1;					// Pin als Eingang schalten um Taster abzufragen
		if(!TASTER) {				// Taster gedrückt
			for(n=0;n<100;n++) {}	// Entprell-Zeit
			while(!TASTER);			// warten bis Taster losgelassen
			status60^=0x81;			// Prog-Bit und Parity-Bit im system_state toggeln
		}
		TASTER=!(status60 & 0x01);	// LED entsprechend Prog-Bit schalten (low=LED an)
		for(n=0;n<100;n++) {}		// falls Hauptroutine keine Zeit verbraucht, der LED etwas Zeit geben, damit sie auch leuchten kann
  } while(1);
}
Ejemplo n.º 3
0
 void Gimbal_Control()
 {
	switch(g.aj4)
	{
		case 1: current_pwm+=10;
				break;
		
		case -1: current_pwm-=10;
				 break;
		
		case 0: break;	
	}
	
	hal.rcout->write(4,current_pwm);
	delay_timer(500);
 }
void main(void)
{
	unsigned char n,count,send_nibble=0,pwm0=0,pwm1=0,pwm2=0,prog_button_level=0;
	signed char cal;
	static __code signed char __at (0x1BFF) trimsave;
	__bit prog_button_toggled=0;

	restart_hw();// Hardware zuruecksetzen
#ifdef FB_DEBUG
	RS_INIT_115200
#else
	RS_INIT_9600
#endif
	TI=1;
	TASTER=0;
	cal=trimsave;
	TRIM = TRIM+trimsave;


	for (n=0;n<50;n++) {		// Warten bis Bus stabil
		TR0=0;					// Timer 0 anhalten
		TH0=eeprom[ADDRTAB+1];	// Timer 0 setzen mit phys. Adr. damit Geräte unterschiedlich beginnen zu senden
		TL0=eeprom[ADDRTAB+2];
		TF0=0;					// Überlauf-Flag zurücksetzen
		TR0=1;					// Timer 0 starten
		while(!TF0);
	}
	count=0;

	restart_app();							// Anwendungsspezifische Einstellungen zuruecksetzen
	bus_return();							// Aktionen bei Busspannungswiederkehr

	do  {
#ifdef FB_DEBUG
		DEBUGPOINT
#endif
		if(APPLICATION_RUN) {	// nur wenn run-mode gesetzt

			// Helligkeit nachführen
		if (dimmziel[count]==dimmwert[count]){
			if (helligkeit[count]!= dimmwert[count]){
				helligkeit[count]=dimmwert[count];
//				rs_send(read_obj_value(count+6));
//				rs_send(read_objflags(count+6));
				if (read_objflags(count+6)&0x40){
					send_obj_value(count+6);
				}
			}
		}
		if(count<2)count++;
		else count=0;

#ifndef FB_DEBUG
#ifdef applilpc
		if (TI){
			switch(send_nibble){
			case 0:
			pwm0=dimmpwm[0];
			RS_SEND(0x00+(pwm0<<4));
			break;
			case 1:
			RS_SEND(0x01+(pwm0 & 0xF0));
			break;
			case 2:
			pwm1=dimmpwm[1];
			RS_SEND(0x02+(pwm1<<4));
			break;
			case 3:
			RS_SEND(0x03+(pwm1 & 0xF0));
			break;
			case 4:
			pwm2=dimmpwm[2];
			RS_SEND(0x04+(pwm2<<4));
			break;
			case 5:
			RS_SEND(0x05+(pwm2& 0xF0));
			break;
			case 6:
			RS_SEND(0x06+(portbuffer & 0xF0));
			break;
			default:
				send_nibble=255;

			}// ende switch
		//RI=0;
		send_nibble++;

		} // ende if(TI)...
#endif
#endif
//		if(RI){

		//if(SBUF=='+')dimmziel[0]++;
		//if(SBUF=='-')dimmziel[0]--;
		//if(SBUF=='c')rs_send(0x55);
//		rs_send(helligkeit[SBUF]);

//		RI=0;
//		}



		if(RTCCON>=0x80) delay_timer();	// Realtime clock Ueberlauf
/*			if(TF0 && (TMOD & 0x0F)==0x01) {	// Vollstrom für Relais ausschalten und wieder PWM ein
#ifndef SPIBISTAB
				TMOD=(TMOD & 0xF0) + 2;			// Timer 0 als PWM
				TAMOD=0x01;
				TH0=DUTY;
#endif
				TF0=0;
#ifndef SPIBISTAB
				AUXR1|=0x10;	// PWM von Timer 0 auf Pin ausgeben
#endif
				PWM=1;			// PWM Pin muss auf 1 gesetzt werden, damit PWM geht !!!
#ifndef SPIBISTAB
				TR0=1;
#else
				P0=portbuffer;
#endif
			}
			if (dimmtimervorteiler>=10){//vorteiler wird alle 50µs in softpwm erhöht
				dimmtimervorteiler-=10;//
				delay_timer();
			}// ergibt eine flanke von 0.50ms

*/
			if (portchanged)port_schalten();	// Ausgänge schalten

			// portbuffer flashen, Abbruch durch ext-int wird akzeptiert und später neu probiert
			// T1-int wird solange abgeschaltet, timeout_count wird ggf. um 4ms (flashzeit) reduziert
		/*	if (fb_state==0 && portbuffer!=eeprom[PORTSAVE]) {
				ET1=0;
				START_WRITECYCLE;
				WRITE_BYTE(0x01,PORTSAVE,portbuffer);
				STOP_WRITECYCLE;
				if (timeout_count>120) timeout_count-=120; else timeout_count=0;
				ET1=1;
			}
		*/
		}// end if(runstate)
		else if (RTCCON>=0x80 && connected)	// Realtime clock ueberlauf
		{			// wenn connected den timeout für Unicast connect behandeln
		RTCCON=0x61;// RTC flag löschen
		if(connected_timeout <= 110)// 11x 520ms --> ca 6 Sekunden
			{
			connected_timeout ++;
			}
			else send_obj_value(T_DISCONNECT);// wenn timeout dann disconnect, flag und var wird in build_tel() gelöscht
		}

		n= tx_buffer[(tx_nextsend-1)&0x07];// ist die letzte objno
		if (tel_arrived || (n<6 && n>8 && tel_sent)) { //
			tel_arrived=0;
			tel_sent=0;
			process_tel();

		}

		// ### PROG Button ###

		TASTER=1;				// Pin als Eingang schalten um Taster abzufragen
		if(!TASTER){ // Taster gedrückt
			if(prog_button_level<255)	prog_button_level++;
			else{
				if(!prog_button_toggled)status60^=0x81;	// Prog-Bit und Parity-Bit im system_state toggeln
				prog_button_toggled=1;
			}
		}
		else {
			if(prog_button_level>0)prog_button_level--;
			else prog_button_toggled=0;
		}
		TASTER=!(status60 & 0x01);	// LED entsprechend Prog-Bit schalten (low=LED an)



		for(n=0;n<100;n++) {}	// falls Hauptroutine keine Zeit verbraucht, der LED etwas Zeit geben, damit sie auch leuchten kann


	} while(1);
}
Ejemplo n.º 5
0
void main(void)
{ 
	unsigned char n,cmd,tasterpegel=0;
	signed char cal;
	static __code signed char __at 0x1BFF trimsave;
#ifdef zeroswitch
	static __code unsigned char __at 0x1BFE phisave;
#endif
	static __code unsigned char __at 0x1BFD blockedsave;
	unsigned char rm_count=0;
	__bit wduf,tastergetoggelt=0;
	wduf=WDCON&0x02;
	restart_hw();							// Hardware zuruecksetzen
// im folgendem wird der watchdof underflow abgefragt und mit gedrücktem Progtaster
// ein resetten der cal Variable veranlasst um wieder per rs232 trimmen zu können.	
	TASTER=1;
	if(!TASTER && wduf)cal=0;
	else cal=trimsave;
	TRIM = (TRIM+trimsave);
	TRIM &= 0x3F;//oberen 2 bits ausblenden
#ifdef zeroswitch
	if(phisave<=36)	phival=phisave;
	else phival=0;
#endif
	if (!wduf){// BUS return verzögerung nur wenn nicht watchdog underflow
		for (n=0;n<50;n++) {		// Warten bis Bus stabil
			TR0=0;					// Timer 0 anhalten
			TH0=eeprom[ADDRTAB+1];	// Timer 0 setzen mit phys. Adr. damit Geräte unterschiedlich beginnen zu senden
			TL0=eeprom[ADDRTAB+2];
			TF0=0;					// Überlauf-Flag zurücksetzen
			TR0=1;					// Timer 0 starten
			while(!TF0);
		}
	}
	WATCHDOG_INIT
	WATCHDOG_START
	restart_app();							// Anwendungsspezifische Einstellungen zuruecksetzen
	if(!wduf)bus_return();							// Aktionen bei Busspannungswiederkehr
	//...rs_init...(6);im folgenden direkt:
	BRGCON&=0xFE;	// Baudrate Generator stoppen
	P1M1&=0xFC;		// RX und TX auf bidirectional setzen
	P1M2&=0xFC;
	SCON=0x50;		// Mode 1, receive enable
	SSTAT|=0xE0;	// TI wird am Ende des Stopbits gesetzt und Interrupt nur bei RX und double TX buffer an
	BRGCON|=0x02;	// Baudrate Generator verwenden aber noch gestoppt
	BRGR1=0x00;	// Baudrate = cclk/((BRGR1,BRGR0)+16)
	BRGR0=0x30;	// für 115200 0030 nehmen, autocal: 600bd= 0x2FF0
	BRGCON|=0x01;	// Baudrate Generator starten
	SBUF=0x55;
	do  {
		WATCHDOG_FEED
		//hand =((eeprom[0xE5]& 0xC0)>0);
		if(APPLICATION_RUN) {	// nur wenn run-mode gesetzt
/*			if (eeprom[0xE5]& 0xC0){
				if (((delay_toggle & 0x07)==0x07))handsteuerung();   // Handbetätigung nur jedes 8.mal ausführen
			}
*/			if(RTCCON>=0x80) delay_timer();	// Realtime clock Ueberlauf
#ifndef zeroswitch
			if(TF0 && (TMOD & 0x0F)==0x01) {	// Vollstrom für Relais ausschalten und wieder PWM ein
	#ifndef SPIBISTAB
				TMOD=(TMOD & 0xF0) + 2;			// Timer 0 als PWM
				TAMOD=0x01;
				TH0=DUTY;
	#endif				
				TF0=0;
	#ifndef SPIBISTAB
				AUXR1|=0x10;	// PWM von Timer 0 auf Pin ausgeben
	#endif
				PWM=1;			// PWM Pin muss auf 1 gesetzt werden, damit PWM geht !!!
	#ifndef SPIBISTAB
				TR0=1;
	#else
				P0=portbuffer;
	#endif
			}
#endif
			
			if (portchanged)port_schalten();	// Ausgänge schalten

/*			// Rückmeldungen senden
			if(rm_send) {	// wenn nichts zu senden ist keine Zeit vertrödeln
				if(rm_send & (1<<rm_count)) {
					if(send_obj_value(rm_count + 12)) {	// falls erfolgreich, dann nächste
						rm_send&=(0xFF-(1<<rm_count));
						rm_count++;
#ifdef MAX_PORTS_8
						rm_count&=0x07;
#else
						rm_count&=0x03;
#endif						
					}
				}
				else {	// RM sollte nicht gesendet werden
					rm_count++;
#ifdef MAX_PORTS_8
						rm_count&=0x07;
#else
						rm_count&=0x03;
#endif						
				}
			}
			else rm_count=0;	// Immer mal wieder auf Null setzen, damit Reihenfolge von 1 bis 8 geht
*/

			// portbuffer flashen, Abbruch durch ext-int wird akzeptiert und später neu probiert
			// T1-int wird solange abgeschaltet, 
		if (fb_state==0 && (TH1<0XC0) && (!wait_for_ack)&& blocked!=blockedsave) {
			START_WRITECYCLE;
			FMADRH= 0x1B;		
			FMADRL= 0xFD; 
			FMDATA= blocked;
			STOP_WRITECYCLE;
		}

		
		}// end if(runstate...
		
		// Telegrammverarbeitung..
		if (tel_arrived ) {//|| tel_sent
			tel_arrived=0;
			tel_sent=0;
			process_tel();
		}
		else {
			for(n=0;n<100;n++);	// falls Hauptroutine keine Zeit verbraucht, der PROG LED etwas Zeit geben, damit sie auch leuchten kann
		}

BREAKPOINT
cmd;
		// Eingehendes Terminal Kommando verarbeiten...
/*		if (RI){
			RI=0;
			cmd=SBUF;
			if(cmd=='c'){
				while(!TI);
				TI=0;
				SBUF=0x55;
			}
			if(cmd=='+'){
				TRIM--;
				cal--;
			}
			if(cmd=='-'){
				TRIM++;
				cal++;
			}
			if(cmd=='w'){
				EA=0;
				START_WRITECYCLE;	//cal an 0x1bff schreiben
#ifdef zeroswitch
				FMADRH= 0x1B;		
				FMADRL= 0xFE; 
				FMDATA= phival;
#else
				FMADRH= 0x1B;		
				FMADRL= 0xFF; 
#endif
				FMDATA=	cal;
				STOP_WRITECYCLE;
				EA=1;				//int wieder freigeben
			}
			if(cmd=='p')status60^=0x81;	// Prog-Bit und Parity-Bit im system_state toggeln
#ifdef zeroswitch
			if(cmd=='<'){
				if (phival){
					phival--;
					TI=0;
					SBUF=phival;
				}
			}	
			if(cmd=='>'){
				if(phival<35){
					phival++;	// 
					TI=0;
					SBUF=phival;
				}
			}
#endif			
			if(cmd=='v'){
				while(!TI);
				TI=0;
				SBUF=VERSION;
			}
			if(cmd=='t'){
				while(!TI);
				TI=0;
				SBUF=TYPE;
			}

		}//end if(RI...
*/		
		TASTER=1;				// Pin als Eingang schalten um Taster abzufragen
		if(!TASTER){ // Taster gedrückt
			if(tasterpegel<255)	tasterpegel++;
			else{
				if(!tastergetoggelt)status60^=0x81;	// Prog-Bit und Parity-Bit im system_state toggeln
				tastergetoggelt=1;
			}
		}
		else {
			if(tasterpegel>0) tasterpegel--;
			else tastergetoggelt=0;
		}
		TASTER=!(status60 & 0x01);	// LED entsprechend Prog-Bit schalten (low=LED an)
  } while(1);
}
Ejemplo n.º 6
0
void main(void)
{ 
	unsigned char n,cmd,tasterpegel=0;
	signed char cal;
	static __code signed char __at 0x1CFF trimsave;  unsigned int base;
	unsigned char pin=0;
#ifdef zykls
	unsigned char tmp,objno,objstate;
#else
	#ifdef zaehler
	unsigned char objno;
	#endif
#endif
	__bit wduf,tastergetoggelt=0;
	wduf=WDCON&0x02;
	TASTER=1;
	if(!TASTER && wduf)cal=0;
	else cal=trimsave;
	TRIM = (TRIM+trimsave);
	TRIM &= 0x3F;//oberen 2 bits ausblenden

	restart_hw();				// Hardware zurücksetzen

 //   rs_init(6);				// serielle Schnittstelle initialisieren
	BRGCON&=0xFE;	// Baudrate Generator stoppen
	P1M1&=0xFC;		// RX und TX auf bidirectional setzen
	P1M2&=0xFC;
	SCON=0x50;		// Mode 1, receive enable
	SSTAT|=0xE0;	// TI wird am Ende des Stopbits gesetzt und Interrupt nur bei RX und double TX buffer an
	BRGCON|=0x02;	// Baudrate Generator verwenden aber noch gestoppt
	BRGR1=0x2F;	// Baudrate = cclk/((BRGR1,BRGR0)+16)
	BRGR0=0xF0;	// für 115200 0030 nehmen, autocal: 600bd= 0x2FF0
	BRGCON|=0x01;	// Baudrate Generator starten
	SBUF=0x55;


  


  restart_app();			// Anwendungsspezifische Einstellungen zurücksetzen

#ifndef IN8_2TE
  portbuffer=P0;			// zunächst keine Änderungen bei Busspannungswiederkehr
  p0h=portbuffer;
#else
  portbuffer=spi_in_out();
  p0h=portbuffer;
#endif
  if(!wduf){
  // Verzögerung Busspannungswiederkehr	
	  for(base=0;base<=(eeprom[0xD4]<<(eeprom[0xFE]>>4)) ;base++){//faktor startverz hohlen und um basis nach links schieben
	//	  start_rtc(130);		// rtc auf 130ms
			RTCCON=0x60;		// RTC anhalten und Flag löschen
			RTCH=0x1D;			// reload Real Time Clock für 65ms
			RTCL=0x40;
			RTCCON=0x61;		// RTC starten
		    while (RTCCON<=0x7F) ;	// Realtime clock ueberlauf abwarten
		    // feed the watchdog
		    EA = 0;
		    WFEED1 = 0xA5;
		    WFEED2 = 0x5A;
		    EA=1;

		    //	  stop_rtc;
	  }
  }
  watchdog_init();
  watchdog_start();

  if(!wduf)bus_return();			// Anwendungsspezifische Einstellungen zurücksetzen

  TASTER=1;
  do  {
//		watchdog_feed();
	    // feed the watchdog
	    EA = 0;
	    WFEED1 = 0xA5;
	    WFEED2 = 0x5A;
	    EA=1;


if(APPLICATION_RUN){	  
#ifndef IN8_2TE
	  p0h=P0;				// prüfen ob ein Eingang sich geändert hat
#else
	  p0h=spi_in_out();
#endif
	    if (p0h!=portbuffer) 
	    {
	      for(n=0;n<8;n++)					// jeden Eingangspin einzel prüfen
	      {
	        //if ((((p0h>>n)&0x01) != ((portbuffer>>n)&0x01))&& !(blocked>>n)&0x01)
	    	  //if ((p0h & bitmask_1[n])!= (portbuffer & bitmask_1[n])&& !(blocked & bitmask_1[n]) )
	    	if (((p0h^portbuffer) & bitmask_1[n])&& !(blocked & bitmask_1[n]) )//kürzeste Version
	        {
	          pin_changed(n);				// Änderung verarbeiten
	        }
	      }
	      portbuffer=p0h;					// neuen Portzustand in buffer speichern
	    }
	      
	      
	      
		if (RTCCON>=0x80){
			delay_timer();	// Realtime clock ueberlauf
		}
	        	 
#ifdef zykls
		for(objno=0;objno<=7;objno++){	
	    	tmp=(eeprom[0xD5+(objno*4)]&0x0C);//0xD5/ bit 2-3 zykl senden aktiv 
    		objstate=read_obj_value(objno);
	    	if (((eeprom[0xCE+(objno>>1)] >> ((objno & 0x01)*4)) & 0x0F)==1){// bei Funktion=Schalten
	    		if ((tmp==0x04 && objstate==1)||(tmp==0x08 && objstate==0)|| tmp==0x0C){//bei zykl senden aktiviert
					n=timercnt[objno];
					if ((n & 0x7F) ==0){ 		//    wenn aus oder abgelaufen
						timercnt[objno] = (eeprom[0xD6+(objno*4)]& 0x3F)+ 0x80 ;//0xD6 Faktor Zyklisch senden x.1 + x.2 )+ einschalten
						timerbase[objno]=(eeprom[0xF6+((objno+1)>>1)]>>(4*((objno&0x01)^0x01)))&0x07;	//Basis zyklisch senden
						if (n & 0x80){// wenn timer ein war
							send_obj_value(objno);		// Eingang x.1 zyklisch senden
						}
					}
				}
				else timercnt[objno]=0;
	  		}
		}
Ejemplo n.º 7
0
//const unsigned char __at 0x1CFF PORTSAVE;
void main(void)
{ 
	unsigned char timer_precounter=0;

	unsigned char n,tasterpegel=0,pin=2;
	unsigned int base;
	unsigned char rm_count=0;
#ifdef zykls
	unsigned char objno,tmp,objstate;
#endif
	__bit wduf;
	__bit tastergetoggelt=0;
	__bit bus_activ=0;

	wduf=WDCON&0x02;
	restart_hw();							// Hardware zuruecksetzen
	TASTER=0;
	TR0=1;
	restart_app();							// Anwendungsspezifische Einstellungen zuruecksetzen
	if(!wduf){
	  // Verzögerung Busspannungswiederkehr	
		  for(base=0;base<=(eeprom[0xD4]<<(eeprom[0xFE]>>4)) ;base++){//faktor startverz hohlen und um basis nach links schieben
		//	  start_rtc(130);		// rtc auf 130ms
				RTCCON=0x60;		// RTC anhalten und Flag löschen
				RTCH=0x1D;			// reload Real Time Clock für 65ms
				RTCL=0x40;
				RTCCON=0x61;		// RTC starten
			    while (RTCCON<=0x7F) ;	// Realtime clock ueberlauf abwarten
			    // feed the watchdog
			    EA = 0;
			    WFEED1 = 0xA5;
			    WFEED2 = 0x5A;
			    EA=1;

			    //	  stop_rtc;
		  }
	  }

	WATCHDOG_INIT
	WATCHDOG_START

#ifndef debugmode
	RS_INIT_600
#else
	RS_INIT_115200
#endif
	SBUF=0x55;

// ################## main loop #########################	

	do  {
		WATCHDOG_FEED

	if(APPLICATION_RUN) {	// nur wenn run-mode gesetzt


	  p0h=P0 & 0x0C;				// prüfen ob ein Eingang sich geändert hat

	  if(!bus_return_ready)
	  {
		  portbuffer=p0h;
	  	  if(!wduf)bus_return();			// Anwendungsspezifische Einstellungen zurücksetzen
	  	  bus_return_ready=1;
	  }
	  if (p0h!=portbuffer) 
	    {	

		  if (((p0h^portbuffer) & bitmask_1[pin])&& !(in_blocked & bitmask_1[pin]) )//kürzeste Version
	        {
	          pin_changed(pin);				// Änderung verarbeiten
	        }
	      portbuffer|=(p0h& bitmask_1[pin]);					// neuen Portzustand in buffer speichern
	      portbuffer&=(p0h| ~bitmask_1[pin]);					// neuen Portzustand in buffer speichern
	     // if(pin==3)pin=2;// maximal 2-3
	   //   else pin=3;	// nächsten pin prüfen..
	      pin^=0x01;// pin ist mit 2 initialisiert somit wird zwischen 2 und 3 hin und hergeschalten
	    }
			if(RTCCON>=0x80){
				RTCCON=0x60;		// RTC Flag löschen
				RTCH=0x0E;			//0E reload Real Time Clock
				RTCL=0xA0;			//A0 16ms +precounter x4
				RTCCON=0x61;		// RTC  Flag löschen
				delay_timer();	// timer handler jedes 4. mal--> 64ms
			}
			if(TF0 && (TMOD & 0x0F)==0x01) {	// Vollstrom für Relais ausschalten und wieder PWM ein
				TMOD=(TMOD & 0xF0) + 2;			// Timer 0 als PWM
				TAMOD=0x01;
				TH0=DUTY;
				TF0=0;
				AUXR1|=0x10;	// PWM von Timer 0 auf Pin ausgeben
				PWM=1;			// PWM Pin muss auf 1 gesetzt werden, damit PWM geht !!!
				TR0=1;
			}

		
			
			if (portchanged)port_schalten();	// Ausgänge schalten

			// Rückmeldungen senden
			if(rm_send&0x03) {	// wenn nichts zu senden ist keine Zeit vertrödeln
				if(rm_send & (1<<rm_count)) {
					if(send_obj_value(rm_count + 16)) {	// falls erfolgreich, dann nächste
						rm_send&=(0xFF-(1<<rm_count));
						rm_count^=0x01;
					}
				}
				else {	// RM sollte nicht gesendet werden
					rm_count^=0x01;
				}
			}
			else rm_count=0;


			// portbuffer flashen, Abbruch durch ext-int wird akzeptiert und später neu probiert
			// T1-int wird solange abgeschaltet, 

			if (fb_state==0 && (TH1<0XC0) && (!wait_for_ack)&& portbuffer!=PORTSAVE) {
				START_WRITECYCLE;
				WRITE_BYTE(0x00,0xFF,portbuffer);
				STOP_WRITECYCLE;
			}
			
#ifdef zykls
		for(objno=2;objno<=3;objno++){	
	    	tmp=(eeprom[0xD5+(objno*4)]&0x0C);//0xD5/ bit 2-3 zykl senden aktiv 
    		objstate=read_obj_value(objno);
    		if (((eeprom[0xCE+(objno>>1)] >> ((objno & 0x01)*4)) & 0x0F)==1){// bei Funktion=Schalten
	    		if ((tmp==0x04 && objstate==1)||(tmp==0x08 && objstate==0)|| tmp==0x0C){//bei zykl senden aktiviert
					n=timercnt[objno];
					if ((n & 0x7F) ==0){ 		//    wenn aus oder abgelaufen
						timercnt[objno] = (eeprom[0xD6+(objno*4)]& 0x3F)+ 0x80 ;//0xD6 Faktor Zyklisch senden x.1 + x.2 )+ einschalten
						timerbase[objno]=(eeprom[0xF6+((objno+1)>>1)]>>(4*((objno&0x01)^0x01)))&0x07;	//Basis zyklisch senden
						if (n & 0x80){// wenn timer ein war
							if(!(in_blocked & bitmask_1[objno]))
							{
							while(!send_obj_value(objno));//send_obj_value(objno);		// Eingang x.1 zyklisch senden
							}
						}
					}
				}
				else timercnt[objno]=0;
	  		}
		}
void main(void)
{ 
	unsigned char n,count,cmd,tasterpegel=0;
	signed char cal;
	static __code signed char __at 0x1BFF trimsave;
	__bit tastergetoggelt=0;
	restart_hw();							// Hardware zuruecksetzen

	cal=trimsave;
	TRIM = TRIM+trimsave;
	//...rs_init...(6);im folgenden direkt:
	BRGCON&=0xFE;	// Baudrate Generator stoppen
	P1M1&=0xFC;		// RX und TX auf bidirectional setzen
	P1M2&=0xFC;
	SCON=0x50;		// Mode 1, receive enable
	SSTAT|=0xE0;	// TI wird am Ende des Stopbits gesetzt und Interrupt nur bei RX und double TX buffer an
	BRGCON|=0x02;	// Baudrate Generator verwenden aber noch gestoppt
	BRGR1=0x2f;	// Baudrate = cclk/((BRGR1,BRGR0)+16)
	BRGR0=0xf0;	// für 115200 0030 nehmen, autocal: 600bd= 0x2FF0
	BRGCON|=0x01;	// Baudrate Generator starten
	SBUF=0x55;

	TASTER=0;
	for (n=0;n<50;n++) {		// Warten bis Bus stabil
		TR0=0;					// Timer 0 anhalten
		TH0=eeprom[ADDRTAB+1];	// Timer 0 setzen mit phys. Adr. damit Geräte unterschiedlich beginnen zu senden
		TL0=eeprom[ADDRTAB+2];
		TF0=0;					// Überlauf-Flag zurücksetzen
		TR0=1;					// Timer 0 starten
		while(!TF0);
	}
	count=0;

	restart_app();							// Anwendungsspezifische Einstellungen zuruecksetzen
	bus_return();							// Aktionen bei Busspannungswiederkehr

	do  {
		if(APPLICATION_RUN) {	// nur wenn run-mode gesetzt

			// Helligkeit nachführen
		if (dimmziel[count]==dimmwert[count]){
			if (helligkeit[count]!= dimmwert[count]){
				helligkeit[count]=dimmwert[count];
//				rs_send(read_obj_value(count+6));
//				rs_send(read_objflags(count+6));
				if (read_objflags(count+6)&0x40)send_obj_value(count+6);
			}
		}
		if(count<2)count++;
		else count=0;
		
		
		
		if (RI){
			RI=0;
			cmd=SBUF;
			if(cmd=='c'){
				while(!TI);
				TI=0;
				SBUF=0x55;
			}
			if(cmd=='+'){
				TRIM--;
				cal--;
			}
			if(cmd=='-'){
				TRIM++;
				cal++;
			}
			if(cmd=='w'){
				EA=0;
				START_WRITECYCLE;	//cal an 0x1bff schreiben
#ifdef zeroswitch
				FMADRH= 0x1B;		
				FMADRL= 0xFE; 
				FMDATA= phival;
#else
				FMADRH= 0x1B;		
				FMADRL= 0xFF; 
#endif
				FMDATA=	cal;
				STOP_WRITECYCLE;
				EA=1;				//int wieder freigeben
			}
			if(cmd=='p')status60^=0x81;	// Prog-Bit und Parity-Bit im system_state toggeln
			if(cmd=='v'){
				while(!TI);
				TI=0;
				SBUF=VERSION;
			}
			if(cmd=='t'){
				while(!TI);
				TI=0;
				SBUF=TYPE;
			}

		}//end if(RI...


		
		//if(RTCCON>=0x80) delay_timer();	// Realtime clock Ueberlauf
/*			if(TF0 && (TMOD & 0x0F)==0x01) {	// Vollstrom für Relais ausschalten und wieder PWM ein
#ifndef SPIBISTAB
				TMOD=(TMOD & 0xF0) + 2;			// Timer 0 als PWM
				TAMOD=0x01;
				TH0=DUTY;
#endif				
				TF0=0;
#ifndef SPIBISTAB
				AUXR1|=0x10;	// PWM von Timer 0 auf Pin ausgeben
#endif
				PWM=1;			// PWM Pin muss auf 1 gesetzt werden, damit PWM geht !!!
#ifndef SPIBISTAB
				TR0=1;
#else
				P0=portbuffer;
#endif				
			}
*/
			if (dimmtimervorteiler>=10){//vorteiler wird alle 50µs in softpwm erhöht
				dimmtimervorteiler-=10;//
				delay_timer();
			}// ergibt eine flanke von 0.50ms

			
			if (portchanged)port_schalten();	// Ausgänge schalten

			// portbuffer flashen, Abbruch durch ext-int wird akzeptiert und später neu probiert
			// T1-int wird solange abgeschaltet, timeout_count wird ggf. um 4ms (flashzeit) reduziert
		/*	if (fb_state==0 && portbuffer!=eeprom[PORTSAVE]) {
				ET1=0;
				START_WRITECYCLE;
				WRITE_BYTE(0x01,PORTSAVE,portbuffer);
				STOP_WRITECYCLE;
				if (timeout_count>120) timeout_count-=120; else timeout_count=0;
				ET1=1;
			}
		*/
		}// end if(runstate)
		else if (RTCCON>=0x80 && connected)	// Realtime clock ueberlauf
			{			// wenn connected den timeout für Unicast connect behandeln
			RTCCON=0x61;// RTC flag löschen
			if(connected_timeout <= 110)// 11x 520ms --> ca 6 Sekunden
				{
				connected_timeout ++;
				}
				else send_obj_value(T_DISCONNECT);// wenn timeout dann disconnect, flag und var wird in build_tel() gelöscht
			}
		
		n= tx_buffer[(tx_nextsend-1)&0x07];// ist die letzte objno
		if (tel_arrived || (n<6 && n>8 && tel_sent)) { // 
			tel_arrived=0;
			tel_sent=0;
			process_tel();
			
		}
    	

		TASTER=1;				// Pin als Eingang schalten um Taster abzufragen
		if(!TASTER){ // Taster gedrückt
			if(tasterpegel<255)	tasterpegel++;
			else{
				if(!tastergetoggelt)status60^=0x81;	// Prog-Bit und Parity-Bit im system_state toggeln
				tastergetoggelt=1;
			}
		}
		else {
			if(tasterpegel>0) tasterpegel--;
			else tastergetoggelt=0;
		}
		TASTER=!(status60 & 0x01);	// LED entsprechend Prog-Bit schalten (low=LED an)
		
		

//		for(n=0;n<100;n++) {}	// falls Hauptroutine keine Zeit verbraucht, der LED etwas Zeit geben, damit sie auch leuchten kann
//		if (status60&0x01)ET0=0;
//		else ET0=1;
	} while(1);
}