// Lua: r = ow.read( id )
static int ow_read( lua_State *L )
{
unsigned id = luaL_checkinteger( L, 1 );
MOD_CHECK_ID( ow, id );
lua_pushinteger( L, onewire_read(id) );
return 1;
}
/**
* 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;
}
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();
}
}
// 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;
}
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;
}
