Using 1-Wire device with Intel Galileo

Using 1-Wire device with Intel Galileo

3 Replies

Many people have had trouble with getting 1-Wire devices to work with the Galileo and Galileo Gen2 boards.

The main reason is that the Galileo and Galileo Gen2 uses IO expanders for many of  its GPIOs. Even with the pins Arduno header pins that have native SoC IO speeds, it is not possible because the GPIOs that control the muxing of those pins uses pins from the IO expanders.

Galileo Muxing For Pin2

Galileo Cypress IO Expander

If we look at the two images taken form the Galileo schematic, IO which is connected to the Arduino Digital 2 pin, is controlled by a mux pin IO2_MUX. This pin is then connected to the Cypress IO expander.

The end result is there is significant latency when switching pin direction using pinMode() becuase it requires I2C transactions with the IO expanders.

I will show a way to use 1-Wire device with the Galileo and Galileo Gen2 boards.

The trick is to use 2 pins instead of 1. For the Galileo, pins 2 and 3 must be used since they are the only pins fast enough to achieve this. For the Galileo Gen2, any pins except pins 7 and 8 can be used.

For this tutorial, I will use a DHT11 sensor which a very cheap and popular 1-Wire humidity and temperature sensor.

The Proper Way

The proper way of doing this is to use a tri-state buffer.

This works because, when pin 3 is pulled HIGH, the tri-state buffer prevents the HIGH signal from being passed to the other side. However, the 1-Wire device still sees a high signal because of the pull-up resistor.
When pin 3 is pulled LOW, the signal passes through the tri-state buffer and a LOW signal is detected by the 1-Wire device.

The Easy Way

For the easy way the only extra hardware needed is a diode such as the 1N4148 signal diode. This essential works the same way as the tri-state buffer method where only a LOW signal passes through because current only passes in one direction through a diode.

