Example #1
0
int i2c_setup() {
	memcpy(I2C, I2CInit, sizeof(I2CInfo) * (sizeof(I2C) / sizeof(I2CInfo)));

	init_i2c(&I2C[0]);
	init_i2c(&I2C[1]);
	init_i2c(&I2C[2]);
	return 0;
}
Example #2
0
uint8_t init_speedy(void){

	uint8_t data = 0x00;

	//Init I2C 1
	if(init_i2c(I2C_1) != 0)
		return 1;

	//Pyro Sensor
	if(write_i2c(I2C_1, ADDR_TPA81, &data, 1) != 1)
		return 11;

	//SRF08 hinten links
	if(write_i2c(I2C_1, SRF_HL, &data, 1) != 1)
		return 12;

	//SRF08 vorne
	if(write_i2c(I2C_1, SRF_V, &data, 1) != 1)
		return 13;

	//SRF08 hinten rechts
	if(write_i2c(I2C_1, SRF_HR, &data, 1) != 1)
		return 14;

	//Init I2C 2
	if(init_i2c(I2C_2) != 0)
		return 2;

	//HMC6343
	if(write_i2c(I2C_2, ADDR_HMC, &data, 1) != 1)
		return 21;

	//MAX11613
	if(write_i2c(I2C_2, ADDR_MAX11613, &data, 1) != 1)
		return 22;

	//LCD
	if(write_i2c(I2C_2, LCD03_ADRESS, &data, 1) != 1)
		return 23;

	//ITG3200
	if(write_i2c(I2C_2, ADDR_ITG, &data, 1) != 1)
		return 24;

	//Init Motor Modul
	if(init_itg() != 0)
		return 3;

	//Init G Sensor ADXL345 on DE0 Nano SoC
	if(!ADXL345_Init())
		return 4;

	return 0;
}
Example #3
0
int main(int argc, char **argv) {

	int result,i;
	int i2c_fd;

	i2c_fd=init_i2c("/dev/i2c-1");
	if (i2c_fd < 0) {
		fprintf(stderr,"Error opening device!\n");
		return -1;
	}

	/* Init display */
	if (init_display(i2c_fd,HT16K33_ADDRESS0,10)) {
		fprintf(stderr,"Error opening display\n");
		return -1;
	}

	result=load_font("tbfont.tb1");

	while(1) {
		for(i=32;i<127;i++) {
			result=put_letter(i,i2c_fd);
			usleep(500000);
		}
	}

	return result;
}
Example #4
0
PUBLIC void setupHardware(void)
{
    //inicializa as configuraçoes do micrococontrolador
    init_mcu();

    //Inicializa driver das interrupcoes
    interrupt_init();

    //Inicializa as portas do microcontrolador
    init_gpio();

    //Inicializa UART
    init_uart();

    //Inicializa TMR0
    init_timer0();

    //Inicializa I2C
    init_i2c();

    //Inicializa ADs
    init_AD();

    //Inicializa PWM
    init_pwm();
}
Example #5
0
int main(int argc, char **argv)
{
        int i, v;
        byte data[20];

        init_i2c("/dev/i2c-1");

        // set mode register to 1 to activate accelerometer
        data[0] = 7;
        data[1] = 1;
        I2cSendData(MMA7660_ADDR,data,2);

        printf("Hit any key to quit\n\n");
        while (1) {
                I2cReadData(MMA7660_ADDR,data,11);
                for (i=0; i<3; i++) {
                        v = (data[i]/2^6)*9.81;
                        if (v>=0x20) v = -(0x40 - v);  //sign extend negatives
                        printf("%c:%3d  ",i+'X',v);
                }
                for (i=3; i<11; i++)
                        printf("%x: %02x  ",i,data[i]);
                printf("\r");
        }
        printf("\n");

        close(deviceDescriptor);

        return 0;
}
Example #6
0
void initialisation(void)
{
	//ADC Off
	ADCON0bits.ADON = 0;
	ADCON1 = 0b00001111;
	
	//Définition des IO
	define_i_o();
	
	//Périphériques		
//	init_timer_0();
	config_port_b();
	init_i2c();	
	init_eusart();
	//config_euart();
	
	//Init GLCD
	GLCD_Initalize();
	Delay10KTCYx(0);		//Modifier?
	GLCD_ClearScreen();		
	
	// On autorise toutes les interruptions
	RCONbits.IPEN = 0;	//1 niveau
	INTCONbits.GIE = 1;
	INTCONbits.PEIE = 1;
}
Example #7
0
int16_t main(void) {
    init_clock();
    init_ui();
    init_pin();
    init_timer();
    init_i2c();
    InitUSB();
    init_oc();

    init_display(&i2c3, 0x70, 0x71);
    init_game(&timer1, &timer2, &A[0], &disp1, &disp2);
    init_gun(&D[13], &A[1], &A[2], &timer3);
    init_launcher(&D[5], &D[8], &D[3], &D[4]);
    init_shooter(&D[6], &D[9], &D[1], &D[2], &D[7], &D[0], &oc3, &oc4);
    init_baller(&D[10], &oc2, &timer4, &shooter, &launcher);
    init_pix(&D[11], &timer5, 30, 0.05);
    init_audio(&D[12]);

    uint8_t level = 0;
    uint8_t hit_flag = 0;
    while (1) {
        ServiceUSB(); // usb times out if not checked fast enough :/
        level = run_game(hit_flag);
        ServiceUSB();
        hit_flag = run_gun(level);
        ServiceUSB();
        run_baller(level);
    }
}
int main (void) {

	uint8_t data = 0;
    uint32_t len = 0;

    //SystemClockUpdate();
    SystemCoreClockUpdate();

    init_i2c();
    uart2_init(115200, CHANNEL_A);		// Control de flujo: NINGUNO
    DACInit();

    uart2_sendString((uint8_t*)"\r\nModulador PSK\r\n");

    while (1) {
    	len = uart2_receive(&data, 1, FALSE);
        if (len > 0) {
                uart2_send(&data, 1);
                procesarBytes(data);
        }
        Timer0_Wait(50);

    }

}
Example #9
0
int main(void)
{
	DDRC |= (1 << DDRC7);
	PORTC |= (1 << PORTC7);
	_delay_ms(2);
	PORTC &= ~(1 << PORTC7);
	
 	init_power();
 	init_timeout_timer();
	init_switch();
	init_ref_clock();
	init_spi(2);
	init_buttons();
	init_serial(2400);
	init_adc();
	init_i2c();
	//Turn on interrupts
	sei();
	play_sounds();
	//Debug: Never Gets here
    while(1)
    {
		_delay_ms(1000);
		get_POT_set_TWIPOT();
	}
}
int main(int argc, char ** argv){
	char c ;
	FILE * fr;
	long start_time, end_time ;
	double diff_time ;
	struct timespec cpu_time ;
	unsigned int size = 0 ;	
	initGPIOs();
	#ifdef MARK1
	init_i2c(3);
	#endif
	fr = fopen (argv[1], "rb");  /* open the file for reading bytes*/
	if(fr < 0){
		printf("cannot open file %s \n", argv[1]);	
	}
	size = fread(configBits, 1, 1024*1024, fr);
	printf("bit file size : %d \n", size);
	//clock_gettime(CLOCK_REALTIME, &cpu_time);
	//start_time = cpu_time.tv_sec ;
	if(serialConfig(configBits, size) < 0){
		printf("config error \n");
		exit(0);	
	}else{
		printf("config success ! \n");	
	}
	//clock_gettime(CLOCK_REALTIME, &cpu_time);
	//end_time = cpu_time.tv_sec ;
	//diff_time = end_time - start_time ;
	//diff_time = diff_time/1000000 ;
	//printf("Configuration took %fs \n", diff_time);
	closeGPIOs();
	fclose(fr);
	return 1;
}
Example #11
0
int16_t main(void) {
    // printf("Starting Rocket Controller...\r\n");
    init_clock();
    init_ui();
    init_pin();
    init_timer();
    init_i2c();
    setup();
    init_servo_driver(&sd1, &i2c3, 16000., 0x0);
    init_servo(&servo4, &sd1, 0);
    InitUSB();
    U1IE = 0xFF; //setting up ISR for USB requests
    U1EIE = 0xFF;
    IFS5bits.USB1IF = 0; //flag
    IEC5bits.USB1IE = 1; //enable
    // uint32_t pid_command;
    servo_set(&servo4, 1500, 0);
    while (1) {
        if (timer_flag(&timer1)) {
            // Blink green light to show normal operation.
            timer_lower(&timer1);
            led_toggle(&led2);
            // servo_set(&servo4, 1500, 0);
        }
    }
}
Example #12
0
void i2c_detect() 
{
	printf("Trying to detect any i2c slaves...\n\r");
	uint8_t addr = 0;
	int i;
	while (1) {
		init_i2c();
		i=40000;
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)); 
		I2C_GenerateSTART(I2C1, ENABLE);
		while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
		I2C_Send7bitAddress(I2C1, addr++, I2C_Direction_Transmitter);
		while (1) {
			if (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
			{
				printf("Found something @ %hhx\n\r",addr);
				break;
			}
			i--;
			if (!i)
			{
				printf("NACK @ %hhx\n\r",addr);
				break;	
			}
		}
	}
}
Example #13
0
int aiao_codec_init(void)
{
    int ret = 0;

	godbox_aic31_reset();
	init_i2c();
    return ret;
}
Example #14
0
static int
init_wrauxr(struct nvbios_init *init, u32 addr, u8 data)
{
	struct nouveau_i2c_port *port = init_i2c(init, -2);
	if (port && init_exec(init))
		return nv_wraux(port, addr, &data, 1);
	return -ENODEV;
}
Example #15
0
static int
init_wri2cr(struct nvbios_init *init, u8 index, u8 addr, u8 reg, u8 val)
{
	struct nouveau_i2c_port *port = init_i2c(init, index);
	if (port && init_exec(init))
		return nv_wri2cr(port, addr, reg, val);
	return -ENODEV;
}
Example #16
0
/**
  * Write a single byte to a register of the accelerometer  
  *
  *@param reg register value of the accelerometer  
  *@param buffer containing the the value of the register 
  *
  *@return the status 0= Failure Others= Success
  */
