void magnetometer_init() {
i2c_write_register(MAGNETOMETER_I2C_ADDR,
MAGNETOMETER_REG_CONF_A_ADDR,
MAGNETOMETER_REG_CONF_A_SETTING);
i2c_write_register(MAGNETOMETER_I2C_ADDR,
MAGNETOMETER_REG_CONF_B_ADDR,
MAGNETOMETER_REG_CONF_B_SETTING);
magnetometer_enable();
magnetometer_configured = TRUE;
}
void large_range_accel_init() {
uint8_t reg[]={LARGE_RANGE_ACCEL_REG_CTRL_REGC_ADDR,LARGE_RANGE_ACCEL_REG_CTRL_REGC_SETTING};
large_range_accel_vars.configured = FALSE;
P5OUT |= 0x10; // set P5.4 as output
P5DIR |= 0x10; // set P5.4 high to enable I2C
i2c_write_register(1,LARGE_RANGE_ACCEL_I2C_ADDR, sizeof(reg), reg);
reg[0]=LARGE_RANGE_ACCEL_REG_CTRL_REGB_ADDR;
reg[1]=LARGE_RANGE_ACCEL_REG_CTRL_REGB_SETTING;
i2c_write_register(1,LARGE_RANGE_ACCEL_I2C_ADDR, sizeof(reg), reg);
large_range_accel_vars.configured = TRUE;
}
void large_range_accel_init() {
P5OUT |= 0x10; // set P5.4 as output
P5DIR |= 0x10; // set P5.4 high to enable I2C
i2c_write_register(LARGE_RANGE_ACCEL_I2C_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGC_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGC_SETTING);
i2c_write_register(LARGE_RANGE_ACCEL_I2C_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGB_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGB_SETTING);
large_range_accel_configured = TRUE;
}
void MPU6050_Initialize()
{
// Configure Gyroscope
i2c_write_register(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_GYRO_CONFIG, 0x00);
// Configure Accelerometer
i2c_write_register(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_ACCEL_CONFIG, 0x10);
// Set clock source and disable sleep mode
i2c_write_register(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_ACCEL_CONFIG, 0x00);
}
void pcf8583_init(void) {
uint8_t tmp[4];
rtc_state = RTC_NOT_FOUND;
uart_puts_P(PSTR("RTC "));
if (i2c_write_register(PCF8583_ADDR, REG_CONTROL, CTL_START_CLOCK) ||
i2c_read_registers(PCF8583_ADDR, REG_YEAR1, 4, tmp)) {
uart_puts_P(PSTR("not found"));
} else {
if (tmp[0] == (tmp[2] ^ 0xff) &&
tmp[1] == (tmp[3] ^ 0xff)) {
rtc_state = RTC_OK;
uart_puts_P(PSTR("ok"));
/* Dummy RTC read to update the year if required */
struct tm time;
read_rtc(&time);
} else {
rtc_state = RTC_INVALID;
uart_puts_P(PSTR("invalid"));
}
}
uart_putcrlf();
}
static int tuner_attach_mt2060(struct ngene_channel *chan)
{
struct ngene *dev = chan->dev;
void *tconf = dev->card_info->tuner_config[chan->number];
u8 drxa = dev->card_info->demoda[chan->number];
struct dvb_frontend *fe = chan->fe, *fe2;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
fe->misc_priv = chan;
#else
fe->sec_priv = chan;
#endif
fe->ops.i2c_gate_ctrl = dev->card_info->gate_ctrl;
dev->card_info->gate_ctrl(fe, 1);
fe2 = mt2060_attach(fe, &chan->i2c_adapter, tconf, 1220);
dev->card_info->gate_ctrl(fe, 0);
i2c_write_register(&chan->i2c_adapter, drxa, 3, 4);
write_demod(&chan->i2c_adapter, drxa, 0x1012, 15);
write_demod(&chan->i2c_adapter, drxa, 0x1007, 0xc27);
write_demod(&chan->i2c_adapter, drxa, 0x0020, 0x003);
return fe2 ? 0 : -ENODEV;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
CHIP_Init();
//delay(100);
I2C_HMC_Initialization();
// Offset zero is Device ID
GPIO_I2C1Init();
uint16_t value = i2c_read_register(0);
// Set an LED on the Starter Kit if success
if (value == DEVICE_ID) {
/// set_led(1,1);
}
i2c_write_register(ConfigurationRegisterA,0x70);
//i2c_write_register(ConfigurationRegisterB,0xA0);//..for Gain = 5
i2c_write_register(ConfigurationRegisterB,0x80);//..440lsb/Gauss
i2c_write_register(ModeRegister,Measurement_SingleShot);
//uint16_t valuex = i2c_read_register(0x06);
for (int i=0;i<100;i++);
int8_t RecData[6] = {0,0,0,0,0,0};
int16_t XVal = 0, YVal = 0, ZVal = 0;
int i =0;
// Measurement data starts at DATAX0, and ends at DATAZ1, 6 bytes long
cmd_array[0] = DataRegisterBegin;
// Read 6 bytes at once
i2c_transfer(HMC_ADDRESS, cmd_array, data_array, 1, 6, I2C_FLAG_WRITE_READ);
XVal = (data_array[1]<<8) | data_array[0];
ZVal = (data_array[3]<<8) | data_array[2];
YVal = (data_array[5]<<8) | data_array[4];
// Infinite loop
while (1){
}
}
char l3gd20_init( L3GD20Unit *unit, uint8_t address , L3GD20DataRate rate, L3GD20FullScale scale )
{
/* 初期化 */
uint8_t data;
unit->address = address;
/* デバイスID確認 */
if ( !i2c_read_register( unit->address, 0x0F, &data, 1, I2CPolling ) ) {
return 0;
}
/* デバイスIDが間違っていれば失敗 */
if ( data != 0xD4 ) {
return 0;
}
/* バンド幅とデーターレート設定 */
data = rate | 0x30 | 0x07;
unit->ctrl_1 = data;
if ( !i2c_write_register( unit->address, 0x20, &data, 1, I2CPolling ) ) {
return 0;
}
/* フルスケールを設定，データ読み込み中にデーターが更新されないようにしている */
data = 0x80 | scale;
if ( !i2c_write_register( unit->address, 0x23, &data, 1, I2CPolling ) ) {
return 0;
}
/* FIFOを有効にする */
data = 0x04;
if ( !i2c_write_register( unit->address, 0x24, &data, 1, I2CPolling ) ) {
return 0;
}
return 1;
}
/* Set the time in the RTC */
void dsrtc_set(struct tm *time) {
uint8_t tmp[7];
if (rtc_state == RTC_NOT_FOUND)
return;
tmp[REG_SECOND] = int2bcd(time->tm_sec);
tmp[REG_MINUTE] = int2bcd(time->tm_min);
tmp[REG_HOUR] = int2bcd(time->tm_hour);
tmp[REG_DOW] = int2bcd(time->tm_wday+1);
tmp[REG_DOM] = int2bcd(time->tm_mday);
tmp[REG_MONTH] = int2bcd(time->tm_mon+1) | 0x80 * (time->tm_year >= 2100);
tmp[REG_YEAR] = int2bcd(time->tm_year % 100);
i2c_write_registers(RTC_ADDR, REG_SECOND, 7, tmp);
i2c_write_register(RTC_ADDR, REG_CONTROL, 0); // 3231: enable oscillator on battery, interrupts off
// 1307: disable SQW output
#ifdef CONFIG_RTC_DS3231
i2c_write_register(RTC_ADDR, REG_CTLSTATUS, 0); // clear "oscillator stopped" flag
#endif
rtc_state = RTC_OK;
}
// Turns on interrupts, sets up the thresholds, and enables interrupts on the ADXL345
void i2c_init_registers()
{
// Set range to 16g and FULL resolution
i2c_write_register(ADXL345_REG_DATA_FORMAT, ADXL345_RANGE_16_G );
// ADXL_BW_RATE = 50 hz, limited by I2C speed
i2c_write_register(ADXL345_REG_BW_RATE, ADXL345_DATARATE_50_HZ);
// Set up threshold for activity, found through trial and error
i2c_write_register(ADXL345_REG_THRESH_ACT, 0x90);
// Turn on the axes that will participate
i2c_write_register(ADXL345_REG_ACT_INACT_CTL, ADXL345_ACT_ac_dc | ADXL345_ACT_X | ADXL345_ACT_Y | ADXL345_ACT_Z);
// Set up interrupt outputs, sent to INT1 pin by default
i2c_write_register(ADXL345_REG_INT_ENABLE, ADXL345_INT_Activity );
//uint32_t value = i2c_read_register(ADXL345_REG_INT_ENABLE);
// Clear interrupts by reading the INT_SOURCE register
i2c_read_register(ADXL345_REG_INT_SOURCE);
// Start measurement
i2c_write_register(ADXL345_REG_POWER_CTL, 0x08);
}
/* Set the time in the RTC */
void pcf8583_set(struct tm *time) {
union {
uint8_t bytes[5];
uint16_t words[2];
} tmp;
if (rtc_state == RTC_NOT_FOUND)
return;
i2c_write_register(PCF8583_ADDR, REG_CONTROL, CTL_STOP_CLOCK);
tmp.bytes[0] = int2bcd(time->tm_sec);
tmp.bytes[1] = int2bcd(time->tm_min);
tmp.bytes[2] = int2bcd(time->tm_hour);
tmp.bytes[3] = int2bcd(time->tm_mday) | ((time->tm_year & 3) << 6);
tmp.bytes[4] = int2bcd(time->tm_mon+1)| ((time->tm_wday ) << 5);
i2c_write_registers(PCF8583_ADDR, REG_SECONDS, 5, &tmp);
tmp.words[0] = time->tm_year + 1900;
tmp.words[1] = (time->tm_year + 1900) ^ 0xffffU;
i2c_write_registers(PCF8583_ADDR, REG_YEAR1, 4, &tmp);
i2c_write_register(PCF8583_ADDR, REG_CONTROL, CTL_START_CLOCK);
rtc_state = RTC_OK;
}
char l3gd20_start( L3GD20Unit *unit )
{
/* パワーダウン解除 */
uint8_t data;
data = unit->ctrl_1 | 0x08;
if ( !i2c_write_register( unit->address, 0x20, &data, 1, I2CPolling ) ) {
return 0;
}
return 1;
}
char l3gd20_stop( L3GD20Unit *unit )
{
/* パワーダウンへ */
uint8_t data;
data = unit->ctrl_1 & ~0x08;
/* 修正 */
if ( !i2c_write_register( unit->address, 0x20, &data, 1, I2CPolling ) ) {
return 0;
}
return 1;
}
int main(int argc, char **argv)
{
// Initialize TIC
isr_init();
tic_init();
irq_set_mask(0x000FFFFF);
//irq_enable();
// Initialize I2C Core
i2c_core_init(0x00, 0xC7);
//MPU6050_Initialize();
for(;;)
{
i2c_write_register(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_WHO_AM_I, 0x00);
}
//i2c_test();
//spi_test();
//gpio_test();
//uart_test();
//timer_test();
}
void magnetometer_enable() {
i2c_write_register(MAGNETOMETER_I2C_ADDR,
MAGNETOMETER_REG_MODE_ADDR,
MAGNETOMETER_REG_MODE_WAKEUP);
}
void large_range_accel_disable() {
i2c_write_register(LARGE_RANGE_ACCEL_I2C_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGB_ADDR,
LARGE_RANGE_ACCEL_REG_CTRL_REGB_SLEEP);
}
void magnetometer_disable() {
i2c_write_register(MAGNETOMETER_I2C_ADDR,
MAGNETOMETER_REG_MODE_ADDR,
MAGNETOMETER_REG_MODE_SLEEP);
}
void large_range_accel_disable() {
uint8_t reg[]={LARGE_RANGE_ACCEL_REG_CTRL_REGB_ADDR,LARGE_RANGE_ACCEL_REG_CTRL_REGB_SLEEP};
i2c_write_register(1,LARGE_RANGE_ACCEL_I2C_ADDR, sizeof(reg), reg);
}
