void Tile::set_air(int air){
airID = air;
if(air==2){
set_range(150);
towerCost+=50;
chargeRate = 40;
upgradeCost = 100;
damage = 20;
}
if(air==3){
set_range(100);
towerCost+=150;
chargeRate = 20;
upgradeCost = 150;
damage = 30;
}
if(air==4){
set_range(125
);
towerCost+=100;
chargeRate = 20;
upgradeCost = 100;
}
if(air==5){
set_range(200);
towerCost+=200;
chargeRate = 20;
upgradeCost = 150;
damage = 100;
}
}
static int init(const struct motion_sensor_t *s)
{
int ret = 0, tmp;
ret = raw_read8(s->addr, LSM6DS0_WHO_AM_I_REG, &tmp);
if (ret)
return EC_ERROR_UNKNOWN;
if (tmp != LSM6DS0_WHO_AM_I)
return EC_ERROR_ACCESS_DENIED;
/*
* This sensor can be powered through an EC reboot, so the state of
* the sensor is unknown here. Initiate software reset to restore
* sensor to default.
* [6] BDU Enable Block Data Update.
* [0] SW_RESET software reset
*
* lsm6ds0 supports both accel & gyro features
* Board will see two virtual sensor devices: accel & gyro.
* Requirement: Accel need be init before gyro.
* SW_RESET is down for accel only!
*/
if (MOTIONSENSE_TYPE_ACCEL == s->type) {
mutex_lock(s->mutex);
ret = raw_read8(s->addr, LSM6DS0_CTRL_REG8, &tmp);
if (ret) {
mutex_unlock(s->mutex);
return EC_ERROR_UNKNOWN;
}
tmp |= (1 | LSM6DS0_BDU_ENABLE);
ret = raw_write8(s->addr, LSM6DS0_CTRL_REG8, tmp);
mutex_unlock(s->mutex);
if (ret)
return EC_ERROR_UNKNOWN;
/* Power Down Gyro */
ret = raw_write8(s->addr,
LSM6DS0_CTRL_REG1_G, 0x0);
if (ret)
return EC_ERROR_UNKNOWN;
ret = set_range(s, s->default_range, 1);
if (ret)
return EC_ERROR_UNKNOWN;
}
if (MOTIONSENSE_TYPE_GYRO == s->type) {
/* Config GYRO Range */
ret = set_range(s, s->default_range, 1);
if (ret)
return EC_ERROR_UNKNOWN;
}
CPRINTF("[%T %s: MS Done Init type:0x%X range:%d]\n",
s->name, s->type, get_range(s));
return ret;
}
void
SliderControl::port_property_changed(const URI& key, const Atom& value)
{
_enable_signal = false;
const Shared::LV2URIMap& uris = App::instance().uris();
if (key == uris.lv2_minimum && value.type() == Atom::FLOAT)
set_range(value.get_float(), _slider->get_adjustment()->get_upper());
else if (key == uris.lv2_maximum && value.type() == Atom::FLOAT)
set_range(_slider->get_adjustment()->get_lower(), value.get_float());
_enable_signal = true;
}
void *gen_class(char *inf)
{
if(*inf == '[')
{ inf++;
if(inf[strlen(inf) - 1] == ']') inf[strlen(inf) - 1] = 0;
else return NULL; }
int state;
void *ret = malloc(32);
if(*inf == '^') { memset(ret, 0xFF, 32); state = 0; inf++; }
else { memset(ret, 0x00, 32); state = 1; }
if(*inf == '-')
{ flp_item(ret, '-'); inf++; }
else if(inf[strlen(inf) - 1] == '-')
{ flp_item(ret, '-'); inf[strlen(inf) - 1] = 0; }
while(*inf)
{
if(*inf == '-')
{
set_range(ret, inf[-1], inf[1], state);
}
else set_item(ret, inf[0], state);
inf++;
}
return ret;
}
void
SliderControl::set_value(const Atom& atom)
{
if (_enabled) {
_enable_signal = false;
float val = atom.get_float();
if (_port_model->is_integer())
val = lrintf(val);
if (_slider->get_value() != val) {
const Gtk::Adjustment* range = _slider->get_adjustment();
const float lower = range->get_lower();
const float upper = range->get_upper();
if (val < lower || val > upper)
set_range(min(lower, val), max(lower, val));
_slider->set_value(val);
}
if (_value_spinner->get_value() != val)
_value_spinner->set_value(val);
_enable_signal = true;
}
}
/*programe main entry*/
int main(const int argc, const char *argv[]) {
char option[BUFSIZE];
int to_print[BUFSIZE];
int negate = 0;
int fpos;
int type;
int i;
FILE *fp;
type = get_valid_com(argc, argv, option, &negate, &fpos);
if (type == 0)
return 1;
if (!set_range(option, to_print, negate))
return 2;
for (i = fpos; i < argc; i++) {
if ((fp = fopen(argv[i], "r+b")) == 0) {
perror("fopen");
return 3;
}
if (type == 1)
display_c(fp, to_print);
else
display_f(fp, to_print);
if (fclose(fp) != 0) {
perror("fclose");
return 4;
}
}
return 0;
}
int
lis331_attach(struct spi_dev_s *spi, int spi_id)
{
int result = ERROR;
lis331_dev.spi = spi;
SPI_LOCK(lis331_dev.spi, true);
/* verify that the device is attached and functioning */
if (read_reg(ADDR_WHO_AM_I) == WHO_I_AM) {
/* set default configuration */
write_reg(ADDR_CTRL_REG2, 0); /* disable interrupt-generating high-pass filters */
write_reg(ADDR_CTRL_REG3, 0); /* no interrupts - we don't use them */
write_reg(ADDR_CTRL_REG5, 0); /* disable wake-on-interrupt */
set_range(LIS331_RANGE_4G);
set_rate(LIS331_RATE_400Hz); /* takes device out of low-power mode */
/* make ourselves available */
register_driver("/dev/lis331", &lis331_fops, 0666, NULL);
result = 0;
} else {
errno = EIO;
}
SPI_LOCK(lis331_dev.spi, false);
return result;
}
void cGtkmmScrollBar::SetRange(int64_t _min, int64_t _max)
{
min = _min;
max = _max;
set_range(min, max);
}
int
HMC5883::init()
{
int ret = ERROR;
/* do I2C init (and probe) first */
if (I2C::init() != OK)
goto out;
/* allocate basic report buffers */
_num_reports = 2;
_reports = new struct mag_report[_num_reports];
if (_reports == nullptr)
goto out;
_oldest_report = _next_report = 0;
/* get a publish handle on the mag topic */
memset(&_reports[0], 0, sizeof(_reports[0]));
_mag_topic = orb_advertise(ORB_ID(sensor_mag), &_reports[0]);
if (_mag_topic < 0)
debug("failed to create sensor_mag object");
/* set range */
set_range(_range_ga);
ret = OK;
/* sensor is ok, but not calibrated */
_sensor_ok = true;
out:
return ret;
}
int set_localiprange (char *word, char *value, int context, void *item)
{
struct lns *lns = (struct lns *) item;
switch (context & ~CONTEXT_DEFAULT)
{
case CONTEXT_LNS:
break;
default:
snprintf (filerr, sizeof (filerr), "'%s' not valid in this context\n",
word);
return -1;
}
if (lns->localaddr) {
snprintf (filerr, sizeof (filerr), "'local ip range' and 'local ip' are mutually exclusive\n");
return -1;
}
lns->localrange = set_range (word, value, lns->localrange);
if (!lns->localrange)
return -1;
#ifdef DEBUG_FILE
l2tp_log (LOG_DEBUG, "range start = %x, end = %x, sense=%ud\n",
ntohl (lns->range->start), ntohl (lns->range->end), lns->range->sense);
#endif
return 0;
}
ProgressWindow::ProgressWindow(ContainerWindow &parent)
{
set(parent,
InfoBoxLayout::landscape
? (LPCTSTR)IDD_PROGRESS_LANDSCAPE
: (LPCTSTR)IDD_PROGRESS);
TCHAR Temp[1024];
_stprintf(Temp, _T("%s %s"), gettext(_T("Version")), XCSoar_Version);
set_item_text(IDC_VERSION, Temp);
#ifdef WINDOWSPC
RECT rc = parent.get_client_rect();
RECT rcp = get_client_rect();
move(rc.left, rc.top, rcp.right - rcp.left, rcp.bottom - rcp.top);
#else
#ifndef GNAV
SHFullScreen(hWnd, SHFS_HIDETASKBAR|SHFS_HIDESIPBUTTON|SHFS_HIDESTARTICON);
#endif
#endif
insert_after(HWND_TOP, true);
set_range(0, 100);
set_step(5);
#ifndef ENABLE_SDL
::SetForegroundWindow(hWnd);
#endif /* !ENABLE_SDL */
update();
}
void
FXAS21002C::reset()
{
/* write 0 0 0 000 00 = 0x00 to CTRL_REG1 to place FXOS21002 in Standby
* [6]: RST=0
* [5]: ST=0 self test disabled
* [4-2]: DR[2-0]=000 for 200Hz ODR
* [1-0]: Active=0, Ready=0 for Standby mode
*/
write_reg(FXAS21002C_CTRL_REG1, 0);
/* write 0000 0000 = 0x00 to CTRL_REG0 to configure range and filters
* [7-6]: BW[1-0]=00, LPF 64 @ 800Hz ODR
* [5]: SPIW=0 4 wire SPI
* [4-3]: SEL[1-0]=00 for 10Hz HPF at 200Hz ODR
* [2]: HPF_EN=0 disable HPF
* [1-0]: FS[1-0]=00 for 1600dps (TBD CHANGE TO 2000dps when final trimmed parts available)
*/
write_checked_reg(FXAS21002C_CTRL_REG0, CTRL_REG0_BW_LOW | CTRL_REG0_FS_2000_DPS);
/* write CTRL_REG1 to configure 800Hz ODR and enter Active mode */
write_checked_reg(FXAS21002C_CTRL_REG1, CTRL_REG1_DR_800HZ | CTRL_REG1_ACTIVE);
/* Set the default */
set_samplerate(0);
set_range(FXAS21002C_DEFAULT_RANGE_DPS);
set_onchip_lowpass_filter(FXAS21002C_DEFAULT_ONCHIP_FILTER_FREQ);
_read = 0;
}
void
L3GD20::reset()
{
// ensure the chip doesn't interpret any other bus traffic as I2C
disable_i2c();
/* set default configuration */
write_reg(ADDR_CTRL_REG1, REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE);
write_reg(ADDR_CTRL_REG2, 0); /* disable high-pass filters */
write_reg(ADDR_CTRL_REG3, 0); /* no interrupts - we don't use them */
write_reg(ADDR_CTRL_REG4, REG4_BDU);
write_reg(ADDR_CTRL_REG5, 0);
write_reg(ADDR_CTRL_REG5, REG5_FIFO_ENABLE); /* disable wake-on-interrupt */
/* disable FIFO. This makes things simpler and ensures we
* aren't getting stale data. It means we must run the hrt
* callback fast enough to not miss data. */
write_reg(ADDR_FIFO_CTRL_REG, FIFO_CTRL_BYPASS_MODE);
set_samplerate(0); // 760Hz
set_range(L3GD20_DEFAULT_RANGE_DPS);
set_driver_lowpass_filter(L3GD20_DEFAULT_RATE, L3GD20_DEFAULT_FILTER_FREQ);
_read = 0;
}
static int
lis331_ioctl(struct file *filp, int cmd, unsigned long arg)
{
int result = ERROR;
switch (cmd) {
case LIS331_SETRATE:
if ((arg & REG1_RATE_MASK) == arg) {
set_rate(arg);
result = 0;
lis331_dev.rate = arg;
}
break;
case LIS331_SETRANGE:
if ((arg & REG4_RANGE_MASK) == arg) {
set_range(arg);
result = 0;
}
break;
case LIS331_SETBUFFER:
lis331_dev.buffer = (struct lis331_buffer *)arg;
result = 0;
break;
}
if (result)
errno = EINVAL;
return result;
}
static int init(const struct motion_sensor_t *s)
{
int ret, resol;
struct si114x_drv_data_t *data = SI114X_GET_DATA(s);
/* initialize only once: light must be declared first. */
if (s->type == MOTIONSENSE_TYPE_LIGHT) {
#ifdef CONFIG_ALS_SI114X_CHECK_REVISION
ret = si114x_revisions(s);
if (ret != EC_SUCCESS)
return ret;
#endif
ret = si114x_initialize(s);
if (ret != EC_SUCCESS)
return ret;
data->state = SI114X_IDLE;
resol = 7;
} else {
if (data->state == SI114X_NOT_READY)
return EC_ERROR_ACCESS_DENIED;
resol = 5;
}
set_range(s, s->default_range, 0);
/*
* Sensor is most likely behind a glass.
* Max out the gain to get correct measurement
*/
set_resolution(s, resol, 0);
CPRINTF("[%T %s: MS Done Init type:0x%X range:%d]\n",
s->name, s->type, get_range(s));
return EC_SUCCESS;
}
Fl_MIDIKeyboard::Fl_MIDIKeyboard (int X, int Y, int W, int H, const char *l) :
Fl_Scroll(X, Y, W, H, l),
_bw_height_ratio(DEFAULT_BW_HEIGHT_RATIO),
_bw_width_ratio(DEFAULT_BW_WIDTH_RATIO),
_autoresize(false),
_autoresized(false),
_kw_resize_min(DEFAULT_KW_RESIZE_MIN),
_kw_resize_max(DEFAULT_KW_RESIZE_MAX),
_base_keyinput(MIDDLE_C),
_autodrag(false) {
box(FL_DOWN_FRAME);
_type = (W >= H) ? MKB_HORIZONTAL : MKB_VERTICAL; // set horizontal/vertical
keyboard = new Fl_Box(kbdx(), kbdy(), 1, 1); // create the keyboard container
keyboard->box(FL_BORDER_BOX);
keyboard->color(FL_WHITE);
end();
set_key_height(); // set keys width and height
_key_width = _old_k_width = _key_height * DEFAULT_WH_RATIO;
_b_width = (int)(_key_width * _bw_width_ratio);
hscrollbar.callback(hscrollbar_cb); // set scrollbar callbacks to overriden functions
scrollbar.callback(scrollbar_cb);
set_range(MKB_2OCTAVE); // default : two octaves range
scroll_mode(MKB_SCROLL_KEYS); // default : scrolling only with PGUP/PGDOWN
press_mode(MKB_PRESS_NONE); // default : playing not active
center_keyboard();
_below_mouse = find_key(Fl::event_x(), Fl::event_y());
}
int16_t
RC_Channel_aux::closest_limit(int16_t angle)
{
// Change scaling to 0.1 degrees in order to avoid overflows in the angle arithmetic
int16_t min = angle_min / 10;
int16_t max = angle_max / 10;
// Make sure the angle lies in the interval [-180 .. 180[ degrees
while (angle < -1800) angle += 3600;
while (angle >= 1800) angle -= 3600;
// Make sure the angle limits lie in the interval [-180 .. 180[ degrees
while (min < -1800) min += 3600;
while (min >= 1800) min -= 3600;
while (max < -1800) max += 3600;
while (max >= 1800) max -= 3600;
// This is done every time because the user might change the min, max values on the fly
set_range(min, max);
// If the angle is outside servo limits, saturate the angle to the closest limit
// On a circle the closest angular position must be carefully calculated to account for wrap-around
if ((angle < min) && (angle > max)){
// angle error if min limit is used
int16_t err_min = min - angle + (angle<min?0:3600); // add 360 degrees if on the "wrong side"
// angle error if max limit is used
int16_t err_max = angle - max + (angle>max?0:3600); // add 360 degrees if on the "wrong side"
angle = err_min<err_max?min:max;
}
servo_out = angle;
// convert angle to PWM using a linear transformation (ignores trimming because the camera limits might not be symmetric)
calc_pwm();
return angle;
}
/*
setup a channels aux servo function
*/
void SRV_Channel::aux_servo_function_setup(void)
{
if (type_setup) {
return;
}
switch (function) {
case k_flap:
case k_flap_auto:
case k_egg_drop:
set_range(100);
break;
case k_heli_rsc:
case k_heli_tail_rsc:
case k_motor_tilt:
case k_boost_throttle:
set_range(1000);
break;
case k_aileron_with_input:
case k_elevator_with_input:
case k_aileron:
case k_elevator:
case k_dspoilerLeft1:
case k_dspoilerLeft2:
case k_dspoilerRight1:
case k_dspoilerRight2:
case k_rudder:
case k_steering:
case k_flaperon_left:
case k_flaperon_right:
case k_tiltMotorLeft:
case k_tiltMotorRight:
case k_elevon_left:
case k_elevon_right:
case k_vtail_left:
case k_vtail_right:
set_angle(4500);
break;
case k_throttle:
case k_throttleLeft:
case k_throttleRight:
// fixed wing throttle
set_range(100);
break;
default:
break;
}
}
FieldTile::FieldTile(Board<Tile>* board_in, size_t i, size_t j, size_t i_max, size_t j_max)
{
is_only_water = false;
board = board_in;
set_range(i,j,i_max,j_max);
find_land_state();
area = (i_max-i)*(j_max-j);
}
int
BMA180::init()
{
int ret = ERROR;
/* do SPI init (and probe) first */
if (SPI::init() != OK)
goto out;
/* allocate basic report buffers */
_reports = new RingBuffer(2, sizeof(accel_report));
if (_reports == nullptr)
goto out;
/* advertise sensor topic */
struct accel_report zero_report;
memset(&zero_report, 0, sizeof(zero_report));
_accel_topic = orb_advertise(ORB_ID(sensor_accel), &zero_report);
/* perform soft reset (p48) */
write_reg(ADDR_RESET, SOFT_RESET);
/* wait 10 ms (datasheet incorrectly lists 10 us on page 49) */
usleep(10000);
/* enable writing to chip config */
modify_reg(ADDR_CTRL_REG0, 0, REG0_WRITE_ENABLE);
/* disable I2C interface */
modify_reg(ADDR_HIGH_DUR, HIGH_DUR_DIS_I2C, 0);
/* switch to low-noise mode */
modify_reg(ADDR_TCO_Z, TCO_Z_MODE_MASK, 0);
/* disable 12-bit mode */
modify_reg(ADDR_OFFSET_T, OFFSET_T_READOUT_12BIT, 0);
/* disable shadow-disable mode */
modify_reg(ADDR_GAIN_Y, GAIN_Y_SHADOW_DIS, 0);
/* disable writing to chip config */
modify_reg(ADDR_CTRL_REG0, REG0_WRITE_ENABLE, 0);
if (set_range(4)) warnx("Failed setting range");
if (set_lowpass(75)) warnx("Failed setting lowpass");
if (read_reg(ADDR_CHIP_ID) == CHIP_ID) {
ret = OK;
} else {
ret = ERROR;
}
out:
return ret;
}
fixed
TaskMinTarget::f(const fixed p)
{
// set task targets
set_range(p);
res = tm.glide_solution(aircraft);
return res.time_elapsed - t_remaining;
}
bool Fl_MIDIKeyboard::set_range(int r) {
switch (r) {
case MKB_PIANO :
set_range(21, 120);
break;
case MKB_5OCTAVE :
set_range(36, 96);
break;
case MKB_4OCTAVE :
set_range(36, 84);
break;
case MKB_2OCTAVE :
set_range (48, 72);
break;
default :
return false;
}
return true;
}
int main() {
iterator i,end;
set_range(i,end);
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
std::cout.put('\n');
return 0;
}
struct disp_struct *
disp_table_new_from_nk_file (const char * filename)
{
struct disp_struct *disp;
struct disp_table *table;
FILE * f;
int j, npt, nread;
float wlmax, wlmin;
disp = disp_new (DISP_TABLE);
table = & disp->disp.table;
f = fopen (filename, "r");
if (f == NULL)
{
notify_error_msg (LOADING_FILE_ERROR, "Cannot open %s", filename);
return NULL;
}
nread = fscanf(f, "%*i %f %f %i\n", & wlmin, & wlmax, &npt);
if (nread < 3)
{
notify_error_msg (LOADING_FILE_ERROR, "File %s not in NK format",
filename);
return NULL;
}
disp_table_init (table, npt+1);
for (j = 0; j <= npt; j++)
{
float nr, ni;
nread = fscanf(f, "%f %f\n", & nr, & ni);
if (nread < 2)
{
notify_error_msg (LOADING_FILE_ERROR, "invalid format for nk table");
goto disp_nk_free;
}
set_index_value (table, j, nr, ni);
}
set_range (table, wlmin * 1.0E3, wlmax * 1.0E3);
fclose (f);
return disp;
disp_nk_free:
disp_table_free (disp);
fclose (f);
return NULL;
}
void set_range(InputIterator1 first1,
InputIterator2 first2,
InputIterator3 tile_first1,
InputIterator3 tile_last1,
InputIterator4 tile_first2,
OutputIterator result)
{
typedef typename std::iterator_traits<InputIterator1>::value_type value_type;
::boost::compute::less<value_type> less_than;
set_range(first1, first2, tile_first1, tile_last1, tile_first2, result, less_than);
}
/**
* \brief Constructor
*
* \param module_name the module name
* \param begin the initial HW address
* \param end the final HW address
* \param irq_num the irq number
*/
UC_master_slave_base::UC_master_slave_base(sc_module_name module_name, unsigned int begin, unsigned int end, int irq_num)
: sc_module(module_name),UC_hw_if_b(module_name),UC_address_manager_class(NULL),m_port("initiator_socket"),m_target_socket("target_socket")
{
m_irq_num = irq_num;
m_target_socket.bind(*this);
m_port.bind(*this);
m_burst_size = 1;
set_range(begin, end);
}
static int d71_layer_init(struct d71_dev *d71,
struct block_header *blk, u32 __iomem *reg)
{
struct komeda_component *c;
struct komeda_layer *layer;
u32 pipe_id, layer_id, layer_info;
get_resources_id(blk->block_info, &pipe_id, &layer_id);
c = komeda_component_add(&d71->pipes[pipe_id]->base, sizeof(*layer),
layer_id,
BLOCK_INFO_INPUT_ID(blk->block_info),
&d71_layer_funcs, 0,
get_valid_inputs(blk),
1, reg, "LPU%d_LAYER%d", pipe_id, layer_id);
if (IS_ERR(c)) {
DRM_ERROR("Failed to add layer component\n");
return PTR_ERR(c);
}
layer = to_layer(c);
layer_info = malidp_read32(reg, LAYER_INFO);
if (layer_info & L_INFO_RF)
layer->layer_type = KOMEDA_FMT_RICH_LAYER;
else
layer->layer_type = KOMEDA_FMT_SIMPLE_LAYER;
set_range(&layer->hsize_in, 4, d71->max_line_size);
set_range(&layer->vsize_in, 4, d71->max_vsize);
malidp_write32(reg, LAYER_PALPHA, D71_PALPHA_DEF_MAP);
layer->supported_rots = DRM_MODE_ROTATE_MASK | DRM_MODE_REFLECT_MASK;
return 0;
}
void
IIS328DQ::reset()
{
/* set default configuration */
write_checked_reg(ADDR_CTRL_REG1,
REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE);
write_checked_reg(ADDR_CTRL_REG2, 0); /* disable high-pass filters */
write_checked_reg(ADDR_CTRL_REG3, 0x02); /* DRDY enable */
write_checked_reg(ADDR_CTRL_REG4, REG4_BDU);
set_samplerate(0, _accel_onchip_filter_bandwidth); //1000Hz
set_range(IIS328DQ_ACCEL_DEFAULT_RANGE_G);
//设置软件滤波器截止频率
set_driver_lowpass_filter(IIS328DQ_DEFAULT_RATE, IIS328DQ_DEFAULT_DRIVER_FILTER_FREQ);
_read = 0;
}
Quad::Quad() :
V(new std::vector<double>)
{
quads[0][0] =
quads[0][1] =
quads[1][0] =
quads[1][1] = 0;
unsigned int V_old_size = V->size();
unsigned int V_new_size = V_old_size + 9;
V->resize(V_new_size, 0.);
v1_offset = V_new_size - 3*3;
v2_offset = V_new_size - 2*3;
v_mid_offset = V_new_size - 1*3;
set_range(0., 1., 0., 1.);
}
static int init(const struct motion_sensor_t *s)
{
int ret = 0, tmp;
ret = raw_read8(s->port, s->addr, L3GD20_WHO_AM_I_REG, &tmp);
if (ret)
return EC_ERROR_UNKNOWN;
if (tmp != L3GD20_WHO_AM_I)
return EC_ERROR_ACCESS_DENIED;
/* All axes are enabled */
ret = raw_write8(s->port, s->addr, L3GD20_CTRL_REG1, 0x0f);
if (ret)
return EC_ERROR_UNKNOWN;
mutex_lock(s->mutex);
ret = raw_read8(s->port, s->addr, L3GD20_CTRL_REG4, &tmp);
if (ret) {
mutex_unlock(s->mutex);
return EC_ERROR_UNKNOWN;
}
tmp |= L3GD20_BDU_ENABLE;
ret = raw_write8(s->port, s->addr, L3GD20_CTRL_REG4, tmp);
mutex_unlock(s->mutex);
if (ret)
return EC_ERROR_UNKNOWN;
/* Config GYRO ODR */
ret = set_data_rate(s, s->default_range, 1);
if (ret)
return EC_ERROR_UNKNOWN;
/* Config GYRO Range */
ret = set_range(s, s->default_range, 1);
if (ret)
return EC_ERROR_UNKNOWN;
CPRINTF("[%T %s: MS Done Init type:0x%X range:%d]\n",
s->name, s->type, get_range(s));
return ret;
}
