...
 
Commits (28)
[submodule "external/OneWire"]
path = external/OneWire
url = https://github.com/PaulStoffregen/OneWire.git
# 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
// 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);
}
//
//
// 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();
}
}
Subproject commit dbc93eba80d1b777af2eefed8e607775f456e9fb
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)
# 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>)
#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;
}
#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);
}
#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_;
};
This diff is collapsed.
#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
This diff is collapsed.
#ifndef OneWire_Direct_RegType_h
#define OneWire_Direct_RegType_h
#include <stdint.h>
// Platform specific I/O register type
#if defined(__AVR__)
#define IO_REG_TYPE uint8_t
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
#define IO_REG_TYPE uint8_t
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
#define IO_REG_TYPE uint32_t
#elif defined(__MKL26Z64__)
#define IO_REG_TYPE uint8_t
#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
#define IO_REG_TYPE uint32_t
#elif defined(__PIC32MX__)
#define IO_REG_TYPE uint32_t
#elif defined(ARDUINO_ARCH_ESP8266)
#define IO_REG_TYPE uint32_t
#elif defined(ARDUINO_ARCH_ESP32)
#define IO_REG_TYPE uint32_t
#define IO_REG_MASK_ATTR
#elif defined(ARDUINO_ARCH_STM32)
#define IO_REG_TYPE uint32_t
#elif defined(__SAMD21G18A__)
#define IO_REG_TYPE uint32_t
#elif defined(RBL_NRF51822)
#define IO_REG_TYPE uint32_t
#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
#define IO_REG_TYPE uint32_t
#elif defined(__riscv)
#define IO_REG_TYPE uint32_t
#else
#define IO_REG_TYPE unsigned int
#endif
#endif
Sensor IDs
brain2: 28 06 71 CD 0A 00 00 C2
node 1: 28 18 4C CD 0A 00 00 E2
node 2: 28 78 61 CD 0A 00 00 35
node 3: 28 71 47 CD 0A 00 00 C7
node 4: 28 70 47 CD 0A 00 00 F0
//
//
// 115200 baud FTDI connection
// set lfuse to 0x5E for 20 MHz xtal
//
// Neil Gershenfeld
// 12/8/10
// Erik Strand
// 11/26/2018 and beyond
//
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include "OneWireMod.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) // this is no longer a button
#define max_buffer 25
void put_char(volatile unsigned char *port, unsigned char pin, char txchar) {
noInterrupts();
//
// 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();
interrupts();
}
void put_hex(volatile unsigned char *port, unsigned char pin, uint8_t hex_char) {
uint8_t val = (hex_char & (0b1111u << 4)) >> 4;
if (val < 10) {
put_char(port, pin, '0' + val);
} else {
put_char(port, pin, 'A' + (val - 10));
}
val = hex_char & 0b1111u;
if (val < 10) {
put_char(port, pin, '0' + val);
} else {
put_char(port, pin, 'A' + (val - 10));
}
}
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);
}
void put_line(volatile unsigned char *port, unsigned char pin, char *str) {
put_string(port, pin, str);
put_char(port, pin, '\n');
}
void put_float(volatile unsigned char *port, unsigned char pin, float x) {
static char buffer[10];
dtostrf(x, 8, 2, buffer);
put_string(port, pin, buffer);
}
OneWire ds(2); // on PA2 (a 4.7K resistor is necessary)
void setup(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;
}
void loop(void) {
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
float celsius;
const unsigned n_nodes = 5;
static float measurements[n_nodes]; // so we can store each temp reading before printing
if (!ds.search(addr)) {
PORTB |= led_pin;
//put_line(&serial_port, serial_pin_out, "No more addresses.");
put_float(&serial_port, serial_pin_out, measurements[i]);
for (unsigned i = 1; i < n_nodes; ++i) {
put_string(&serial_port, serial_pin_out, ", ");
put_float(&serial_port, serial_pin_out, measurements[i]);
}
put_char(&serial_port, serial_pin_out, '\n');
ds.reset_search();
for (unsigned i = 0; i < n_nodes; ++i) {
measurements[i] = 0;
}
// Wait five seconds
delay(200);
PORTB &= ~led_pin;
delay(4800);
return;
}
/*
put_string(&serial_port, serial_pin_out, "ROM=");
for (i = 0; i < 8; i++) {
put_char(&serial_port, serial_pin_out, ' ');
put_hex(&serial_port, serial_pin_out, addr[i]);
}
put_char(&serial_port, serial_pin_out, '\n');
*/
if (OneWire::crc8(addr, 7) != addr[7]) {
put_line(&serial_port, serial_pin_out, "CRC is not valid!");
return;
}
// the first ROM byte indicates which chip
switch (addr[0]) {
case 0x10:
//put_line(&serial_port, serial_pin_out, " Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
//put_line(&serial_port, serial_pin_out, " Chip = DS18B20");
type_s = 0;
break;
case 0x22:
//put_line(&serial_port, serial_pin_out, " Chip = DS1822");
type_s = 0;
break;
default:
put_line(&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_hex(&serial_port, serial_pin_out, present);
//put_char(&serial_port, serial_pin_out, ' ');
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
//put_hex(&serial_port, serial_pin_out, data[i]);
}
//put_string(&serial_port, serial_pin_out, " CRC=");
//put_hex(&serial_port, serial_pin_out, OneWire::crc9(data, 8));
// 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;
switch (addr[1]) {
case 0x06:
measurements[0] = celsius;
break;
case 0x18:
measurements[1] = celsius;
break;
case 0x78:
measurements[2] = celsius;
break;
case 0x71:
measurements[3] = celsius;
break;
case 0x70:
measurements[4] = celsius;
break;
default:
put_line(&serial_port, serial_pin_out, "Error: unrecognized temperature node");
}
/*
put_string(&serial_port, serial_pin_out, " Temperature = ");
put_float(&serial_port, serial_pin_out, celsius);
put_string(&serial_port, serial_pin_out, " Celsius, ");
put_float(&serial_port, serial_pin_out, fahrenheit);
put_line(&serial_port, serial_pin_out, " Fahrenheit");
*/
}