Improving 1-wire slave device support

Author: mikaelpatel

README.md

@@ -17,6 +17,7 @@ Version: 1.8
 * [Hardware One-Wire Bus Manager, DS2482, Hardware::OWI](./src/Hardware/OWI.h)
 * [Software One-Wire Slave Device, Slave::OWI](./src/Slave/OWI.h)
 * [Programmable Resolution 1-Wire Digital Thermometer, DS18B20](./src/Driver/DS18B20.h)
+* [One-Wire Interface Remove Arduino](./src/Driver/Arduino.h)
 
 ## Example Sketches
 

examples/Arduino/Arduino.ino

@@ -0,0 +1,71 @@
+#include "GPIO.h"
+#include "OWI.h"
+#include "Software/OWI.h"
+#include "Driver/Arduino.h"
+#include "assert.h"
+#include "benchmark.h"
+
+// One-Wire Interface Remove Arduino (Master)
+Software::OWI<BOARD::D7> owi;
+Arduino arduino(owi);
+
+void setup()
+{
+  Serial.begin(57600);
+  while (!Serial);
+
+  uint8_t rom[owi.ROM_MAX] = { 0 };
+  int8_t last = owi.FIRST;
+  int id = 0;
+  int pins;
+
+  // Search for device and set short address (label)
+  last = owi.search_rom(arduino.FAMILY, rom, last);
+  ASSERT(last != owi.ERROR);
+  arduino.rom(rom);
+  arduino.label_rom(id);
+  Serial.print(id);
+  Serial.print(':');
+  arduino.print_rom();
+  Serial.println();
+
+  // Get number of digital pins and read pin state
+  ASSERT((pins = arduino.num_digital_pins()) > 0);
+  Serial.print(F("arduino.num_digital_pins="));
+  Serial.println(pins);
+  Serial.println(F("arduino.digitalRead:"));
+  for (int i = 0; i < pins; i++) {
+    Serial.print('D');
+    Serial.print(i);
+    Serial.print(':');
+    Serial.println(arduino.digitalRead(i));
+  }
+
+  // Get number of analog inputs and read analog values
+  ASSERT((pins = arduino.num_analog_inputs()) > 0);
+  Serial.print(F("arduino.num_analog_inputs="));
+  Serial.println(pins);
+  Serial.println(F("arduino.analogRead:"));
+  for (int i = 0; i < pins; i++) {
+    Serial.print('A');
+    Serial.print(i);
+    Serial.print(':');
+    Serial.println(arduino.analogRead(i));
+  }
+
+  // Set builtin led pin to output
+  ASSERT(arduino.pinMode(13, OUTPUT) == 0);
+
+  // Set pulse width modulated pin(3) to 50% duty(127)
+  ASSERT(arduino.analogWrite(3, 127) == 0);
+}
+
+void loop()
+{
+  // Classical blink sketch loop; measure micro-seconds to perform
+  // one-wire interface remote arduino functions
+  MEASURE(arduino.digitalWrite(13, HIGH));
+  delay(1000);
+  MEASURE(arduino.digitalWrite(13, LOW));
+  delay(1000);
+}

examples/ROM/ROM.ino

