onewire.c

Go to the documentation of this file.

#include "main-header.h"
#include "onewire.h"
#include "ds18b20crc.h"
#include "powersave.h"
 
// there are some timing operations in this file that
// break with optimisations
 
#pragma GCC optimize ("O0")
 
#define ONEWIRE_TIMER 5
 
#define ONEWIRE_INTERVAL 600
static volatile uint32_t usctr;
 
static int freq_divider = 0;
static int reset(struct onewire_hwdef *hw);
static void write_bit_0(struct onewire_hwdef *hw);
static void write_bit_1(struct onewire_hwdef *hw);
static byte read_bit(struct onewire_hwdef *hw);
static void write_byte(struct onewire_hwdef *hw, byte b);
static byte read_byte(struct onewire_hwdef *hw);
//static byte read_pin();
 
static byte buf[12];
static inline void read_buf(struct onewire_hwdef *hw, int cnt);
static byte toggler;
static long last_run;
 
static int is_valid(byte *recvBuf) {
  int crc_calc = onewire_crc(recvBuf, 8);
  int crc_read = recvBuf[8];
 
  return (crc_calc == crc_read) ? 1 : 0;
}
 
static void print_recvbuf(byte *recvBuf) {
  char hexbuf[40];
 
  bufToHex((char *)&hexbuf, recvBuf, 10);
  printf("Recv: %s", hexbuf);
  int crc_calc = onewire_crc(recvBuf, 8);
  int crc_read = recvBuf[8];
 
  printf("(CRC calc: 0x%x, read: 0x%x) %s\r\n", crc_calc, crc_read,
         (crc_calc == crc_read) ? "OK" : "FAIL");
}
 
 
// this is hardcoded to pin PC7 - (speed!) - once it works try mculib again
// GPIOx_IDR
volatile uint32_t *r_adr = (volatile uint32_t *)0x40020810;
static inline byte read_pin(int mask) __attribute__ ((always_inline));
 
static inline byte read_pin(int mask) {
  // did try: this does not work. 2/1/2018 cnw
  //return mculib_pin_get(get_pin());
  return ((*r_adr) & mask) ? 1 : 0;
}
static inline void pull_low() __attribute__ ((always_inline));
// GPIOx_ODR
volatile uint32_t *wr_adr = (volatile uint32_t *)0x40020814;
static inline void pull_low(int offset, int us) {
  int delayus = (us == 0) ? 0 : (us / freq_divider);
 
  (*wr_adr) &= ~(1 << offset);
  //mculib_pin_set(pin,0);
  usctr = 0;
  while (delayus > usctr) {
  }
  (*wr_adr) |= 1 << offset;
 
  //mculib_pin_set(pin,1); // open-drain - switch transistor off
  return;
}
 
static void delay_us(int us) {
  int delayus = us / freq_divider;
 
  usctr = 0;
  while (usctr < delayus) {
    ;;
  }
  return;
}
 
static void ow_timer_irq() {
  usctr++;
}
static int timer_enable() {
  int r;
  // will call STM32 timer2_irq 500 times a second
  int freqreq = 100000; // one IRQ every 10us
 
  freq_divider = 10;
  r = mculib_timer_enable_simple(MAIN_MCULIBHANDLE, ONEWIRE_TIMER, freqreq, &ow_timer_irq);
  if (r) {
    mculib_print_mappings(&printf);
    printf("onewire MCULIB Error (failed to enable timer %i): %i\r\n", ONEWIRE_TIMER, r);
  } else {
    printf("Timer %i enabled with frequency %i (divider to us: %i)\r\n", ONEWIRE_TIMER, freqreq, freq_divider);
  }
  return r;
}
static int read_temperature(struct onewire_hwdef *hw, byte *error) {
  int res = 20005;
  int r;
  int repeat;
 
  *error = 0;
  //printf("Running onewire\r\n");
  if ((r = mculib_pin_out_opendrain(MAIN_MCULIBHANDLE, hw->pin, HAL_PIN_FASTEST))) {
    printf("Failed to configure pin %i for opendrain output: %i\r\n", hw->pin, r);
    *error = 2;
    return 20001;
  }
 
  timer_enable();
  /*
   * int started =mculib_get_seconds_since_boot();
   * while ((mculib_get_seconds_since_boot() - started) < 5) {
   * goto finish;
   * }
   */
 
  if (!reset(hw)) {
    printf("No onewire device detected. abort\r\n");
    *error = 3;
    res = 20003;
    goto finish;
  }
  printf("Onewire device detected.\r\n");
  for (repeat = 0; repeat < 5; repeat++) {
    write_byte(hw, 0x33); // readrom
    read_buf(hw, 9);
    delay_us(500);
 
    reset(hw);
    write_byte(hw, 0xCC);       // SKIP ROM
    delay_us(50);               // wait for whatever?
 
    write_byte(hw, 0x44);       // convert temperature
    delay_us(5000);             // wait for conversion
 
    reset(hw);
    write_byte(hw, 0xCC);       // SKIP ROM
    delay_us(50);               // wait for whatever?
    write_byte(hw, 0xBE);       // read scratchpad (the temperature)
    read_buf(hw, 9);
 
    if (is_valid((byte *)buf)) {
      break;
    }
  }
  if (!is_valid((byte *)buf)) {
    *error = 4;
    res = 20004;
    goto finish;
  }
  uint16_t tempRaw = ((uint16_t)buf[1]) << 8 | buf[0];
  int neg = 0;
 
  if (tempRaw & (1 << 15)) {
    neg = 1;
    tempRaw = 0xFFFF - tempRaw;
  }
  int32_t temp_c100 = (6 * ((int32_t)tempRaw)) + (tempRaw / 4);
 
  if (neg) {
    temp_c100 = 0 - temp_c100;
  }
  printf("Temp: %i, %i\r\n", (int)tempRaw, (int)temp_c100);
  res = temp_c100;
finish:
  mculib_timer_disable(MAIN_MCULIBHANDLE, ONEWIRE_TIMER);
  mculib_pin_release(MAIN_MCULIBHANDLE, hw->pin);
  mculib_pin_out(MAIN_MCULIBHANDLE, hw->pin, HAL_PIN_SLOWEST);
  mculib_pin_release(MAIN_MCULIBHANDLE, hw->pin);
  return res;
}
static int reset(struct onewire_hwdef *hw) {
  int r;
 
  pull_low(hw->offset, 500); // min 480us
  usctr = 0;
  int low = 0;
  int high = 0;
 
  while (usctr < (480)) {
    r = read_pin(1 << hw->offset);
    if (r == 0) {
      low++;
    } else if (r == 1) {
      high++;
    } else {
      printf("Error reading pin: %i\r\n", r);
      return 0;
    }
  }
  //printf("Presence detection: low=%i, high=%i, ctr=%i, lctr=%i\r\n",low,high,ctr,total);
 
  // if we have no high signal we have neither DS18B20 and no pull-up
  // if we have no low signal we have pull-up and no DS18B20
  if ((low == 0) || (high == 0)) {
    return 0;
  }
  return 1;
}
static byte read_byte(struct onewire_hwdef *hw) {
  int i;
  byte res = 0;
 
  for (i = 0; i < 8; i++) {
    byte b = read_bit(hw);
    b = b << i;
    res |= b;
  }
  return res;
}
static void write_byte(struct onewire_hwdef *hw, byte b) {
  int i;
 
  for (i = 0; i < 8; i++) {
    // sending LSB first...
    if ((b >> i) & 1) {
      write_bit_1(hw);
    } else {
      write_bit_0(hw);
    }
  }
}
 
