.gitmodules

+[submodule "external/OneWire"]
+	path = external/OneWire
+	url = https://github.com/PaulStoffregen/OneWire.git

Makefile

+# This Makefile compiles and flashes four different programs:
+# - led_on
+# - button_contact
+# - timer_test
+# - button_toggle
+# - button_serial
+#
+# To program a board, first make sure the PROGRAMMER variable is set correctly.
+# (If you're using your own HTM(a)A programmer board, use usbtiny.) Each board
+# will also have to have its fuses set once, which can be done by running
+# "make program-fuses". Finally, run make program_<program_name>. For example,
+# "make program_button_toggle" will build and flash the button_toggle program.
+
+MMCU=attiny44
+F_CPU = 20000000
+CFLAGS=-mmcu=$(MMCU) -Wall -Os -DF_CPU=$(F_CPU) \
+	-I external/OneWire \
+	-I /usr/share/arduino/hardware/arduino/cores/arduino
+#PROGRAMMER = atmelice_isp
+PROGRAMMER = usbtiny
+
+%.hex: %.elf
+	avr-objcopy -O ihex $< $@;\
+	avr-size --mcu=$(MMCU) --format=avr $@
+
+#%.o: %.c
+#	avr-g++ $(CFLAGS) -I./ -o $@ $<
+
+program_%: %.hex
+	avrdude -p t44 -P usb -c $(PROGRAMMER) -U flash:w:$<
+
+external/OneWire/OneWire.o: external/OneWire/OneWire.cpp external/OneWire/OneWire.h
+	avr-g++ -c $(CFLAGS) -I./ -o $@ $<
+
+button_serial.o: button_serial.c external/OneWire/OneWire.h
+	avr-g++ -c $(CFLAGS) -I./ -o $@ $<
+
+button_serial.elf: button_serial.o OneWire.o
+	avr-g++ $(CFLAGS) -o $@ $^
+
+.PHONY: default
+#default: program_button_serial
+default: button_serial.hex
+
+program-fuses:
+	avrdude -p t44 -P usb -c $(PROGRAMMER) -U lfuse:w:0x5E:m

blink.cpp

+// Compile with
+// avr-g++ -x c++ -mmcu=attiny44 -Wall -Os -c -DF_CPU=20000000 -I/usr/share/arduino/hardware/arduino/cores/arduino -I/usr/share/arduino/hardware/arduino/variants/standard blink.cpp
+// avr-g++ -x c++ -mmcu=attiny44 -Wall -Os -c -DF_CPU=20000000 -I/usr/share/arduino/hardware/arduino/cores/arduino -I/usr/share/arduino/hardware/arduino/variants/standard /usr/share/arduino/hardware/arduino/cores/arduino/wiring.c
+// avr-g++ -x c++ -mmcu=attiny44 -Wall -Os -c -DF_CPU=20000000 -I/usr/share/arduino/hardware/arduino/cores/arduino -I/usr/share/arduino/hardware/arduino/variants/standard /usr/share/arduino/hardware/arduino/cores/arduino/wiring_digital.c
+// avr-ar rcs libcore.a hooks.o wiring.o wiring_digital.o
+
+#include <Arduino.h>
+
+void setup() {
+    pinMode(5, OUTPUT);
+}
+
+void loop() {
+    digitalWrite(5, LOW);
+    delay(1000);
+    digitalWrite(5, HIGH);
+    delay(400);
+}

button_serial.c

