Exemplo n.º 1
0
/**
 * Set the onewire LED GPIO controller outputs
 *
 * @param mask		Mask of outputs to enable
 *
 * @return EC_SUCCESS, or non-zero if error.
 */
static int led_set_mask(int mask)
{
	int rv;

	/* Reset the 1-wire bus */
	rv = onewire_reset();
	if (rv)
		return rv;

	/* Skip ROM, since only one device */
	onewire_write(0xcc);

	/* Write and turn on the LEDs */
	onewire_write(0x5a);
	onewire_write(mask);
	onewire_write(~mask);  /* Repeat inverted */

	rv = onewire_read();   /* Confirmation byte */
	if (rv != 0xaa)
		return EC_ERROR_UNKNOWN;

	/* The next byte is a read-back of the chip status.  Since we're only
	 * using lines as outputs, we can ignore it. */
	return EC_SUCCESS;
}
Exemplo n.º 2
0
float ds1820_read()
{
  uint8_t busy = 1;

  onewire_reset();
  onewire_write(0xCC);
  onewire_write(0x44);

  delay(750);
  while(busy == 0)
  {
    busy = onewire_read();
    printf("busy: %d\n", busy);
  }

  onewire_reset();
  onewire_write(0xCC);
  onewire_write(0xBE);

  uint8_t lsb, msb, th, tl, reserved1, reserved2, count_remain, count_per_c, crc;
  float real_temp = 0.0f;
  signed char temp_read = 0;

  lsb = onewire_read();
  msb = onewire_read();
  th = onewire_read();
  tl = onewire_read();
  reserved1 = onewire_read();
  reserved2 = onewire_read();
  count_remain = onewire_read();
  count_per_c = onewire_read();
  crc = onewire_read();

  uint8_t data[] = {lsb, msb, th, tl, reserved1, reserved2, count_remain, count_per_c};

  onewire_reset();

  if(crc_read(data) == crc)
  {
    temp_read = (signed char)(lsb>>1);

    if(msb == 255)
      temp_read = temp_read | 0x80;

    real_temp = (float)temp_read + 0.85f - (float)count_remain/(float)count_per_c;
    real_temp = (int)(real_temp * 10) / 10.0f;
  }
uint16_t onewire_temp_read(void) 
{ 
    uint8_t temp1,temp2;
    int16_t raw;

    onewire_reset();
    onewire_write(0xcc);
    onewire_write(0x44);

    onewire_reset();
    onewire_write(0xcc);
    onewire_write(0xbe);

    temp1 = onewire_read();
    temp2 = onewire_read();

    raw = (temp2 << 8) | temp1;
    return ((6 * raw) + raw / 4);
	
}
void onewire_id_read(void) 
{ 
  int i;

  onewire_reset();
  onewire_write(0x33);
  
  for(i = 0; i < 8; i++)
    {
      onewire_id[i] = onewire_read();
    }
}
Exemplo n.º 5
0
// Lua: ow.write( id, v, power)
static int ow_write( lua_State *L )
{
  int power = 0;
  unsigned id = luaL_checkinteger( L, 1 );
  MOD_CHECK_ID( ow, id );

  int v = (int)luaL_checkinteger( L, 2 );
  if( v > 255 )
    return luaL_error( L, "wrong arg range" );
  if(lua_isnumber(L, 3))
    power = lua_tointeger(L, 3);
  if(power!=0)
    power = 1;

  onewire_write((uint8_t)id, (uint8_t)v, (uint8_t)power);

  return 0;
}
Exemplo n.º 6
0
// return the temperature in C multiplied by 16
int read_DS1820()
{
  uint8 i;
  uint8 present = 0;
  uint8 dataread[12];
  int temp_read;

  // we might do a ds.depower() here, but the reset will take care of it.
  
  present = onewire_reset();
  onewire_select(DS1820_addr);    
  onewire_write(0xBE,0);         // Read Scratchpad
  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    dataread[i] = onewire_read();
  }
  temp_read = ((dataread[1] << 8) | dataread[0]);
  if (!is_DS18B20) {
    // temp_read is currently in half degrees.
    temp_read *= 8.0;
    //
    temp_read += - ( 8 * (dataread[7]- dataread[6]) )/dataread[7];
  }
  return temp_read;
}
Exemplo n.º 7
0
int ICACHE_FLASH_ATTR ds18b20_read(ds18b20_data *read) {
	byte i;
	byte present = 0;
	byte type_s;
	byte data[12];
	byte addr[8];
	byte crc;
	float celsius;
	//float fahrenheit;

	DS18B20_DBG("Look for OneWire Devices on PIN =%d", gpioPin);

	if (!onewire_search(gpioPin, addr)) {
		DS18B20_DBG("No more addresses.");
		onewire_reset_search(gpioPin);
		delay_ms(250);
		return;
	}

	DS18B20_DBG("ADDRESS = %02x %02x %02x %02x %02x %02x %02x %02x",
			addr[0], addr[1], addr[2], addr[3],
			addr[4], addr[5], addr[6], addr[7]);

	// the first ROM byte indicates which chip
	switch (addr[0]) {
		case 0x10:
			DS18B20_DBG("  Chip = DS18S20");  // or old DS1820
			type_s = 1;
			break;
		case 0x28:
			DS18B20_DBG("  Chip = DS18B20");
			type_s = 0;
			break;
		case 0x22:
			DS18B20_DBG("  Chip = DS1822");
			type_s = 0;
			break;
		default:
			DS18B20_DBG("Device is not a DS18x20 family device.");
			return;
	} 

	onewire_reset(gpioPin);
	onewire_select(gpioPin, addr);
	onewire_write(gpioPin, 0x44, 1);
        // start conversion, use ds.write(0x44,1) with parasite power on at the end

	delay_ms(1000);

	present = onewire_reset(gpioPin);
	onewire_select(gpioPin, addr);
	onewire_write(gpioPin, 0xBE, 1);   // Read Scratchpad

	//DS18B20_DBG("  Present = %d", present);
	for ( i = 0; i < 9; i++) {         // we need 9 bytes
		data[i] = onewire_read(gpioPin);
		DS18B20_DBG("  DATA: %02x ", data[i]);
	}
	crc = onewire_crc8(data, 8);
	DS18B20_DBG(" CRC=%d ", crc);

	if (crc != data[8]) {
		DS18B20_DBG("CRC is not valid!");
		return;
	}

	// Convert the data to actual temperature
	// because the result is a 16 bit signed integer, it should
	// be stored to an "int16_t" type, which is always 16 bits
	// even when compiled on a 32 bit processor.
	int16_t raw = (data[1] << 8) | data[0];
	if (type_s) {
		raw = raw << 3; // 9 bit resolution default
		if (data[7] == 0x10) {
			// "count remain" gives full 12 bit resolution
			raw = (raw & 0xFFF0) + 12 - data[6];
		}
	} else {
		byte cfg = (data[4] & 0x60);
		// at lower res, the low bits are undefined, so let's zero them
		if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
		else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
		else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
		//// default is 12 bit resolution, 750 ms conversion time
	}

	celsius = (float) raw / 16.0;
	//fahrenheit = celsius * 1.8 + 32.0;
	read->temp = celsius;

	DS18B20_DBG("Temperature = ");

	char *temp_string = (char*) os_zalloc(64);

	c_sprintf(temp_string, "%f", read->temp);
	DS18B20_DBG("  %s Celsius", temp_string);
	os_free(temp_string);

	//DS18B20_DBG(" %2.2f Fahrenheit", fahrenheit);

	return 1;
}
Exemplo n.º 8
0
//
// Do a ROM skip
//
void ICACHE_FLASH_ATTR onewire_skip() {
	onewire_write(ONEWIRE_SKIP_ROM, 0); // Skip ROM
}
Exemplo n.º 9
0
//
// Do a ROM select
//
void ICACHE_FLASH_ATTR onewire_select(const uint8 *rom) {
	onewire_write(ONEWIRE_MATCH_ROM, 0); // Choose ROM
	for (uint8 i = 0; i < 8; i++) {
		onewire_write(rom[i], 0);
	}
}
Exemplo n.º 10
0
/* pass array of 8 bytes in */
uint32 ICACHE_FLASH_ATTR onewire_search(struct onewire_search_state *state) {

	// If last search returned the last device (no conflicts).
	if (state->lastDeviceFlag) {
		init_search_state(state);
		return FALSE;
	}

	// 1-Wire reset
	if (!onewire_reset()) {
		// Reset the search and return fault code.
		init_search_state(state);
		return ONEWIRE_SEARCH_NO_DEVICES;
	}

	// issue the search command
	onewire_write(ONEWIRE_SEARCH_ROM, 0);

	uint8 search_direction;
	int32 last_zero = -1;

	// Loop through all 8 bytes = 64 bits
	int32 id_bit_index;
	for (id_bit_index = 0; id_bit_index < 8 * ROM_BYTES; id_bit_index++) {
		const uint32 rom_byte_number = id_bit_index / BITS_PER_BYTE;
		const uint32 rom_byte_mask = 1 << (id_bit_index % BITS_PER_BYTE);

		// Read a bit and its complement
		const uint32 id_bit = onewire_read_bit();
		const uint32 cmp_id_bit = onewire_read_bit();

		// Line high for both reads means there are no slaves on the 1wire bus.
		if (id_bit == 1 && cmp_id_bit == 1) {
			// Reset the search and return fault code.
			init_search_state(state);
			return ONEWIRE_SEARCH_NO_DEVICES;
		}

		// No conflict for current bit: all devices coupled have 0 or 1
		if (id_bit != cmp_id_bit) {
			// Obviously, we continue the search using the same bit as all the devices have.
			search_direction = id_bit;
		} else {
			// if this discrepancy is before the Last Discrepancy
			// on a previous next then pick the same as last time
			if (id_bit_index < state->lastDiscrepancy) {
				search_direction = ((state->address[rom_byte_number]
						& rom_byte_mask) > 0);
			} else {
				// if equal to last pick 1, if not then pick 0
				search_direction = (id_bit_index == state->lastDiscrepancy);
			}

			// if 0 was picked then record its position in LastZero
			if (search_direction == 0) {
				last_zero = id_bit_index;
			}
		}

		// set or clear the bit in the ROM byte rom_byte_number with mask rom_byte_mask
		if (search_direction == 1) {
			state->address[rom_byte_number] |= rom_byte_mask;
		} else {
			state->address[rom_byte_number] &= ~rom_byte_mask;
		}

		// For the current bit position, write the bit we choose to use in the current search.
		// Any devices that don't match are disabled.
		onewire_write_bit(search_direction);
	}

	state->lastDiscrepancy = last_zero;

	// check for last device
	if (state->lastDiscrepancy == -1) {
		state->lastDeviceFlag = TRUE;
	}

	if (crc8(state->address, 7) != state->address[7]) {
		// Reset the search and return fault code.
		init_search_state(state);
		return ONEWIRE_SEARCH_CRC_INVALID;
	}

	return ONEWIRE_SEARCH_FOUND;
}
Exemplo n.º 11
0
void start_DS1820()
{
  onewire_reset();
  onewire_select(DS1820_addr);
  onewire_write(0x44,0);         // start conversion, with parasite power off at the end
}