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);
  }

//intialize
void 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);
}