uint8_t st_LIS3LwriteSingleRegister(uint8_t reg, uint8_t* buffer)
{

  init_i2c();
  if (msp430_i2c_write(I2C_START,LIS3L_I2C_ADDRESS, 1, &reg)!=0)
    return msp430_i2c_write(I2C_STOP,LIS3L_I2C_ADDRESS, 1, buffer);
  else  
    return 0; //Failure 
}
Example #17
0
uint8_t Init_IMU(void){
	init_i2c();
	__delay_cycles(800);
	if (initGyro()){return 1;}
	__delay_cycles(800);
	if (initXM()){return 1;}
	__delay_cycles(800);
return 0;
}
Example #18
0
int main(void) {
	WDTCTL = WDTPW + WDTHOLD;                 			// Stop WDT
	PM5CTL0 &= ~LOCKLPM5;

//Set clock speed
	CSCTL0_H = CSKEY >> 8;                    // Unlock CS registers
	CSCTL1 = DCOFSEL_6;                       // Set DCO to 8MHz
	CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK; // Set SMCLK = MCLK = DCO
	// ACLK = VLOCLK
	CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;     // Set all dividers to 1
	CSCTL0_H = 0;                             // Lock CS registers
//Set clock speed

	rate_gyr_x = 0;
	rate_gyr_y = 0;
	rate_gyr_z = 0;

	init_i2c();
	initGyro();
	initXM();

	while (1) {
		////////////READ GYROSCOPE//////////////
		xRate_L = single_byte_read_i2c(gyro_Address, OUT_X_L_G);
		xRate_H = single_byte_read_i2c(gyro_Address, OUT_X_H_G);
		yRate_L = single_byte_read_i2c(gyro_Address, OUT_Y_L_G);
		yRate_H = single_byte_read_i2c(gyro_Address, OUT_Y_H_G);
		zRate_L = single_byte_read_i2c(gyro_Address, OUT_Z_L_G);
		zRate_H = single_byte_read_i2c(gyro_Address, OUT_Z_H_G);

		/////////////READ ACCELEROMETER/////////////////
		xaccel_L = single_byte_read_i2c(XMAddress, OUT_X_L_A);
		xaccel_H = single_byte_read_i2c(XMAddress, OUT_X_H_A);
		yaccel_L = single_byte_read_i2c(XMAddress, OUT_Y_L_A);
		yaccel_H = single_byte_read_i2c(XMAddress, OUT_Y_H_A);
		zaccel_L = single_byte_read_i2c(XMAddress, OUT_Z_L_A);
		zaccel_H = single_byte_read_i2c(XMAddress, OUT_Z_H_A);

		////////////////CONVERT TO MEANINGFUL DATA//////////////////////
		gyrRawx = (xRate_L | xRate_H << 8);
		gyrRawy = (yRate_L | yRate_H << 8);
		gyrRawz = (zRate_L | zRate_H << 8);

		rate_gyr_x = gyrRawx * G_GAIN;
		rate_gyr_y = gyrRawy * G_GAIN;
		rate_gyr_z = gyrRawz * G_GAIN;

		accRawx = (xaccel_L | xaccel_H << 8);
		accRawy = (yaccel_L | yaccel_H << 8);
		accRawz = (zaccel_L | zaccel_H << 8);

		g_x = (accRawx * A_GAIN) / thousand;
		g_y = (accRawy * A_GAIN) / thousand;
		g_z = (accRawz * A_GAIN) / thousand;
	}
}
Example #19
0
void airdrums_stick(void){

    //initial setup
    WDTCTL = WDTPW + WDTHOLD; // Stop WDT

    P1SEL &= 0;
    P1SEL2 &= 0;
    P1SEL |= BIT6 + BIT7; // Assign I2C pins to USCI_B0
    P1SEL2|= BIT6 + BIT7; // Assign I2C pins to USCI_B0

    // LED pin
    P1DIR |= 0x01;
    P1OUT = 0x00;

    // start up i2c bus
    init_i2c();

    //intialise some globals
    highCount = 0;
    isDown = FALSE;
    driftCount=0;

    // Give the nrf plenty of time to start up;
    // it gets pissy if you talk to it too early.

    __delay_cycles(10000);
    nrfInit();
    __delay_cycles(10000);
    // Start TX with address '!'.
    // Hard coded because why not
    nrfStartTX('!');
    __delay_cycles(10000);

    //transmit stuff to set up mpu6050
    //set sensitivity levels
    MPU6050_write_byte(MPU6050_GYRO_CONFIG, MPU6050_FS_SEL_2000);
    MPU6050_write_byte(MPU6050_ACCEL_CONFIG, MPU6050_AFS_SEL_16G);

    //wake sensor up by clearing sleep bit
    MPU6050_write_byte (MPU6050_PWR_MGMT_1, 0);

    // initialise circular buffer
    circ_init();

    // Do some quick and dirty drift correction
    findDrift();

    // Set up timer interrupts for main loop
    CCTL0 = CCIE;                    // CCR0 interrupt enabled
    TACTL = TASSEL_2 + MC_1 + ID_3;  // SMCLK/8, upmode
    CCR0 =  (1000000 / 8 / PROCESS_RATE_HZ); // Set process rate
    // CCR0 = 417; // 300 Hz

    _BIS_SR(CPUOFF + GIE); // Enter LPM0 w/ interrupt
    while(1);
}
Example #20
0
void init_all(void)
{
	init_uart();
	init_pll();
	act8600_setting();
	init_ddr();
//	init_lcd();
	init_i2c();
//	init_pwm();
}
Example #21
0
int main(int argc, char ** argv)
{
	if(argc < 2)
	{
		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
		return -1;
	}

//	int fd = init_rs232(argv[1]);

	int fd = init_i2c(argv[1], 0x48);

	uint8_t value[2];

	struct i2c_cmd cmd;
//	cmd.i2c_cmd = 0x55;
//	cmd.i2c_addr = 0x91;
	cmd.i2c_reg = 0x00;
//	cmd.i2c_bytes = 2;

	while(true)
	{
		struct timespec time_before, time_after;
		clock_gettime(CLOCK_MONOTONIC, &time_before);
	
		
		const int write_ret = write(fd, (void *)&cmd, sizeof(cmd));
		const int read_ret = read(fd, (void *)value, 2);
//		value[0] = 0x1a;
//		value[1] = 0xf0;
		if(read_ret < 0)
		{
			printf("Error on read(fd, value, 2): %d %s\n", errno, strerror(errno));
			continue;
		}
		
		const uint16_t value_ntohs = 	(value[1] >> 4) | (value[0] << 4);
		uint16_t value_twosc = value_ntohs;
		if(value_ntohs & 0x0800)
		{
			value_twosc = value_ntohs - 1;
			value_twosc ^= 0xfff;
		}
		const float value_float = ((float)value_twosc) * 0.0625;

		clock_gettime(CLOCK_MONOTONIC, &time_after);

		printf( "%09d,%09d,%09d,%09d,%06d,%f\n", time_before.tv_sec, time_before.tv_nsec, time_after.tv_sec, time_after.tv_nsec, value_twosc, value_float);
		fflush(stdout);

		sleep(1);
	}

	return 0;
};	
Example #22
0
/**
  * Write multiple bytes (registers) in the accelerometer  
  *
  *@param reg register value of the accelerometer from where the writing will get started   
  *@param count number of the bytes to be written  
  *@param buffer storing the bytes to be written 
  *
  *@return the status 0= Failure Others= Success
  */
