예제 #1
0
int main(void)
{
	clock_setup();
	gpio_setup();
	usart_setup();
	i2c_setup();
	/*uint8_t data[1]={(0x4 << ACC_CTRL_REG1_A_ODR_SHIFT) | ACC_CTRL_REG1_A_XEN};*/
	uint8_t data[1]={0x97};
	write_i2c(I2C1, I2C_ACC_ADDR, ACC_CTRL_REG1_A, 1, data);
	data[0]=0x08;
	write_i2c(I2C1, I2C_ACC_ADDR, ACC_CTRL_REG4_A, 1, data);
	uint16_t acc_x;

	while (1) {

		read_i2c(I2C1, I2C_ACC_ADDR, ACC_STATUS, 1, data);
		/*my_usart_print_int(USART2, data[0]);*/
		read_i2c(I2C1, I2C_ACC_ADDR, ACC_OUT_X_L_A, 1, data);
		acc_x=data[0];
		read_i2c(I2C1, I2C_ACC_ADDR, ACC_OUT_X_H_A, 1, data);
		acc_x|=(data[0] << 8);
		my_usart_print_int(USART2, (int16_t) acc_x);
		//int i;
		//for (i = 0; i < 800000; i++)    /* Wait a bit. */
		//  __asm__("nop");
	}

	return 0;
}
예제 #2
0
파일: device.c 프로젝트: tandenghua/SH
int i2c_init()
{
	/*open I2C 设备*/
	if ((pt->fd_config = open(I2C_DEVICE, O_RDWR)) < 0) {
		perror(I2C_DEVICE);
		return 1;
	}
	/*设定 I2C 设备总线地址*/
	if ((ioctl(pt->fd_config, I2C_SLAVE, 0x53)) < 0) {
		perror("ioctl i2c address error!");
		return 1;
	}

	if (-1 == (read_i2c(pt->fd_config, i2c_add, pt->p_config, 224)))
		return 1;/*读取默认配置文件*/

	i2c_add[1] = 228;
	/*开机设置默认选择为第一主菜单第一附属菜单*/
	write_i2c(pt->fd_config, i2c_add, pt->p_config + 228, 12);
	i2c_add[1] = 240;
	/*开机设置默认选择为第一主菜单第一附属菜单*/
	write_i2c(pt->fd_config, i2c_add, pt->p_config  +240, 16);

	return 0;
}
예제 #3
0
static int __init trust_init(void)
{
	if(io == -1) {
		printk(KERN_ERR "You must set an I/O address with io=0x???\n");
		return -EINVAL;
	}
	if(!request_region(io, 2, "Trust FM Radio")) {
		printk(KERN_ERR "trust: port 0x%x already in use\n", io);
		return -EBUSY;
	}
	if(video_register_device(&trust_radio, VFL_TYPE_RADIO, radio_nr)==-1)
	{
		release_region(io, 2);
		return -EINVAL;
	}

	printk(KERN_INFO "Trust FM Radio card driver v1.0.\n");

	write_i2c(2, TDA7318_ADDR, 0x80);	/* speaker att. LF = 0 dB */
	write_i2c(2, TDA7318_ADDR, 0xa0);	/* speaker att. RF = 0 dB */
	write_i2c(2, TDA7318_ADDR, 0xc0);	/* speaker att. LR = 0 dB */
	write_i2c(2, TDA7318_ADDR, 0xe0);	/* speaker att. RR = 0 dB */
	write_i2c(2, TDA7318_ADDR, 0x40);	/* stereo 1 input, gain = 18.75 dB */

	tr_setvol(0x8000);
	tr_setbass(0x8000);
	tr_settreble(0x8000);
	tr_setstereo(1);

	/* mute card - prevents noisy bootups */
	tr_setmute(1);

	return 0;
}
예제 #4
0
void pmx::GpioBoard::setup()
{
	if (!connected_)
	{
		logger().error() << "setup() : GpioBoard NOT CONNECTED !" << utils::end;
		return;
	}

	write_i2c(CONFIG_P0, 0x00); //defines all pins on Port0 are outputs
	write_i2c(OUT_P0, 0x00); //clears all relays

	write_i2c(CONFIG_P1, 0xFF); //defines all pins on Port1 are inputs
	write_i2c(IN_P1, 0x00); //clears all relays
	usleep(PAUSE);
}
예제 #5
0
//Performs a software reset on all devices on the I2C bus
int I2C::softwareReset(void)
{
	char rst[] = {0x6};
	write_i2c(0x0,1,rst); //Software reset command
	
	return 0;
}
예제 #6
0
static int trust_s_ctrl(struct v4l2_ctrl *ctrl)
{
	struct radio_isa_card *isa =
		container_of(ctrl->handler, struct radio_isa_card, hdl);
	struct trust *tr = container_of(isa, struct trust, isa);

	switch (ctrl->id) {
	case V4L2_CID_AUDIO_BASS:
		write_i2c(tr, 2, TDA7318_ADDR, 0x60 | basstreble2chip[ctrl->val]);
		return 0;
	case V4L2_CID_AUDIO_TREBLE:
		write_i2c(tr, 2, TDA7318_ADDR, 0x70 | basstreble2chip[ctrl->val]);
		return 0;
	}
	return -EINVAL;
}
예제 #7
0
static int trust_initialize(struct radio_isa_card *isa)
{
	struct trust *tr = container_of(isa, struct trust, isa);

	tr->ioval = 0xf;
	write_i2c(tr, 2, TDA7318_ADDR, 0x80);	/* speaker att. LF = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xa0);	/* speaker att. RF = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xc0);	/* speaker att. LR = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0xe0);	/* speaker att. RR = 0 dB */
	write_i2c(tr, 2, TDA7318_ADDR, 0x40);	/* stereo 1 input, gain = 18.75 dB */

	v4l2_ctrl_new_std(&isa->hdl, &trust_ctrl_ops,
				V4L2_CID_AUDIO_BASS, 0, 15, 1, 8);
	v4l2_ctrl_new_std(&isa->hdl, &trust_ctrl_ops,
				V4L2_CID_AUDIO_TREBLE, 0, 15, 1, 8);
	return isa->hdl.error;
}
예제 #8
0
static int trust_s_mute_volume(struct radio_isa_card *isa, bool mute, int vol)
{
	struct trust *tr = container_of(isa, struct trust, isa);

	tr->ioval = (tr->ioval & 0xf7) | (mute << 3);
	outb(tr->ioval, isa->io);
	write_i2c(tr, 2, TDA7318_ADDR, vol ^ 0x1f);
	return 0;
}
예제 #9
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;
}
예제 #10
0
uint8_t read_pixel_temp(uint8_t pixel, uint8_t data_tpa[]){

	uint8_t byte = 1;
	uint8_t command;
	uint8_t bytes_read;

	//Festlegen des Rigsters ab dem gelesen werden soll, abhaenig vom Patam: pixel
	switch (pixel){

			//Alle pixel
			case 0:
				byte = 8;
				command = 2;
				break;
			case 1:
				command = 2;
				break;
			case 2:
				command = 3;
				break;
			case 3:
				command = 4;
				break;
			case 4:
				command = 5;
				break;
			case 5:
				command = 6;
				break;
			case 6:
				command = 7;
				break;
			case 7:
				command = 8;
				break;
			case 8:
				command = 9;
				break;
		}

	//Registernr an modul schreiben
	if(write_i2c(I2C_1, ADDR_TPA81, &command, 1) != 1)
		return -2;


	//Lesen der Daten vom Modul
	bytes_read = read_i2c(I2C_1, ADDR_TPA81, data_tpa, byte);

	//Pruefen ob die geforderten Bytes gelesen wurden
	if(bytes_read == byte)
		return bytes_read;

	return -1;

}
예제 #11
0
/**
 * nmk_i2c_xfer() - I2C transfer function used by kernel framework
 * @i2c_adap: Adapter pointer to the controller
 * @msgs: Pointer to data to be written.
 * @num_msgs: Number of messages to be executed
 *
 * This is the function called by the generic kernel i2c_transfer()
 * or i2c_smbus...() API calls. Note that this code is protected by the
 * semaphore set in the kernel i2c_transfer() function.
 *
 * NOTE:
 * READ TRANSFER : We impose a restriction of the first message to be the
 * 		index message for any read transaction.
 * 		- a no index is coded as '0',
 * 		- 2byte big endian index is coded as '3'
 * 		!!! msg[0].buf holds the actual index.
 * 		This is compatible with generic messages of smbus emulator
 * 		that send a one byte index.
 * 		eg. a I2C transation to read 2 bytes from index 0
 *			idx = 0;
 *			msg[0].addr = client->addr;
 *			msg[0].flags = 0x0;
 *			msg[0].len = 1;
 *			msg[0].buf = &idx;
 *
 *			msg[1].addr = client->addr;
 *			msg[1].flags = I2C_M_RD;
 *			msg[1].len = 2;
 *			msg[1].buf = rd_buff
 *			i2c_transfer(adap, msg, 2);
 *
 * WRITE TRANSFER : The I2C standard interface interprets all data as payload.
 *		If you want to emulate an SMBUS write transaction put the
 *		index as first byte(or first and second) in the payload.
 *		eg. a I2C transation to write 2 bytes from index 1
 *			wr_buff[0] = 0x1;
 *			wr_buff[1] = 0x23;
 *			wr_buff[2] = 0x46;
 *			msg[0].flags = 0x0;
 *			msg[0].len = 3;
 *			msg[0].buf = wr_buff;
 *			i2c_transfer(adap, msg, 1);
 *
 * To read or write a block of data (multiple bytes) using SMBUS emulation
 * please use the i2c_smbus_read_i2c_block_data()
 * or i2c_smbus_write_i2c_block_data() API
 */
