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

/* * Reads MAC address if available or uses fixed one */void macaddr_init(u8 *mac_addr){	u8 buffer[6];	u8 fixed_mac[6] = {0x00, 0x03, 0x7F, 0x09, 0x0B, 0xAD};#if defined(OFFSET_MAC_ADDRESS)	memcpy(buffer, (void *)(CFG_FLASH_BASE		+ OFFSET_MAC_DATA_BLOCK + OFFSET_MAC_ADDRESS), 6);	/*	 * Check first LSBit (I/G bit) and second LSBit (U/L bit) in MSByte of vendor part	 * both of them should be 0:	 * I/G bit == 0 -> Individual MAC address (unicast address)	 * U/L bit == 0 -> Burned-In-Address (BIA) MAC address	 */	if (CHECK_BIT((buffer[0] & 0xFF), 0) != 0 ||	    CHECK_BIT((buffer[0] & 0xFF), 1) != 0) {		memcpy(buffer, fixed_mac, 6);		mac_is_not_valid = 1;	}#else	memcpy(buffer, fixed_mac, 6);	mac_is_not_valid = 1;#endif	memcpy(mac_addr, buffer, 6);}

void SoundPlayer_SendCommand(SoundPlayer *sp, uint16_t command) {	int8_t bit;		CLEAR_BIT(sp->port, sp->clockPin);		Util_WaitMicros(1000);		if(CHECK_BIT(command, 15))		SET_BIT(sp->port, sp->dataPin);	else		CLEAR_BIT(sp->port, sp->dataPin);		Util_WaitMicros(1000);		SET_BIT(sp->port, sp->clockPin);		for(bit = 14; bit >= 0; bit--) {		Util_WaitMicros(200);				CLEAR_BIT(sp->port, sp->clockPin);				if(CHECK_BIT(command, bit))			SET_BIT(sp->port, sp->dataPin);		else			CLEAR_BIT(sp->port, sp->dataPin);				Util_WaitMicros(200);				SET_BIT(sp->port, sp->clockPin);	}}

int main(int argc, char* argv[]){    //unlock the system level control register    volatile void *devcfg_ctrl = getvaddr(0xF8007000);    volatile void *semdev = getvaddr(0x42C00000);//    printf("/t/tInitial: 0x%x/n", *((volatile unsigned *)(semdev)+0));     *((volatile unsigned *)devcfg_ctrl) = *((volatile unsigned *)devcfg_ctrl) & ~PCAP_PR;    *((volatile unsigned *)(semdev)+4) = 1; //set icap_grant to 1    while(!CHECK_BIT(*((volatile unsigned *)(semdev)+0), 2)){ } //Wait till we are in the observation state     //    printf("/t/tObservation: 0x%x/n", *((volatile unsigned *)(semdev)+0));     //Attempting to enter idle state    *((volatile unsigned*)(semdev)+3) = 224;    *((volatile unsigned*)(semdev)+1) = 1;    *((volatile unsigned*)(semdev)+1) = 0;    while(CHECK_BIT(*((volatile unsigned *)(semdev)+0), 1) || CHECK_BIT(*((volatile unsigned *)(semdev)+0), 2) || CHECK_BIT(*((volatile unsigned *)(semdev)+0), 3) || CHECK_BIT(*((volatile unsigned *)(semdev)+0), 4) || CHECK_BIT(*((volatile unsigned *)(semdev)+0), 5)){} //Wait till we are in the Idle state.    //while(CHECK_BIT(*((volatile unsigned *)(semdev)+0), 2)){ }  //    printf("/t/tEntering Idle State: 0x%x/n", *((volatile unsigned *)(semdev)+0));     //    printf("SEM Core Initialisation completed, and ready for injection./n");    return 0;}

unsigned int memtest(multiboot_info_t* mbd, unsigned int magic){	magic = (int) magic;	terminal_writestring(MULTIBOOT_TEST);	if (CHECK_BIT(mbd->flags, 0))	{		vgatestok();		terminal_writestring(MEMORY_MAP_TEST);				if (CHECK_BIT(mbd->flags, 6))		{			vgatestok();			terminal_printf("/nLower memory : %d KB/n", mbd->mem_lower);			terminal_printf("Upper memory : %d KB/n/n", mbd->mem_upper);		}		else		{			vgatestko();			return (1);		}		return (0);	}	vgatestko();	return (1);}

int fpidinlock (int pid,int ldes){		struct	pentry	*pptr;		int bit_s;		int r=0;		//unsigned long ctime;		pptr=&proctab[pid];#ifdef DEBUGD		kprintf("/nInside find function ldes=%d, pid=%d, lheld50=%d/n",ldes,pid,pptr->lheld50);#endif		if (ldes-100>31)		{			bit_s=ldes-132;			if (r=CHECK_BIT(pptr->lheld50,bit_s))				CLEAR(pptr->lheld50,bit_s);			return (r);		}		else		{			bit_s=ldes-100;			if  (r=CHECK_BIT(pptr->lheld32,bit_s))					CLEAR(pptr->lheld32,bit_s);			return(r);		}		//should not come here		return 0;}

static WORD initdata(){	union 	{		WORD tempvar;		struct 		{			BYTE LoByte;			BYTE HiByte;		} bytes;	} TWOBYTES;	BYTE programflags;	XEEBeginRead(sizeof(AppConfig)+ 49000); //This is a cheat, needs to fix memory map properly!	programflags = XEERead();			//ONLY autorun program on first execution	if (initflag == 0)	{		initflag=1;		runprogram = CHECK_BIT(programflags,0);			debugoutput = CHECK_BIT(programflags,1);	}	TWOBYTES.bytes.HiByte = XEERead();	TWOBYTES.bytes.LoByte = XEERead();	return(TWOBYTES.tempvar);}

LOCAL voidrotary_intr_handler(int8_t key){    uint8 direction = 0;    uint32 inputs;        inputs = PIN_IN; //Read input register    //Read rotary state    if (CHECK_BIT(inputs,13) == CHECK_BIT(inputs,12))        direction = 1;    //Not that sure what this does yet and where the register is used for    uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);    //disable interrupt    gpio_pin_intr_state_set(GPIO_ID_PIN(12), GPIO_PIN_INTR_DISABLE);    //clear interrupt status    GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(12));    //Disarm timer    os_timer_disarm(&rotary_debounce_timer);    //Setup timer    os_timer_setfn(&rotary_debounce_timer, (os_timer_func_t *)rotary_debounce, direction);    //Arm the debounce timer    os_timer_arm(&rotary_debounce_timer, 350, 0);}

void lcdWriteBits(__s8 bits, __u8 char_mode){	mcpOutput(pin_rs, char_mode);	bool z;	int i;	for(i=7; i>=4; i--)	{		z = CHECK_BIT(bits,i);		if(z)			mcpOutput(pin_db[i-4], 1);		else			mcpOutput(pin_db[i-4], 0);	}	lcdPulseEnable();		for(i=3; i>=0; i--)	{		z = CHECK_BIT(bits,i);		if(z)			mcpOutput(pin_db[i], 1);		else			mcpOutput(pin_db[i], 0);	}	lcdPulseEnable();}

int main(void) {  char x = 0x0F, i;  for (i = 0; i < 8; i++) {    printf("%d : %d/n", i, CHECK_BIT(x, i) > 0);    if (!CHECK_BIT(x, i)) SET_BIT(x, i);    else UNSET_BIT(x, i);  }  printf("x: %x/n", x);}

void CLogoState::Update(float fDT){    m_fDT = fDT;    m_fStateTimer += fDT;    m_pGUI->Update(fDT);    if (CHECK_BIT(m_nPhaseCheck, 2) == TRUE)    {        return;    }    if (m_fStateTimer > IMAGECHANGETIMER)    {        if (FadeToWhite(fDT, 1.0f) == TRUE)        {            if (FadeToNotBlack(fDT, 0.0f) == TRUE)            {                if (CHECK_BIT(m_nPhaseCheck, 0) == FALSE)                {                    SET_BIT(m_nPhaseCheck, 0);                    m_fStateTimer = 0;                    m_pGPLogo->SetVisible(false);                    m_pStudioLogo->SetVisible(true);                    m_fFadeIn = 0;                    m_fFadeOut = 0;                }                else if (CHECK_BIT(m_nPhaseCheck, 1) == FALSE)                {                    SET_BIT(m_nPhaseCheck, 1);                    m_fStateTimer = 0;                    m_pStudioLogo->SetVisible(false);                    m_pTeamLogo->SetVisible(true);                    m_fFadeIn = 0;                    m_fFadeOut = 0;                }                else if (CHECK_BIT(m_nPhaseCheck, 2) == FALSE)                {                    SET_BIT(m_nPhaseCheck, 2);                    m_fStateTimer = 0;                    m_pTeamLogo->SetVisible(false);                    m_fFadeIn = 0;                    m_fFadeOut = 0;                    QueueStateChange(STATE_CH_MAINMENU);                }            }        }    }    if (m_fFadeIn >= 0.0f && FadeToNotBlack(fDT, 0.0f) == FALSE)    {        return;    }}

/* This function reads the memory from <currentPtr> and sets		* * a DEntry object's values.  Then prints all the required info		* * in the format.  Returns 1 if there are no more entries left		*/int printNode(void *currentPtr) {	DEntry Entry; int i;	/* Get the status byte, no need for ntohs because */	memcpy(&Entry.status, currentPtr, 1);	currentPtr++;		if (!CHECK_BIT(Entry.status, 0))						/* checks if the bit in <pos> is 1 */		return 1;		/* Get the starting block	*/	memcpy(&Entry.startBlock, currentPtr, 4);	Entry.startBlock = ntohl(Entry.startBlock);	currentPtr += 4;			/*	No need for this right now, maybe later 	 *  memcpy(&Entry.numBlocks, currentPtr, 4);	 *	Entry.numBlocks = ntohl(Entry.numBlocks);	 */		currentPtr += 4;										/* Don't need the number of blocks	*/		memcpy(&Entry.fileSize, currentPtr, 4);	Entry.fileSize = ntohl(Entry.fileSize);	currentPtr += 4;	currentPtr += 7;										/* Don't need the creation date		*/		memcpy(&Entry.modifyTimeYear, currentPtr, 2);	Entry.modifyTimeYear = ntohs(Entry.modifyTimeYear);		/* Get the year as a short int		*/	currentPtr += 2;		for (i = 0;i < 5;i++) {		memcpy(&Entry.modifyTime[i], currentPtr, 1);		/* store the date as YYYYMMDDHHSS	*/		currentPtr++;	}			memcpy(Entry.fileName, currentPtr, 31);					/* Get filename from 31 bytes, its already  */	currentPtr += 37;										/* null terminated. skip the unused bytes	*/	/* Output nicely */	if (CHECK_BIT(Entry.status, 1))		printf("F");	else		printf("D");			printf("%10d%30s %4d/", Entry.fileSize, Entry.fileName, Entry.modifyTimeYear);	for (i = 0;i < 4;i++) {		if (i == 0)			printf("%.2d/", Entry.modifyTime[i]);		else if (i == 1)			printf("%.2d ", Entry.modifyTime[i]);		else			printf("%.2d:", Entry.modifyTime[i]);	}	printf("%.2d/n", Entry.modifyTime[4]);	return 0;}

void __attribute__ ((interrupt)) __cs3_isr_wwdg(void) {	uint32_t msr = PWMSR;	PWMSR = 0b111000;	if(CHECK_BIT(msr, 5)) {//		mb_core_message("COMPARE/n");	}	if(CHECK_BIT(msr, 4)) {//		mb_core_print(msr);	}	if(CHECK_BIT(msr, 3)) {//		mb_core_message("FIFO-EMPTY/n");		// push a new compare value		PWMSAR = makeSpeed(pwm_cmp);	}}

void SoundPlayer_Play(SoundPlayer *sp) {	SoundPlayer_SendCommand(sp, SP_PLAY);		//Initialize the blocking timeout of 50ms	Util_BlockWhile(0, 50);		//PIN is two bytes before the associated PORT	//Block until the busy pin goes high, or 50ms has passed	while(Util_BlockWhile( !CHECK_BIT(*(sp->port - 2), sp->busyPin), 0 ));		//Block until the busy signal goes low	while(CHECK_BIT(*(sp->port - 2), sp->busyPin));		//Wait 10ms. Otherwise the module can get confused with repeated play requests.	Util_WaitMillis(10);}

static struct smp_msg *smp_check_for_message(int curr_cpu, int *source_mailbox){    struct smp_msg *msg;    acquire_spinlock_nocheck(&cpu_msg_spinlock[curr_cpu]);    msg = smp_msgs[curr_cpu];    if(msg != 0) {        smp_msgs[curr_cpu] = msg->next;        release_spinlock(&cpu_msg_spinlock[curr_cpu]);        //		dprintf(" found msg 0x%x in cpu mailbox/n", msg);        *source_mailbox = MAILBOX_LOCAL;    } else {        // try getting one from the broadcast mailbox        release_spinlock(&cpu_msg_spinlock[curr_cpu]);        acquire_spinlock_nocheck(&broadcast_msg_spinlock);        msg = smp_broadcast_msgs;        while(msg != 0) {            if(CHECK_BIT(msg->proc_bitmap, curr_cpu) != 0) {                // we have handled this one already                msg = msg->next;                continue;            }            // mark it so we wont try to process this one again            msg->proc_bitmap = SET_BIT(msg->proc_bitmap, curr_cpu);            *source_mailbox = MAILBOX_BCAST;            break;        }        release_spinlock(&broadcast_msg_spinlock);        //		dprintf(" found msg 0x%x in broadcast mailbox/n", msg);    }    return msg;}

staticunsigned long long test_alloc(ivshmem_pci_dev_t *dev, size_t size){/* * first implementation: First Fit * * param: size = # of needed _frames_ * * returns index of first free frame * returns -1 if memory is filled * * */    unsigned long long n;    unsigned long long cnt = 0;    for(n=0; n< dev->num_of_frames; n++)    {	if (!CHECK_BIT(dev->bitmap,n))	{	    cnt++;	} else	{	    cnt = 0;	}	// return index of first free frame belonging to a block of at least N free frames!	if (cnt >= size) {	return (n - cnt + 1); // return index of first free frame belonging to a block of at least N free frames!	}    }    return -1; //not enough memory}

void do_gtell( CHAR_DATA * ch, char * argument ) {  CHAR_DATA * gch;  char        buf[ MAX_STRING_LENGTH ];  if ( argument[ 0 ] == '/0' ) {    send_to_char( AT_GREEN, "Tell your group what?/n/r", ch );    return;  }  if ( CHECK_BIT( ch->act, PLR_NO_TELL ) ) {    send_to_char( AT_GREEN, "Your message didn't get through!/n/r", ch );    return;  }  /*   * Note use of send_to_char, so gtell works on sleepers.   */  sprintf( buf, "%s tells the group '%s'./n/r", ch->name, argument );  for ( gch = char_list; gch; gch = gch->next ) {    if ( gch->deleted ) {      continue;    }    if ( is_same_group( gch, ch ) ) {      send_to_char( AT_GREEN, buf, gch );    }  }  return;}

/* exchanges a byte (full duplex) with the controller */static byte send_and_receive_byte(byte send_data) {    byte received_data = 0x00;    unsigned char i;    /* send bit by bit */    for(i = 0; i < 8; i++) {        /* send our bit by setting the command pin with our send_data "i" bit */        if(CHECK_BIT(send_data, i) == 0) {            DS2MSP_PORTOUT &= ~DS2MSP_COMMAND_PIN;        } else {            DS2MSP_PORTOUT |=  DS2MSP_COMMAND_PIN;        }        /* sinalize that our data is there and ask for the controller data by           setting the clock pin to low */        DS2MSP_PORTOUT &= ~DS2MSP_CLOCK_PIN;        bit_delay();        /* receive the data sent by the controller */        if((DS2MSP_PORTIN & DS2MSP_DATA_PIN) != 0) {            received_data |= (1 << i);        }        /* set the clock to high */        DS2MSP_PORTOUT |= DS2MSP_CLOCK_PIN;        bit_delay();    }        return received_data;}

void do_emote( CHAR_DATA * ch, char * argument ) {  char   buf[ MAX_STRING_LENGTH ];  char * plast;  if ( !IS_NPC( ch ) && CHECK_BIT( ch->act, PLR_NO_EMOTE ) ) {    send_to_char( AT_PURPLE, "You are an emotionless blob./n/r", ch );    return;  }  if ( argument[ 0 ] == '/0' ) {    send_to_char( AT_PURPLE, "Emote what?/n/r", ch );    return;  }  for ( plast = argument; *plast != '/0'; plast++ ) {    ;  }  sprintf( buf, "%s%s", ( *argument == '/'' ) ? "" : " ", argument );  if ( isalpha( plast[ -1 ] ) ) {    strcat( buf, "." );  }  act( AT_PINK, "$n$T", ch, NULL, buf, TO_ROOM );  act( AT_PINK, "$n$T", ch, NULL, buf, TO_CHAR );  return;}

void printbits(uint32_t n, uint8_t bits) {  unsigned int step;  // Loop over bits, printing as we go  step = 4;  // A buffer for collecting the 0s and 1s before printing as a group  char output[MESSAGE_MAX_PAYLOAD];  int j = 0;  for (int i = bits - 1; i >= 0; i--) {    if (CHECK_BIT(n, i)) {      // dprintf("1");      output[j]='1';    } else {      // dprintf("0");      output[j]='0';    }    j++;    if (i % step == 0) {      // dprintf(" ");      output[j]=' ';      j++;    }    assert(j < MESSAGE_MAX_PAYLOAD - 2);  }  output[j++]='/n';  output[j++]='/0';  dprintf("%s", output);}

int add_to_board(shape s, board * b){	int i, j;	int * map;	int * (*map_func)(int i, int j) = get_map_func(s, 0);	for(i = 0; i < 4; i++){		for(j = 0; j < 4; j++){			map = map_func(i , j);			//set piece in board			if(CHECK_BIT(shape_bytes[s.type][BYTE_MAP(map)], BIT_MAP(map))){				if(s.y == -1)					return -1;								b->xy[s.x + X_MAP(map)][s.y + Y_MAP(map)] = s.type + 1;			}		}		}	return 1;}

int draw_shape(shape s, int board_x, int board_y){	int i, j;	int * map;	int * (*map_func)(int i, int j) = get_map_func(s, 0);	int y_vals[4];	int height = 0;	attron(COLOR_PAIR(s.type+1));	for(i = 0; i < 4; i++){		for(j = 0; j < 4; j++){			map = map_func(i , j);			if(CHECK_BIT(shape_bytes[s.type][BYTE_MAP(map)], BIT_MAP(map))){				mvaddch(s.y + Y_MAP(map) + board_y, ((s.x + X_MAP(map))*2)  + (board_x) + 1,  ' '|A_REVERSE);				mvaddch(s.y + Y_MAP(map) + board_y, ((s.x + X_MAP(map))*2) + (board_x) + 2,  ' '|A_REVERSE);				if(!in_array(s.y + Y_MAP(map), y_vals, 4)){					y_vals[height] = s.y + Y_MAP(map);					height++;				}			}/*else{				mvaddch(s.y + Y_MAP(map) + board_y, ((s.x + X_MAP(map))*2)  + (board_x*2) + 1,  'x');				mvaddch(s.y + Y_MAP(map) + board_y, ((s.x + X_MAP(map))*2) + (board_x*2) + 2,  'x');			}*/					}	}	attroff(COLOR_PAIR(s.type+1));	return height;}

void sfsadd(sSuperStruct *s, char *name){	printf("dans sfs add avec fichier : %s /n", name);	if(fileExists(name)){		int compteur=0;		int add_taille=0; //addition des tailles->permet de récupérer la taille du bitmap		int num_bit;		//quelle place est encore disponible dans les files entries		if(s->fe[0].size!=0)		printf("le premier fichier est %s /n",s->fe[0].name);		// CHECK_BIT(var, pos) ((var) &(1<<pos))		while( CHECK_BIT(s->fe[compteur].name[0], 6) ){		//while(s->fe[compteur].size!=0){			//printf("parcours fichier %s",s->fe[compteur].name);			compteur++;		}		printf("on recupere la taille des num_bit /n");		num_bit=get_bit_free();		printf("on a récuperer les bits /n");		// printf("nous sommes au %d compteur et add_taille vaut %d num_bit %d /n", compteur, add_taille, num_bit);		//récupération taille fichier		struct stat st;		stat(name, &st);		printf("la taille du fichier est %d /n", st.st_size);		strcpy(s->fe[compteur].name, name);		s->fe[compteur].size=st.st_size;		int num=0;		//remplissage des bytes du bitmap		int nbre_bloc= (st.st_size/1024)+1; //obtient le nombre de bloc == le nombre de bits du bitmap		int byte_asked; //le byte du tab_bitmap sur lequel l'on travail		byte buf[1024];		init_byte(buf, 1024);		int i, fp;		fp=fopen(name, "r");		for(i=num_bit; i<num_bit+nbre_bloc; i++){			byte_asked= i/8; //quel byte de tabBitmap est affecté?			s->fe[compteur].indexBlock[num]=i; //enregistre le numéro du bloc dans la file entries			s->sbit.tabBitmap[byte_asked]=s->sbit.tabBitmap[byte_asked]^(1<<(i%8)); //enregistre la présence du fichier sur le bit XXX byte_asked			printf("remplissage du tabBitmap et le byte vaut %d /n",s->sbit.tabBitmap[byte_asked]);			fread(buf, 1024,1, fp); //lecture des bytes du fichier demandée			printf("LE BUFFER contient %s /n", buf);			file_to_buffer(s->fc.data[i], buf, 1024);			printf("Après copies l'on a dans le tableau %s /n", s->fc.data[i]);			num++;		}		fclose(fp);	} else {		printf("Fichier existe pas : %s /n/n", name);	}}

/** * /brief Prints a single character to a serial port. */void serial_putchar(char c){  // TODO: Wait until FIFO can hold more characters (i.e. TX_FIFO_E == 1)  while(!CHECK_BIT(*UART_LSR, 5))    ;  //Write character  (*(char *) UART_BASE) = c;}

/* *   Save a character and inventory. *   Would be cool to save NPC's too for quest purposes, *   some of the infrastructure is provided. */void save_char_obj( CHAR_DATA * ch ) {  FILE      * fp;  CHAR_DATA * pet;  char        buf[ MAX_STRING_LENGTH ];  char        strsave[ MAX_INPUT_LENGTH  ];  if ( IS_NPC( ch ) ) {    return;  }  if ( ch->desc && ch->desc->original ) {    ch = ch->desc->original;  }  update_playerlist( ch );  ch->save_time = current_time;  fclose( fpReserve );  /* player files parsed directories by Yaz 4th Realm */  sprintf( strsave, "%s%c/%s", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );  if ( !( fp = fopen( strsave, "w" ) ) ) {    sprintf( buf, "Save_char_obj: fopen %s: ", ch->name );    bug( buf, 0 );    perror( strsave );  } else {    fwrite_char( ch, fp );    if ( ch->carrying ) {      fwrite_obj( ch, ch->carrying, fp, 0, FALSE );    }    if ( !IS_NPC( ch ) && ch->pcdata->storage ) {      fwrite_obj( ch, ch->pcdata->storage, fp, 0, TRUE );    }    for ( pet = ch->in_room->people; pet; pet = pet->next_in_room ) {      if ( IS_NPC( pet ) ) {        if ( CHECK_BIT( pet->act, ACT_PET ) && ( pet->master == ch ) ) {          save_pet( ch, fp, pet );          break;        }      }    }    tail_chain();    fprintf( fp, "#END/n" );  }  fclose( fp );  fpReserve = fopen( NULL_FILE, "r" );  return;}

/* * Get MAC address stored in flash */static void ag7240_get_ethaddr(struct eth_device *dev) {	unsigned char *mac = dev->enetaddr;#ifdef OFFSET_MAC_ADDRESS	unsigned char buffer[6];	// get MAC address from flash and check it	memcpy(buffer, (void *)(CFG_FLASH_BASE + OFFSET_MAC_DATA_BLOCK + OFFSET_MAC_ADDRESS), 6);	/*	 * check first LSBit (I/G bit) and second LSBit (U/L bit) in MSByte of vendor part	 * both of them should be 0:	 * I/G bit == 0 -> Individual MAC address (unicast address)	 * U/L bit == 0 -> Burned-In-Address (BIA) MAC address	 */	if(CHECK_BIT((buffer[0] & 0xFF), 0) == 0 && CHECK_BIT((buffer[0] & 0xFF), 1) == 0){		mac[0] = (buffer[0] & 0xFF);		mac[1] = (buffer[1] & 0xFF);		mac[2] = (buffer[2] & 0xFF);		mac[3] = (buffer[3] & 0xFF);		mac[4] = (buffer[4] & 0xFF);		mac[5] = (buffer[5] & 0xFF);	} else {		// 00-03-7F (Atheros Communications, Inc.)		mac[0] = 0x00;		mac[1] = 0x03;		mac[2] = 0x7f;		mac[3] = 0x09;		mac[4] = 0x0b;		mac[5] = 0xad;		printf("## Error: MAC address in FLASH is invalid, using fixed!/n");	}#else	// 00-03-7F (Atheros Communications, Inc.)	mac[0] = 0x00;	mac[1] = 0x03;	mac[2] = 0x7f;	mac[3] = 0x09;	mac[4] = 0x0b;	mac[5] = 0xad;#endif}

static inline uint isBitSet(cbuf_t ptr, int offset) {//	LOGD("isBitSet(%d, %d) called", ptr, offset);	int t, poff, off;	if(offset < 0) {		offset = -offset;		poff = -(offset / BITS + 1);		off = BITS - (offset % BITS);//		LOGD(" offset<0: off=%d, poff=%d", off, poff);		t = CHECK_BIT(*(ptr + poff), off);	} else if (offset < 8) {//		LOGD(" offset<8: ---");		t = CHECK_BIT(*ptr, offset);	} else {		poff = offset / BITS;		off = offset % BITS;//		LOGD(" ---: off=%d, poff=%d", off, poff);		t = CHECK_BIT(*(ptr + poff), off);	}//	LOGD("isBitSet(%d) exited", t);	return t;}

void ICACHE_FLASH_ATTRbutton_push(uint8 debounce){    if (debounce == 1)    {        os_timer_disarm(&button_timer);        os_timer_setfn(&button_timer, (os_timer_func_t *)button_push, 0);        os_timer_arm(&button_timer, 100, 1);    }    if (CHECK_BIT(PIN_IN,0) == 0 && button_last_state == 0)    {        os_printf("Button press/n");        os_timer_disarm(&button_timer);        os_timer_setfn(&button_timer, (os_timer_func_t *)button_push, 1);        os_timer_arm(&button_timer, 1000, 0);        button_last_state = 1;     }    if (CHECK_BIT(PIN_IN,0) == 1 && button_last_state == 1)        button_last_state = 0;}

void do_reply( CHAR_DATA * ch, char * argument ) {  CHAR_DATA * victim;  int         position;  if ( !IS_NPC( ch ) && CHECK_BIT( ch->act, PLR_SILENCE ) ) {    send_to_char( AT_WHITE, "Your message didn't get through./n/r", ch );    return;  }  if ( !( victim = ch->reply ) ) {    send_to_char( AT_WHITE, "They aren't here./n/r", ch );    return;  }  if ( argument[ 0 ] == '/0' ) {    send_to_char( AT_WHITE, "Reply what?/n/r", ch );    return;  }  if ( ( !IS_IMMORTAL( ch ) && !IS_AWAKE( victim ) ) || ( CHECK_BIT( victim->in_room->room_flags, ROOM_SILENT ) && ( get_trust( ch ) < L_APP ) ) ) {    act( AT_WHITE, "$E can't hear you.", ch, 0, victim, TO_CHAR );    return;  }  if ( victim->desc && victim->desc->pString ) {    act( AT_WHITE, "$E is in a writing buffer.", ch, 0, victim, TO_CHAR );    return;  }  act( AT_WHITE, "You tell $N '$t'",  ch, argument, victim, TO_CHAR );  position         = victim->position;  victim->position = POS_STANDING;  act( AT_WHITE, "$n tells you '$t'", ch, argument, victim, TO_VICT );  victim->position = position;  victim->reply    = ch;  return;}

/* * Get MAC address stored in flash */static void ag7240_get_ethaddr(struct eth_device *dev){	unsigned char *mac = dev->enetaddr;	unsigned char buffer[6];#ifdef OFFSET_MAC_ADDRESS	// get MAC address from flash and check it	memcpy(buffer, (void *)(CFG_FLASH_BASE + OFFSET_MAC_DATA_BLOCK + OFFSET_MAC_ADDRESS), 6);	// check LSBit and second LCBit in MSByte of vendor part -> both of them should be 0	if(CHECK_BIT((buffer[0] & 0xFF), 0) == 0 && CHECK_BIT((buffer[0] & 0xFF), 1) == 0){		mac[0] = (buffer[0] & 0xFF);		mac[1] = (buffer[1] & 0xFF);		mac[2] = (buffer[2] & 0xFF);		mac[3] = (buffer[3] & 0xFF);		mac[4] = (buffer[4] & 0xFF);		mac[5] = (buffer[5] & 0xFF);	} else {		// 00-03-7F (Atheros Communications, Inc.)		mac[0] = 0x00;		mac[1] = 0x03;		mac[2] = 0x7f;		mac[3] = 0x09;		mac[4] = 0x0b;		mac[5] = 0xad;		printf("## Error: MAC address stored in flash is invalid!/nUsing fixed address!/n");	}#else	// 00-03-7F (Atheros Communications, Inc.)	mac[0] = 0x00;	mac[1] = 0x03;	mac[2] = 0x7f;	mac[3] = 0x09;	mac[4] = 0x0b;	mac[5] = 0xad;	printf("## Error: Using fixed MAC address!/n");#endif}

void printPatternMaskInLatex(int mask) {  int i, count;  count = 0;  printf("$$//left//{ ");  for (i = 0; i < 16; i++) {    if (!!CHECK_BIT(mask, i)) {      print2x2MatrixInLatex(i);      count++;      if (count == 8)        printf("/////n");    }  }  printf(" //right//} $$/n");}