@@ -0,0 +1,110 @@
+#include "GPIO.h"
+#include "OWI.h"
+#include "Software/OWI.h"
+#include "assert.h"
+
+Software::OWI<BOARD::D7> owi;
+
+void setup()
+{
+  Serial.begin(57600);
+  while (!Serial);
+}
+
+void loop()
+{
+  // The Standard ROM functions:
+  // 1. Read ROM from single device on the bus.
+  // 2. Skip ROM to address all devices
+  // 3. Match ROM to address a specific device.
+  // 4. Search ROM to iterate devices.
+  // 5. Alarm Search to iterate devices with alarm set.
+  // 6. Match LABEL to use short addressing (Extended function).
+
+  uint8_t ROM[OWI::ROM_MAX];
+  uint8_t label;
+  int8_t last;
+  uint8_t id;
+  bool res;
+
+  // Read ROM from slave, and print
+  ASSERT(owi.read_rom(ROM));
+  Serial.print(F("read_rom:"));
+  print(ROM);
+  Serial.println();
+
+  // Address slave with skip rom
+  ASSERT(res = owi.skip_rom());
+  Serial.print(F("skip_rom:res="));
+  Serial.println(res);
+  owi.write(0);
+
+  // Address slave with match rom
+  ASSERT(res = owi.match_rom(ROM));
+  Serial.print(F("match_rom:res="));
+  Serial.println(res);
+  owi.write(0);
+
+  // Address slave with search rom
+  id = 0;
+  last = owi.FIRST;
+  memset(ROM, 0, sizeof(ROM));
+  do {
+    last = owi.search_rom(1, ROM, last);
+    if (last == owi.ERROR) break;
+    label = 10;
+    owi.write(0x15);
+    owi.write(label);
+    Serial.print(F("search_rom["));
+    Serial.print(id);
+    Serial.print(F("]:"));
+    print(ROM);
+    Serial.print(F(":label_rom:label="));
+    Serial.println(label);
+    id += 1;
+  } while (last != owi.LAST);
+
+  // Address slave with alarm search
+  last = owi.FIRST;
+  id = 0;
+  memset(ROM, 0, sizeof(ROM));
+  do {
+    last = owi.alarm_search(ROM, last);
+    if (last == owi.ERROR) break;
+    owi.write(0x16);
+    label = owi.read();
+    Serial.print(F("alarm_search["));
+    Serial.print(id++);
+    Serial.print(F("]:"));
+    print(ROM);
+    Serial.print(F(":read_label:label="));
+    Serial.println(label);
+  } while (last != owi.LAST);
+
+  // Address slave with match label
+  ASSERT(res = owi.match_label(10));
+  owi.write(0);
+  Serial.print(F("match_label:res="));
+  Serial.println(res);
+  Serial.println();
+
+  delay(2000);
+}
+
+void print(uint8_t* rom)
+{
+  // Print 1-Wire ROM identity code; family, serial number and crc
+  Serial.print(F("famly="));
+  if (rom[0] < 0x10) Serial.print('0');
+  Serial.print(rom[0], HEX);
+  Serial.print(F(",sn="));
+  for (size_t i = 1; i < OWI::ROM_MAX - 1; i++) {
+    if (rom[i] < 0x10) Serial.print('0');
+    Serial.print(rom[i], HEX);
+    if (i < OWI::ROM_MAX - 2) Serial.print(',');
+  }
+  Serial.print(F(",crc="));
+  uint8_t crc = rom[OWI::ROM_MAX - 1];
+  if (crc < 0x10) Serial.print('0');
+  Serial.print(crc, HEX);
+}

examples/Slave/Arduino/Arduino.ino

