void	CRenderer::SetTransform( const Base::Math::CMatrix4x4 &_transform, const eMatrixTransformType _type )
{
	switch( _type )
	{
		case	eWorld:			m_WorldMat = _transform;	break;
		case	eView:			m_ViewMat = _transform;		break;
		case	eProjection:	m_ProjMat = _transform;		break;
		default:
				g_Log->Warning( "Unknown transformation type..." );
	}

	setBit( m_bDirtyMatrices, _type );
}

unsigned char OLED::read(void)
{
	char data=0;
	clrBit(OLED_scl_port,OLED_scl_pin);
	setBit(OLED_sda_port,OLED_sda_pin);	//make sda high
	clrBit(OLED_sda_port,OLED_sda_pin);	//make sda input
	for(int i=0 ; i<8 ;i++)
	{
		//make scl high
		setBit(OLED_scl_port,OLED_scl_pin);
		_delay_us(usDelay);//delay
		if(ifHigh(OLED_sda_read,OLED_sda_pin))	//check if sda then update data
		{
			data|=0x01;
		}
		clrBit(OLED_scl_port,OLED_scl_pin);		//make scl low 
		_delay_us(usDelay);						//delay
		data=data<<1;							//left shift data
	}
	//not sending ack!!
	return data;								//return data
}

/*
 * Find (add allocate) a free data block.
 * The approach simply involves a scan of the block map for a zero.
 * It's fatal, at this point, if none is found.
 */
int allocBlock(void)
{
  int block = findNextClear(BMap, SB->sb_first_block, SB->sb_blocks);
  if (block == -1) {
    fprintf(stderr,"Could not allocate free data block (necessary).\n");
    exit(1);
  }

  /* mark it as allocated */
  setBit(BMap,block);

  return block;
}

/* Set the number of averages: 0, 4, 8, 16 or 32.
*
*/
void ADC_Module::setAveraging(uint8_t num) {

    if (calibrating) wait_for_cal();

    if (num <= 1) {
        num = 0;
        // *ADC_SC3_avge = 0;
        clearBit(ADC_SC3, ADC_SC3_AVGE_BIT);
    } else {
        // *ADC_SC3_avge = 1;
        setBit(ADC_SC3, ADC_SC3_AVGE_BIT);
        if (num <= 4) {
            num = 4;
            // *ADC_SC3_avgs0 = 0;
            // *ADC_SC3_avgs1 = 0;
            clearBit(ADC_SC3, ADC_SC3_AVGS0_BIT);
            clearBit(ADC_SC3, ADC_SC3_AVGS1_BIT);
        } else if (num <= 8) {
            num = 8;
            // *ADC_SC3_avgs0 = 1;
            // *ADC_SC3_avgs1 = 0;
            setBit(ADC_SC3, ADC_SC3_AVGS0_BIT);
            clearBit(ADC_SC3, ADC_SC3_AVGS1_BIT);
        } else if (num <= 16) {
            num = 16;
            // *ADC_SC3_avgs0 = 0;
            // *ADC_SC3_avgs1 = 1;
            clearBit(ADC_SC3, ADC_SC3_AVGS0_BIT);
            setBit(ADC_SC3, ADC_SC3_AVGS1_BIT);
        } else {
            num = 32;
            // *ADC_SC3_avgs0 = 1;
            // *ADC_SC3_avgs1 = 1;
            setBit(ADC_SC3, ADC_SC3_AVGS0_BIT);
            setBit(ADC_SC3, ADC_SC3_AVGS1_BIT);
        }
    }
    analog_num_average = num;
}

void hardware_light_enable(uint8_t level)
{
    hardware_flashlight(0);
        
    if(level > 2) 
        level = 2;
    
    DDRA &= ~0b00000111; // clear all //
    PORTA &= ~0b00000111; // clear all //
    
    setBit(level, DDRA); // Powers Sensor //
    clrBit(level, PORTA);
}

	void BitWriter::addBit(LBit input)
	{
		setBit(work_on, bitPointer, input);
		bitPointer++;
		if(bitPointer >= 8)
		{
			data->push_back(work_on);
			work_on = 0x00;
			bitPointer = 0;
			dataSize++;
		}

	}

Packet ProcessingElement::trafficShuffle()
{

    int nbits =
        (int)
        log2ceil((double)
                 (GlobalParams::mesh_dim_x *
                  GlobalParams::mesh_dim_y));
    int dnode = 0;
    for (int i = 0; i < nbits - 1; i++)
        setBit(dnode, i + 1, getBit(local_id, i));
    setBit(dnode, 0, getBit(local_id, nbits - 1));

    Packet p;
    p.src_id = local_id;
    p.dst_id = dnode;

    p.timestamp = sc_time_stamp().to_double() / GlobalParams::clock_period_ps;
    p.size = p.flit_left = getRandomSize();

    return p;
}