uint8_t st_LIS3LwriteMultipleRegisters(uint8_t reg,uint8_t count, uint8_t* buffer )
{
 uint8_t modified_reg;

 init_i2c();
 modified_reg= fixAddress(count,reg); 
 if (msp430_i2c_write(I2C_START,LIS3L_I2C_ADDRESS, 1,&modified_reg)!=0)
   return msp430_i2c_write(I2C_STOP,LIS3L_I2C_ADDRESS, count, buffer); 
 else 
   return 0; //Failure
}
Example #23
0
void main(void)
{
	DDRC = 0xff;
	PORTC = 0xff;
	unsigned char ch,ch1;
	unsigned char buf[10];

	uart1_init();
	lcd_init();	
	lcd_char('*');
	
	init_i2c();
	
	WR_I2C(0,0x57);//Sec
    WR_I2C(1,0x59);//Min
	WR_I2C(2,0x11 | (1<<5)|(1<<6) );//Hr
    WR_I2C(3,1);//Day
	WR_I2C(4,0x31);//Date
    WR_I2C(5,0x12);//Month
	WR_I2C(6,0x99);//year
	
	while(1)
	{	
		ch = RD_I2C(0,0);//sec
		sprintf(buf,"\n\rSec = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);

		ch = RD_I2C(1,0);//min
		sprintf(buf,"\n\rMin = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);
	
		ch = RD_I2C(2,0);//hr
		sprintf(buf,"\n\rHr = %02d",Hex2Dec( ch & 0x1F ) );
		uart1_transmit_string(buf);
	
		ch = RD_I2C(3,0);//day
		sprintf(buf,"\n\rDay = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);

		ch = RD_I2C(4,0);//date
		sprintf(buf,"\n\rDate = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);
	
		ch = RD_I2C(5,0);//month
		sprintf(buf,"\n\rMonth = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);

		ch = RD_I2C(6,0);//year
		sprintf(buf,"\n\rYear = %02d",Hex2Dec(ch));
		uart1_transmit_string(buf);
		_delay_ms(1000);
	
	}
}
Example #24
0
int main() {
    DLN_RESULT result;

    DlnConnect("localhost", DLN_DEFAULT_SERVER_PORT);

    // Check device count
    uint32_t device_count;
    result = DlnGetDeviceCount(&device_count);
    if (!DLN_SUCCEEDED(result)) {
        std::cout << "Failed to get DLN device count" << std::endl;
        return -1;
    }
    if (device_count != 1) {
        std::cout << "There should be one and only one DLN device connected. There are "
                  << device_count << std::endl;
        return -1;
    }

    // Try to open our device
    HDLN handle;
    result = DlnOpenDevice(0, &handle);
    if (!DLN_SUCCEEDED(result)) {
        std::cout << "Failed to open DLN device" << std::endl;
        return -1;
    }

    // Print out some info about our DLN device
    DLN_VERSION version;
    uint32_t sn, id;
    DlnGetVersion(handle, &version);
    DlnGetDeviceSn(handle, &sn);
    DlnGetDeviceId(handle, &id);
    std::cout << "Opened DLN device: " << sn << "\t" << id << std::endl;

    // Initialize all the things
    init_i2c(handle);
    init_analog(handle);

    // Instantiate the rover controller
    RoverControl rover(handle);

    while (true) {
        rover.update();
    }

    cleanup_analog(handle);

    DlnCloseHandle(handle);

    DlnDisconnectAll();

    return 0;
}
Example #25
0
int main(int argc, char **argv)
{
	int i;
	byte data[2];
	init_i2c("/dev/i2c-0");

		I2cReadData(0x38,data,1);
		printf("data1 %x\n",data[0]);
		printf("data2 %x\n",data[1]);
		printf("data3 %x\n",data[2]);

	return 0;
}
Example #26
0
/** Enable of disable the I2C Bus
  *    
  * 
  *@param newMode holds the value to set or clear the I2C bus mode 
  * 
  */
uint8_t dev_mode_DEV_MSP_ACCELEROMETER(uint8_t newMode)
{
   switch (newMode) {
   case DEV_MODE_ON:
      init_i2c();
      break;
   case DEV_MODE_OFF:
      msp430_i2c_clearModeI2C();
      break;
   default:
      return DEV_UNSUPPORTED;
   }

   return DEV_OK;
}
Example #27
0
static int
init_rdauxr(struct nvbios_init *init, u32 addr)
{
	struct nouveau_i2c_port *port = init_i2c(init, -2);
	u8 data;

	if (port && init_exec(init)) {
		int ret = nv_rdaux(port, addr, &data, 1);
		if (ret)
			return ret;
		return data;
	}

	return -ENODEV;
}
Example #28
0
void init_all()
{
    init_gpio();
    pwm_init();
    adc_init();
    init_all_pulse_counter();
    LPLD_Flash_Init();
    init_sdhc();          //SD卡模块初始化   
    uart_interr_init();
    init_i2c();           //MPU6050初始化
    //LPLD_MMA8451_Init();
    OLED_Init();
    pit_init();
    init_paranum();   
    init_setpara();    
    init_readpara();
    save.g_s16SDDenoteNum = 0;//防止不小心保存非0数
}
Example #29
0
int main()
{
    init_timer();
    init_ATX_power();
    init_serial();
    init_stdio();
    init_safety_switches();
    init_i2c();
    init_laser_power();
    init_heaters();
    init_main_laser();
    sei();

    enable_ATX_power();
    uint32_t b = millisecond_time();
    while (!ATX_power_state()) {
        enable_ATX_power();
        continue;
    }
    uint32_t a = millisecond_time();
    printf("ATX power: %ld msec\n", a - b);
    enable_heater_1();          // aka water pump
    delay_milliseconds(2000);
    enable_heater_0();          // aka high voltage supply
    set_laser_power(4095 / 3);  // 1/3rd power
    printf("Main Laser!  Danger!\n");

    while (true) {
        if (getchar() == '\r') {
            if (e_is_stopped())
                printf("Emergency Stop.  No fire.\n");
            else if (lid_is_open())
                printf("Lid is open.  No fire.\n");
            else {
                printf("Fire!\n");
                enable_main_laser();
                delay_milliseconds(PULSE_MS);
                disable_main_laser();
            }
        }
    }
}
/* Main */
void main()
{
   unsigned short int count = 0;
   unsigned char data;

   /* Allow peripheral init */
   delay(1000);

   /* Initialize PIC USART to operate at 19200 baud */
   init_serial();

   /* Initialize I2C */
   init_i2c();

   /* Turn ON and setup up LCD */
   init_lcd();
   
   /* Loop reception and echo it back */
   receive_next:
  
   while(!PIR1bits.RCIF);
   /* Echo received character */
   data = RCREG;
   TXREG = data;
   
   /* Send the received byte to EEPROM */
   write_to_eeprom(data, count);

   count++;

   if(count == 16)
   {
      dump_to_lcd();
      count = 0;
   }
  
   goto receive_next;
   
   /* Shouldn't get here! */
   while(1);
}