コード例 #1
0
ファイル: grovepi.c プロジェクト: KurtE/mraa
static int
mraa_grovepi_read_internal(int function, int pin)
{
    uint8_t data[5];
    uint8_t result[3];
    data[0] = GROVEPI_REGISTER;
    data[1] = function;
    data[2] = pin;
    data[3] = 0;
    data[4] = 0;
    if (mraa_i2c_write(grovepi_bus, data, 5) != MRAA_SUCCESS) {
        syslog(LOG_WARNING, "grovepi: failed to write command to i2c bus /dev/i2c-%d", grovepi_bus->busnum);
        return -1;
    }
    if (mraa_i2c_write_byte(grovepi_bus, 1) != MRAA_SUCCESS) {
        syslog(LOG_WARNING, "grovepi: failed to write to i2c bus /dev/i2c-%d", grovepi_bus->busnum);
        return -1;
    }
    if (function == GROVEPI_GPIO_READ) {
        if (mraa_i2c_read(grovepi_bus, result, 1) != 1) {
            syslog(LOG_WARNING, "grovepi: failed to read result from i2c bus /dev/i2c-%d", grovepi_bus->busnum);
            return -1;
        }
        return result[0];
    }
    if (function == GROVEPI_AIO_READ) {
        if (mraa_i2c_read(grovepi_bus, result, 3) != 3) {
            syslog(LOG_WARNING, "grovepi: failed to read result from i2c bus /dev/i2c-%d", grovepi_bus->busnum);
            return -1;
        }
        return (result[1] << 8) | result [2];
    }
    return -1;
}
コード例 #2
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
atlsci_status_ret_t atlsci_status(int sensor_type) {
    int ret = -1;
    uint8_t rx_buffer[STRING_SIZE] = {0};
    char * status_msg = "STATUS";
    int success = 0;

    ret = set_sensor_address(i2c_context, sensor_type);

    if (ret == MRAA_SUCCESS)
    {
        ret = send_string(i2c_context, status_msg);
        if (ret == MRAA_SUCCESS)
        {
            ret = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
            success = ATLSCI_SUCCESS_BYTE_INDICATOR;
        }
        else
        {
        	log_mraa_response("atlsci_status()", ret);
        }
    }
    else
    {
    	log_mraa_response("atlsci_status()", ret);
    }
    return parse_atlsci_status(rx_buffer, success);
}
コード例 #3
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
/*
 * Run the read command 'r' to read the data obtained from the sensor
 *
 * Return message format:
 *    For ORP, pH, D.O.:
 *      1 DATA null
 *    where DATA represents many bytes.
 *    For Conductivity:
 *      1 EC , TDS, SAL , SG null
 *    where EC, TDS, SAL, SG represent many bytes
 */
atlsci_read_ret_t atlsci_read(int sensor_type) {
    int ret = -1;
    uint8_t rx_buffer[STRING_SIZE] = {0};

    ret = set_sensor_address(i2c_context, sensor_type);

    if (ret == MRAA_SUCCESS)
    {
        ret = send_string(i2c_context, "r");
        if (ret == MRAA_SUCCESS)
        {
            ret = mraa_i2c_read(i2c_context,
                                rx_buffer,
                                sizeof(rx_buffer));

            return parse_atlsci_read(sensor_type, rx_buffer);
        }
        else
        {
        	log_mraa_response("atlsci_read()", ret);
        }
    }
    else
    {
    	log_mraa_response("atlsci_read()", ret);
    }

    return parse_atlsci_read_fail();
}
コード例 #4
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
atlsci_led_ret_t atlsci_led(int sensor_type, int action)
{
    char * led_on =    "L,1";	//Turn on LEDs
    char * led_off =   "L,0"; 	//Turn off LEDs
    char * led_query = "L,?"; 	//Query LEDs
    uint8_t rx_buffer[STRING_SIZE] = {0};

    int ret = set_sensor_address(i2c_context, sensor_type);

    switch (action)
    {
        case ATLSCI_LED_ON:    ret = send_string(i2c_context, led_on); break;
        case ATLSCI_LED_OFF:   ret = send_string(i2c_context, led_off); break;
        case ATLSCI_LED_QUERY: ret = send_string(i2c_context, led_query); break;
        default:               ret = -1; break;
    }

    if (ret == MRAA_SUCCESS)
    {
        ret = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
        if(action == ATLSCI_LED_QUERY)
			printf("%s\n", rx_buffer);
        return parse_atlsci_led(rx_buffer, action);
    }

    log_mraa_response("atlsci_led()", ret);

    return parse_atlsci_led(rx_buffer, action);

}
コード例 #5
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
/*
 * Temperature compensation is only enable for pH, DO, and Conductivity sensor.
 * ORP does not have this feature. The value that it takes is expressed in float value nn.n
 */