void digitalWrite(const PIN pin, unsigned int value) {
    unsigned long addr;
    unsigned long bitMask;

    pinToMem(pin, &addr, &bitMask);
      
    unsigned long reg = getReg(addr + GPIO_DATAOUT);
    if (value)
      reg = setBit(reg, bitMask);
    else 
      reg = clearBit(reg, bitMask);
    setReg(addr + GPIO_DATAOUT,reg);
}

Cspi::Cspi(u08 spiNum, Cpin* _pinSS, SPI_INTLVL_t _intLevel,
		SPI_PRESCALER_t _prescaler, SPI_MODE_t _mode, bool msbFirst,
		bool master, bool clk2X) {
	switch (spiNum) {
	case 0:
		base = &SPIC;
		break;
	case 1:
		base = &SPID;
		break;
	default:
		while (1) {
		}
		break;
	}
	this->pinSS = _pinSS;
	this->intLevel = _intLevel;
	this->mode = _mode;
	setGroup(base->INTCTRL, SPI_INTLVL_gm, _intLevel);
	setGroup(base->CTRL, SPI_PRESCALER_gm, _prescaler);
	setGroup(base->CTRL, SPI_MODE_gm, _mode);
	if (msbFirst) {
		clrBit(base->CTRL, SPI_DORD_bp);
	} else {
		setBit(base->CTRL, SPI_DORD_bp);
	}
	if (master) {
		setBit(base->CTRL, SPI_MASTER_bp);
	} else {
		clrBit(base->CTRL, SPI_MASTER_bp);
	}
	if (clk2X) {
		setBit(base->CTRL, SPI_CLK2X_bp);
	} else {
		clrBit(base->CTRL, SPI_CLK2X_bp);
	}
	setBit(base->CTRL, SPI_ENABLE_bp);
}

int test (void)
{
    size_t a = 0;
    for (size_t i = 0; i < 8*sizeof(a); ++i) {
        setBit(a, i, true);
        if (a != (0x01llu << i)) {
            std::cout << "error setting bit " << i << " to true " << std::endl;
        }
        printBit(a);
        a = 0;
    }
    return 0;
    a = ~0;
    for (size_t i = 0; i < 8*sizeof(a); ++i) {
        setBit(a, i, false);
        if (a != (~(0x01llu << i))) {
            std::cout << "error setting bit " << i << " to true " << std::endl;
        }
        a = ~0;
    }

    return 0;
}

/**
 * Scrubs an image of all secret messages so you can hide your tracks!
 * 
 * @param image the image to scrub
 */
void Steg::scrub(const std::string &image)
{
	std::vector<char> scrubbedBytes;
	read(scrubbedBytes, image);
	auto throwOut = getHeaderSize(scrubbedBytes);

	for (int i = throwOut; i < scrubbedBytes.size(); i++)
	{
		// set all low-order bits to 1
		setBit(scrubbedBytes.at(i), 0, 1);
	}

	write(scrubbedBytes, image);
}

        inline bool testPixel(const QPoint& pos)
        {
            if ( !_rect.contains(pos) )
                return false;

            const int idx = _rect.width() * (pos.y() - _rect.y()) + 
                (pos.x() - _rect.x());

            const bool marked = testBit(idx);
            if ( !marked )
                setBit(idx, true);

            return !marked;
        }

NoximPacket NoximProcessingElement::trafficButterfly()
{

    int nbits =
	(int)
	log2ceil((double)
		 (NoximGlobalParams::mesh_dim_x *
		  NoximGlobalParams::mesh_dim_y));
    int dnode = 0;
    for (int i = 1; i < nbits - 1; i++)
	setBit(dnode, i, getBit(local_id, i));
    setBit(dnode, 0, getBit(local_id, nbits - 1));
    setBit(dnode, nbits - 1, getBit(local_id, 0));

    NoximPacket p;
    p.src_id = local_id;
    p.dst_id = dnode;

    p.timestamp = sc_time_stamp().to_double() / 1000;
    p.size = p.flit_left = getRandomSize();

    return p;
}

void strat_init(struct strategy * strat){
	strat->flags = 0;
	strat->loaded_elts = 0;
	rand_disp_position=0;
	strat_flags=0;
	setBit(strat_flags,LINT_IS_LOADED); //we got one at the beginning...
	
	//Strat_State = STRAT_GET_ELT_ON_TABLE;
	/*everything is fucked up ... playing with emergency behaviour :'( */
	Strat_State = STRAT_EMERGENCY_BEHAVIOUR; 
	
	current_building_area = 1; //we start by building in our area...

 }

int main(){
 int x;
 bitSet bs = makeBitSet();

 printf("display test \n");
 displayBitSet(bs);
 printf("set test \n");

 setBit(&bs, 3);
 displayBitSet(bs);
 setBit(&bs, 5);
 displayBitSet(bs);

 printf("value test \n");
 x = bitValue(bs, 3);
 printf("bit value: %d \n", x);
 x = bitValue(bs, 2);
 printf("bit value: %d \n", x);
 
 printf("bit clear test \n");
 clearBit(&bs, 3);
 displayBitSet(bs);
}