+//
+//
+// serial_button.c
+//
+// 115200 baud FTDI connection that outputs '0' or '1' depending
+// on the state of a physical button
+//
+// set lfuse to 0x5E for 20 MHz xtal
+//
+// Neil Gershenfeld
+// 12/8/10
+// Erik Strand
+// 11/26/2018
+//
+#include <avr/io.h>
+#include <util/delay.h>
+#include <avr/pgmspace.h>
+
+#include "OneWire.h"
+
+#define output(directions,pin) (directions |= pin) // set port direction for output
+#define set(port,pin) (port |= pin) // set port pin
+#define clear(port,pin) (port &= (~pin)) // clear port pin
+#define pin_test(pins,pin) (pins & pin) // test for port pin
+#define bit_test(byte,bit) (byte & (1 << bit)) // test for bit set
+#define bit_delay_time 8.5 // bit delay for 115200 with overhead
+#define bit_delay() _delay_us(bit_delay_time) // RS232 bit delay
+#define half_bit_delay() _delay_us(bit_delay_time/2) // RS232 half bit delay
+#define char_delay() _delay_ms(10) // char delay
+#define delay(duration) _delay_ms(duration); // drop-in replacement for Arduino delay
+
+#define serial_port PORTA
+#define serial_direction DDRA
+#define serial_pins PINA
+#define serial_pin_in (1 << PA0)
+#define serial_pin_out (1 << PA1)
+
+#define led_pin (1 << PB2)
+#define button_pin (1 << PA7)
+
+#define max_buffer 25
+
+void put_char(volatile unsigned char *port, unsigned char pin, char txchar) {
+    //
+    // send character in txchar on port pin
+    //    assumes line driver (inverts bits)
+    //
+    // start bit
+    //
+    clear(*port,pin);
+    bit_delay();
+    //
+    // unrolled loop to write data bits
+    //
+    if bit_test(txchar,0)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,1)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,2)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,3)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,4)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,5)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,6)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    if bit_test(txchar,7)
+    set(*port,pin);
+    else
+    clear(*port,pin);
+    bit_delay();
+    //
+    // stop bit
+    //
+    set(*port,pin);
+    bit_delay();
+    //
+    // char delay
+    //
+    bit_delay();
+}
+
+void put_string(volatile unsigned char *port, unsigned char pin, char *str) {
+    //
+    // print a null-terminated string
+    //
+    static int index;
+    index = 0;
+    do {
+        put_char(port, pin, str[index]);
+        ++index;
+    } while (str[index] != 0);
+}
+
+OneWire  ds(11);  // on pin 10 (a 4.7K resistor is necessary)
+
+//void setup(void) {
+//    Serial.begin(9600);
+//}
+
+void loop(void) {
+    byte i;
+    byte present = 0;
+    byte type_s;
+    byte data[12];
+    byte addr[8];
+    float celsius, fahrenheit;
+
+    if ( !ds.search(addr)) {
+        put_string(&serial_port, serial_pin_out, "No more addresses.");
+        ds.reset_search();
+        delay(250);
+        return;
+    }
+
+    //Serial.print("ROM =");
+    put_string(&serial_port, serial_pin_out, "ROM=");
+    for( i = 0; i < 8; i++) {
+        put_char(&serial_port, serial_pin_out, ' ');
+        //Serial.print(addr[i], HEX);
+        put_string(&serial_port, serial_pin_out, "xxx");
+        //put_string(&serial_port, serial_pin_out, addr[i])
+    }
+
+    if (OneWire::crc8(addr, 7) != addr[7]) {
+        put_string(&serial_port, serial_pin_out, "CRC is not valid!");
+        return;
+    }
+    //Serial.println();
+
+    // the first ROM byte indicates which chip
+    switch (addr[0]) {
+        case 0x10:
+        put_string(&serial_port, serial_pin_out, "  Chip = DS18S20");  // or old DS1820
+        type_s = 1;
+        break;
+        case 0x28:
+        put_string(&serial_port, serial_pin_out, "  Chip = DS18B20");
+        type_s = 0;
+        break;
+        case 0x22:
+        put_string(&serial_port, serial_pin_out, "  Chip = DS1822");
+        type_s = 0;
+        break;
+        default:
+        put_string(&serial_port, serial_pin_out, "Device is not a DS18x20 family device.");
+        return;
+    }
+
+    ds.reset();
+    ds.select(addr);
+    ds.write(0x44, 1);        // start conversion, with parasite power on at the end
+
+    delay(1000);     // maybe 750ms is enough, maybe not
+    // we might do a ds.depower() here, but the reset will take care of it.
+
+    present = ds.reset();
+    ds.select(addr);
+    ds.write(0xBE);         // Read Scratchpad
+
+    put_string(&serial_port, serial_pin_out, "  Data = ");
+    put_string(&serial_port, serial_pin_out, "xxx");
+    //put_string(&serial_port, serial_pin_out, present, HEX);
+    put_string(&serial_port, serial_pin_out, " ");
+    for ( i = 0; i < 9; i++) {           // we need 9 bytes
+        data[i] = ds.read();
+        //Serial.print(data[i], HEX);
+        put_string(&serial_port, serial_pin_out, " thing");
+    }
+    put_string(&serial_port, serial_pin_out, " CRC=");
+    //put_string(&serial_port, serial_pin_out, OneWire::crc8(data, 8), HEX);
+
+    // 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;
+    put_string(&serial_port, serial_pin_out, "  Temperature = ");
+    //put_string(&serial_port, serial_pin_out, celsius);
+    put_string(&serial_port, serial_pin_out, " Celsius, ");
+    //put_string(&serial_port, serial_pin_out, fahrenheit);
+    put_string(&serial_port, serial_pin_out, " Fahrenheit");
+}
+
+int main(void) {
+    // Set clock divider to 1.
+    CLKPR = (1 << CLKPCE);
+    CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
+
+    // Initialize output pins.
+    set(serial_port, serial_pin_out);
+    output(serial_direction, serial_pin_out);
+
+    // Configure led pin as an output.
+    DDRB |= led_pin;
+
+    // Configure button_pin as an input.
+    DDRA &= ~button_pin;
+
+    // Activate button_pin's pullup resistor.
+    PORTA |= button_pin;
+
+    while (1) {
+        // Turn on the LED when the button is pressed.
+        if (PINA & button_pin) {
+            // Turn off the LED.
+            PORTB &= ~led_pin;
+            //put_char(&serial_port, serial_pin_out, '0');
+        } else {
+            PORTB |= led_pin;
+            //put_char(&serial_port, serial_pin_out, '1');
+        }
+        //_delay_us(10000);
+        loop();
+    }
+}

OneWire @ dbc93eba

+Subproject commit dbc93eba80d1b777af2eefed8e607775f456e9fb

node_board/CMakeLists.txt

+cmake_minimum_required(VERSION 3.13) # 3.13 is required for target_link_options
+project(NodeBoard CXX)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+include(cmake/shared_settings.cmake)
+find_package(PNG REQUIRED)
+
+add_executable(generate_node_board
+    main.cpp
+    png_writer.cpp
+    png_writer.h
+)
+target_include_directories(generate_node_board PUBLIC ${PNG_INCLUDE_DIR})
+target_link_libraries(generate_node_board shared_settings ${PNG_LIBRARY})
+target_compile_features(generate_node_board PUBLIC cxx_std_17)

node_board/cmake/shared_settings.cmake

+# This file defines an interface library used to add common compile flags to all libraries and
+# executables in FunkyCT.
+
+add_library(shared_settings INTERFACE)
+
+# Warning flags
+target_compile_options(shared_settings INTERFACE
+    -Wall
+    -Wcast-align
+    -Wcast-qual
+    -Wextra
+    -Wundef
+    -Wuseless-cast
+    -Wzero-as-null-pointer-constant
+    -pedantic
+)
+
+# Speed flags
+target_compile_options(shared_settings INTERFACE -march=native -ffast-math)
+
+# Build type for profile generation
+target_compile_options(shared_settings INTERFACE $<$<CONFIG:ProfileGenerate>:
+    -fprofile-generate
+    -O3
+    -DNDEBUG
+>)
+target_link_options(shared_settings INTERFACE $<$<CONFIG:ProfileGenerate>:-fprofile-generate>)
+
+# Build type for profile use
+target_compile_options(shared_settings INTERFACE $<$<CONFIG:ProfileUse>:
+    -fprofile-use
+    -O3
+    -DNDEBUG
+>)
+target_link_options(shared_settings INTERFACE $<$<CONFIG:ProfileUse>:-fprofile-use>)

node_board/main.cpp