atlsci_temp_comp_ret_t atlsci_temp_comp(int sensor_type, atlsci_temp_comp_param param, float value)
{
	atlsci_temp_comp_ret_t ret;
	uint8_t rx_buffer[STRING_SIZE] = {0};
	char cal_temp[TEMP_COMP_SIZE] = "T,";
	int success = set_sensor_address(i2c_context, sensor_type);
	char *pt_cal = cal_temp;

	switch(param)
	{
		case SET_TEMPERATURE:		sprintf(pt_cal + TEMP_COMP_INDEX, "%.1f", value);
						success = send_string(i2c_context, cal_temp); break;
						
		case QUERY_TEMPERATURE:		success = send_string (i2c_context, cal_query); break;
		
		default:			return atlsci_temp_comp_fail(param);
	}
    if (success == MRAA_SUCCESS)
    {
        success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
    	if(param == QUERY_TEMPERATURE)
    		printf("%s\n", rx_buffer);
        //First bit of rx_buffer will be '1' if write is successful
    	ret.success = (int)rx_buffer[0];
    }
    else
    {
    	log_mraa_response("atlsci_temp_comp()", success);
    	ret.success = -1;
    }
	return ret;
}
コード例 #6
0
ファイル: imuTest.c プロジェクト: jamesbvaughan/moth-project
mraa_result_t mag_update() {
  mraa_result_t result;
  int bytesRead;
  result = mraa_i2c_write_byte(mag_context, HMC5883L_DATA_REG);
  if (result != MRAA_SUCCESS) {
    printError("unable to write to compass (9)");
    return result;
  }
  bytesRead = mraa_i2c_read(mag_context, mag_rx_tx_buf, DATA_REG_SIZE);
  if (bytesRead != DATA_REG_SIZE) {
    printError("unable to read from compass (10)");
    return result;
  }

  // x
  mag_coor[0] = (mag_rx_tx_buf[HMC5883L_X_MSB_REG] << 8 ) | mag_rx_tx_buf[HMC5883L_X_LSB_REG];
  // z
  mag_coor[2] = (mag_rx_tx_buf[HMC5883L_Z_MSB_REG] << 8 ) | mag_rx_tx_buf[HMC5883L_Z_LSB_REG];
  // y
  mag_coor[1] = (mag_rx_tx_buf[HMC5883L_Y_MSB_REG] << 8 ) | mag_rx_tx_buf[HMC5883L_Y_LSB_REG];

  save_log_value(RAW_COMPASS_X, mag_coor[0], 1);
  save_log_value(RAW_COMPASS_Y, mag_coor[1], 1);
  save_log_value(RAW_COMPASS_Z, mag_coor[2], 1);
  save_log_value(HEADING, mag_heading(), 1);
  save_log_value(DIRECTION, mag_direction(), 1);

  return MRAA_SUCCESS;
}
コード例 #7
0
ファイル: i2c.c プロジェクト: pbosetti/mruby-mraa
mrb_value
mrb_mraa_i2c_read(mrb_state *mrb, mrb_value self){
    mraa_i2c_context i2c;
    mrb_int length;

    uint8_t *rbuf;
    mrb_int num_of_read;
    int ai, i;

    mrb_value mrv_rbuf;

    Data_Get_Struct(mrb, self, &mrb_mraa_i2c_ctx_type, i2c);

    mrb_get_args(mrb, "i", &length);

    rbuf = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t) * length);
    memset(rbuf, 0, sizeof(uint8_t) * length);

    num_of_read = mraa_i2c_read(i2c, rbuf, length);

    mrv_rbuf = mrb_ary_new_capa(mrb, num_of_read);
    ai = mrb_gc_arena_save(mrb);
    for (i = 0; i < num_of_read; i++){
        mrb_ary_push(mrb, mrv_rbuf, mrb_fixnum_value(rbuf[i]));
        mrb_gc_arena_restore(mrb, ai);
    }

    mrb_free(mrb, rbuf);

    return mrb_assoc_new(mrb, mrv_rbuf, mrb_fixnum_value(num_of_read));
}
コード例 #8
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
static atlsci_cal_ret_t atlsci_cal_conductivity(atlsci_cal_param_t param, int value)
{
	atlsci_cal_ret_t ret;
	int success = set_sensor_address(i2c_context, ATLSCI_CONDUCTIVITY);
	uint8_t rx_buffer[STRING_SIZE] = {0};
	char cal_dry[CONDUCTIVITY_CAL_DRY_SIZE] = "Cal,dry";
	char cal_one[CONDUCTIVITY_CAL_ONE_SIZE] = "Cal,one,";
	char cal_low[CONDUCTIVITY_CAL_LOW_SIZE] = "Cal,low,";
	char cal_high[CONDUCTIVITY_CAL_HIGH_SIZE] = "Cal,high,";
	char *pt_cal = NULL;

	switch(param.cal_conductivity)
	{
		case CONDUCTIVITY_CALIBRATION_CLEAR:			success = send_string(i2c_context, cal_clear); break;

		case CONDUCTIVITY_CALIBRATION_QUERY:			success = send_string(i2c_context, cal_query); break;

		case CONDUCTIVITY_DRY_CALIBRATION:			success = send_string(i2c_context, cal_dry); break;

		case CONDUCTIVITY_SINGLE_CALIBRATION_POINT:		pt_cal = cal_one;
									sprintf((pt_cal + CONDUCTIVITY_INDEX_ONE), "%d", value); 	//set value to end of string
									success = send_string(i2c_context, cal_one); break;

		case CONDUCTIVITY_LOW_DUAL_CALIBRATION_POINT:   	pt_cal = cal_low;
									sprintf((pt_cal + CONDUCTIVITY_INDEX_LOW), "%d", value);
									success = send_string(i2c_context, cal_low); break;

		case CONDUCTIVITY_HIGH_DUAL_CALIBRATION_POINT:  	pt_cal = cal_high;
									sprintf((pt_cal + CONDUCTIVITY_INDEX_HIGH), "%d", value);
									success = send_string(i2c_context, cal_high); break;
        	
        	default:         					return atlsci_cal_fail(param);
	}
    if (success == MRAA_SUCCESS)
    {
        success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
    	if(param.cal_conductivity == CONDUCTIVITY_CALIBRATION_QUERY)
        {
            ret.query = malloc(QUERY_SIZE);
            uint8_t * rx_ptr = rx_buffer; rx_ptr++;
            sprintf(ret.query, "%s", rx_ptr);
            //ret.query = rx_buffer;
        }
    		//printf("%s\n", rx_buffer);
        //First bit of rx_buffer will be '1' if write is successful
    	ret.success = (int)rx_buffer[0];
    }
    else
    {
    	log_mraa_response("atlsci_cal_conductivity()", success);
    	ret.success = -1;
    }
	return ret;
}
コード例 #9
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
static atlsci_cal_ret_t atlsci_cal_ph(atlsci_cal_param_t param, float value)
{
    atlsci_cal_ret_t ret;
	int success = set_sensor_address(i2c_context, ATLSCI_PH);
    uint8_t rx_buffer[STRING_SIZE] = {0};
    char cal_low[PH_CAL_LOW_SIZE] = "Cal,low,";
    char cal_mid[PH_CAL_MID_SIZE] = "Cal,mid,";
    char cal_high[PH_CAL_HIGH_SIZE] = "Cal,high";
    char *pt_cal = NULL;

    switch(param.cal_ph)
    {
    	case PH_CALIBRATION_CLEAR:		success = send_string(i2c_context, cal_clear); break;

    	case PH_CALIBRATION_QUERY:		success = send_string(i2c_context, cal_query); break;

    	case PH_LOW_CALIBRATION_POINT:  	pt_cal = cal_low;
    						sprintf(pt_cal + PH_INDEX_LOW, "%.2f", value);
    						success = send_string(i2c_context, cal_low); break;

    	case PH_MID_CALIBRATION_POINT:		pt_cal = cal_mid;
    						sprintf((pt_cal + PH_INDEX_MID), "%.2f", value);
    						success = send_string(i2c_context, cal_mid); break;

    	case PH_HIGH_CALIBRATION_POINT: 	pt_cal = cal_high;
    						sprintf((pt_cal + PH_INDEX_HIGH), "%.2f", value);
    						success = send_string(i2c_context, cal_high); break;
        
        default:         			return atlsci_cal_fail(param);
    }

    if (success == MRAA_SUCCESS)
    {
        success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
    	if(param.cal_ph == PH_CALIBRATION_QUERY)
        {
            ret.query = malloc(QUERY_SIZE);
            //ret.query = rx_buffer;
            uint8_t * rx_ptr = rx_buffer; rx_ptr++;
            sprintf(ret.query, "%s", rx_ptr);
        }
        //First bit of rx_buffer will be '1' if write is successful
    	ret.success = (int)rx_buffer[0];
    }
    else
    {
    	log_mraa_response("atlsci_cal_ph()", success);
    	ret.success = -1;
    }
	return ret;
}
コード例 #10
0
ファイル: i2c_HMC5883L.c プロジェクト: AnastasiaFab/mraa
int
main(int argc, char **argv)
{
    mraa_init();
    float direction = 0;
    int16_t x = 0, y = 0, z = 0;
    char rx_tx_buf[MAX_BUFFER_LENGTH];

//! [Interesting]
    mraa_i2c_context i2c;
    i2c = mraa_i2c_init(0);

    mraa_i2c_address(i2c, HMC5883L_I2C_ADDR);
    rx_tx_buf[0] = HMC5883L_CONF_REG_B;
    rx_tx_buf[1] = GA_1_3_REG;
    mraa_i2c_write(i2c, rx_tx_buf, 2);
//! [Interesting]

    mraa_i2c_address(i2c, HMC5883L_I2C_ADDR);
    rx_tx_buf[0] = HMC5883L_MODE_REG;
    rx_tx_buf[1] = HMC5883L_CONT_MODE;
    mraa_i2c_write(i2c, rx_tx_buf, 2);

    for(;;) {
        mraa_i2c_address(i2c, HMC5883L_I2C_ADDR);
        mraa_i2c_write_byte(i2c, HMC5883L_DATA_REG);

        mraa_i2c_address(i2c, HMC5883L_I2C_ADDR);
        mraa_i2c_read(i2c, rx_tx_buf, DATA_REG_SIZE);

        x = (rx_tx_buf[HMC5883L_X_MSB_REG] << 8 ) | rx_tx_buf[HMC5883L_X_LSB_REG] ;
        z = (rx_tx_buf[HMC5883L_Z_MSB_REG] << 8 ) | rx_tx_buf[HMC5883L_Z_LSB_REG] ;
        y = (rx_tx_buf[HMC5883L_Y_MSB_REG] << 8 ) | rx_tx_buf[HMC5883L_Y_LSB_REG] ;

        //scale and calculate direction
        direction = atan2(y * SCALE_0_92_MG, x * SCALE_0_92_MG);

        //check if the signs are reversed
        if (direction < 0)
            direction += 2 * M_PI;

        printf("Compass scaled data x : %f, y : %f, z : %f\n", x * SCALE_0_92_MG, y * SCALE_0_92_MG, z * SCALE_0_92_MG) ;
        printf("Heading : %f\n", direction * 180/M_PI) ;
    }
}
コード例 #11
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
static atlsci_cal_ret_t atlsci_cal_orp(atlsci_cal_param_t param, int value)
{
	atlsci_cal_ret_t ret;
	uint8_t rx_buffer[STRING_SIZE] = {0};
	char cal_single[ORP_CAL_SIZE] = "Cal,";
	int success = set_sensor_address(i2c_context, ATLSCI_ORP);
	char *pt_cal = cal_single;

	switch(param.cal_orp)
	{
		case ORP_CALIBRATION_CLEAR:			success = send_string(i2c_context, cal_clear); break;

		case ORP_CALIBRATION_QUERY:			success = send_string(i2c_context, cal_query); break;

		case ORP_SINGLE_CALIBRATION_POINT:		sprintf((pt_cal + ORP_INDEX), "%d", value);
								success = send_string(i2c_context, cal_single); break;

        	default:         return atlsci_cal_fail(param);
	}

    if (success == MRAA_SUCCESS)
    {
        success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
    	if(param.cal_orp == ORP_CALIBRATION_QUERY)
        {
            ret.query = malloc(QUERY_SIZE);
            uint8_t * rx_ptr = rx_buffer; rx_ptr++;
            sprintf(ret.query, "%s", rx_ptr);
            //ret.query = rx_buffer;
        }
    		//printf("%s\n", rx_buffer);

        //First bit of rx_buffer will be '1' if write is successful
    	ret.success = (int)rx_buffer[0];
    }
    else
    {
    	log_mraa_response("atlsci_cal_orp()", success);
    	ret.success = -1;
    }
	return ret;
}
コード例 #12
0
ファイル: sensors.c プロジェクト: willtd/CitizenWater
static atlsci_cal_ret_t atlsci_cal_dissolved_oxygen(atlsci_cal_param_t param)
{
	atlsci_cal_ret_t ret;
	int success = set_sensor_address(i2c_context, ATLSCI_DO);
	uint8_t rx_buffer[STRING_SIZE] = {0};
	char * cal_atmospheric_oxygen_level = "Cal";
	char * cal_0 = "Cal,0";

	switch(param.cal_do)
	{
		case DO_CALIBRATION_CLEAR:			success = send_string(i2c_context, cal_clear); break;
		case DO_CALIBRATION_QUERY:			success = send_string(i2c_context, cal_query); break;
		case DO_ATMOSPHERIC_CALIBRATION:		success = send_string(i2c_context, cal_atmospheric_oxygen_level); break;
		case DO_ZERO_LEVEL_CALIBRATION:			success = send_string(i2c_context, cal_0); break;
        	
        	default:         return atlsci_cal_fail(param);
	}

    if (success == MRAA_SUCCESS)
    {
        success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer));
    	if(param.cal_do == DO_CALIBRATION_QUERY)
        {
            ret.query = malloc(QUERY_SIZE);
            uint8_t * rx_ptr = rx_buffer; rx_ptr++;
            sprintf(ret.query, "%s", rx_ptr);
            //ret.query = (char *)rx_buffer;
            //ret.query = rx_buffer;
        }
    		//printf("%s\n", rx_buffer);
        //First bit of rx_buffer will be '1' if write is successful
    	ret.success = (int)rx_buffer[0];
    }
    else
    {
    	log_mraa_response("atlsci_cal_do()", success);
    	ret.success = -1;
    }
	return ret;
}
コード例 #13
0
ファイル: imuTest.c プロジェクト: jamesbvaughan/moth-project
mraa_result_t gyro_update() {
  mraa_result_t result;
  result = mraa_i2c_write_byte(gyro_context, ITG3200_TEMP_H);
  if (result != MRAA_SUCCESS) {
    printError("unable to write to gyro (5)");
    return result;
  }

  result = mraa_i2c_read(gyro_context, gyro_buffer, DATA_REG_SIZE);
  if (result != MRAA_SUCCESS) {
    printError("unable to read from gyro (6)");
    return result;
  }

  //temp
  //
  gyro_temperature = (gyro_buffer[0] << 8 ) | gyro_buffer[1];
  // x
  gyro_rotation[0] = ((gyro_buffer[2] << 8 ) | gyro_buffer[3]) + gyro_offsets[0];
  // y
  gyro_rotation[1] = ((gyro_buffer[4] << 8 ) | gyro_buffer[5]) + gyro_offsets[1];
  // z
  gyro_rotation[2] = ((gyro_buffer[6] << 8 ) | gyro_buffer[7]) + gyro_offsets[2];

  save_log_value(RAW_TEMP, gyro_temperature, 1);
  save_log_value(TEMP, gyro_getTemperature(), 1);
  save_log_value(RAW_ANG_X, gyro_rotation[0], 1);
  save_log_value(RAW_ANG_Y, gyro_rotation[1], 1);
  save_log_value(RAW_ANG_Z, gyro_rotation[2], 1);
  float* ang = gyro_getRotation();
  save_log_value(ANG_X, ang[0], 1);
  save_log_value(ANG_Y, ang[1], 1);
  save_log_value(ANG_Z, ang[2], 1);

  return MRAA_SUCCESS;
}
コード例 #14
0
ファイル: mraa-i2c.c プロジェクト: Hbrinj/mraa
mraa_result_t
i2c_get(int bus, uint8_t device_address, uint8_t register_address, uint8_t* data)
{
    mraa_result_t status = MRAA_SUCCESS;
    mraa_i2c_context i2c = mraa_i2c_init(bus);
    if (i2c == NULL) {
        return MRAA_ERROR_NO_RESOURCES;
    }
    status = mraa_i2c_address(i2c, device_address);
    if (status != MRAA_SUCCESS) {
        goto i2c_get_exit;
    }
    status = mraa_i2c_write_byte(i2c, register_address);
    if (status != MRAA_SUCCESS) {
        goto i2c_get_exit;
    }
    status = mraa_i2c_read(i2c, data, 1) == 1 ? MRAA_SUCCESS : MRAA_ERROR_UNSPECIFIED;
    if (status != MRAA_SUCCESS) {
        goto i2c_get_exit;
    }
i2c_get_exit:
    mraa_i2c_stop(i2c);
    return status;
}
コード例 #15
0
ファイル: ecezo.c プロジェクト: g-vidal/upm
// I2C read helper
static int readBytes(const ecezo_context dev, uint8_t *buffer, int len)
{
    assert(dev != NULL);
    assert(dev->i2c != NULL);

    bool done = false;
    int rv;
    int retries = 10;

    while (!done && (retries-- > 0))
    {
        if ((rv = mraa_i2c_read(dev->i2c, buffer, len)) < 0)
        {
            printf("%s: mraa_i2c_read(code) failed.\n", __FUNCTION__);
            return rv;
        }

#if defined(ECEZO_DEBUG)
        printf("CODE: %02x\n", buffer[0]);
#endif

        if (buffer[0] == 0xff || buffer[0] == 0x02)
        {
            // no data available, or error
            return -1;
        }
        else if (buffer[0] == 0x01)
        {
            // data is ready
            done = true;

            // now we need to move the data one byte down so the rest
            // of this driver can work as-is.
            memmove(buffer, (buffer + 1), len - 1);
        }
        else
        {
            // buffer[0] 0xfe - data is pending. wait and loop again.
            upm_delay_ms(CMD_DELAY);
        }
    }

    if (retries <= 0)
    {
        printf("%s: timed out waiting for correct response.\n", __FUNCTION__);
        return -1;
    }

#if defined(ECEZO_DEBUG)
    printf("%s: Got %d bytes\n", __FUNCTION__, rv);

    for (int i=0; i<rv; i++)
    {
        printf("%02x (%c) ", buffer[i],
               isprint(buffer[i]) ? buffer[i] : '@');
    }
    printf("\n");
#endif // ECEZO_DEBUG

    return rv;
}
コード例 #16
0
ファイル: i2c.hpp プロジェクト: TizenTeam/mraa
        /**
	 * Read length bytes from the bus into *data pointer
         *
         * @param data Data to read into
         * @param length Size of read in bytes to make
         * @return pointer to std::string
         */
        int read(uint8_t *data, int length) {
            return mraa_i2c_read(m_i2c, data, length);
        }