自学教程：C++ CLEARBIT函数代码示例

void ckps_init_state_variables(void){ _BEGIN_ATOMIC_BLOCK(); hall.stroke_period = 0xFFFF; hall.advance_angle = HALL_ADVANCE; //=0 CLEARBIT(flags, F_STROKE); CLEARBIT(flags, F_VHTPER); CLEARBIT(flags, F_HALLEV); CLEARBIT(flags, F_SPSIGN); SETBIT(flags2, F_SHUTTER); SETBIT(flags2, F_SHUTTER_S); SETBIT(flags, F_IGNIEN); TCCR0 = 0; //timer is stopped (останавливаем таймер0) MCUCR|=_BV(ISC11); //falling edge for INT1 MCUCR|=_BV(ISC10); TIMSK|=_BV(TOIE1);                   //enable Timer 1 overflow interrupt. Used for correct calculation of very low RPM hall.t1oc = 0;                       //reset overflow counter hall.t1oc_s = 255;                   //RPM is very low#ifdef STROBOSCOPE hall.strobe = 0;#endif hall.knkwnd_mode = 0; _END_ATOMIC_BLOCK();}

void Button_SingleInit(sButtonPinPort buttonPinPort){#ifdef __AVR__#if defined (__AVR_ATmega16__)	if(buttonPinPort.port == &PINA)	{		CLEARBIT(DDRA, buttonPinPort.pin);		SETBIT(PORTA, buttonPinPort.pin);	}#else   if(0)   {   }#endif	else if(buttonPinPort.port == &PINB)	{		CLEARBIT(DDRB, buttonPinPort.pin);		SETBIT(PORTB, buttonPinPort.pin);	}	else if(buttonPinPort.port == &PINC)	{		CLEARBIT(DDRC, buttonPinPort.pin);		SETBIT(PORTC, buttonPinPort.pin);	}	else if(buttonPinPort.port == &PIND)	{		CLEARBIT(DDRD, buttonPinPort.pin);		SETBIT(PORTD, buttonPinPort.pin);	}#endif	}

void ckps_init_state(void){ _BEGIN_ATOMIC_BLOCK(); if ((IOCFG_CB(IOP_CKPS) == (fnptr_t)iocfg_g_ckps) || (IOCFG_CB(IOP_CKPS) == (fnptr_t)iocfg_g_ckpsi)) {  CLEARBIT(flags2, F_SELEDGE); //falling edge  hall.ckps_inpalt = 1; //not remapped } else  hall.ckps_inpalt = 0; //CKPS mapped on other input ckps_init_state_variables(); CLEARBIT(flags, F_ERROR); //Compare channels do not connected to lines of ports (normal port mode) //(Каналы Compare не подключены к линиям портов (нормальный режим портов)) TCCR1A = 0; TCCR1B = _BV(CS11)|_BV(CS10);  //Tune timer 1 (clock = 312.5 kHz) TCCR0B = _BV(CS01)|_BV(CS00);  //Tune timer 0 (clock = 312.5 kHz) if (hall.ckps_inpalt)  TIMSK1|=_BV(ICIE1);    //enable input capture interrupt only if CKPS is not remapped _END_ATOMIC_BLOCK();}

void ckps_init_state_variables(void){ _BEGIN_ATOMIC_BLOCK(); hall.stroke_period = 0xFFFF; hall.advance_angle = hall.shutter_wnd_width; //=0 CLEARBIT(flags, F_STROKE); CLEARBIT(flags, F_VHTPER); CLEARBIT(flags, F_HALLEV); CLEARBIT(flags, F_SPSIGN); SETBIT(flags, F_IGNIEN); SETBIT(flags2, F_SHUTTER); SETBIT(flags2, F_SHUTTER_S); TIMSK1|=_BV(TOIE1);                  //enable Timer 1 overflow interrupt. Used for correct calculation of very low RPM hall.t1oc = 0;                       //reset overflow counter hall.t1oc_s = 255;                   //RPM is very low#ifdef STROBOSCOPE hall.strobe = 0;#endif hall.knkwnd_mode = 0;#ifdef DWELL_CONTROL hall.cr_acc_time = 0;#endif#ifdef FUEL_INJECT hall.cur_chan = 0;#endif _END_ATOMIC_BLOCK();}

void touch_init(){//uint8_t chan){    //set up the I/O pins E1, E2, E3 to be output pins    CLEARBIT(TRISEbits.TRISE1); //I/O pin set to output    CLEARBIT(TRISEbits.TRISE2); //I/O pin set to output    CLEARBIT(TRISEbits.TRISE3); //I/O pin set to output    // ADC init    //disable ADC    CLEARBIT(AD1CON1bits.ADON);    //initialize PIN    SETBIT(TRISBbits.TRISB15); //set TRISE RB15 to input    SETBIT(TRISBbits.TRISB9); //set TRISE RB9 to input    SETBIT(AD1PCFGLbits.PCFG15); // RB15 analog ADC1CH15    SETBIT(AD1PCFGLbits.PCFG9); // RB9 analog ADC1CH9    //Configure ADxCON1    SETBIT(AD1CON1bits.AD12B); //set 12b Operation Mode    AD1CON1bits.FORM = 0; //set integer output    AD1CON1bits.SSRC = 0x7; //set automatic conversion    //Configure ADxCON2    AD1CON2 = 0; //not using scanning sampling    //Configure ADxCON3    CLEARBIT(AD1CON3bits.ADRC); //internal clock source    AD1CON3bits.SAMC = 0x1F; //sample-to-conversion clock = 31Tad    AD1CON3bits.ADCS = 0x2; //Tad = 3Tcy (Time cycles)    //Leave ADxCON4 at its default value    //enable ADC    SETBIT(AD1CON1bits.ADON);}

/** * set a single port to Output or Input - function requrired for wiringPi interface * @param pin - port relative to pinBase * @param newMode - 0 - Output; 1 - Input * @return new value of complete port */int Max7312::configPort(int pin, bool newMode){   if (isLowerPort(pin)) {      if(newMode)      {         SETBIT(_port1_mode, (GET_LOWER_PIN_ID(pin)));      }      else      {         CLEARBIT(_port1_mode, (GET_LOWER_PIN_ID(pin)));      }      configPort1(_port1_mode);      return _port1_mode;   } else {      if(newMode)      {         SETBIT(_port2_mode, (GET_HIGHER_PIN_ID(pin)));      }      else      {         CLEARBIT(_port2_mode, (GET_HIGHER_PIN_ID(pin)));      }      configPort2(_port2_mode);      return _port2_mode;   }}

void touch_select_dim(uint8_t dim){    /*    if (dim == 1){ // x        //set up the I/O pins E1, E2, E3 so that the touchscreen X-coordinate pin        //connects to the ADC        CLEARBIT(PORTEbits.RE1);        SETBIT(PORTEbits.RE2);        SETBIT(PORTEbits.RE3);    }else if (dim == 2){ // y        SETBIT(PORTEbits.RE1);        CLEARBIT(PORTEbits.RE2);        CLEARBIT(PORTEbits.RE3);    } else{        SETBIT(PORTEbits.RE1);        SETBIT(PORTEbits.RE2);        CLEARBIT(PORTEbits.RE3);    }    */    if (dim == 1){ // x        //set up the I/O pins E1, E2, E3 so that the touchscreen X-coordinate pin        //connects to the ADC        CLEARBIT(LATEbits.LATE1);        SETBIT(LATEbits.LATE2);        SETBIT(LATEbits.LATE3);    }else if (dim == 2){ // y        SETBIT(LATEbits.LATE1);        CLEARBIT(LATEbits.LATE2);        CLEARBIT(LATEbits.LATE3);    } else{        SETBIT(LATEbits.LATE1);        SETBIT(LATEbits.LATE2);        CLEARBIT(LATEbits.LATE3);    }}

static void key(byte mode) /*!  @brief     Keys the transmitter and produces a sidetone  .. but only if the corresponding functions (TXKEY and SIDETONE) have been set in the feature register. This function also handles a request to invert the keyer line if necessary (TXINV bit).  This is a private function. @param mode    UP or DOWN  */{	    if (mode == DOWN)     {        if (volflags & SIDETONE) // Are we generating a Sidetone?        {            OCR0A = ctcvalue;		// Then switch on the Sidetone generator            OCR0B = ctcvalue;                        // Activate CTC mode            TCCR0A |= (1<<COM0B0 | 1<<WGM01);                        // Configure prescaler            TCCR0B = 1<<CS01;        }                if (volflags & TXKEY) // Are we keying the TX?        {            if (yackflags & TXINV) // Do we need to invert keying?                CLEARBIT(OUTPORT,OUTPIN);            else                SETBIT(OUTPORT,OUTPIN);        }    }        if (mode == UP)     {        if (volflags & SIDETONE) // Sidetone active?        {            TCCR0A = 0;            TCCR0B = 0;        }                if (volflags & TXKEY) // Are we keying the TX?        {            if (yackflags & TXINV) // Do we need to invert keying?                SETBIT(OUTPORT,OUTPIN);            else                CLEARBIT(OUTPORT,OUTPIN);        }    }    }

void timedAlarmCheck(void){	for (uint8_t alarm=1; alarm<=4; alarm++)	{		uint16_t pos = 400 + ((alarm-1)*15); //400 415 430 445		if (eepromReadByte(pos+0) == 1)		{				uint8_t sensorpos = findSensor(				eepromReadByte(pos+1),				eepromReadByte(pos+2),				eepromReadByte(pos+3),				eepromReadByte(pos+4),				eepromReadByte(pos+5),				eepromReadByte(pos+6),				eepromReadByte(pos+7),				eepromReadByte(pos+8));				int8_t value = (int8_t)sensorValues[(sensorpos*SENSORSIZE)+VALUE1];				char sign = sensorValues[(sensorpos*SENSORSIZE)+SIGN];				if (sign == '-') value *= -1;				int8_t target = eepromReadByteSigned(pos+10);				if (					(eepromReadByte(pos+9) == 1 && value < target)					||					(eepromReadByte(pos+9) == 2 && value == target)					||					(eepromReadByte(pos+9) == 3 && value > target)				)				{					//ALARM					//DDR=in/out PIN=value/pullup PORT=state					uint8_t pin = eepromReadByte(pos+11);					if (pin >= 1 && pin <= 4)					{						if (eepromReadByte(pos+12) == 1)						{							SETBIT(PORTC, (1+pin));						}						else							CLEARBIT(PORTC, (1+pin));					} 				} else if (eepromReadByte(pos+13) == 1) { 					//REVERSE					uint8_t pin = eepromReadByte(pos+11);					if (pin >= 1 && pin <= 4)					{						if (eepromReadByte(pos+12) == 1)							CLEARBIT(PORTC, (1+pin));						else							SETBIT(PORTC, (1+pin));					} 				}		}	}}

void main(){	//Init LCD	__C30_UART=1;		lcd_initialize();	lcd_clear();        touch_init();        CLEARBIT(T1CONbits.TON); // Disable Timer        CLEARBIT(T1CONbits.TCS); // Select internal instruction cycle clock        CLEARBIT(T1CONbits.TGATE); // Disable Gated Timer mode        TMR1 = 0x00; // Clear timer register        T1CONbits.TCKPS = 0b10; // Select 1:64 Prescaler        PR1 = 2000; // Load the period value        IPC0bits.T1IP = 0x01; // Set Timer1 Interrupt Priority Level        CLEARBIT(IFS0bits.T1IF); // Clear Timer1 Interrupt Flag        SETBIT(IEC0bits.T1IE); // Enable Timer1 interrupt        while(1) {            int i = 0;                                    touch_select_dim(0);            lock = 1;            TMR1 = 0x00;            SETBIT(T1CONbits.TON); // Start Timer            while(lock);                        for (i = 0; i < 5; i++) {                xs[i] = touch_adc();            }            // read y            touch_select_dim(1);            lock = 1;            TMR1 = 0x00;            SETBIT(T1CONbits.TON); // Start Timer            while(lock);            for (i = 0; i < 5; i++) {                ys[i] = touch_adc();            }                        qsort(xs, 5, sizeof(uint16_t), cmpfunc);            qsort(ys, 5, sizeof(uint16_t), cmpfunc);            lcd_locate(0,0);            lcd_printf("x position:             ");            lcd_locate(0,0);            lcd_printf("x position: %d", xs[2]);            lcd_locate(0,1);            lcd_printf("y position:             ");            lcd_locate(0,1);            lcd_printf("y position: %d", ys[2]);        }}

void lcd_spi_transmit_CMD(unsigned char temp){   CLEARBIT(PORTB,RS);   CLEARBIT(PORTB,SS_bar);   SPDR = temp;   while(!TESTBIT(SPSR,SPIF));   SPSR &= 0x7F;   SETBIT(PORTB, SS_bar); }

/*! * /brief   sends a chunk of data and does not block * /param   thisport = which port to use * /param	data = pointer to data to send * /param	length = number of bytes to send * /return	SSP_TX_BUFOVERRUN = tried to send too much data * /return	SSP_TX_WAITING = data sent and waiting for an ack to arrive * /return	SSP_TX_BUSY = a packet has already been sent, but not yet acked * * /note * */int16_t qssp::ssp_SendData(const uint8_t *data, const uint16_t length ){    int16_t value = SSP_TX_WAITING;    if( (length + 2) > thisport->txBufSize ) {        // TRYING to send too much data.        value = SSP_TX_BUFOVERRUN;    } else if( thisport->SendState == SSP_IDLE ) {#ifdef ACTIVE_SYNCH        if( thisport->sendSynch == TRUE )  {            sf_SendSynchPacket();        }#endif#ifdef SYNCH_SEND        if( length == 0 ) {            // TODO this method could allow a task/user to start a synchronisation step if a zero is mistakenly passed to this function.            //      could add a check for a NULL data pointer, or use some sort of static flag that can only be accessed by a static function            //      that must be called before calling this function.            // we are attempting to send a synch packet            thisport->txSeqNo = 0;                        // make this zero to cause the other end to re-synch with us            SETBIT(thisport->flags, SENT_SYNCH);        } else {            // we are sending a data packet            CLEARBIT( thisport->txSeqNo, ACK_BIT );     // make sure we are not sending a ACK packet            thisport->txSeqNo++;                        // update the sequence number.            if( thisport->txSeqNo > 0x7F) {             // check for sequence number rollover                thisport->txSeqNo = 1;                  // if we do have rollover then reset to 1 not zero,                // zero is reserviced for synchronization requests            }        }#else        CLEARBIT( thisport->txSeqNo, ACK_BIT );     // make sure we are not sending a ACK packet        thisport->txSeqNo++;                        // update the sequence number.        if( thisport->txSeqNo > 0x7F) {             // check for sequence number rollover            thisport->txSeqNo = 1;                  // if we do have rollover then reset to 1 not zero,            // zero is reserved for synchronization requests        }#endif        CLEARBIT( thisport->flags, ACK_RECEIVED);        thisport->SendState = SSP_AWAITING_ACK;        value = SSP_TX_WAITING;        thisport->retryCount = 0;				// zero out the retry counter for this transmission        sf_MakePacket( thisport->txBuf, data, length, thisport->txSeqNo );        sf_SendPacket( );				// punch out the packet to the serial port        sf_SetSendTimeout(  );	// do the timeout values         if (debug)             qDebug()<<"Sent DATA PACKET:"<<thisport->txSeqNo;    } else {        // error we are already sending a packet. Need to wait for the current packet to be acked or timeout.        value = SSP_TX_BUSY;         if (debug)             qDebug()<<"Error sending TX was busy";    }    return value;}

void led_init(void){  LEDDIR |= _BV(LEDBIT);  CLEARBIT(PINSEL1, 28);  CLEARBIT(PINSEL1, 29);  led_off();}

/*;********************************* NAME:       lcd_spi_transmit_DATA ASSUMES:    temp = byte to transmit to LCD.             SPI port is configured. RETURNS:    nothing MODIFIES:   temp, SPCR CALLED BY:  init_dsp, update DESCRITION: outputs a byte passed in r16 via SPI port. Waits for             data to be written by spi port before continuing. ***************************************************************** */  void lcd_spi_transmit_DATA(unsigned char data){    PORTB = (1 << RS);    CLEARBIT(PORTB, SS_bar);    CLEARBIT(SPSR, SPIF);    SPDR = data;    while(!TESTBIT(SPSR,SPIF));    SPSR &= 0x7F;    SETBIT(PORTB, SS_bar);  }

//intializevoid initialize(void){    size_t i;    //bit-array set to one    for (i = 0; i < size; i++ ){        SETBIT(threadstack, i);    }    CLEARBIT(threadstack, 0);    CLEARBIT(threadstack, 1);    //http://www.mathcs.emory.edu/~cheung/Courses/255/Syllabus/1-C-intro/bit-array.html    }

void kbd_scan(void){	uint8_t	kbd_value;	uint8_t	key_id;	kbd_value = KBD_PORT;	for (key_id = 0; key_id < 8; key_id++)	{		if (TESTBIT(kbd_value_1, key_id) && 			TESTBIT(kbd_value_2, key_id) &&			!TESTBIT(kbd_value, key_id))						CLEARBIT(kbd_value_1, key_id);					else if (!TESTBIT(kbd_value_1, key_id) && //key pressed			TESTBIT(kbd_value_2, key_id) &&			!TESTBIT(kbd_value, key_id))		{			CLEARBIT(kbd_value_2, key_id);		}		else if (!TESTBIT(kbd_value_1, key_id) && 			TESTBIT(kbd_value_2, key_id) &&			TESTBIT(kbd_value, key_id))			 			SETBIT(kbd_value_1, key_id);					else if (!TESTBIT(kbd_value_1, key_id) && 			!TESTBIT(kbd_value_2, key_id) &&			TESTBIT(kbd_value, key_id))			 			SETBIT(kbd_value_1, key_id);					else if (TESTBIT(kbd_value_1, key_id) && 			!TESTBIT(kbd_value_2, key_id) &&			!TESTBIT(kbd_value, key_id))			 			CLEARBIT(kbd_value_1, key_id);		else if (TESTBIT(kbd_value_1, key_id) && // key released			!TESTBIT(kbd_value_2, key_id) &&			TESTBIT(kbd_value, key_id))		{	 			SETBIT(kbd_value_2, key_id);						SETBIT(key_pressed, key_id);		}		else if (!TESTBIT(kbd_value_1, key_id) && // key still pressed			!TESTBIT(kbd_value_2, key_id) &&			!TESTBIT(kbd_value, key_id))		{	 		}	}}

void tlc5940_init(void){	//enable clocks to GPIO block	LPC_SYSCON->SYSAHBCLKCTRL |= (1UL <<  6);	INIT_GPIO(SCLK_PORT, SCLK);	INIT_GPIO(XLAT_PORT, XLAT);	INIT_GPIO(SIN_PORT, SIN);	//INIT_GPIO(GSCLK_PORT, GSCLK);	//INIT_GPIO(DCPRG_PORT, DCPRG);	//INIT_GPIO(VPRG_PORT, VPRG);	INIT_GPIO(BLANK_PORT, BLANK);	CLEARBIT(SCLK_PORT, SCLK);	CLEARBIT(XLAT_PORT, XLAT);	CLEARBIT(SIN_PORT, SIN); 	//CLEARBIT(GSCLK_PORT, GSCLK); 	//CLEARBIT(DCPRG_PORT, DCPRG);	//SETBIT(VPRG_PORT, VPRG);	SETBIT(BLANK_PORT, BLANK);	/* Init IOCON - Nothing works without this... */	LPC_SYSCON->SYSAHBCLKCTRL |= (1 <<  16);	/* TMR16B1 -- GSCLK Generator */	//	LPC_SYSCON->SYSAHBCLKCTRL |=  (1<<8);             	// Enable Clock for TMR1//	LPC_IOCON->PIO1_9 |= (1<<0);//	LPC_TMR16B1->MR0 = 118;					//Fire Interrupt each .02 second (20 ms or 50 Hz)//	LPC_TMR16B1->PR = 1;							  	//	LPC_TMR16B1->EMR |= (3<<4);							//Toggle on MR0//	LPC_TMR16B1->MCR |= (1<<1);							//Reset on MR0	  //  	LPC_TMR16B1->TCR |= (1<<0);                        	// GO		/* TMR16B0 -- Interrupt timer */		LPC_SYSCON->SYSAHBCLKCTRL |=  (1<<7);             	// Enable Clock for TMR0	//LPC_IOCON->PIO1_9 |= (1<<0);	LPC_TMR16B0->MR2 = 20000;							//Fire Interrupt each .02 second (20 ms or 50 Hz)	LPC_TMR16B0->PR = 48;							  		LPC_TMR16B0->MCR |= (1<<6);							//Interrupt on MR2	LPC_TMR16B0->MCR |= (1<<7);							//Reset on MR2	NVIC_EnableIRQ(TIMER_16_0_IRQn);         			//enable interrupt 	    	LPC_TMR16B0->TCR |= (1<<0);                        	// GO		/* GS CLK */	LPC_SYSCON->CLKOUTDIV = 59;	LPC_SYSCON->CLKOUTCLKSEL = 0;	LPC_SYSCON->CLKOUTUEN = 0;	LPC_SYSCON->CLKOUTUEN = 1;	LPC_IOCON->PIO0_1 |= (1<<0);}

void	shift_init(void){	SETBIT(SHIFT_OUT_DDR, SHIFT_OUT_BIT);	SETBIT(SHIFT_CLK_DDR, SHIFT_CLK_BIT);	SETBIT(SHIFT_LATCH_DDR, SHIFT_LATCH_BIT);	CLEARBIT(SHIFT_OUT_PORT, SHIFT_OUT_BIT);	CLEARBIT(SHIFT_CLK_PORT, SHIFT_CLK_BIT);	CLEARBIT(SHIFT_LATCH_PORT, SHIFT_LATCH_BIT);	controls[0] = 0x00;	controls[1] = 0x00;	old_controls[0] = 0xFF;	old_controls[1] = 0xFF;	}

void TIMER16_0_IRQHandler(void){	//Make sure interrupt flag is set -- not sure if needed	if(LPC_TMR16B0->IR & (1<<2))	{		uint8_t first_cycle = 0;		uint8_t data_count = 0;		uint16_t tmp;									LPC_IOCON->PIO0_1 &= ~(1<<0);		SETBIT(BLANK_PORT, BLANK);//		if(CHECKBIT(VPRG_PORT, VPRG))//		{//			CLEARBIT(VPRG_PORT, VPRG);//			first_cycle = 1;//		}		if(xlat_pulse)		{			PULSE(XLAT_PORT, XLAT);			xlat_pulse = 0;		}		if(first_cycle)			PULSE(SCLK_PORT, SCLK);			CLEARBIT(BLANK_PORT, BLANK);		LPC_IOCON->PIO0_1 |= (1<<0);		while(1)		{		 	if(data_count < NUM_TLC5940 * NUM_SIN_BITS)			{				tmp = pwm[data_count/12];				tmp &= BV(11 - (data_count%12));			 	if(tmp)				//if(gsdata[data_count])					SETBIT(SIN_PORT, SIN);				else					CLEARBIT(SIN_PORT, SIN);				PULSE(SCLK_PORT, SCLK);				data_count++;			}else{				xlat_pulse = 1;				break;			}		}		LPC_TMR16B0->IR |= (1<<2);	}}

short SqAtakd (short sq, short side)/************************************************************************** * *  To determine if sq is attacked by any pieces from side. * **************************************************************************/{   register BitBoard *a, b, *c, d, blocker;   int t;      a = board.b[side];   /* Knights */   if (a[knight] & MoveArray[knight][sq])      return (true);   /* Kings */   if (a[king] & MoveArray[king][sq])      return (true);   /* Pawns */   if (a[pawn] & MoveArray[ptype[1^side]][sq])      return (true);         c = FromToRay[sq];   blocker = board.blocker;   /* Bishops & Queen */   b = (a[bishop] | a[queen]) & MoveArray[bishop][sq];   d = ~b & blocker;    while (b)   {      t = leadz (b);      if (!(c[t] & d))         return (true);      CLEARBIT (b, t);    }   /* Rooks & Queen */   b = (a[rook] | a[queen]) & MoveArray[rook][sq];   d = ~b & blocker;   while (b)   {      t = leadz (b);      if (!(c[t] & d))         return (true);      CLEARBIT (b, t);    }   return (false);}

// Configure the real-time task timer and its interrupt.void timers_initialize() {  //Set Timer1 to generate an interrupt every 10ms (100Hz) ==> PR1=500  CLEARBIT(T1CONbits.TON); //Disable Timer  CLEARBIT(T1CONbits.TCS); //Select internal instruction cycle clock  CLEARBIT(T1CONbits.TGATE); //Disable Gated Timer mode  T1CONbits.TCKPS = 0b11; //Select 1:256 Prescaler  PR1 = 500; //Load the period value ==> running at 100Hz now!  TMR1 = 0x00; //Clear timer register  IPC0bits.T1IP = 0x01; // Set Timer1 Interrupt Priority Level  CLEARBIT(IFS0bits.T1IF); // Clear Timer1 Interrupt Flag  SETBIT(IEC0bits.T1IE); // Enable Timer1 interrupt  SETBIT(T1CONbits.TON); // Start Timer}

void touch_select_dim(uint8_t dim) {    if (dim == 0) {        // x dim        CLEARBIT(LATEbits.LATE1);        SETBIT(LATEbits.LATE2);        SETBIT(LATEbits.LATE3);        AD1CHS0bits.CH0SA = 0xF;    } else {        // ydim        SETBIT(LATEbits.LATE1);        CLEARBIT(LATEbits.LATE2);        CLEARBIT(LATEbits.LATE3);        AD1CHS0bits.CH0SA = 0x9;    }}

void uart2_init(uint16_t baud){	// ==== Stop UART port	CLEARBIT(U2MODEbits.UARTEN); //Disable UART for configuration	// Disable Interrupts	IEC1bits.U2RXIE = 0;	IEC1bits.U2TXIE = 0;	// Clear Interrupt flag bits	IFS1bits.U2RXIF = 0;	IFS1bits.U2TXIF = 0;	// Set IO pins	TRISFbits.TRISF4 = 1; //set as input UART2 RX pin	TRISFbits.TRISF5 = 0; //set as output UART2 TX pin	// baud rate	// use the following equation to compute the proper	// setting for a specific baud rate	U2MODEbits.BRGH = 0; //Set low speed baud rate	U2BRG = (uint32_t)800000 / baud -1; //Set the baudrate to be at 9600	// Operation settings and start port	U2MODE = 0; // 8-bit, no parity and, 1 stop bit	U2MODEbits.RTSMD = 0; //select simplex mode	U2MODEbits.UEN = 0; //select simplex mode	U2MODE |= 0x00;	U2MODEbits.UARTEN = 1; //enable UART        //uint8_t c = 0;        //while(U2STAbits.URXDA)        //    c = U2RXREG & 0x00FF;	U2STA = 0;	U2STAbits.UTXEN = 1; //enable UART TX        //U2STAbits.URXEN = 1; //enable UART RX}

uint8_t *WriteToNrf(uint8_t ReadWrite, uint8_t reg, uint8_t *val, uint8_t antVal){	//ReadWrite --> "R" or "W", reg --> 'register', *val --> array with package, antVal --> number of int in array	if(ReadWrite == W)//If it is in READMODE, then addr is already 0x00	{		reg = W_REGISTER + reg;	}	static uint8_t ret[32];	//Array to be returned in the end		_delay_us(10);						//Delay for 10us	CLEARBIT(PORTB,CSNPin);				//Set CSN Low - nRf starts listening for commands 10us after CSN Low	_delay_us(12);						//Delay for 12us	WriteReadByteSPI(reg);				//"reg" --> Set nRf to write or read mode	_delay_us(10);		for(int i = 0; i<antVal; i++)	{		if(ReadWrite == R && reg != W_TX_PAYLOAD)		{			//READ A REGISTRY			ret[i] = WriteReadByteSPI(NOP);		//Send dummy Byte to read data			_delay_us(10);		}		else		{			//Write to nRF			WriteReadByteSPI(val[i]);			//Send command one at a time			_delay_us(10);		}	}	SETBIT(PORTB,CSNPin);		//nRf into IDLE with CSN HIGH	return ret;					//Return the data read}

/*! * /brief   Runs the send process, checks for receipt of ack, timeouts and resends if needed. * /param   thisport = which port to use * /return  SSP_TX_WAITING - waiting for a valid ACK to arrive * /return  SSP_TX_TIMEOUT - failed to receive a valid ACK in the timeout period, after retrying. * /return  SSP_TX_IDLE    - not expecting a ACK packet (no current transmissions in progress) * /return  SSP_TX_ACKED   - valid ACK received before timeout period. * * /note * */int16_t qssp::ssp_SendProcess( ){    int16_t value = SSP_TX_WAITING;    if (thisport->SendState == SSP_AWAITING_ACK ) {        if (sf_CheckTimeout() == TRUE) {            if (thisport->retryCount < thisport->maxRetryCount) {                // Try again                sf_SendPacket();                sf_SetSendTimeout();                value = SSP_TX_WAITING;            } else {                // Give up, # of trys has exceded the limit                value = SSP_TX_TIMEOUT;                CLEARBIT( thisport->flags, ACK_RECEIVED);                thisport->SendState = SSP_IDLE;                if (debug)                  qDebug()<<"Send TimeOut!";            }        } else {            value = SSP_TX_WAITING;        }    } else if( thisport->SendState == SSP_ACKED ) {        SETBIT( thisport->flags, ACK_RECEIVED);        value = SSP_TX_ACKED;        thisport->SendState = SSP_IDLE;    } else {        thisport->SendState = SSP_IDLE;        value = SSP_TX_IDLE;    }    return value;}

char amdEraseSector(char sector){	// to erase device you must execute the erase command sequence	// DQ7 is data polling and DQ6 is toggle status bits.	//refer to the table on page 9 to erase all sectors	// Erase operation will take approx 8 seconds to run its 1 second per sector	//65535bits 	struct AMD_Settings *Point_AMD = &Data;	uint32_t sector_erase=0; 		AMD_DATA_DDR |= ALL_PORT_MASK;	SETBIT(AMD_CTRL_PORT_WE, AMD_WE);	AMD_CTRL_PORT_CEOE |= (1 << AMD_OE) & ~(1 << AMD_CE);	CLEARBIT(AMD_CTRL_PORT_CEOE, AMD_CE);	// SEND THE 5 Unlock commands 		AMD_Send_Command(AMD_DATA_MASK_AA, AMD_ADDR_MASK_555);	AMD_Send_Command(AMD_DATA_MASK_55, AMD_ADDR_MASK_2AA);	AMD_Send_Command(AMD_DATA_MASK_80, AMD_ADDR_MASK_555);	AMD_Send_Command(AMD_DATA_MASK_AA, AMD_ADDR_MASK_555);	AMD_Send_Command(AMD_DATA_MASK_55, AMD_ADDR_MASK_2AA);		// Erase specific sectors 	sector_erase = sector; 	sector_erase <<= 16; 		AMD_Send_Command(AMD_DATA_MASK_30, sector_erase );	_delay_ms(2);		return;}

void ckps_init_state(void){ _BEGIN_ATOMIC_BLOCK(); ckps_init_state_variables(); CLEARBIT(flags, F_ERROR); MCUCR|=_BV(ISC11); //falling edge for INT1 MCUCR|=_BV(ISC10); //set flag indicating that Hall sensor input is available WRITEBIT(flags, F_HALLSIA, IOCFG_CHECK(IOP_PS)); GICR|=  CHECKBIT(flags, F_HALLSIA) ? _BV(INT1) : 0; //INT1 enabled only when Hall sensor input is available //Compare channels do not connected to lines of ports (normal port mode) //(Каналы Compare не подключены к линиям портов (нормальный режим портов)) TCCR1A = 0; //Tune timer 1 (clock = 250kHz) TCCR1B = _BV(CS11)|_BV(CS10); //enable overflow interrupt of timer 0 //(разрешаем прерывание по переполнению таймера 0) TIMSK|= _BV(TOIE0); _END_ATOMIC_BLOCK();}

//seive function this takes only one argument because the create function allows only one parameter.void *eratosthenes(void *threadnum){    size_t i;    size_t min;    size_t max;    size_t offset = 0;    size_t ops = (long int)threadnum;    long long z;            for (i = 0; i < (ops+1); i++){        max = offset + sieve[i];        min = offset + 1;        offset += sieve[i];        if (sqrt(size) < max){            max = sqrt(size);        }    }        //http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes    for(i = min; i < (max+1); i++){        if(TESTBIT(threadstack, i)){            //z = i^2            // all values that are mulitles of z should be marked            for (z = i * i; z < size; z += i){                if(TESTBIT(threadstack, z)){                    CLEARBIT(threadstack, z);                }            }        }    }    return 0;}

int main(void){uint8_t p=0;uint8_t value;DDRB |= (1<<DDB0); //ledSETBIT(PORTB,0);NRF_Init();NRF_Config();INT0_init();NRF_Start_RX();sei();while(1){if(p++%2){CLEARBIT(PORTB, 0);}else{ SETBIT(PORTB, 0);}_delay_ms(1000);	value=NRF_Read_Register_Value(STATUS);}	return 0;}

int32_t serdes777_rwbits(int32_t rwflag,void *ptr,int32_t len,HUFF *hp){    int32_t i,bit;    if ( rwflag == 0 )    {        for (i=0; i<len; i++)        {            if ( (bit= hgetbit(hp)) < 0 )                return(-1);            if ( bit != 0 )                SETBIT(ptr,i);            else CLEARBIT(ptr,i);        }        //printf("rbits.%d (%02x)/n",len,*(uint8_t *)ptr);    }    else    {        //printf("wbits.%d (%02x)/n",len,*(uint8_t *)ptr);        for (i=0; i<len; i++)            if ( hputbit(hp,GETBIT(ptr,i) != 0) < 0 )                return(-100*i-100);    }    //printf("rwbits len.%d (%02x)/n",len,*(uint8_t *)dest);    //printf("(%d) ",*(uint8_t *)ptr);    return(len);}