+#include "png_writer.h"
+#include <iostream>
+
+//--------------------------------------------------------------------------------------------------
+struct Rectangle {
+    int32_t x_min;
+    int32_t x_max;
+    int32_t y_min;
+    int32_t y_max;
+};
+
+//--------------------------------------------------------------------------------------------------
+class Board {
+public:
+    Board(double width, double height, double pix_per_mm, double min_cut_thickness)
+    : width_(width), height_(height), pix_per_mm_(pix_per_mm),
+      min_cut_thickness_(min_cut_thickness), width_px_(to_px(width_)), height_px_(to_px(height_)),
+      min_cut_thickness_px_(to_px(min_cut_thickness_))
+    {
+        png_writer_.allocate(width_px_ + 4 * min_cut_thickness_px_,
+                             height_px_ + 4 * min_cut_thickness_px_);
+        png_writer_.set_all_pixels(255);
+        draw_int_rectangle(0, width_px_, 0, height_px_, 0);
+    }
+
+    int32_t to_px(double x) {
+        return static_cast<int32_t>(pix_per_mm_ * x);
+    }
+
+    void set_pixel(int32_t x, int32_t y, uint8_t value = 255) {
+        x = std::max(-2 * min_cut_thickness_px_, x);
+        x = std::min(width_px_ + 2 * min_cut_thickness_px_, x);
+        y = std::max(-2 * min_cut_thickness_px_, y);
+        y = std::min(height_px_ + 2 * min_cut_thickness_px_, y);
+        png_writer_.set_pixel(2 * min_cut_thickness_px_ + x,
+                              2 * min_cut_thickness_px_ + height_px_ - y - 1,
+                              value);
+    }
+
+    void draw_int_rectangle(
+        int32_t x_min, int32_t x_max, int32_t y_min, int32_t y_max, uint8_t value = 255
+    ) {
+        for (int32_t x = x_min; x < x_max; ++x) {
+            for (int32_t y = y_min; y < y_max; ++y) {
+                set_pixel(x, y, value);
+            }
+        }
+    }
+
+    void draw_rectangle(
+        double x_min, double x_max, double y_min, double y_max, uint8_t value = 255
+    ) {
+        draw_int_rectangle(to_px(x_min), to_px(x_max), to_px(y_min), to_px(y_max), value);
+    }
+
+    void draw_rectangle(Rectangle const& r, uint8_t value = 255) {
+        draw_int_rectangle(r.x_min, r.x_max, r.y_min, r.y_max, value);
+    }
+
+    void draw_pad(double x_min, double x_max, double y_min, double y_max) {
+        draw_rectangle(x_min - min_cut_thickness_, x_max + min_cut_thickness_,
+                       y_min - min_cut_thickness_, y_max + min_cut_thickness_,
+                       0);
+        draw_rectangle(x_min, x_max, y_min, y_max, 255);
+    }
+
+    void save(char const* filename) {
+        png_writer_.write(filename);
+    }
+
+    void save_outline(char const* filename) {
+        png_writer_.set_all_pixels_black();
+        draw_int_rectangle(0, width_px_, 0, height_px_);
+        save(filename);
+    }
+
+public:
+    PngWriter png_writer_;
+    double width_;
+    double height_;
+    double pix_per_mm_;
+    double min_cut_thickness_;
+    int32_t width_px_;
+    int32_t height_px_;
+    int32_t min_cut_thickness_px_;
+};
+
+//--------------------------------------------------------------------------------------------------
+// All length measurements are in mm.
+int main() {
+    // reused vars... dirty C style
+    double pad_x_min;
+    double pad_x_max;
+    double pad_y_min;
+    double pad_y_max;
+
+    // board params
+    // width is deduced later
+    double const height = 18;
+    double const ppmm = 50; // equivalent to 1270 ppi
+    double const min_cut_thickness = 0.38;
+    double const min_trace_thickness = 0.35;
+
+    // SOIC dims
+    double const pad_width = 0.6;
+    double const pad_height = 2.4;
+    double const soic_height = 7;
+    double const soic_pitch = 1.27;
+    double const soic_width = 3 * soic_pitch + pad_width;
+
+    // deduce width and make the board
+    double const width = soic_width + 3 * min_cut_thickness + 3 * min_trace_thickness;
+    std::cout << "Board width: " << width << "mm\n";
+    Board board(width, height, ppmm, min_cut_thickness);
+
+    // SOIC pads
+    double const soic_x_min = min_trace_thickness + min_cut_thickness;
+    double const soic_x_max = soic_x_min + 3 * soic_pitch + pad_width;
+    double const soic_btm_y = 0.5 * (height - soic_height);
+    double const soic_top_y = height - soic_btm_y;
+    for (int32_t i = 0; i < 4; ++i) {
+        pad_x_min = soic_x_min + i * soic_pitch;
+        pad_x_max = pad_x_min + pad_width;
+        pad_y_max = soic_btm_y + pad_height;
+        board.draw_rectangle(pad_x_min, pad_x_max, soic_btm_y, pad_y_max);
+        pad_y_min = soic_top_y - pad_height;
+        board.draw_rectangle(pad_x_min, pad_x_max, pad_y_min, soic_top_y);
+    }
+
+    // Ground pads and traces
+    double const cable_pad_width = (width - 2 * min_cut_thickness) / 3;
+    double const cable_pad_height = soic_btm_y - min_cut_thickness;
+    double const bridge_offset = 0.5 * (pad_width - min_trace_thickness);
+    board.draw_rectangle(0, cable_pad_width, 0, cable_pad_height);
+    board.draw_rectangle(0, min_trace_thickness, 0, height);
+    board.draw_rectangle(soic_x_min + bridge_offset,
+                         soic_x_min + bridge_offset + min_trace_thickness,
+                         cable_pad_height,
+                         cable_pad_height + min_cut_thickness);
+    board.draw_rectangle(0,
+                         cable_pad_width,
+                         soic_top_y + 2 * min_cut_thickness + min_trace_thickness,
+                         height);
+
+    // Data pads and traces
+    double const data_pad_x_min = cable_pad_width + min_cut_thickness;
+    double const data_pad_x_max = data_pad_x_min + cable_pad_width;
+    board.draw_rectangle(data_pad_x_min, data_pad_x_max, 0, cable_pad_height);
+    board.draw_rectangle(data_pad_x_max,
+                         soic_x_max + min_cut_thickness + min_trace_thickness,
+                         cable_pad_height - min_cut_thickness,
+                         cable_pad_height);
+    board.draw_rectangle(soic_x_max + min_cut_thickness,
+                         soic_x_max + min_cut_thickness + min_trace_thickness,
+                         cable_pad_height,
+                         soic_btm_y + pad_height + min_cut_thickness);
+    board.draw_rectangle(soic_x_min + bridge_offset,
+                         soic_x_max + min_cut_thickness + min_trace_thickness,
+                         soic_btm_y + pad_height + min_cut_thickness,
+                         soic_btm_y + pad_height + min_cut_thickness + min_trace_thickness);
+    board.draw_rectangle(soic_x_min + bridge_offset,
+                         soic_x_min + bridge_offset + min_trace_thickness,
+                         soic_btm_y + pad_height + min_cut_thickness,
+                         soic_top_y + min_cut_thickness);
+    board.draw_rectangle(soic_x_min + bridge_offset,
+                         data_pad_x_max,
+                         soic_top_y + min_cut_thickness,
+                         soic_top_y + min_cut_thickness + min_trace_thickness);
+    board.draw_rectangle(data_pad_x_min, data_pad_x_max, soic_top_y + min_cut_thickness, height);
+
+    // VCC pads and traces
+    double const vcc_pad_x_min = 2 * (cable_pad_width + min_cut_thickness);
+    // pad 1
+    board.draw_rectangle(vcc_pad_x_min,
+                         width,
+                         0,
+                         // Note the fudge factor... It makes mods happy.
+                         cable_pad_height - min_cut_thickness - min_trace_thickness - 0.025);
+    board.draw_rectangle(width - min_trace_thickness, width, 0, height);
+    // pad 2
+    board.draw_rectangle(vcc_pad_x_min,
+                         width,
+                         height - cable_pad_height,
+                         height);
+    // pad extension
+    board.draw_rectangle(soic_x_max + min_cut_thickness,
+                         width,
+                         soic_top_y - pad_height - min_cut_thickness,
+                         height - cable_pad_height);
+    double const vcc_pin_x = soic_x_min + soic_pitch + bridge_offset;
+    board.draw_rectangle(vcc_pin_x,
+                         width,
+                         soic_top_y - pad_height - min_cut_thickness - min_trace_thickness,
+                         soic_top_y - pad_height - min_cut_thickness);
+    board.draw_rectangle(vcc_pin_x,
+                         vcc_pin_x + min_trace_thickness,
+                         soic_top_y - pad_height - min_cut_thickness,
+                         soic_top_y);
+
+    // Extend pad divisions
+    board.draw_rectangle(cable_pad_width,
+                         cable_pad_width + min_cut_thickness,
+                         -min_cut_thickness,
+                         0,
+                         0);
+    board.draw_rectangle(cable_pad_width,
+                         cable_pad_width + min_cut_thickness,
+                         height,
+                         height + min_cut_thickness,
+                         0);
+    board.draw_rectangle(width - cable_pad_width - min_cut_thickness,
+                         width - cable_pad_width,
+                         -min_cut_thickness,
+                         0,
+                         0);
+    board.draw_rectangle(width - cable_pad_width - min_cut_thickness,
+                         width - cable_pad_width,
+                         height,
+                         height + min_cut_thickness,
+                         0);
+
+    board.save("node_board_traces.png");
+    board.save_outline("node_board_outline.png");
+
+    return 0;
+}