Since we are now using two pins, we will also need to make changes in the libraries used. As an example, I modified the DHT-11 library from Adafruit.

 #ifndef DHT_H
 #define DHT_H
 #if ARDUINO >= 100
  #include "Arduino.h"
 #else
  #include "WProgram.h"
 #endif

 /* DHT library 

 MIT license
 written by Adafruit Industries

 Modified by Dino Tinitigan (dino.tinitigan@intel.com to work on Intel Galileo boards
 */

 // how many timing transitions we need to keep track of. 2 * number bits + extra
 #define MAXTIMINGS 85

 #define DHT11 11
 #define DHT22 22
 #define DHT21 21
 #define AM2301 21

 class DHT {
  private:
  uint8_t data[];
  uint8_t _inpin, _outpin, _type, _count;
  unsigned long _lastreadtime;
  boolean firstreading;
  int pulseLength(int pin);
  void delayMicrosGal(unsigned long usec);
  int bitsToByte(int bits[]);

  public:
  DHT(uint8_t inPin, uint8_t outPin,uint8_t type, uint8_t count=);
  void begin(void);
  float readTemperature(bool S=false);
  float convertCtoF(float);
  float computeHeatIndex(float tempFahrenheit, float percentHumidity);
  float readHumidity(void);
  boolean read(void);

 };
 #endif

 /* DHT library 

 MIT license
 written by Adafruit Industries

 Modified by Dino Tinitigan (dino.tinitigan@intel.com to work on Intel Galileo boards
 */

 #include "DHT.h"

 DHT::DHT(uint8_t inPin, uint8_t outPin, uint8_t type, uint8_t count) {
  _inpin = inPin;
  _outpin = outPin;
  _type = type;
  _count = count;
  firstreading = true;
 }

 void DHT::begin(void) {
  // set up the pins!
  pinMode(_inpin, INPUT);
  pinMode(_outpin, INPUT);
  digitalWrite(_outpin, HIGH);
  _lastreadtime = ;
 }

 //boolean S == Scale. True == Farenheit; False == Celcius
 float DHT::readTemperature(bool S) {
  float f;

  if (read()) {
  switch (_type) {
  case DHT11:
  f = data[];
  if(S)
  f = convertCtoF(f);

  return f;
  case DHT22:
  case DHT21:
  f = data[] & 0x7F;
  f *= ;
  f += data[];
  f /= ;
  if (data[] & 0x80)
  f *= -;
  if(S)
  f = convertCtoF(f);

  return f;
  }
  }
  return NAN;
 }

 float DHT::convertCtoF(float c) {
  return c *  /  + ;
 }

 float DHT::readHumidity(void) {
  float f;
  if (read()) {
  switch (_type) {
  case DHT11:
  f = data[];
  return f;
  case DHT22:
  case DHT21:
  f = data[];
  f *= ;
  f += data[];
  f /= ;
  return f;
  }
  }
  return NAN;
 }

 float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) {
  // Adapted from equation at: https://github.com/adafruit/DHT-sensor-library/issues/9 and
  // Wikipedia: http://en.wikipedia.org/wiki/Heat_index
  return -42.379 +
  2.04901523 * tempFahrenheit +
  10.14333127 * percentHumidity +
  -0.22475541 * tempFahrenheit*percentHumidity +
  -0.00683783 * pow(tempFahrenheit, ) +
  -0.05481717 * pow(percentHumidity, ) +
  0.00122874 * pow(tempFahrenheit, ) * percentHumidity +
  0.00085282 * tempFahrenheit*pow(percentHumidity, ) +
  -0.00000199 * pow(tempFahrenheit, ) * pow(percentHumidity, );
 }

 boolean DHT::read(void) {
  uint8_t laststate = HIGH;
  uint8_t counter = ;
  uint8_t j = , i;
  unsigned long currenttime;

  int bitContainer[];

  // Check if sensor was read less than two seconds ago and return early
  // to use last reading.
  currenttime = millis();
  if (currenttime < _lastreadtime) {
  // ie there was a rollover
  _lastreadtime = ;
  }
  if (!firstreading && ((currenttime - _lastreadtime) < )) {
  return true; // return last correct measurement
  //delay(2000 - (currenttime - _lastreadtime));
  }
  firstreading = false;
  /*
  Serial.print("Currtime: "); Serial.print(currenttime);
  Serial.print(" Lasttime: "); Serial.print(_lastreadtime);
  */
  _lastreadtime = millis();

  data[] = data[] = data[] = data[] = data[] = ;

  // pull the pin high and wait 250 milliseconds
  pinMode(_outpin, OUTPUT_FAST);
  pinMode(_inpin, INPUT_FAST);
  digitalWrite(_outpin, HIGH);
  delay();

  // now pull it low for ~20 milliseconds
  noInterrupts();
  digitalWrite(_outpin, LOW);
  delay();
  digitalWrite(_outpin, HIGH);
  delayMicrosGal();

  //read the 40 bits
  delayMicrosGal();
  for(int bytes = ; bytes < ; bytes++)
  {
  for(int i = ; i < ; i++)
  {
  int pulse = pulseLength(_inpin);
  if(pulse > )
  {
  bitContainer[i] = ;
  }
  else
  {
  bitContainer[i] = ;
  }
  }
  data[bytes] = bitsToByte(bitContainer);
  }

  interrupts();

  //Serial.println(j, DEC);
  /**
  Serial.print(data[0], HEX); Serial.print(", ");
  Serial.print(data[1], HEX); Serial.print(", ");
  Serial.print(data[2], HEX); Serial.print(", ");
  Serial.print(data[3], HEX); Serial.print(", ");
  Serial.print(data[4], HEX); Serial.print(" =? ");
  Serial.println(data[0] + data[1] + data[2] + data[3], HEX);
  **/
  /**
  Serial.println(data[0]);
  Serial.println(data[1]);
  Serial.println(data[2]);
  Serial.println(data[3]);
  Serial.println(data[4]);
  **/
  // check we read 40 bits and that the checksum matches

  if((data[] == ((data[] + data[] + data[] + data[]) & 0xFF)))
  {
  return true;
  }

  return false;

 }

 void DHT::delayMicrosGal(unsigned long usec)
 {
  unsigned long a = micros();
  unsigned long b = a;
  while((b-a) < usec)
  {
  b = micros();
  }
 }

 int DHT::pulseLength(int pin)
 {
  unsigned long a = micros();
  unsigned long b = a;
  unsigned long c = a;
  int timeout = ;
  int fastPin = ;
  int highValue = ;

  if(PLATFORM_NAME == "GalileoGen2")
  {
  switch(pin)
  {
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x08);
  highValue = 0x08;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x10);
  highValue = 0x10;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x20);
  highValue = 0x20;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x40);
  highValue = 0x40;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_RW(0x10);
  highValue = 0x10;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_CW(0x01);
  highValue = 0x01;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_CW(0x02);
  highValue = 0x02;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_RW(0x04);
  highValue = 0x04;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x04);
  highValue = 0x04;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_RW(0x08);
  highValue = 0x08;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x80);
  highValue = 0x80;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_NC_RW(0x20);
  highValue = 0x20;
  break;
  default:
  highValue = ;
  break;
  }
  }
  else
  {
  switch(_inpin)
  {
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x40);
  highValue = 0x40;
  break;
  case :
  fastPin = GPIO_FAST_ID_QUARK_SC(0x80);
  highValue = 0x80;
  break;
  default:
  highValue = ;
  break;
  }
  }
  a = micros();
  while(fastGpioDigitalRead(fastPin) == )
  {
  b= micros();
  if((b - a) >= timeout)
  {
  break;
  }
  }
  a = micros();
  while(fastGpioDigitalRead(fastPin) == highValue)
  {
  b= micros();
  if((b - a) >= timeout)
  {
  break;
  }
  }
  return (b - a);
  return ;
 }

 int DHT::bitsToByte(int bits[])
 {
  int data = ;
  for(int i = ; i < ; i++)
  {
  if (bits[i])
  {
  data |= (int)( << ( - i));
  }
  }
  return data;
 }

 // Example testing sketch for various DHT humidity/temperature sensors
 // Written by ladyada, public domain

 #include "DHT.h"

 #define DHTIN 2 // what pin we're connected to
 #define DHTOUT 3

 // Uncomment whatever type you're using!
 #define DHTTYPE DHT11 // DHT 11
 //#define DHTTYPE DHT22 // DHT 22 (AM2302)
 //#define DHTTYPE DHT21 // DHT 21 (AM2301)

 // Connect pin 1 (on the left) of the sensor to +5V
 // Connect pin 2 of the sensor to whatever your DHTPIN is
 // Connect pin 4 (on the right) of the sensor to GROUND
 // Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

 DHT dht(DHTIN,DHTOUT, DHTTYPE);

 void setup() {
  Serial.begin();
  Serial.println("DHTxx test!");

  dht.begin();
 }

 void loop() {
  // Wait a few seconds between measurements.
  delay();

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
  Serial.println("Failed to read from DHT sensor!");
  return;
  }

  // Compute heat index
  // Must send in temp in Fahrenheit!
  float hi = dht.computeHeatIndex(f, h);

  Serial.print("Humidity: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: ");
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print(f);
  Serial.print(" *F\t");
  Serial.print("Heat index: ");
  Serial.print(hi);
  Serial.println(" *F");
 }

原文地址：http://bigdinotech.com/tutorials/galileo-tutorials/using-1-wire-device-with-intel-galileo/