@@ -0,0 +1,108 @@
+#include "GPIO.h"
+#include "OWI.h"
+#include "Slave/OWI.h"
+#include "Driver/Arduino.h"
+
+/** ROM identity code (in program memory). */
+const uint8_t ROM[OWI::ROM_MAX] PROGMEM = {
+  Arduino::FAMILY, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x80
+};
+
+/** One-Wire Slave Device Bus Manager. */
+Slave::OWI<BOARD::D7> owi(ROM);
+
+/**
+ * Setup One-Wire Remote Arduino Slave Device. Set alarm
+ * state to allow alarm search before reading analog input.
+ */
+void setup()
+{
+  owi.alarm(true);
+}
+
+/**
+ * Service incoming one-wire rom and remote arduino functions.
+ */
+void loop()
+{
+  // Additional sketch code could be placed here before
+  // polling one-wire bus for commands
+  if (!owi.rom_command()) return;
+
+  const size_t BUF_MAX = 32;
+  uint8_t buf[BUF_MAX];
+  uint16_t value;
+  uint8_t pin;
+  uint8_t mode;
+  uint8_t* bp;
+  uint8_t count;
+  uint8_t res;
+  uint8_t duty;
+
+  // Read and dispatch remote arduino commands
+  switch (owi.read_command()) {
+  case Arduino::PIN_MODE:
+    pin = owi.read(6);
+    mode = owi.read(2);
+    pinMode(pin, mode);
+    break;
+  case Arduino::DIGITAL_READ:
+    pin = owi.read(6);
+    value = digitalRead(pin);
+    owi.write(value, 1);
+    break;
+  case Arduino::DIGITAL_WRITE:
+    pin = owi.read(6);
+    value = owi.read(1);
+    digitalWrite(pin, value);
+    break;
+  case Arduino::ANALOG_READ:
+    pin = owi.read(6);
+    value = analogRead(pin);
+    owi.alarm(value > 512);
+    owi.write(&value, sizeof(value));
+    break;
+  case Arduino::ANALOG_WRITE:
+    pin = owi.read(6);
+    duty = owi.read();
+    analogWrite(pin, duty);
+    break;
+  case Arduino::SRAM_READ:
+    owi.read(&bp, sizeof(bp));
+    count = owi.read();
+    owi.write(bp, count);
+    break;
+  case Arduino::SRAM_WRITE:
+    owi.read(&bp, sizeof(bp));
+    count = owi.read();
+    owi.read(bp, count + 1);
+    break;
+  case Arduino::EEPROM_READ:
+    owi.read(&bp, sizeof(bp));
+    count = owi.read();
+    owi.crc(0);
+    while (count--) owi.write(eeprom_read_byte(bp++));
+    owi.write(owi.crc());
+    break;
+  case Arduino::EEPROM_WRITE:
+    owi.read(&bp, sizeof(bp));
+    count = owi.read();
+    res = 0b00;
+    if (count > BUF_MAX) {
+      while (count--) owi.read();
+      owi.read();
+    }
+    else if (owi.read(buf, count)) {
+      eeprom_write_block(buf, bp, count);
+      res = 0b10;
+    }
+    owi.write(res, 2);
+    break;
+  case Arduino::DIGITAL_PINS:
+    owi.write(NUM_DIGITAL_PINS, 6);
+    break;
+  case Arduino::ANALOG_PINS:
+    owi.write(NUM_ANALOG_INPUTS, 6);
+    break;
+  }
+}

examples/Slave/DS18B20/DS18B20.ino

@@ -18,7 +18,7 @@ enum {
 } __attribute__((packed));
 
 /**
- * DS18B20 Memory Map.
+ * DS18B20 Scratchpad structure.
  */
 struct scratchpad_t {
   int16_t temperature;		//!< Temperature reading (9-12 bits).
@@ -29,7 +29,9 @@ struct scratchpad_t {
 } __attribute__((packed));
 
 // ROM identity for slave device
-uint8_t ROM[OWI::ROM_MAX];
+const uint8_t ROM[OWI::ROM_MAX] PROGMEM = {
+  FAMILY_CODE, 0x12, 0x34, 0x56, 0x78, 0x89, 0x9a, 0xab
+};
 
 // Slave device one wire access
 Slave::OWI<BOARD::D7> owi(ROM);
@@ -46,16 +48,16 @@ scratchpad_t scratchpad = {
 // Analog pin used for emulated temperature reading
 const int pin = A0;
 
+// Use builtin led; active during conversion delay
+GPIO<BOARD::D13> led;
+
 void setup()
 {
-  // Random ROM identity code
-  ROM[0] = FAMILY_CODE;
-  uint8_t* p = (uint8_t*) 0;
-  for (size_t i = 1; i < OWI::ROM_MAX; i++) ROM[i] = *p++;
+  led.output();
 }
 
-// This sketch uses approx. 1900 bytes (Uno) of program storage space,
-// and 38 bytes for global variables (random access memory)
+// This sketch uses approx. 1500 bytes (Uno) of program storage space,
+// and less than 40 bytes for global variables (random access memory)
 void loop()
 {
   // Application could do something in the background before
@@ -73,9 +75,11 @@ void loop()
     value >>= 2;
     owi.alarm(value >= scratchpad.high_trigger ||
 	      value <= scratchpad.low_trigger);
+    led.high();
     break;
   case READ_SCRATCHPAD:
     owi.write(&scratchpad, sizeof(scratchpad));
+    led.low();
     break;
   case WRITE_SCRATCHPAD:
     owi.read(&scratchpad.high_trigger, 3);