static int nmk_i2c_xfer(struct i2c_adapter *i2c_adap,
		struct i2c_msg msgs[], int num_msgs)
{
	int status;
	int i;
	u32 cause;
	struct nmk_i2c_dev *dev = i2c_get_adapdata(i2c_adap);

	status = init_hw(dev);
	if (status)
		return status;

	clk_enable(dev->clk);

	/* setup the i2c controller */
	setup_i2c_controller(dev);

	for (i = 0; i < num_msgs; i++) {
		if (unlikely(msgs[i].flags & I2C_M_TEN)) {
			dev_err(&dev->pdev->dev, "10 bit addressing"
					"not supported\n");
			return -EINVAL;
		}
		dev->cli.slave_adr	= msgs[i].addr;
		dev->cli.buffer		= msgs[i].buf;
		dev->cli.count		= msgs[i].len;
		dev->stop = (i < (num_msgs - 1)) ? 0 : 1;
		dev->result = 0;

		if (msgs[i].flags & I2C_M_RD) {
			/* it is a read operation */
			dev->cli.operation = I2C_READ;
			status = read_i2c(dev);
		} else {
			/* write operation */
			dev->cli.operation = I2C_WRITE;
			status = write_i2c(dev);
		}
		if (status || (dev->result)) {
			/* get the abort cause */
			cause =	(readl(dev->virtbase + I2C_SR) >> 4) & 0x7;
			dev_err(&dev->pdev->dev, "error during I2C"
					"message xfer: %d\n", cause);
			dev_err(&dev->pdev->dev, "%s\n",
				cause >= ARRAY_SIZE(abort_causes)
				? "unknown reason" : abort_causes[cause]);
			clk_disable(dev->clk);
			return status;
		}
		udelay(I2C_DELAY);
	}
예제 #12
0
void GpioPCA9555::setValueP0(int port, int pin, int value)
{
	if (!connected_)
	{
		logger().error() << "setValueP0() : GpioBoard NOT CONNECTED !" << logs::end;
		return;
	}

	int out = 0;

	if (value == 1)
		out = port0Value_ | (0x01 << pin);
	else if (value == 0)
		out = port0Value_ & (0xFE << pin);

	write_i2c(port, out);
}
예제 #13
0
uint8_t read_umgebungs_temp(void){

	uint8_t temperatur = 0;

	//Festlegen des zu lesenden Registers
	uint8_t cmd_reg_1 = {1};

	//Registernr an modul schreiben
	if(write_i2c(I2C_1, ADDR_TPA81, &cmd_reg_1, 1) != 1)
		return -1;

	//Lesen der Umgebungstemperatur
	if(read_i2c(I2C_1, ADDR_TPA81, &temperatur, 1) != 1)
		return -1;
	
	//Rueckgabe der Umgebungstemperatur
	return temperatur;
}
예제 #14
0
uint8_t read_version_tpa81(void){

	uint8_t version = 0;

	//Festlegen des zu lesenden Registers
	uint8_t cmd_reg_0 = {0};
	
	//Registernr an modul schreiben
	if(write_i2c(I2C_1, ADDR_TPA81, &cmd_reg_0, 1) != 1)
		return -1;

	//Lesen der Versionsnummer
	if(read_i2c(I2C_1, ADDR_TPA81, &version, 1) != 1)
		return -1;

	//Rueckgabe der Verison
	return version;
}
예제 #15
0
void process_set_command(const char *command, int i2c_handle, char *reply, int reply_size)
{
	uint8_t address, reg, value;
	int n = sscanf(command, "set %hhd %hhd %hhd", &address, &reg, &value);
	if (n != 3) {
		fprintf(stderr, "ERROR => Incorrect arguments. Expected slave 2ddress, i2c register and value.\n");
		strcpy(reply, "ERROR\r\n");
		return;
	}

	int result = write_i2c(i2c_handle, address, reg, value, 1);
	if (result == -1) {
		char message[100];
		snprintf(message, sizeof(message),
			"ERROR => Error writing i2c value at address=%d, register=%d. The error was", 
			(int)address, (int)reg);
		perror(message);
		strcpy(reply, "ERROR\r\n");
		return;
	}

	strncpy(reply, "OK\r\n", reply_size);
}
예제 #16
0
int main (int argc, char *argv[])
{
	struct pci_access *pacc;
	struct pci_dev *dev;
	struct pci_filter filter;
	char *msg;
	uint16_t command;
	int v1_1 = 0, i2c;

	if (argc != 2 &&
	    ((argc != 3) ||
	     (!(v1_1 = !strcmp(argv[2], "1.1")) && strcmp(argv[2], "1.0")))) {
		fprintf(stderr,
			"VT6307 OHCI mode config\n"
			"Version 0.9\n"
			"Copyright (C) 2007 Krzysztof Halasa <*****@*****.**>\n"
			"\n"
			"Usage: vt6307ohciver <pci_device> [ 1.0 | 1.1 ]\n");
		exit(1);
	}

	if (iopl(3)) {
		fprintf(stderr, "iopl() failed (must be root)\n");
		exit(1);
	}

	pacc = pci_alloc();
	pci_filter_init(pacc, &filter);
	if ((msg = pci_filter_parse_slot(&filter, argv[1]))) {
		fprintf(stderr, "Invalid pci_device\n");
		exit(1);
	}

	filter.vendor = VENDOR_ID;
	filter.device = DEVICE_ID;

	pci_init(pacc);
	pci_scan_bus(pacc);

	for (dev = pacc->devices; dev; dev = dev->next)
		if (pci_filter_match(&filter, dev))
			break;

	if (!dev) {
		fprintf(stderr, "Device %s not found\n", argv[2]);
		exit(1);
	}

	pci_fill_info(dev, PCI_FILL_BASES | PCI_FILL_SIZES);

	if (dev->size[0] != MEM_SIZE || dev->size[1] != IO_SIZE) {
		fprintf(stderr, "Unexpected MEM/IO region size, is it"
			" VT6307 chip?\n");
		exit(1);
	}

	command = pci_read_word(dev, PCI_COMMAND);

	if ((command & PCI_COMMAND_IO) == 0) {
		fprintf(stderr, "Device disabled, trying to enable it\n");
		pci_write_word(dev, PCI_COMMAND, command | PCI_COMMAND_IO);
	}

	io_ports = dev->base_addr[1] & PCI_BASE_ADDRESS_IO_MASK;

	i2c = (inl(io_ports + 0x20) & 0x80) ? 0 : 1;

	fprintf(stderr, "I/O region #1 is at %04X\n", io_ports);
	fprintf(stderr, "It seems your VT6307 chip is connected to %s "
		"EEPROM\n", i2c ? "I^2C (24c01 or similar)" : "93c46");

	if (argc == 3) {
		/* enable direct access to pins */
		outl_p(inl(io_ports) | 0x80, io_ports);
		if (i2c)
			write_i2c(0x22, v1_1 ? 8 : 0);
		else
			write_4w(0x11, v1_1 ? 8 : 0);
		/* disable direct access to pins */
		outl_p(0x20, io_ports + 0x20);
		fprintf(stderr, "Please reboot\n");
	} else
		display(dev->base_addr[0] & PCI_BASE_ADDRESS_MEM_MASK);

	if ((command & PCI_COMMAND_IO) == 0) {
		fprintf(stderr, "Disabling device\n");
		pci_write_word(dev, PCI_COMMAND, command);
	}

	exit(0);
}
예제 #17
0
void interrupt isr(void) {
    if (TMR1IF) {
        TMR1IF = 0;
        if(switch_dur_mult >= SWITCH_ON_DURATION_MULT) {
           off();
        } else {
           switch_dur_mult++;
        }
    }
#ifdef DHT22_ENABLED
    if (TMR2IF) {
        TMR2IF = 0;
        switch (dht22_state) {
            case 1:
                start_read_dht22_pullup();
                break;
            default:
                dht22_abort();
        }
    }
#endif
    if (IOCIF) {
        asm("MOVLW 0xff");
#ifdef _12F1840
        asm("banksel IOCAF");
        asm("XORWF IOCAF, W");
        asm("ANDWF IOCAF, F");
#else
        asm("banksel IOCBF");
        asm("XORWF IOCBF, W");
        asm("ANDWF IOCBF, F");
#endif
        unsigned char t = TMR2;
        TMR2 = 0; // reset timeout
#ifdef _12F1840
        if (PORTAbits.RA4 == 0) {// we care only about HI => LO transition
#else
        if (PORTBbits.RB0 == 0) {// we care only about HI => LO transition            
#endif
            if (dht22_state < 4) {
                dht22_state++;
            } else {
                if (dht22_bit_index > 7) {
                    dht22_bit_index = 0;
                    dht22_index++;
                }
                if (t > DHT22_CUTOFF_TIME) {
                    dht22_bits[dht22_index] |= (1 << (7 - dht22_bit_index));
                }
                dht22_bit_index++;
                if (dht22_bit_index == 8 &&
                        dht22_index >= (DHT22_MAX_BYTES - 1)) {
                    unsigned char sum = dht22_bits[0] + dht22_bits[1] + dht22_bits[2] + dht22_bits[3];
                    if (sum != dht22_bits[4]) {// checksum doesn't match up?
                        // indicate error
                        dht22_bits[0] = dht22_bits[1] = dht22_bits[2] = dht22_bits[3] = 0;
                    }
                    dht22_abort();
                }
            }
        }
    }

    if (SSPIF) {
        unsigned char i2c_state = SSPSTAT & 0b00100100;
        // 0b00100000 = D/nA
        // 0b00000100 = R/nW
        // prevent overflow
        if (rx_index >= RX_SIZE) {
            rx_index = 0;
        }
        switch (i2c_state) {
            case 0b00000000: // STATE1: Maser Write, Last Byte = Address
                rx_index = 0;
                command = 0;
                // do a dummy read
                rx_buffer[0] = SSPBUF;
                for (int i = 0; i < RX_SIZE; i++) {
                    rx_buffer[i] = 0;
                }
                break;
            case 0b00100000: // STATE2: Maser Write, Last Byte = Data
                rx_buffer[rx_index++] = SSPBUF;
                if (rx_index == 1) {
                    command = rx_buffer[0]; // save command
                    // input
                    switch (command) {
                        case 0x78:
                            ENTER_BOOTLOADER = 1;
                            asm("pagesel 0x000");
                            asm("goto 0x000");
                            break;
                        case 0x12:
                            start_read_dht22();
                            break;
                    }
                }
                if (rx_index == 2) {
                    // input
                    switch (command) {
                        case 0x01:
                            counter++;
                            on(rx_buffer[1]);
                            break;
                    }
                }
                break;
            case 0b00000100: // STATE3: Maser Read, Last Byte = Address
                rx_index = 0;
            case 0b00100100: // STATE4: Maser Read, Last Byte = Data
                // output
                switch (command) {
                    case 0x01:
                        if(rx_index == 0)
                            rx_buffer[0] = counter;
                        break;
                    case 0x13: // read humidity
                        rx_buffer[0] = dht22_bits[1];
                        rx_buffer[1] = dht22_bits[0];
                        break;
                    case 0x14: // // read temperature
                        rx_buffer[0] = dht22_bits[3];
                        rx_buffer[1] = dht22_bits[2];
                        break;
                    default:
                        rx_buffer[0] = rx_buffer[1] = 0;
                }
                write_i2c(rx_buffer[rx_index++]);
                break;
        }
        SSPCON1bits.CKP = 1;
        SSPIF = 0;
    }

}
예제 #18
0
파일: camera.c 프로젝트: XHelaoshi/USER
void Camera_thread_entry (void* parameter)
{
		uint8_t ret=0;
	  int i,fd;
	int ttt;
	//等待TIM3 初始化完毕
	 rt_sem_take(&rt_tim3_sem, RT_WAITING_FOREVER);
		rt_memset((void*)RAM_Buffer,0,JPEG_BUFFER_CNT*(JPEG_BUFFER_SIZE+1));
		//RAM_Buffer[JPEG_BUFFER_CNT*(JPEG_BUFFER_SIZE+1)-1]=0xff;
	  ret=CF5642C_init();
	  if(1==ret)
		{
			//Prepair for Camera to SPI LCD

		  Cam_Stop();
		  Camera_key();
			
			while(1)
			{
				
				CF5642C_DMA_Init();
				write_i2c(0x3503, 0x0);//to enable AGC/AEC
				write_i2c(0x3b07 ,0x0a);//return to rolling strobe
				rt_memset((void*)RAM_Buffer,0,4*JPEG_BUFFER_CNT*(JPEG_BUFFER_SIZE+1));
				//rt_memset((void*)RAM_Buffer,0,1);
				rt_kprintf("waiting for shutter...\n");
				while(!cam_capture_ok){}
					cam_capture_ok=0;
					soi_index=0;
				eoi_index=0;
				tail_index=0;
				jpeg_soi_flag=0;
				jpeg_eoi_flag=0;
				Cam_Capture();
				rt_sem_take(&rt_camera_sem, RT_WAITING_FOREVER);
				while(!dma_freebuf_ok){}
					dma_freebuf_ok = 0;
					for(i=0;i<JPEG_BUFFER_CNT*(JPEG_BUFFER_SIZE+1);i++)
					{
						
						temp1 = RAM_Buffer[i]&0xff;
						temp2 = RAM_Buffer[i]>>8&0xff;
						temp3 = RAM_Buffer[i]>>16&0xff;
						temp4 = RAM_Buffer[i]>>24&0xff;
						
						if((temp1 == 0xff)&&(temp2 == 0xd8))
						{
							jpeg_soi_flag	=1;
							soi_index	= i;						
						}
						else if((temp2 == 0xff)&&(temp3 == 0xd8))
						{
							jpeg_soi_flag	=1;	
							soi_index	= i;
						}
						else if((temp3 == 0xff)&&(temp4 == 0xd8))
						{
							jpeg_soi_flag	=1;	
							soi_index	= i;
						}					
						if(jpeg_soi_flag == 1){
//							rt_kprintf("%02x",temp1);
//							rt_kprintf("%02x",temp2);
//							rt_kprintf("%02x",temp3);
//							rt_kprintf("%02x",temp4);					
							//search for eoi
							if((temp1 == 0xff)&&(temp2 == 0xd9))//[][][2][1]
						{
//							if(jpeg_off_flag == 1)
//								goto next;
//							else
//								jpeg_off_flag++;	
							jpeg_eoi_flag	=1;
							eoi_index	= i;
							tail_index = 2;
							goto next;
						}
						else if((temp2 == 0xff)&&(temp3 == 0xd9))//[][3][2][]
						{
							jpeg_eoi_flag	=1;	
							eoi_index	= i;
							tail_index = 1;
							goto next;
						}
						else if((temp3 == 0xff)&&(temp4 == 0xd9))//[4][3][][]
						{
							jpeg_eoi_flag	=1;	
							eoi_index	= i;
							tail_index = 0;
							goto next;
						}	
						else if((tempp == 0xff)&&(temp1 == 0xd9))//[][][][1] | [4]
						{
							jpeg_eoi_flag	=1;	
							eoi_index	= i;
							tail_index = 3;
							goto next;
						}
						tempp = temp4;
					}
					}
		next:	Cam_Stop();		
					rt_kprintf("start write \n");
					
					sprintf(file_string,"%d",file_index);
					file_index++;
					mywrite_usb(file_string);
//			fd = open("/ud/text.text", O_WRONLY | O_CREAT,0);	
//			if (fd >= 0)
//			{
//				//TIM_Cmd(TIM3,ENABLE);
//			
//					write(fd,(uint8_t *)&RAM_Buffer[soi_index-1], eoi_index-soi_index+2);					
//					//rt_kprintf("%d\n", count);
//				
//				
//				close(fd);
//			}
//			rt_kprintf("write over\n");
										
				
/******				
				TM_ILI9341_Rotate(TM_ILI9341_Orientation_Landscape_2);
				TM_ILI9341_SetCursorPosition(0, 0, picture_x - 1, picture_y - 1);
				TM_ILI9341_SendCommand(ILI9341_GRAM);	
						//Wirte GRAM
				ILI9341_WRX_SET;
				for (i = 0; i < picture_x*picture_y; i++) 
				{
					ILI9341_CS_RESET;
					ILI9341_SPI->DR=(RAM_Buffer[i])&0xff;
					while (!SPI_I2S_GetFlagStatus(ILI9341_SPI, SPI_I2S_FLAG_TXE));
					ILI9341_CS_SET;
					
					ILI9341_CS_RESET;		
					ILI9341_SPI->DR=(RAM_Buffer[i]>>8)&0xff;			
					while (!SPI_I2S_GetFlagStatus(ILI9341_SPI, SPI_I2S_FLAG_TXE));
					ILI9341_CS_SET;
				}
				if(camera_status==0)
				{
					TM_ILI9341_Rotate(TM_ILI9341_Orientation_Portrait_1);
					LCD_SetCursor(0,0);
				}
				*******/
			}
		}
예제 #19
0
int sysI2cWrite(unsigned char addr_i2c, unsigned char *data, unsigned int bufsize)
{
  int nmax=1000;
  while((nmax>0)&&(write_i2c(addr_i2c,data,bufsize)==FALSE)){ nmax--;__no_operation(); }
  return nmax;
}
예제 #20
0
static void tr_setvol(__u16 vol)
{
	curvol = vol / 2048;
	write_i2c(2, TDA7318_ADDR, curvol ^ 0x1f);
}
예제 #21
0
static void tr_setbass(__u16 bass)
{
	curbass = bass / 4370;
	write_i2c(2, TDA7318_ADDR, 0x60 | basstreble2chip[curbass]);
}
예제 #22
0
void update_x_translation(void){
	write_i2c (SENSORS_I2C, MPU6050_ADDR, 0x01, 0x01);
	read_i2c (SENSORS_I2C, MPU6050_ADDR, 0x01);
}
예제 #23
0
int main(int argc, char **argv, char **envp) {
	
	int file;
	const char *filename = "/dev/i2c-1";
	if((file = open(filename, O_RDWR)) < 0) {
		perror("Failed to open the i2c bus.\n");
		exit(1);
	}
	
	int device_addr = 0x53;
	if(ioctl(file, I2C_SLAVE, device_addr) < 0) {
		printf("Failed to acquire bus and/or talk to slave.\n");
		exit(1);
	}
	
	write_i2c(file, 0x2c, SAMPLING_RATE); //BW_RATE -- Last 4 bits = sampling rate
	write_i2c(file, 0x31, 0x20 | RANGE); //DATA_FORMAT -- Last 2 bits = range
	write_i2c(file, 0x2e, 0x02); //INT_ENABLE
	write_i2c(file, 0x38, 0x41); //FIFO_CTL
	write_i2c(file, 0x2d, 0x08); //POWER_CTL
	
	int buttons[] = BUTTON_GPIO_PINS;
	int button_size = sizeof(buttons)/sizeof(buttons[0]);
	int button_active_edges[] = BUTTON_ACTIVE_EDGES;
	
	struct pollfd fdset[button_size];
	int nfds = button_size;	
	int gpio_fd[button_size];
	int button;
	for(button = 0; button < button_size; button++)
	{
		gpio_export(buttons[button]);
		gpio_set_dir(buttons[button], "in");
		gpio_set_edge(buttons[button], button_active_edges[button] ? "rising" : "falling");
		gpio_fd[button] = gpio_fd_open(buttons[button], O_RDONLY);
	}
	int num_samples = 0;
	long int z_nooffset = 0;
	long int z_accumulator = 0;
	long int previous_z_accumulator = 0;
	long int z_diff = 0;
	long int previous_z = 0;
	long int z_jerk_fifo[QUEUE_LENGTH] = {0};
	long int z_accel_fifo[QUEUE_LENGTH] = {0};
	while(1) {

		memset((void*)fdset, 0, sizeof(fdset));
		for(button = 0; button < button_size; button++) {		
			fdset[button].fd = gpio_fd[button];
			fdset[button].events = POLLPRI;
		}
		poll(fdset, nfds, 100);
		for(button = 0; button < button_size; button++) {
			if(fdset[button].revents & POLLPRI) {
				char buf[1];
				read(fdset[button].fd, buf, 1);
				
				int button_state;
				gpio_get_value(buttons[button], &button_state);
				while(button_state == button_active_edges[button]) {
					char write_buf[1];
					write_buf[0] = 0x32;
					if(write(file, write_buf,1) != 1) {
						printf("Failed to write to the i2c bus.\n");
					}

					int reg_num;
					signed char read_buf[6];
					if(read(file, read_buf, 6) != 6) {
						printf("Failed to read from the i2c bus.\n");
					}
					else {
						long int z_data = ((((long int)read_buf[5]) << 8) 
							| (0xff & read_buf[4]));
						num_samples++;
						
						if( num_samples > 1 ) {
							z_diff = (z_data - previous_z);
							z_nooffset += (z_diff - 
								z_jerk_fifo[QUEUE_LENGTH - 1]); 
							z_accumulator = (z_nooffset);
						}
							
						/*if( num_samples % 1 == 0 ) {
							printf("                          \r");
							printf("Current vel = %d\r", z_nooffset);
							fflush(stdout);
						}*/
						
						if( (z_accumulator * previous_z_accumulator) < 0
							&& abs(z_accumulator - 
							previous_z_accumulator) > 50 ) {
							
							// Put stuff to do on hits here!
							printf("HIT!\n");
							printf("Acceleration = %d.\n", z_nooffset);
							fflush(stdout);
						}
						
						int index;
						for( index = QUEUE_LENGTH - 1; 
							index >= 0; index-- ){
							z_jerk_fifo[index] = z_jerk_fifo[index - 1];
							z_accel_fifo[index] = z_accel_fifo[index - 1];
						}
						z_jerk_fifo[0] = z_diff;
						z_accel_fifo[0] = z_nooffset;
						previous_z = z_data;
						previous_z_accumulator = z_accumulator;
					}
					gpio_get_value(buttons[button], &button_state);
				}
			}
		}	
	}
}
예제 #24
0
static void tr_settreble(__u16 treble)
{
	curtreble = treble / 4370;
	write_i2c(2, TDA7318_ADDR, 0x70 | basstreble2chip[curtreble]);
}