node_board/png_writer.cpp

+#include "png_writer.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <cstring>
+
+#include <iostream>
+
+//..................................................................................................
+PngWriter::PngWriter(): width_(0), height_(0), row_pointers_(nullptr) {}
+
+//..................................................................................................
+PngWriter::~PngWriter() {
+    if (row_pointers_ != nullptr) {
+        free();
+    }
+}
+
+//..................................................................................................
+void PngWriter::free() {
+    for (int32_t y = 0; y < height_; y++) {
+        std::free(row_pointers_[y]);
+    }
+    std::free(row_pointers_);
+    width_ = 0;
+    height_ = 0;
+}
+
+//..................................................................................................
+void PngWriter::allocate(int32_t width, int32_t height) {
+    if (row_pointers_ != nullptr) {
+        free();
+    }
+    width_ = width;
+    height_ = height;
+    row_pointers_ = (png_bytep*)malloc(sizeof(png_bytep) * height_);
+    for (int y = 0; y < height_; y++) {
+        row_pointers_[y] = (png_bytep)malloc(row_size());
+    }
+}
+
+//..................................................................................................
+void PngWriter::set_pixel(int32_t x, int32_t y, uint8_t value) {
+    png_bytep row = row_pointers_[y];
+    png_bytep px = &(row[x * 3]);
+    px[0] = value;
+    px[1] = value;
+    px[2] = value;
+}
+
+//..................................................................................................
+void PngWriter::set_all_pixels(uint8_t value) {
+    for (int y = 0; y < height_; y++) {
+        png_bytep row = row_pointers_[y];
+        for (int x = 0; x < width_; x++) {
+            png_bytep px = &(row[x * 3]);
+            px[0] = value;
+            px[1] = value;
+            px[2] = value;
+        }
+    }
+}
+
+//..................................................................................................
+void PngWriter::set_all_pixels_black() {
+    for (int y = 0; y < height_; y++) {
+        std::memset(row_pointers_[y], 0, row_size());
+    }
+}
+
+//..................................................................................................
+void PngWriter::write(char const* filename) {
+    auto fp = fopen(filename, "wb");
+    if (!fp) {
+        std::cout << "Couldn't make file\n";
+        abort();
+    }
+
+    png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+    if (!png) {
+        std::cout << "Couldn't make png_structp\n";
+        abort();
+    }
+
+    png_infop info = png_create_info_struct(png);
+    if (!info) {
+        std::cout << "Couldn't make png_structp\n";
+        abort();
+    }
+
+    if (setjmp(png_jmpbuf(png))) {
+        std::cout << "Couldn't set jump\n";
+        abort();
+    }
+
+    png_init_io(png, fp);
+    // Output is 8bit depth, RGB format.
+    png_set_IHDR(png,
+                 info,
+                 width_,
+                 height_,
+                 8,
+                 PNG_COLOR_TYPE_RGB,
+                 PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_DEFAULT,
+                 PNG_FILTER_TYPE_DEFAULT
+    );
+    png_write_info(png, info);
+
+    if (png_get_rowbytes(png, info) != row_size()) {
+        std::cout << "Allocated bad amount of memory\n";
+        abort();
+    }
+
+    // To remove the alpha channel for PNG_COLOR_TYPE_RGB format,
+    // Use png_set_filler().
+    //png_set_filler(png_, 0, PNG_FILLER_AFTER);
+
+    png_write_image(png, row_pointers_);
+    png_write_end(png, NULL);
+
+    if (png && info) {
+        png_destroy_write_struct(&png, &info);
+    }
+
+    fclose(fp);
+}

node_board/png_writer.h