static void write_bit_1(struct onewire_hwdef *hw) {
  pull_low(hw->offset, 0);
  //pull_low(get_pin(),5);
  delay_us(61); // 50 *should* be enough
}
static void write_bit_0(struct onewire_hwdef *hw) {
  pull_low(hw->offset, 61);
  delay_us(11);
}
static byte read_bit(struct onewire_hwdef *hw) {
  int sampletime = 15 / freq_divider;
  int samples = 0;
  int val = 0;
 
  pull_low(hw->offset, 5); // this should be low for 1us - 5us and sample at 10us. we can't be that exact on stm32lxx
  usctr = 0;
  val = read_pin(1 << hw->offset);
  while (usctr < sampletime) {
    samples++;
    val = val + read_pin(1 << hw->offset);
  }
  delay_us(65); //min 60 us wait slot thing
  //printf("Read bit: %i of %i samples \r\n",val,samples);
  return (val > 0) ? 1 : 0;
  //return (val == samples) ? 1 : 0;
}
static inline void read_buf(struct onewire_hwdef *hw, int cnt) {
  int i;
 
  for (i = 0; i < sizeof(buf); i++) {
    buf[i] = 0xDA;
  }
  for (i = 0; i < cnt; i++) {
    byte b = read_byte(hw);
    buf[i] = b;
  }
  print_recvbuf((byte *)buf);
}
 
 
int query_onewire(struct onewire_hwdef *hw, byte *error) {
  int i;
  int temp = 30000;
 
  power_set_speed(10);
  for (i = 0; i < 5; i++) {
    temp = read_temperature(hw, error);
    printf("Temperature (pin %i): %i\r\n", hw->pin, temp);
    if ((temp > 8500) || (*error != 0)) {
      printf("Onewire above threshold - failed! \r\n");
    } else {
      break;
    }
  }
  if (temp > 7500) {
    return 0;
  }
  return temp;
}
 
/*********************************************************************************
 * callbacks from sensors framework
 *******************************************************************************/
// called each time the sensors framework wants a reading
int onewire_run(byte idx, byte *error) {
  *error = 0;
  struct onewire_hwdef hw;
 
  if ((idx == 212) && (CONFIG_FLAGS_TEMP212)) {
    hw.offset = 12;
    hw.pin = 212; // PIN onewire is connected to
    return query_onewire(&hw, error);
  }
 
  if ((idx == 207) && (CONFIG_FLAGS_TEMP207)) {
    hw.offset = 7;
    hw.pin = 207; // PIN onewire is connected to
    return query_onewire(&hw, error);
  }
 
  if ((idx == 211) && (CONFIG_FLAGS_TEMP211)) {
    hw.offset = 11;
    hw.pin = 211; // PIN onewire is connected to
    return query_onewire(&hw, error);
  }
  return 0;
}
// callback from sensors framework
int onewire_reading_size(byte idx) {
  return 2;
}
 
int onewire_init(byte idx) {
  last_run = 0;
  toggler = 0;
  return 0;
}