NoximPacket NoximProcessingElement::trafficShuffle()
{
    int nbits = (int)log2ceil(
                              (double)(NoximGlobalParams::mesh_dim_x *
                                       NoximGlobalParams::mesh_dim_y *
                                       NoximGlobalParams::mesh_dim_z  ));
    int dnode = 0;
    for   (int i = 0; i < nbits - 1; i++)
        setBit(dnode, i + 1, getBit(local_id, i        ));
    setBit(dnode, 0    , getBit(local_id, nbits - 1));
    
    NoximPacket p;
    p.src_id = local_id;
    p.dst_id = dnode   ;
    
    p.timestamp = sc_time_stamp().to_double() / 1000;
    p.size      = p.flit_left = getRandomSize();
    
//    if (p.src_id == p.dst_id)
//        cout << "Traffic generator has generated a packet is sent from a node to itself !!! \n";

    return p;
}

/* Initialize stuff:
*  - Start Vref module
*  - Clear all fail flags
*  - Internal reference (default: external vcc)
*  - Mux between a and b channels (b channels)
*  - Calibrate with 32 averages and low speed
*  - When first calibration is done it sets:
*     - Resolution (default: 10 bits)
*     - Conversion speed and sampling time (both set to medium speed)
*     - Averaging (set to 4)
*/
void ADC_Module::analog_init() {

    // default settings:
    /*
        - 10 bits resolution
        - 4 averages
        - vcc reference
        - no interrupts
        - pga gain=1
        - conversion speed = medium
        - sampling speed = medium
    initiate to 0 (or 1) so the corresponding functions change it to the correct value
    */
    analog_res_bits = 0;
    analog_max_val = 0;
    analog_num_average = 0;
    analog_reference_internal = 2;
    var_enableInterrupts = 0;
    pga_value = 1;

    conversion_speed = 0;
    sampling_speed =  0;

    calibrating = 0;

    fail_flag = ADC_ERROR_CLEAR; // clear all errors

    num_measurements = 0;

    // select b channels
    // *ADC_CFG2_muxsel = 1;
    setBit(ADC_CFG2, ADC_CFG2_MUXSEL_BIT);

    // set reference to vcc
    setReference(ADC_REF_3V3);

    // set resolution to 10
    setResolution(10);

    // the first calibration will use 32 averages and lowest speed,
    // when this calibration is over the averages and speed will be set to default by wait_for_cal and init_calib will be cleared.
    init_calib = 1;
    setAveraging(32);
    setConversionSpeed(ADC_LOW_SPEED);
    setSamplingSpeed(ADC_LOW_SPEED);

    // begin init calibration
    calibrate();
}

//int mgetline(char s[], int lim);
int main() {
	unsigned int x;
	unsigned char p;
	int* x1;
	scanf_s("%x\n", &x);
	p = getchar();

	printf("%x\n", x);
	printf("%u\n", p);

	x1=setBit(x,p);
	printf("%x", x1);
	getchar();
	return 0;
}

void	CRenderer::Reset( const uint32 _flags )
{
	if( isBit( _flags, eShader ) )
		m_spSelectedShader = NULL;

	if( isBit( _flags, eBlend ) )
		m_spSelectedBlend = m_BlendMap[ "none" ];

	if( isBit( _flags, eTexture ) )
	{
		for( uint32 i=0; i<MAX_TEXUNIT; i++ )
			m_aspSelectedTextures[ i ] = NULL;
	}

	if( isBit( _flags, eMatrices ) )
	{
		m_WorldMat.Identity();
		m_ViewMat.Identity();
		m_ProjMat.Identity();
		setBit( m_bDirtyMatrices, eWorld );
		setBit( m_bDirtyMatrices, eView );
		setBit( m_bDirtyMatrices, eProjection );
	}
}

/*Add a single (at least 8x over-) sampling of the data and clock
lines to the circular buffer.

Note: dataVal and clockVal represent a single bit, but need not
actually be 0 or 1-- they can be 0 and 15, or 0 and 3, or whatever.
Analog signals (0,1,2, or 3) are even OK.
*/
void JRS_PCM_add_sample(JRS_PCM *p,int clockVal,int dataVal)
{
	p->data_bits[p->end]=dataVal;
	p->clk_bits[p->end]=clockVal;
	p->end++;p->len++;
	p->end&=PCM_bit_mask;

	if (p->len>16)
	{/*We have a long string of data and clock bits-- cut them back a bit*/
		int trough=clock_trough(p);
		setBit(p,extract_bit(p,trough));
		p->len=PCM_bit_mask&(p->end-trough);/*Set the new end-of-buffer to the clock trough*/
		p->prevTrough=trough;
	}
}