+#include <png.h>
+#include <cstdint>
+
+//--------------------------------------------------------------------------------------------------
+// This class is derived from code by Guillaume Cottenceau, copyright 2002-2010 and distributed
+// under the X11 license. https://gist.github.com/niw/5963798
+class PngWriter {
+public:
+    PngWriter();
+    ~PngWriter();
+
+    void free();
+    void allocate(int32_t width, int32_t height);
+    png_bytep* row_pointers() { return row_pointers_; }
+    void set_pixel(int32_t x, int32_t y, uint8_t value = 255);
+    void set_all_pixels(uint8_t value);
+    void set_all_pixels_black();
+    void write(char const* filename);
+
+private:
+    uint32_t row_size() { return 3 * width_; }
+
+    int32_t width_;
+    int32_t height_;
+    png_bytep* row_pointers_;
+};

strandstring/OneWireMod.cpp

+/*
+Copyright (c) 2007, Jim Studt  (original old version - many contributors since)
+
+The latest version of this library may be found at:
+  http://www.pjrc.com/teensy/td_libs_OneWire.html
+
+OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since
+January 2010.
+
+DO NOT EMAIL for technical support, especially not for ESP chips!
+All project support questions must be posted on public forums
+relevant to the board or chips used.  If using Arduino, post on
+Arduino's forum.  If using ESP, post on the ESP community forums.
+There is ABSOLUTELY NO TECH SUPPORT BY PRIVATE EMAIL!
+
+Github's issue tracker for OneWire should be used only to report
+specific bugs.  DO NOT request project support via Github.  All
+project and tech support questions must be posted on forums, not
+github issues.  If you experience a problem and you are not
+absolutely sure it's an issue with the library, ask on a forum
+first.  Only use github to report issues after experts have
+confirmed the issue is with OneWire rather than your project.
+
+Back in 2010, OneWire was in need of many bug fixes, but had
+been abandoned the original author (Jim Studt).  None of the known
+contributors were interested in maintaining OneWire.  Paul typically
+works on OneWire every 6 to 12 months.  Patches usually wait that
+long.  If anyone is interested in more actively maintaining OneWire,
+please contact Paul (this is pretty much the only reason to use
+private email about OneWire).
+
+OneWire is now very mature code.  No changes other than adding
+definitions for newer hardware support are anticipated.
+
+Version 2.3:
+  Unknown chip fallback mode, Roger Clark
+  Teensy-LC compatibility, Paul Stoffregen
+  Search bug fix, Love Nystrom
+
+Version 2.2:
+  Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com
+  Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030
+  Fix DS18B20 example negative temperature
+  Fix DS18B20 example's low res modes, Ken Butcher
+  Improve reset timing, Mark Tillotson
+  Add const qualifiers, Bertrik Sikken
+  Add initial value input to crc16, Bertrik Sikken
+  Add target_search() function, Scott Roberts
+
+Version 2.1:
+  Arduino 1.0 compatibility, Paul Stoffregen
+  Improve temperature example, Paul Stoffregen
+  DS250x_PROM example, Guillermo Lovato
+  PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com
+  Improvements from Glenn Trewitt:
+  - crc16() now works
+  - check_crc16() does all of calculation/checking work.
+  - Added read_bytes() and write_bytes(), to reduce tedious loops.
+  - Added ds2408 example.
+  Delete very old, out-of-date readme file (info is here)
+
+Version 2.0: Modifications by Paul Stoffregen, January 2010:
+http://www.pjrc.com/teensy/td_libs_OneWire.html
+  Search fix from Robin James
+    http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
+  Use direct optimized I/O in all cases
+  Disable interrupts during timing critical sections
+    (this solves many random communication errors)
+  Disable interrupts during read-modify-write I/O
+  Reduce RAM consumption by eliminating unnecessary
+    variables and trimming many to 8 bits
+  Optimize both crc8 - table version moved to flash
+
+Modified to work with larger numbers of devices - avoids loop.
+Tested in Arduino 11 alpha with 12 sensors.
+26 Sept 2008 -- Robin James
+http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
+
+Updated to work with arduino-0008 and to include skip() as of
+2007/07/06. --RJL20
+
+Modified to calculate the 8-bit CRC directly, avoiding the need for
+the 256-byte lookup table to be loaded in RAM.  Tested in arduino-0010
+-- Tom Pollard, Jan 23, 2008
+
+Jim Studt's original library was modified by Josh Larios.
+
+Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Much of the code was inspired by Derek Yerger's code, though I don't
+think much of that remains.  In any event that was..
+    (copyleft) 2006 by Derek Yerger - Free to distribute freely.
+
+The CRC code was excerpted and inspired by the Dallas Semiconductor
+sample code bearing this copyright.
+//---------------------------------------------------------------------------
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// Except as contained in this notice, the name of Dallas Semiconductor
+// shall not be used except as stated in the Dallas Semiconductor
+// Branding Policy.
+//--------------------------------------------------------------------------
+*/
+
+#include <Arduino.h>
+#include "OneWireMod.h"
+#include "OneWire_direct_gpio.h"
+
+
+void OneWire::begin(uint8_t pin)
+{
+	pinMode(pin, INPUT);
+	bitmask = PIN_TO_BITMASK(pin);
+	baseReg = PIN_TO_BASEREG(pin);
+#if ONEWIRE_SEARCH
+	reset_search();
+#endif
+}
+
+
+// Perform the onewire reset function.  We will wait up to 250uS for
+// the bus to come high, if it doesn't then it is broken or shorted
+// and we return a 0;
+//
+// Returns 1 if a device asserted a presence pulse, 0 otherwise.
+//
+uint8_t OneWire::reset(void)
+{
+	IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
+	volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
+	uint8_t r;
+	uint8_t retries = 125;
+
+	noInterrupts();
+	DIRECT_MODE_INPUT(reg, mask);
+	interrupts();
+	// wait until the wire is high... just in case
+	do {
+		if (--retries == 0) return 0;
+		delayMicroseconds(2);
+	} while ( !DIRECT_READ(reg, mask));
+
+	noInterrupts();
+	DIRECT_WRITE_LOW(reg, mask);
+	DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
+	interrupts();
+	delayMicroseconds(480);
+	noInterrupts();
+	DIRECT_MODE_INPUT(reg, mask);	// allow it to float
+	delayMicroseconds(70);
+	r = !DIRECT_READ(reg, mask);
+	interrupts();
+	delayMicroseconds(410);
+	return r;
+}
+
+//
+// Write a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+void OneWire::write_bit(uint8_t v)
+{
+	IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
+	volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
+
+	if (v & 1) {
+		noInterrupts();
+		DIRECT_WRITE_LOW(reg, mask);
+		DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
+		delayMicroseconds(10);
+		DIRECT_WRITE_HIGH(reg, mask);	// drive output high
+		interrupts();
+		delayMicroseconds(55);
+	} else {
+		noInterrupts();
+		DIRECT_WRITE_LOW(reg, mask);
+		DIRECT_MODE_OUTPUT(reg, mask);	// drive output low
+		delayMicroseconds(65);
+		DIRECT_WRITE_HIGH(reg, mask);	// drive output high
+		interrupts();
+		delayMicroseconds(5);
+	}
+}
+
+//
+// Read a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+uint8_t OneWire::read_bit(void)
+{
+	IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask;
+	volatile IO_REG_TYPE *reg IO_REG_BASE_ATTR = baseReg;
+	uint8_t r;
+
+	noInterrupts();
+	DIRECT_MODE_OUTPUT(reg, mask);
+	DIRECT_WRITE_LOW(reg, mask);
+	delayMicroseconds(3);
+	DIRECT_MODE_INPUT(reg, mask);	// let pin float, pull up will raise
+	delayMicroseconds(10);
+	r = DIRECT_READ(reg, mask);
+	interrupts();
+	delayMicroseconds(53);
+	return r;
+}
+
+//
+// Write a byte. The writing code uses the active drivers to raise the
+// pin high, if you need power after the write (e.g. DS18S20 in
+// parasite power mode) then set 'power' to 1, otherwise the pin will
+// go tri-state at the end of the write to avoid heating in a short or
+// other mishap.
+//
+void OneWire::write(uint8_t v, uint8_t power /* = 0 */) {
+    uint8_t bitMask;
+
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+	OneWire::write_bit( (bitMask & v)?1:0);
+    }
+    if ( !power) {
+	noInterrupts();
+	DIRECT_MODE_INPUT(baseReg, bitmask);
+	DIRECT_WRITE_LOW(baseReg, bitmask);
+	interrupts();
+    }
+}
+
+void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) {
+  for (uint16_t i = 0 ; i < count ; i++)
+    write(buf[i]);
+  if (!power) {
+    noInterrupts();
+    DIRECT_MODE_INPUT(baseReg, bitmask);
+    DIRECT_WRITE_LOW(baseReg, bitmask);
+    interrupts();
+  }
+}
+
+//
+// Read a byte
+//
+uint8_t OneWire::read() {
+    uint8_t bitMask;
+    uint8_t r = 0;
+
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+	if ( OneWire::read_bit()) r |= bitMask;
+    }
+    return r;
+}
+
+void OneWire::read_bytes(uint8_t *buf, uint16_t count) {
+  for (uint16_t i = 0 ; i < count ; i++)
+    buf[i] = read();
+}
+
+//
+// Do a ROM select
+//
+void OneWire::select(const uint8_t rom[8])
+{
+    uint8_t i;
+
+    write(0x55);           // Choose ROM
+
+    for (i = 0; i < 8; i++) write(rom[i]);
+}
+
+//
+// Do a ROM skip
+//
+void OneWire::skip()
+{
+    write(0xCC);           // Skip ROM
+}
+
+void OneWire::depower()
+{
+	noInterrupts();
+	DIRECT_MODE_INPUT(baseReg, bitmask);
+	interrupts();
+}
+
+#if ONEWIRE_SEARCH
+
+//
+// You need to use this function to start a search again from the beginning.
+// You do not need to do it for the first search, though you could.
+//
+void OneWire::reset_search()
+{
+  // reset the search state
+  LastDiscrepancy = 0;
+  LastDeviceFlag = false;
+  LastFamilyDiscrepancy = 0;
+  for(int i = 7; ; i--) {
+    ROM_NO[i] = 0;
+    if ( i == 0) break;
+  }
+}
+
+// Setup the search to find the device type 'family_code' on the next call
+// to search(*newAddr) if it is present.
+//
+void OneWire::target_search(uint8_t family_code)
+{
+   // set the search state to find SearchFamily type devices
+   ROM_NO[0] = family_code;
+   for (uint8_t i = 1; i < 8; i++)
+      ROM_NO[i] = 0;
+   LastDiscrepancy = 64;
+   LastFamilyDiscrepancy = 0;
+   LastDeviceFlag = false;
+}
+
+//
+// Perform a search. If this function returns a '1' then it has
+// enumerated the next device and you may retrieve the ROM from the
+// OneWire::address variable. If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then a 0 is returned.  If a new device is found then
+// its address is copied to newAddr.  Use OneWire::reset_search() to
+// start over.
+//
+// --- Replaced by the one from the Dallas Semiconductor web site ---
+//--------------------------------------------------------------------------
+// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
+// search state.
+// Return TRUE  : device found, ROM number in ROM_NO buffer
+//        FALSE : device not found, end of search
+//
+bool OneWire::search(uint8_t *newAddr, bool search_mode /* = true */)
+{
+   uint8_t id_bit_number;
+   uint8_t last_zero, rom_byte_number;
+   bool    search_result;
+   uint8_t id_bit, cmp_id_bit;
+
+   unsigned char rom_byte_mask, search_direction;
+
+   // initialize for search
+   id_bit_number = 1;
+   last_zero = 0;
+   rom_byte_number = 0;
+   rom_byte_mask = 1;
+   search_result = false;
+
+   // if the last call was not the last one
+   if (!LastDeviceFlag) {
+      // 1-Wire reset
+      if (!reset()) {
+         // reset the search
+         LastDiscrepancy = 0;
+         LastDeviceFlag = false;
+         LastFamilyDiscrepancy = 0;
+         return false;
+      }
+
+      // issue the search command
+      if (search_mode == true) {
+        write(0xF0);   // NORMAL SEARCH
+      } else {
+        write(0xEC);   // CONDITIONAL SEARCH
+      }
+
+      // loop to do the search
+      do
+      {
+         // read a bit and its complement
+         id_bit = read_bit();
+         cmp_id_bit = read_bit();
+
+         // check for no devices on 1-wire
+         if ((id_bit == 1) && (cmp_id_bit == 1)) {
+            break;
+         } else {
+            // all devices coupled have 0 or 1
+            if (id_bit != cmp_id_bit) {
+               search_direction = id_bit;  // bit write value for search
+            } else {
+               // if this discrepancy if before the Last Discrepancy
+               // on a previous next then pick the same as last time
+               if (id_bit_number < LastDiscrepancy) {
+                  search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);
+               } else {
+                  // if equal to last pick 1, if not then pick 0
+                  search_direction = (id_bit_number == LastDiscrepancy);
+               }
+               // if 0 was picked then record its position in LastZero
+               if (search_direction == 0) {
+                  last_zero = id_bit_number;
+
+                  // check for Last discrepancy in family
+                  if (last_zero < 9)
+                     LastFamilyDiscrepancy = last_zero;
+               }
+            }
+
+            // set or clear the bit in the ROM byte rom_byte_number
+            // with mask rom_byte_mask
+            if (search_direction == 1)
+              ROM_NO[rom_byte_number] |= rom_byte_mask;
+            else
+              ROM_NO[rom_byte_number] &= ~rom_byte_mask;
+
+            // serial number search direction write bit
+            write_bit(search_direction);
+
+            // increment the byte counter id_bit_number
+            // and shift the mask rom_byte_mask
+            id_bit_number++;
+            rom_byte_mask <<= 1;
+
+            // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
+            if (rom_byte_mask == 0) {
+                rom_byte_number++;
+                rom_byte_mask = 1;
+            }
+         }
+      }
+      while(rom_byte_number < 8);  // loop until through all ROM bytes 0-7
+
+      // if the search was successful then
+      if (!(id_bit_number < 65)) {
+         // search successful so set LastDiscrepancy,LastDeviceFlag,search_result
+         LastDiscrepancy = last_zero;
+
+         // check for last device
+         if (LastDiscrepancy == 0) {
+            LastDeviceFlag = true;
+         }
+         search_result = true;
+      }
+   }
+
+   // if no device found then reset counters so next 'search' will be like a first
+   if (!search_result || !ROM_NO[0]) {
+      LastDiscrepancy = 0;
+      LastDeviceFlag = false;
+      LastFamilyDiscrepancy = 0;
+      search_result = false;
+   } else {
+      for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];
+   }
+   return search_result;
+  }
+
+#endif
+
+#if ONEWIRE_CRC
+// The 1-Wire CRC scheme is described in Maxim Application Note 27:
+// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
+//
+
+#if ONEWIRE_CRC8_TABLE
+// Dow-CRC using polynomial X^8 + X^5 + X^4 + X^0
+// Tiny 2x16 entry CRC table created by Arjen Lentz
+// See http://lentz.com.au/blog/calculating-crc-with-a-tiny-32-entry-lookup-table
+static const uint8_t PROGMEM dscrc2x16_table[] = {
+	0x00, 0x5E, 0xBC, 0xE2, 0x61, 0x3F, 0xDD, 0x83,
+	0xC2, 0x9C, 0x7E, 0x20, 0xA3, 0xFD, 0x1F, 0x41,
+	0x00, 0x9D, 0x23, 0xBE, 0x46, 0xDB, 0x65, 0xF8,
+	0x8C, 0x11, 0xAF, 0x32, 0xCA, 0x57, 0xE9, 0x74
+};
+
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
+// and the registers.  (Use tiny 2x16 entry CRC table)
+uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
+{
+	uint8_t crc = 0;
+
+	while (len--) {
+		crc = *addr++ ^ crc;  // just re-using crc as intermediate
+		crc = pgm_read_byte(dscrc2x16_table + (crc & 0x0f)) ^
+		pgm_read_byte(dscrc2x16_table + 16 + ((crc >> 4) & 0x0f));
+	}
+
+	return crc;
+}
+#else
+//
+// Compute a Dallas Semiconductor 8 bit CRC directly.
+// this is much slower, but a little smaller, than the lookup table.
+//
+uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
+{
+	uint8_t crc = 0;
+
+	while (len--) {
+#if defined(__AVR__)
+		crc = _crc_ibutton_update(crc, *addr++);
+#else
+		uint8_t inbyte = *addr++;
+		for (uint8_t i = 8; i; i--) {
+			uint8_t mix = (crc ^ inbyte) & 0x01;
+			crc >>= 1;
+			if (mix) crc ^= 0x8C;
+			inbyte >>= 1;
+		}
+#endif
+	}
+	return crc;
+}
+#endif
+
+#if ONEWIRE_CRC16
+bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc)
+{
+    crc = ~crc16(input, len, crc);
+    return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
+}
+
+uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc)
+{
+#if defined(__AVR__)
+    for (uint16_t i = 0 ; i < len ; i++) {
+        crc = _crc16_update(crc, input[i]);
+    }
+#else
+    static const uint8_t oddparity[16] =
+        { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
+
+    for (uint16_t i = 0 ; i < len ; i++) {
+      // Even though we're just copying a byte from the input,
+      // we'll be doing 16-bit computation with it.
+      uint16_t cdata = input[i];
+      cdata = (cdata ^ crc) & 0xff;
+      crc >>= 8;
+
+      if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
+          crc ^= 0xC001;
+
+      cdata <<= 6;
+      crc ^= cdata;
+      cdata <<= 1;
+      crc ^= cdata;
+    }
+#endif
+    return crc;
+}
+#endif
+
+#endif

strandstring/OneWireMod.h

+#ifndef OneWire_h
+#define OneWire_h
+
+#ifdef __cplusplus
+
+#include <stdint.h>
+
+#if defined(__AVR__)
+#include <util/crc16.h>
+#endif
+
+#if ARDUINO >= 100
+#include <Arduino.h>       // for delayMicroseconds, digitalPinToBitMask, etc
+#else
+#include "WProgram.h"      // for delayMicroseconds
+#include "pins_arduino.h"  // for digitalPinToBitMask, etc
+#endif
+
+// You can exclude certain features from OneWire.  In theory, this
+// might save some space.  In practice, the compiler automatically
+// removes unused code (technically, the linker, using -fdata-sections
+// and -ffunction-sections when compiling, and Wl,--gc-sections
+// when linking), so most of these will not result in any code size
+// reduction.  Well, unless you try to use the missing features
+// and redesign your program to not need them!  ONEWIRE_CRC8_TABLE
+// is the exception, because it selects a fast but large algorithm
+// or a small but slow algorithm.
+
+// you can exclude onewire_search by defining that to 0
+#ifndef ONEWIRE_SEARCH
+#define ONEWIRE_SEARCH 1
+#endif
+
+// You can exclude CRC checks altogether by defining this to 0
+#ifndef ONEWIRE_CRC
+#define ONEWIRE_CRC 1
+#endif
+
+// Select the table-lookup method of computing the 8-bit CRC
+// by setting this to 1.  The lookup table enlarges code size by
+// about 250 bytes.  It does NOT consume RAM (but did in very
+// old versions of OneWire).  If you disable this, a slower
+// but very compact algorithm is used.
+//#ifndef ONEWIRE_CRC8_TABLE
+//#define ONEWIRE_CRC8_TABLE 1
+//#endif
+
+// You can allow 16-bit CRC checks by defining this to 1
+// (Note that ONEWIRE_CRC must also be 1.)
+#ifndef ONEWIRE_CRC16
+#define ONEWIRE_CRC16 1
+#endif
+
+// Board-specific macros for direct GPIO
+#include "OneWire_direct_regtype.h"
+
+class OneWire
+{
+  private:
+    IO_REG_TYPE bitmask;
+    volatile IO_REG_TYPE *baseReg;
+
+#if ONEWIRE_SEARCH
+    // global search state
+    unsigned char ROM_NO[8];
+    uint8_t LastDiscrepancy;
+    uint8_t LastFamilyDiscrepancy;
+    bool LastDeviceFlag;
+#endif
+
+  public:
+    OneWire(uint8_t pin) { begin(pin); }
+    void begin(uint8_t pin);
+
+    // Perform a 1-Wire reset cycle. Returns 1 if a device responds
+    // with a presence pulse.  Returns 0 if there is no device or the
+    // bus is shorted or otherwise held low for more than 250uS
+    uint8_t reset(void);
+
+    // Issue a 1-Wire rom select command, you do the reset first.
+    void select(const uint8_t rom[8]);
+
+    // Issue a 1-Wire rom skip command, to address all on bus.
+    void skip(void);
+
+    // Write a byte. If 'power' is one then the wire is held high at
+    // the end for parasitically powered devices. You are responsible
+    // for eventually depowering it by calling depower() or doing
+    // another read or write.
+    void write(uint8_t v, uint8_t power = 0);
+
+    void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);
+
+    // Read a byte.
+    uint8_t read(void);
+
+    void read_bytes(uint8_t *buf, uint16_t count);
+
+    // Write a bit. The bus is always left powered at the end, see
+    // note in write() about that.
+    void write_bit(uint8_t v);
+
+    // Read a bit.
+    uint8_t read_bit(void);
+
+    // Stop forcing power onto the bus. You only need to do this if
+    // you used the 'power' flag to write() or used a write_bit() call
+    // and aren't about to do another read or write. You would rather
+    // not leave this powered if you don't have to, just in case
+    // someone shorts your bus.
+    void depower(void);
+
+#if ONEWIRE_SEARCH
+    // Clear the search state so that if will start from the beginning again.
+    void reset_search();
+
+    // Setup the search to find the device type 'family_code' on the next call
+    // to search(*newAddr) if it is present.
+    void target_search(uint8_t family_code);
+
+    // Look for the next device. Returns 1 if a new address has been
+    // returned. A zero might mean that the bus is shorted, there are
+    // no devices, or you have already retrieved all of them.  It
+    // might be a good idea to check the CRC to make sure you didn't
+    // get garbage.  The order is deterministic. You will always get
+    // the same devices in the same order.
+    bool search(uint8_t *newAddr, bool search_mode = true);
+#endif
+
+#if ONEWIRE_CRC
+    // Compute a Dallas Semiconductor 8 bit CRC, these are used in the
+    // ROM and scratchpad registers.
+    static uint8_t crc8(const uint8_t *addr, uint8_t len);
+
+#if ONEWIRE_CRC16
+    // Compute the 1-Wire CRC16 and compare it against the received CRC.
+    // Example usage (reading a DS2408):
+    //    // Put everything in a buffer so we can compute the CRC easily.
+    //    uint8_t buf[13];
+    //    buf[0] = 0xF0;    // Read PIO Registers
+    //    buf[1] = 0x88;    // LSB address
+    //    buf[2] = 0x00;    // MSB address
+    //    WriteBytes(net, buf, 3);    // Write 3 cmd bytes
+    //    ReadBytes(net, buf+3, 10);  // Read 6 data bytes, 2 0xFF, 2 CRC16
+    //    if (!CheckCRC16(buf, 11, &buf[11])) {
+    //        // Handle error.
+    //    }
+    //
+    // @param input - Array of bytes to checksum.
+    // @param len - How many bytes to use.
+    // @param inverted_crc - The two CRC16 bytes in the received data.
+    //                       This should just point into the received data,
+    //                       *not* at a 16-bit integer.
+    // @param crc - The crc starting value (optional)
+    // @return True, iff the CRC matches.
+    static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0);
+
+    // Compute a Dallas Semiconductor 16 bit CRC.  This is required to check
+    // the integrity of data received from many 1-Wire devices.  Note that the
+    // CRC computed here is *not* what you'll get from the 1-Wire network,
+    // for two reasons:
+    //   1) The CRC is transmitted bitwise inverted.
+    //   2) Depending on the endian-ness of your processor, the binary
+    //      representation of the two-byte return value may have a different
+    //      byte order than the two bytes you get from 1-Wire.
+    // @param input - Array of bytes to checksum.
+    // @param len - How many bytes to use.
+    // @param crc - The crc starting value (optional)
+    // @return The CRC16, as defined by Dallas Semiconductor.
+    static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0);
+#endif
+#endif
+};
+
+// Prevent this name from leaking into Arduino sketches
+#ifdef IO_REG_TYPE
+#undef IO_REG_TYPE
+#endif
+
+#endif // __cplusplus
+#endif // OneWire_h

strandstring/OneWire_direct_gpio.h

+#ifndef OneWire_Direct_GPIO_h
+#define OneWire_Direct_GPIO_h
+
+// This header should ONLY be included by OneWire.cpp.  These defines are
+// meant to be private, used within OneWire.cpp, but not exposed to Arduino
+// sketches or other libraries which may include OneWire.h.
+
+#include <stdint.h>
+
+// Platform specific I/O definitions