Use secconfig.example.h, ignore secconfig.h

PCB v2, new optimized Payload Format, better Beacon Mode

.gitignore

@@ -0,0 +1,2 @@
+*.sch-bak
+*.kicad_pcb-bak

Case/ATTNode.scad

@@ -12,7 +12,7 @@ translate([5,43.5,50])rotate(a=[270,0,270]) union() {
     translate([9.5,y,-5]) rotate(a=[-45,0,0]) cube(size=[9,0.9,10]);
     translate([20,y,-5]) rotate(a=[-45,0,0]) cube(size=[9,0.9,10]);
   }
-  translate([0.55,-1.5,14.5]) cube(size=[37.1,50.5,1]);
+  translate([0.55,-1.5,14.5]) cube(size=[37.1,51.6,1]);
   translate([1,-1.5,15.4]) cube(size=[36,51,1.2]);
   translate([-4,-4,16.5]) cube(size=[60,60,2]);
 }

Case/ATTNode_v2.scad

@@ -0,0 +1,96 @@
+$fn=100;
+$fs = 0.01;
+
+module roundedcube(size = [1, 1, 1], center = false, radius = 0.5, apply_to = "all") {
+	// If single value, convert to [x, y, z] vector
+	size = (size[0] == undef) ? [size, size, size] : size;
+
+	translate_min = radius;
+	translate_xmax = size[0] - radius;
+	translate_ymax = size[1] - radius;
+	translate_zmax = size[2] - radius;
+
+	diameter = radius * 2;
+
+	module build_point(type = "sphere", rotate = [0, 0, 0]) {
+		if (type == "sphere") {
+			sphere(r = radius);
+		} else if (type == "cylinder") {
+			rotate(a = rotate)
+			cylinder(h = diameter, r = radius, center = true);
+		}
+	}
+
+	obj_translate = (center == false) ?
+		[0, 0, 0] : [
+			-(size[0] / 2),
+			-(size[1] / 2),
+			-(size[2] / 2)
+		];
+
+	translate(v = obj_translate) {
+		hull() {
+			for (translate_x = [translate_min, translate_xmax]) {
+				x_at = (translate_x == translate_min) ? "min" : "max";
+				for (translate_y = [translate_min, translate_ymax]) {
+					y_at = (translate_y == translate_min) ? "min" : "max";
+					for (translate_z = [translate_min, translate_zmax]) {
+						z_at = (translate_z == translate_min) ? "min" : "max";
+
+						translate(v = [translate_x, translate_y, translate_z])
+						if (
+							(apply_to == "all") ||
+							(apply_to == "xmin" && x_at == "min") || (apply_to == "xmax" && x_at == "max") ||
+							(apply_to == "ymin" && y_at == "min") || (apply_to == "ymax" && y_at == "max") ||
+							(apply_to == "zmin" && z_at == "min") || (apply_to == "zmax" && z_at == "max")
+						) {
+							build_point("sphere");
+						} else {
+							rotate = 
+								(apply_to == "xmin" || apply_to == "xmax" || apply_to == "x") ? [0, 90, 0] : (
+								(apply_to == "ymin" || apply_to == "ymax" || apply_to == "y") ? [90, 90, 0] :
+								[0, 0, 0]
+							);
+							build_point("cylinder", rotate);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+rotate(a=[180,0,0]) {
+// Front Part
+union() {
+  difference() {
+    union() {
+      translate([0.8,0.8,0]) cube(size=[35.6,27.8,5]);
+      translate([0,0,5]) roundedcube([37.2,29.4,9.5], false, 1, "zmax");
+    }
+    translate([1.6,1.6,-0.1]) cube(size=[34,26.2,7.3]);
+    translate([1.6,2.6,-0.1]) cube(size=[34,24.2,13]);
+    translate([1.6,1.6,-0.1]) cube(size=[6,26.2,13]);
+    for(y=[9:+3:25]) {
+      translate([5.6,y,12.3]) rotate(a=[45,0,0]) cube(size=[12,0.8,3]);
+      translate([19.6,y,12.3]) rotate(a=[45,0,0]) cube(size=[12,0.8,3]);
+    }
+  }
+  translate([16.1,1.6,5.3]) rotate(a=[0,90,0]) cylinder(r=0.3,h=5);
+  translate([16.1,27.8,5.3]) rotate(a=[0,90,0]) cylinder(r=0.3,h=5);
+}
+
+// Back Part
+translate([0,40,0]) difference() {
+  roundedcube([37.2,29.4,8.6], false, 1, "zmax");
+  translate([0.75,0.75,0-0.1]) cube(size=[35.7,27.9,5.1]);
+  translate([1.6,1.6,-0.1]) cube(size=[34,26.2,7.1]);
+  // Mounting Holes Start
+  translate([7,14.7,7]) cylinder(r1=3.7,r2=1.75,h=1.6);
+  translate([30.2,14.7,7]) cylinder(r1=3.7,r2=1.75,h=1.6);
+  translate([18.6,7,7]) cylinder(r1=3.7,r2=1.75,h=1.6);
+  // Mounting Holes End
+  translate([-1,14.7,-28.5]) rotate(a=[0,90,0]) cylinder(r=30,h=39);
+}
+}

Case/README.md

@@ -1,4 +1,4 @@
-# TinyLoRa Case
+# ATTNode Case
 
-A 3D-Printable Case for the TinyLora SMD PCB.
+A 3D-Printable Case for the ATTNode SMD PCB.
 OpenSCAD Design and STL for direct 3D-Printing

Firmware/.gitignore

@@ -3,3 +3,4 @@
 !.vscode/tasks.json
 !.vscode/extensions.json
 *.code-workspace
+src/secconfig.h

Firmware/.vscode/extensions.json

@@ -3,5 +3,8 @@
     // for the documentation about the extensions.json format
     "recommendations": [
         "platformio.platformio-ide"
+    ],
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
     ]
 }

Firmware/LICENSE

@@ -0,0 +1,24 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Firmware/README.md

@@ -1,6 +1,8 @@
-# TinyLoRa Firmware
+# ATTNode Firmware
 
-Example Sensor Node Firmware with a BMP/E280 or SHT21 Sensor. Used Sensor has to be set via #define in the src/secconfig.h (HAS_BME280 or HAS_SHT21). Please change the values in src/secconfig.h to your Keys from https://console.thethingsnetwork.org. Device has to be set to ABP Mode. Also since there is no permanent storage to store the Frame Counter, please disable the Frame Counter Check in the TTN console.
+Example Sensor Node Firmware with a BMP/E280 or SHT21 Sensor. Used Sensor has to be set via #define in the src/secconfig.h (HAS_BME280 or HAS_SHT21). Please change the values in src/secconfig.h to your Keys from https://console.thethingsnetwork.org. Device has to be set to ABP Mode and the Frame Counter has to be set to 16 Bit.
+
+For a complete explanation of the Parameters possible in the secconfig.h see https://www.attno.de/sites/attnode/20-firmware
 
 The code also supports the RFM69W wireless module instead of the RFM95W LoRa module. For this purpose you need a receiver. Example code for a receiver in python (tested on a Raspberry Pi, RFM69 connected via SPI) can be found at https://www.seiichiro0185.org/git/IOT/sensord
 
@@ -11,15 +13,61 @@ Project was created using PlatformIO Atmel-AVR Framework
 ```
 function Decoder(bytes, port) {
   var decoded = {};
-  decoded.t = (bytes[0]) | (bytes[1] << 8 ) | (bytes[2] << 16 ) | (bytes[3] << 24)
-  decoded.t = decoded.t / 100
-  decoded.p = (bytes[4]) | (bytes[5] << 8 ) | (bytes[6] << 16 ) | (bytes[7] << 24)
-  decoded.p = decoded.p / 100
-  decoded.h = (bytes[8]) | (bytes[9] << 8 ) | (bytes[10] << 16 ) | (bytes[11] << 24)
-  decoded.h = decoded.h / 100
-  decoded.v = (bytes[12]) | (bytes[13] << 8 ) | (bytes[14] << 16 ) | (bytes[15] << 24)
-  decoded.v = decoded.v / 1000
+
+  if (bytes.length == 16) {
+    // Old Payload Format
+    decoded.t = ((bytes[0]) | (bytes[1] << 8 ) | (bytes[2] << 16 ) | (bytes[3] << 24)) / 100.0;
+    decoded.p = ((bytes[4]) | (bytes[5] << 8 ) | (bytes[6] << 16 ) | (bytes[7] << 24)) / 100.0;
+    decoded.h = ((bytes[8]) | (bytes[9] << 8 ) | (bytes[10] << 16 ) | (bytes[11] << 24)) / 100.0;
+    decoded.v = ((bytes[12]) | (bytes[13] << 8 ) | (bytes[14] << 16 ) | (bytes[15] << 24)) / 1000.0;
+  } else {
+    // New Payload Format
+    // We always have Battery Voltage (uint8_t)
+    decoded.v = (bytes[0] * 20) / 1000.0;
+
+    // Alarm Triggered (uint8_t)
+    if (bytes.length == 2)
+      decoded.a = bytes[1];
+
+    // Temperature 2 * DS18B20
+    if (bytes.length == 6){
+      decoded.t1 = ((bytes[2]) | (bytes[3] << 8 )) / 100.0;
+      decoded.t2 = ((bytes[4]) | (bytes[5] << 8 )) / 100.0;
+      return decoded;
+    }
+
+    // Temperature (int32_t)
+    if (bytes.length >= 5)
+      decoded.t = ((bytes[1]) | (bytes[2] << 8 ) | (bytes[3] << 16 ) | (bytes[4] << 24)) / 100.0;
+  
+    // Humidity (int32_t)
+    if (bytes.length >= 9)
+      decoded.h = ((bytes[5]) | (bytes[6] << 8 ) | (bytes[7] << 16 ) | (bytes[8] << 24)) / 100.0;
+
+    // Alarm Triggered (uint8_t)
+    if (bytes.length == 10)
+      decoded.a = bytes[9];
+
+    // SHT21 + Brightness (int16_t)
+    if (bytes.length == 11)
+      decoded.b = ((bytes[9]) | (bytes[10] << 8 ));
+
+    // Atmospheric Pressure (int32_t)
+    if (bytes.length >= 13)
+      decoded.p = ((bytes[9]) | (bytes[10] << 8 ) | (bytes[11] << 16 ) | (bytes[12] << 24)) / 100.0;
+
+    // Alarm Triggered (uint8_t)
+    if (bytes.length == 14)
+      decoded.a = bytes[13];
+
+    // BME280 + Brightness (int16_t)
+    if (bytes.length == 15)
+      decoded.b = ((bytes[13]) | (bytes[14] << 8 ));
+  }
 
   return decoded;
 }
 ```
+
+## License
+The firmware-code in this repository is licensed under the 3-clause BSD License (see LICENSE-File)

Firmware/lib/DallasTemperature/DallasTemperature.cpp

@@ -0,0 +1,885 @@
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+#include "DallasTemperature.h"
+
+#if ARDUINO >= 100
+#include "Arduino.h"
+#else
+extern "C" {
+#include "WConstants.h"
+}
+#endif
+
+// OneWire commands
+#define STARTCONVO      0x44  // Tells device to take a temperature reading and put it on the scratchpad
+#define COPYSCRATCH     0x48  // Copy EEPROM
+#define READSCRATCH     0xBE  // Read EEPROM
+#define WRITESCRATCH    0x4E  // Write to EEPROM
+#define RECALLSCRATCH   0xB8  // Reload from last known
+#define READPOWERSUPPLY 0xB4  // Determine if device needs parasite power
+#define ALARMSEARCH     0xEC  // Query bus for devices with an alarm condition
+
+// Scratchpad locations
+#define TEMP_LSB        0
+#define TEMP_MSB        1
+#define HIGH_ALARM_TEMP 2
+#define LOW_ALARM_TEMP  3
+#define CONFIGURATION   4
+#define INTERNAL_BYTE   5
+#define COUNT_REMAIN    6
+#define COUNT_PER_C     7
+#define SCRATCHPAD_CRC  8
+
+// Device resolution
+#define TEMP_9_BIT  0x1F //  9 bit
+#define TEMP_10_BIT 0x3F // 10 bit
+#define TEMP_11_BIT 0x5F // 11 bit
+#define TEMP_12_BIT 0x7F // 12 bit
+
+#define NO_ALARM_HANDLER ((AlarmHandler *)0)
+
+DallasTemperature::DallasTemperature()
+{
+#if REQUIRESALARMS
+	setAlarmHandler(NO_ALARM_HANDLER);
+#endif
+}
+DallasTemperature::DallasTemperature(OneWire* _oneWire)
+{
+	setOneWire(_oneWire);
+#if REQUIRESALARMS
+	setAlarmHandler(NO_ALARM_HANDLER);
+#endif
+}
+
+bool DallasTemperature::validFamily(const uint8_t* deviceAddress) {
+	switch (deviceAddress[0]) {
+	case DS18S20MODEL:
+	case DS18B20MODEL:
+	case DS1822MODEL:
+	case DS1825MODEL:
+	case DS28EA00MODEL:
+		return true;
+	default:
+		return false;
+	}
+}
+
+void DallasTemperature::setOneWire(OneWire* _oneWire) {
+
+	_wire = _oneWire;
+	devices = 0;
+	ds18Count = 0;
+	parasite = false;
+	bitResolution = 9;
+	waitForConversion = true;
+	checkForConversion = true;
+
+}
+
+// initialise the bus
+void DallasTemperature::begin(void) {
+
+	DeviceAddress deviceAddress;
+
+	_wire->reset_search();
+	devices = 0; // Reset the number of devices when we enumerate wire devices
+	ds18Count = 0; // Reset number of DS18xxx Family devices
+
+	while (_wire->search(deviceAddress)) {
+
+		if (validAddress(deviceAddress)) {
+
+			if (!parasite && readPowerSupply(deviceAddress))
+				parasite = true;
+
+			bitResolution = max(bitResolution, getResolution(deviceAddress));
+
+			devices++;
+			if (validFamily(deviceAddress)) {
+				ds18Count++;
+			}
+		}
+	}
+
+}
+
+// returns the number of devices found on the bus
+uint8_t DallasTemperature::getDeviceCount(void) {
+	return devices;
+}
+
+uint8_t DallasTemperature::getDS18Count(void) {
+	return ds18Count;
+}
+
+// returns true if address is valid
+bool DallasTemperature::validAddress(const uint8_t* deviceAddress) {
+	return (_wire->crc8(deviceAddress, 7) == deviceAddress[7]);
+}
+
+// finds an address at a given index on the bus
+// returns true if the device was found
+bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) {
+
+	uint8_t depth = 0;
+
+	_wire->reset_search();
+
+	while (depth <= index && _wire->search(deviceAddress)) {
+		if (depth == index && validAddress(deviceAddress))
+			return true;
+		depth++;
+	}
+
+	return false;
+
+}
+
+// attempt to determine if the device at the given address is connected to the bus
+bool DallasTemperature::isConnected(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	return isConnected(deviceAddress, scratchPad);
+
+}
+
+// attempt to determine if the device at the given address is connected to the bus
+// also allows for updating the read scratchpad
+bool DallasTemperature::isConnected(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+	bool b = readScratchPad(deviceAddress, scratchPad);
+	return b && (_wire->crc8(scratchPad, 8) == scratchPad[SCRATCHPAD_CRC]);
+}
+
+bool DallasTemperature::readScratchPad(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+
+	// send the reset command and fail fast
+	int b = _wire->reset();
+	if (b == 0)
+		return false;
+
+	_wire->select(deviceAddress);
+	_wire->write(READSCRATCH);
+
+	// Read all registers in a simple loop
+	// byte 0: temperature LSB
+	// byte 1: temperature MSB
+	// byte 2: high alarm temp
+	// byte 3: low alarm temp
+	// byte 4: DS18S20: store for crc
+	//         DS18B20 & DS1822: configuration register
+	// byte 5: internal use & crc
+	// byte 6: DS18S20: COUNT_REMAIN
+	//         DS18B20 & DS1822: store for crc
+	// byte 7: DS18S20: COUNT_PER_C
+	//         DS18B20 & DS1822: store for crc
+	// byte 8: SCRATCHPAD_CRC
+	for (uint8_t i = 0; i < 9; i++) {
+		scratchPad[i] = _wire->read();
+	}
+
+	b = _wire->reset();
+	return (b == 1);
+}
+
+void DallasTemperature::writeScratchPad(const uint8_t* deviceAddress,
+		const uint8_t* scratchPad) {
+
+	_wire->reset();
+	_wire->select(deviceAddress);
+	_wire->write(WRITESCRATCH);
+	_wire->write(scratchPad[HIGH_ALARM_TEMP]); // high alarm temp
+	_wire->write(scratchPad[LOW_ALARM_TEMP]); // low alarm temp
+
+	// DS1820 and DS18S20 have no configuration register
+	if (deviceAddress[0] != DS18S20MODEL)
+		_wire->write(scratchPad[CONFIGURATION]);
+
+	_wire->reset();
+
+	// save the newly written values to eeprom
+	_wire->select(deviceAddress);
+	_wire->write(COPYSCRATCH, parasite);
+	delay(20); // <--- added 20ms delay to allow 10ms long EEPROM write operation (as specified by datasheet)
+
+	if (parasite)
+		delay(10); // 10ms delay
+	_wire->reset();
+
+}
+
+bool DallasTemperature::readPowerSupply(const uint8_t* deviceAddress) {
+
+	bool ret = false;
+	_wire->reset();
+	_wire->select(deviceAddress);
+	_wire->write(READPOWERSUPPLY);
+	if (_wire->read_bit() == 0)
+		ret = true;
+	_wire->reset();
+	return ret;
+
+}
+
+// set resolution of all devices to 9, 10, 11, or 12 bits
+// if new resolution is out of range, it is constrained.
+void DallasTemperature::setResolution(uint8_t newResolution) {
+
+	bitResolution = constrain(newResolution, 9, 12);
+	DeviceAddress deviceAddress;
+	for (int i = 0; i < devices; i++) {
+		getAddress(deviceAddress, i);
+		setResolution(deviceAddress, bitResolution, true);
+	}
+
+}
+
+// set resolution of a device to 9, 10, 11, or 12 bits
+// if new resolution is out of range, 9 bits is used.
+bool DallasTemperature::setResolution(const uint8_t* deviceAddress,
+		uint8_t newResolution, bool skipGlobalBitResolutionCalculation) {
+
+	// ensure same behavior as setResolution(uint8_t newResolution)
+	newResolution = constrain(newResolution, 9, 12);
+
+	// return when stored value == new value
+	if (getResolution(deviceAddress) == newResolution)
+		return true;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+
+		// DS1820 and DS18S20 have no resolution configuration register
+		if (deviceAddress[0] != DS18S20MODEL) {
+
+			switch (newResolution) {
+			case 12:
+				scratchPad[CONFIGURATION] = TEMP_12_BIT;
+				break;
+			case 11:
+				scratchPad[CONFIGURATION] = TEMP_11_BIT;
+				break;
+			case 10:
+				scratchPad[CONFIGURATION] = TEMP_10_BIT;
+				break;
+			case 9:
+			default:
+				scratchPad[CONFIGURATION] = TEMP_9_BIT;
+				break;
+			}
+			writeScratchPad(deviceAddress, scratchPad);
+
+			// without calculation we can always set it to max
+			bitResolution = max(bitResolution, newResolution);
+
+			if (!skipGlobalBitResolutionCalculation
+					&& (bitResolution > newResolution)) {
+				bitResolution = newResolution;
+				DeviceAddress deviceAddr;
+				for (int i = 0; i < devices; i++) {
+					getAddress(deviceAddr, i);
+					bitResolution = max(bitResolution,
+							getResolution(deviceAddr));
+				}
+			}
+		}
+		return true;  // new value set
+	}
+
+	return false;
+
+}
+
+// returns the global resolution
+uint8_t DallasTemperature::getResolution() {
+	return bitResolution;
+}
+
+// returns the current resolution of the device, 9-12
+// returns 0 if device not found
+uint8_t DallasTemperature::getResolution(const uint8_t* deviceAddress) {
+
+	// DS1820 and DS18S20 have no resolution configuration register
+	if (deviceAddress[0] == DS18S20MODEL)
+		return 12;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		switch (scratchPad[CONFIGURATION]) {
+		case TEMP_12_BIT:
+			return 12;
+
+		case TEMP_11_BIT:
+			return 11;
+
+		case TEMP_10_BIT:
+			return 10;
+
+		case TEMP_9_BIT:
+			return 9;
+		}
+	}
+	return 0;
+
+}
+
+// sets the value of the waitForConversion flag
+// TRUE : function requestTemperature() etc returns when conversion is ready
+// FALSE: function requestTemperature() etc returns immediately (USE WITH CARE!!)
+//        (1) programmer has to check if the needed delay has passed
+//        (2) but the application can do meaningful things in that time
+void DallasTemperature::setWaitForConversion(bool flag) {
+	waitForConversion = flag;
+}
+
+// gets the value of the waitForConversion flag
+bool DallasTemperature::getWaitForConversion() {
+	return waitForConversion;
+}
+
+// sets the value of the checkForConversion flag
+// TRUE : function requestTemperature() etc will 'listen' to an IC to determine whether a conversion is complete
+// FALSE: function requestTemperature() etc will wait a set time (worst case scenario) for a conversion to complete
+void DallasTemperature::setCheckForConversion(bool flag) {
+	checkForConversion = flag;
+}
+
+// gets the value of the waitForConversion flag
+bool DallasTemperature::getCheckForConversion() {
+	return checkForConversion;
+}
+
+bool DallasTemperature::isConversionComplete() {
+	uint8_t b = _wire->read_bit();
+	return (b == 1);
+}
+
+// sends command for all devices on the bus to perform a temperature conversion
+void DallasTemperature::requestTemperatures() {
+
+	_wire->reset();
+	_wire->skip();
+	_wire->write(STARTCONVO, parasite);
+
+	// ASYNC mode?
+	if (!waitForConversion)
+		return;
+	blockTillConversionComplete(bitResolution);
+
+}
+
+// sends command for one device to perform a temperature by address
+// returns FALSE if device is disconnected
+// returns TRUE  otherwise
+bool DallasTemperature::requestTemperaturesByAddress(
+		const uint8_t* deviceAddress) {
+
+	uint8_t bitResolution = getResolution(deviceAddress);
+	if (bitResolution == 0) {
+		return false; //Device disconnected
+	}
+
+	_wire->reset();
+	_wire->select(deviceAddress);
+	_wire->write(STARTCONVO, parasite);
+
+	// ASYNC mode?
+	if (!waitForConversion)
+		return true;
+
+	blockTillConversionComplete(bitResolution);
+
+	return true;
+
+}
+
+// Continue to check if the IC has responded with a temperature
+void DallasTemperature::blockTillConversionComplete(uint8_t bitResolution) {
+
+	int delms = millisToWaitForConversion(bitResolution);
+	if (checkForConversion && !parasite) {
+		unsigned long now = millis();
+		while (!isConversionComplete() && (millis() - delms < now))
+			;
+	} else {
+		delay(delms);
+	}
+
+}
+
+// returns number of milliseconds to wait till conversion is complete (based on IC datasheet)
+int16_t DallasTemperature::millisToWaitForConversion(uint8_t bitResolution) {
+
+	switch (bitResolution) {
+	case 9:
+		return 94;
+	case 10:
+		return 188;
+	case 11:
+		return 375;
+	default:
+		return 750;
+	}
+
+}
+
+// sends command for one device to perform a temp conversion by index
+bool DallasTemperature::requestTemperaturesByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+
+	return requestTemperaturesByAddress(deviceAddress);
+
+}
+
+// Fetch temperature for device index
+float DallasTemperature::getTempCByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+	if (!getAddress(deviceAddress, deviceIndex)) {
+		return DEVICE_DISCONNECTED_C;
+	}
+
+	return getTempC((uint8_t*) deviceAddress);
+
+}
+
+// Fetch temperature for device index
+float DallasTemperature::getTempFByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+
+	if (!getAddress(deviceAddress, deviceIndex)) {
+		return DEVICE_DISCONNECTED_F;
+	}
+
+	return getTempF((uint8_t*) deviceAddress);
+
+}
+
+// reads scratchpad and returns fixed-point temperature, scaling factor 2^-7
+int16_t DallasTemperature::calculateTemperature(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+
+	int16_t fpTemperature = (((int16_t) scratchPad[TEMP_MSB]) << 11)
+			| (((int16_t) scratchPad[TEMP_LSB]) << 3);
+
+	/*
+	 DS1820 and DS18S20 have a 9-bit temperature register.
+
+	 Resolutions greater than 9-bit can be calculated using the data from
+	 the temperature, and COUNT REMAIN and COUNT PER °C registers in the
+	 scratchpad.  The resolution of the calculation depends on the model.
+
+	 While the COUNT PER °C register is hard-wired to 16 (10h) in a
+	 DS18S20, it changes with temperature in DS1820.
+
+	 After reading the scratchpad, the TEMP_READ value is obtained by
+	 truncating the 0.5°C bit (bit 0) from the temperature data. The
+	 extended resolution temperature can then be calculated using the
+	 following equation:
+
+	 COUNT_PER_C - COUNT_REMAIN
+	 TEMPERATURE = TEMP_READ - 0.25 + --------------------------
+	 COUNT_PER_C
+
+	 Hagai Shatz simplified this to integer arithmetic for a 12 bits
+	 value for a DS18S20, and James Cameron added legacy DS1820 support.
+
+	 See - http://myarduinotoy.blogspot.co.uk/2013/02/12bit-result-from-ds18s20.html
+	 */
+
+	if (deviceAddress[0] == DS18S20MODEL) {
+		fpTemperature = ((fpTemperature & 0xfff0) << 3) - 16
+				+ (((scratchPad[COUNT_PER_C] - scratchPad[COUNT_REMAIN]) << 7)
+						/ scratchPad[COUNT_PER_C]);
+	}
+
+	return fpTemperature;
+}
+
+// returns temperature in 1/128 degrees C or DEVICE_DISCONNECTED_RAW if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_RAW is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+int16_t DallasTemperature::getTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return calculateTemperature(deviceAddress, scratchPad);
+	return DEVICE_DISCONNECTED_RAW;
+
+}
+
+// returns temperature in degrees C or DEVICE_DISCONNECTED_C if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_C is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+float DallasTemperature::getTempC(const uint8_t* deviceAddress) {
+	return rawToCelsius(getTemp(deviceAddress));
+}
+
+// returns temperature in degrees F or DEVICE_DISCONNECTED_F if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_F is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+float DallasTemperature::getTempF(const uint8_t* deviceAddress) {
+	return rawToFahrenheit(getTemp(deviceAddress));
+}
+
+// returns true if the bus requires parasite power
+bool DallasTemperature::isParasitePowerMode(void) {
+	return parasite;
+}
+
+// IF alarm is not used one can store a 16 bit int of userdata in the alarm
+// registers. E.g. an ID of the sensor.
+// See github issue #29
+
+// note if device is not connected it will fail writing the data.
+void DallasTemperature::setUserData(const uint8_t* deviceAddress,
+		int16_t data) {
+	// return when stored value == new value
+	if (getUserData(deviceAddress) == data)
+		return;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[HIGH_ALARM_TEMP] = data >> 8;
+		scratchPad[LOW_ALARM_TEMP] = data & 255;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+}
+
+int16_t DallasTemperature::getUserData(const uint8_t* deviceAddress) {
+	int16_t data = 0;
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		data = scratchPad[HIGH_ALARM_TEMP] << 8;
+		data += scratchPad[LOW_ALARM_TEMP];
+	}
+	return data;
+}
+
+// note If address cannot be found no error will be reported.
+int16_t DallasTemperature::getUserDataByIndex(uint8_t deviceIndex) {
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+	return getUserData((uint8_t*) deviceAddress);
+}
+
+void DallasTemperature::setUserDataByIndex(uint8_t deviceIndex, int16_t data) {
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+	setUserData((uint8_t*) deviceAddress, data);
+}
+
+// Convert float Celsius to Fahrenheit
+float DallasTemperature::toFahrenheit(float celsius) {
+	return (celsius * 1.8) + 32;
+}
+
+// Convert float Fahrenheit to Celsius
+float DallasTemperature::toCelsius(float fahrenheit) {
+	return (fahrenheit - 32) * 0.555555556;
+}
+
+// convert from raw to Celsius
+float DallasTemperature::rawToCelsius(int16_t raw) {
+
+	if (raw <= DEVICE_DISCONNECTED_RAW)
+		return DEVICE_DISCONNECTED_C;
+	// C = RAW/128
+	return (float) raw * 0.0078125;
+
+}
+
+// convert from raw to Fahrenheit
+float DallasTemperature::rawToFahrenheit(int16_t raw) {
+
+	if (raw <= DEVICE_DISCONNECTED_RAW)
+		return DEVICE_DISCONNECTED_F;
+	// C = RAW/128
+	// F = (C*1.8)+32 = (RAW/128*1.8)+32 = (RAW*0.0140625)+32
+	return ((float) raw * 0.0140625) + 32;
+
+}
+
+#if REQUIRESALARMS
+
+/*
+
+ ALARMS:
+
+ TH and TL Register Format
+
+ BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0
+ S    2^6   2^5   2^4   2^3   2^2   2^1   2^0
+
+ Only bits 11 through 4 of the temperature register are used
+ in the TH and TL comparison since TH and TL are 8-bit
+ registers. If the measured temperature is lower than or equal
+ to TL or higher than or equal to TH, an alarm condition exists
+ and an alarm flag is set inside the DS18B20. This flag is
+ updated after every temperature measurement; therefore, if the
+ alarm condition goes away, the flag will be turned off after
+ the next temperature conversion.
+
+ */
+
+// sets the high alarm temperature for a device in degrees Celsius
+// accepts a float, but the alarm resolution will ignore anything
+// after a decimal point.  valid range is -55C - 125C
+void DallasTemperature::setHighAlarmTemp(const uint8_t* deviceAddress,
+		int8_t celsius) {
+
+	// return when stored value == new value
+	if (getHighAlarmTemp(deviceAddress) == celsius)
+		return;
+
+	// make sure the alarm temperature is within the device's range
+	if (celsius > 125)
+		celsius = 125;
+	else if (celsius < -55)
+		celsius = -55;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[HIGH_ALARM_TEMP] = (uint8_t) celsius;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+
+}
+
+// sets the low alarm temperature for a device in degrees Celsius
+// accepts a float, but the alarm resolution will ignore anything
+// after a decimal point.  valid range is -55C - 125C
+void DallasTemperature::setLowAlarmTemp(const uint8_t* deviceAddress,
+		int8_t celsius) {
+
+	// return when stored value == new value
+	if (getLowAlarmTemp(deviceAddress) == celsius)
+		return;
+
+	// make sure the alarm temperature is within the device's range
+	if (celsius > 125)
+		celsius = 125;
+	else if (celsius < -55)
+		celsius = -55;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[LOW_ALARM_TEMP] = (uint8_t) celsius;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+
+}
+
+// returns a int8_t with the current high alarm temperature or
+// DEVICE_DISCONNECTED for an address
+int8_t DallasTemperature::getHighAlarmTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return (int8_t) scratchPad[HIGH_ALARM_TEMP];
+	return DEVICE_DISCONNECTED_C;
+
+}
+
+// returns a int8_t with the current low alarm temperature or
+// DEVICE_DISCONNECTED for an address
+int8_t DallasTemperature::getLowAlarmTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return (int8_t) scratchPad[LOW_ALARM_TEMP];
+	return DEVICE_DISCONNECTED_C;
+
+}
+
+// resets internal variables used for the alarm search
+void DallasTemperature::resetAlarmSearch() {
+
+	alarmSearchJunction = -1;
+	alarmSearchExhausted = 0;
+	for (uint8_t i = 0; i < 7; i++) {
+		alarmSearchAddress[i] = 0;
+	}
+
+}
+
+// This is a modified version of the OneWire::search method.
+//
+// Also added the OneWire search fix documented here:
+// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
+//
+// Perform an alarm 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
+// DallasTemperature::resetAlarmSearch() to start over.
+bool DallasTemperature::alarmSearch(uint8_t* newAddr) {
+
+	uint8_t i;
+	int8_t lastJunction = -1;
+	uint8_t done = 1;
+
+	if (alarmSearchExhausted)
+		return false;
+	if (!_wire->reset())
+		return false;
+
+	// send the alarm search command
+	_wire->write(0xEC, 0);
+
+	for (i = 0; i < 64; i++) {
+
+		uint8_t a = _wire->read_bit();
+		uint8_t nota = _wire->read_bit();
+		uint8_t ibyte = i / 8;
+		uint8_t ibit = 1 << (i & 7);
+
+		// I don't think this should happen, this means nothing responded, but maybe if
+		// something vanishes during the search it will come up.
+		if (a && nota)
+			return false;
+
+		if (!a && !nota) {
+			if (i == alarmSearchJunction) {
+				// this is our time to decide differently, we went zero last time, go one.
+				a = 1;
+				alarmSearchJunction = lastJunction;
+			} else if (i < alarmSearchJunction) {
+
+				// take whatever we took last time, look in address
+				if (alarmSearchAddress[ibyte] & ibit) {
+					a = 1;
+				} else {
+					// Only 0s count as pending junctions, we've already exhausted the 0 side of 1s
+					a = 0;
+					done = 0;
+					lastJunction = i;
+				}
+			} else {
+				// we are blazing new tree, take the 0
+				a = 0;
+				alarmSearchJunction = i;
+				done = 0;
+			}
+			// OneWire search fix
+			// See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
+		}
+
+		if (a)
+			alarmSearchAddress[ibyte] |= ibit;
+		else
+			alarmSearchAddress[ibyte] &= ~ibit;
+
+		_wire->write_bit(a);
+	}
+
+	if (done)
+		alarmSearchExhausted = 1;
+	for (i = 0; i < 8; i++)
+		newAddr[i] = alarmSearchAddress[i];
+	return true;
+
+}
+
+// returns true if device address might have an alarm condition
+// (only an alarm search can verify this)
+bool DallasTemperature::hasAlarm(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+
+		int8_t temp = calculateTemperature(deviceAddress, scratchPad) >> 7;
+
+		// check low alarm
+		if (temp <= (int8_t) scratchPad[LOW_ALARM_TEMP])
+			return true;
+
+		// check high alarm
+		if (temp >= (int8_t) scratchPad[HIGH_ALARM_TEMP])
+			return true;
+	}
+
+	// no alarm
+	return false;
+
+}
+
+// returns true if any device is reporting an alarm condition on the bus
+bool DallasTemperature::hasAlarm(void) {
+
+	DeviceAddress deviceAddress;
+	resetAlarmSearch();
+	return alarmSearch(deviceAddress);
+}
+
+// runs the alarm handler for all devices returned by alarmSearch()
+// unless there no _AlarmHandler exist.
+void DallasTemperature::processAlarms(void) {
+
+if (!hasAlarmHandler())
+{
+	return;
+}
+
+	resetAlarmSearch();
+	DeviceAddress alarmAddr;
+
+	while (alarmSearch(alarmAddr)) {
+		if (validAddress(alarmAddr)) {
+			_AlarmHandler(alarmAddr);
+		}
+	}
+}
+
+// sets the alarm handler
+void DallasTemperature::setAlarmHandler(const AlarmHandler *handler) {
+	_AlarmHandler = handler;
+}
+
+// checks if AlarmHandler has been set.
+bool DallasTemperature::hasAlarmHandler()
+{
+  return _AlarmHandler != NO_ALARM_HANDLER;
+}
+
+#endif
+
+#if REQUIRESNEW
+
+// MnetCS - Allocates memory for DallasTemperature. Allows us to instance a new object
+void* DallasTemperature::operator new(unsigned int size) { // Implicit NSS obj size
+
+	void * p;// void pointer
+	p = malloc(size);// Allocate memory
+	memset((DallasTemperature*)p,0,size);// Initialise memory
+
+	//!!! CANT EXPLICITLY CALL CONSTRUCTOR - workaround by using an init() methodR - workaround by using an init() method
+	return (DallasTemperature*) p;// Cast blank region to NSS pointer
+}
+
+// MnetCS 2009 -  Free the memory used by this instance
+void DallasTemperature::operator delete(void* p) {
+
+	DallasTemperature* pNss = (DallasTemperature*) p; // Cast to NSS pointer
+	pNss->~DallasTemperature();// Destruct the object
+
+	free(p);// Free the memory
+}
+
+#endif

Firmware/lib/DallasTemperature/DallasTemperature.h

@@ -0,0 +1,251 @@
+#ifndef DallasTemperature_h
+#define DallasTemperature_h
+
+#define DALLASTEMPLIBVERSION "3.7.9" // To be deprecated
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// set to true to include code for new and delete operators
+#ifndef REQUIRESNEW
+#define REQUIRESNEW false
+#endif
+
+// set to true to include code implementing alarm search functions
+#ifndef REQUIRESALARMS
+#define REQUIRESALARMS true
+#endif
+
+#include <inttypes.h>
+#include <OneWire.h>
+
+// Model IDs
+#define DS18S20MODEL 0x10  // also DS1820
+#define DS18B20MODEL 0x28
+#define DS1822MODEL  0x22
+#define DS1825MODEL  0x3B
+#define DS28EA00MODEL 0x42
+
+// Error Codes
+#define DEVICE_DISCONNECTED_C -127
+#define DEVICE_DISCONNECTED_F -196.6
+#define DEVICE_DISCONNECTED_RAW -7040
+
+typedef uint8_t DeviceAddress[8];
+
+class DallasTemperature {
+public:
+
+	DallasTemperature();
+	DallasTemperature(OneWire*);
+
+	void setOneWire(OneWire*);
+
+	// initialise bus
+	void begin(void);
+
+	// returns the number of devices found on the bus
+	uint8_t getDeviceCount(void);
+
+	// returns the number of DS18xxx Family devices on bus
+	uint8_t getDS18Count(void);
+
+	// returns true if address is valid
+	bool validAddress(const uint8_t*);
+
+	// returns true if address is of the family of sensors the lib supports.
+	bool validFamily(const uint8_t* deviceAddress);
+
+	// finds an address at a given index on the bus
+	bool getAddress(uint8_t*, uint8_t);
+
+	// attempt to determine if the device at the given address is connected to the bus
+	bool isConnected(const uint8_t*);
+
+	// attempt to determine if the device at the given address is connected to the bus
+	// also allows for updating the read scratchpad
+	bool isConnected(const uint8_t*, uint8_t*);
+
+	// read device's scratchpad
+	bool readScratchPad(const uint8_t*, uint8_t*);
+
+	// write device's scratchpad
+	void writeScratchPad(const uint8_t*, const uint8_t*);
+
+	// read device's power requirements
+	bool readPowerSupply(const uint8_t*);
+
+	// get global resolution
+	uint8_t getResolution();
+
+	// set global resolution to 9, 10, 11, or 12 bits
+	void setResolution(uint8_t);
+
+	// returns the device resolution: 9, 10, 11, or 12 bits
+	uint8_t getResolution(const uint8_t*);
+
+	// set resolution of a device to 9, 10, 11, or 12 bits
+	bool setResolution(const uint8_t*, uint8_t,
+			bool skipGlobalBitResolutionCalculation = false);
+
+	// sets/gets the waitForConversion flag
+	void setWaitForConversion(bool);
+	bool getWaitForConversion(void);
+
+	// sets/gets the checkForConversion flag
+	void setCheckForConversion(bool);
+	bool getCheckForConversion(void);
+
+	// sends command for all devices on the bus to perform a temperature conversion
+	void requestTemperatures(void);
+
+	// sends command for one device to perform a temperature conversion by address
+	bool requestTemperaturesByAddress(const uint8_t*);
+
+	// sends command for one device to perform a temperature conversion by index
+	bool requestTemperaturesByIndex(uint8_t);
+
+	// returns temperature raw value (12 bit integer of 1/128 degrees C)
+	int16_t getTemp(const uint8_t*);
+
+	// returns temperature in degrees C
+	float getTempC(const uint8_t*);
+
+	// returns temperature in degrees F
+	float getTempF(const uint8_t*);
+
+	// Get temperature for device index (slow)
+	float getTempCByIndex(uint8_t);
+
+	// Get temperature for device index (slow)
+	float getTempFByIndex(uint8_t);
+
+	// returns true if the bus requires parasite power
+	bool isParasitePowerMode(void);
+
+	// Is a conversion complete on the wire? Only applies to the first sensor on the wire.
+	bool isConversionComplete(void);
+
+	int16_t millisToWaitForConversion(uint8_t);
+
+#if REQUIRESALARMS
+
+	typedef void AlarmHandler(const uint8_t*);
+
+	// sets the high alarm temperature for a device
+	// accepts a int8_t.  valid range is -55C - 125C
+	void setHighAlarmTemp(const uint8_t*, int8_t);
+
+	// sets the low alarm temperature for a device
+	// accepts a int8_t.  valid range is -55C - 125C
+	void setLowAlarmTemp(const uint8_t*, int8_t);
+
+	// returns a int8_t with the current high alarm temperature for a device
+	// in the range -55C - 125C
+	int8_t getHighAlarmTemp(const uint8_t*);
+
+	// returns a int8_t with the current low alarm temperature for a device
+	// in the range -55C - 125C
+	int8_t getLowAlarmTemp(const uint8_t*);
+
+	// resets internal variables used for the alarm search
+	void resetAlarmSearch(void);
+
+	// search the wire for devices with active alarms
+	bool alarmSearch(uint8_t*);
+
+	// returns true if ia specific device has an alarm
+	bool hasAlarm(const uint8_t*);
+
+	// returns true if any device is reporting an alarm on the bus
+	bool hasAlarm(void);
+
+	// runs the alarm handler for all devices returned by alarmSearch()
+	void processAlarms(void);
+
+	// sets the alarm handler
+	void setAlarmHandler(const AlarmHandler *);
+
+	// returns true if an AlarmHandler has been set
+	bool hasAlarmHandler();
+
+#endif
+
+	// if no alarm handler is used the two bytes can be used as user data
+	// example of such usage is an ID.
+	// note if device is not connected it will fail writing the data.
+	// note if address cannot be found no error will be reported.
+	// in short use carefully
+	void setUserData(const uint8_t*, int16_t);
+	void setUserDataByIndex(uint8_t, int16_t);
+	int16_t getUserData(const uint8_t*);
+	int16_t getUserDataByIndex(uint8_t);
+
+	// convert from Celsius to Fahrenheit
+	static float toFahrenheit(float);
+
+	// convert from Fahrenheit to Celsius
+	static float toCelsius(float);
+
+	// convert from raw to Celsius
+	static float rawToCelsius(int16_t);
+
+	// convert from raw to Fahrenheit
+	static float rawToFahrenheit(int16_t);
+
+#if REQUIRESNEW
+
+	// initialize memory area
+	void* operator new (unsigned int);
+
+	// delete memory reference
+	void operator delete(void*);
+
+#endif
+
+private:
+	typedef uint8_t ScratchPad[9];
+
+	// parasite power on or off
+	bool parasite;
+
+	// used to determine the delay amount needed to allow for the
+	// temperature conversion to take place
+	uint8_t bitResolution;
+
+	// used to requestTemperature with or without delay
+	bool waitForConversion;
+
+	// used to requestTemperature to dynamically check if a conversion is complete
+	bool checkForConversion;
+
+	// count of devices on the bus
+	uint8_t devices;
+
+	// count of DS18xxx Family devices on bus
+	uint8_t ds18Count;
+
+	// Take a pointer to one wire instance
+	OneWire* _wire;
+
+	// reads scratchpad and returns the raw temperature
+	int16_t calculateTemperature(const uint8_t*, uint8_t*);
+
+	void blockTillConversionComplete(uint8_t);
+
+#if REQUIRESALARMS
+
+	// required for alarmSearch
+	uint8_t alarmSearchAddress[8];
+	int8_t alarmSearchJunction;
+	uint8_t alarmSearchExhausted;
+
+	// the alarm handler function pointer
+	AlarmHandler *_AlarmHandler;
+
+#endif
+
+};
+#endif

Firmware/lib/LoRaWAN/LoRaWAN.cpp

@@ -35,7 +35,7 @@ void LoRaWAN::setKeys(unsigned char NwkSkey[], unsigned char AppSkey[], unsigned
 *
 *****************************************************************************************
 */
-void LoRaWAN::Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned int Frame_Counter_Tx)
+void LoRaWAN::Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned int Frame_Counter_Tx, lora_dr_t datarate,unsigned char Frame_Port)
 {
   //Define variables
   unsigned char i;
@@ -66,7 +66,6 @@ void LoRaWAN::Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned
     111	(0xE0) Proprietary
   */
 
-
   // Unconfirmed data up
   unsigned char Mac_Header = 0x40;
 
@@ -74,12 +73,11 @@ void LoRaWAN::Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned
   // unsigned char Mac_Header = 0x80;
 
   unsigned char Frame_Control = 0x00;
-  unsigned char Frame_Port = 0x01;
+  //unsigned char Frame_Port = 0x01;
 
   //Encrypt the data
   Encrypt_Payload(Data, Data_Length, Frame_Counter_Tx, Direction);
 
-
   //Build the Radio Package
   RFM_Data[0] = Mac_Header;
 
@@ -119,13 +117,12 @@ void LoRaWAN::Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned
   //Add MIC length to RFM package length
   RFM_Package_Length = RFM_Package_Length + 4;
 
+  //Set Lora Datarate
+  _rfm95->RFM_Set_Datarate(datarate);
   //Send Package
   _rfm95->RFM_Send_Package(RFM_Data, RFM_Package_Length);
 }
 
-
-
-
 /*
    Encryption stuff after this line
 */

Firmware/lib/LoRaWAN/LoRaWAN.h

@@ -40,7 +40,7 @@ class LoRaWAN
   public:
     LoRaWAN(RFM95 &rfm95);
     void setKeys(unsigned char NwkSkey[], unsigned char AppSkey[], unsigned char DevAddr[]);
-    void Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned int Frame_Counter_Tx);
+    void Send_Data(unsigned char *Data, unsigned char Data_Length, unsigned int Frame_Counter_Tx, lora_dr_t datarate,unsigned char Frame_Port);
 
   private:
     RFM95 *_rfm95;

Firmware/lib/OneWire/OneWire.cpp

@@ -0,0 +1,580 @@
+/*
+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 "OneWire.h"
+#include "util/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

Firmware/lib/OneWire/OneWire.h

@@ -0,0 +1,182 @@
+#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 "util/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() { }
+    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

Firmware/lib/OneWire/util/OneWire_direct_gpio.h

@@ -0,0 +1,420 @@
+#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
+
+#if defined(__AVR__)
+#define PIN_TO_BASEREG(pin)             (portInputRegister(digitalPinToPort(pin)))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR asm("r30")
+#define IO_REG_MASK_ATTR
+#if defined(__AVR_ATmega4809__)
+#define DIRECT_READ(base, mask)         (((*(base)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   ((*((base)-8)) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  ((*((base)-8)) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask)    ((*((base)-4)) &= ~(mask))
+#define DIRECT_WRITE_HIGH(base, mask)   ((*((base)-4)) |= (mask))
+#else
+#define DIRECT_READ(base, mask)         (((*(base)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   ((*((base)+1)) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  ((*((base)+1)) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask)    ((*((base)+2)) &= ~(mask))
+#define DIRECT_WRITE_HIGH(base, mask)   ((*((base)+2)) |= (mask))
+#endif
+
+#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
+#define PIN_TO_BASEREG(pin)             (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin)             (1)
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR __attribute__ ((unused))
+#define DIRECT_READ(base, mask)         (*((base)+512))
+#define DIRECT_MODE_INPUT(base, mask)   (*((base)+640) = 0)
+#define DIRECT_MODE_OUTPUT(base, mask)  (*((base)+640) = 1)
+#define DIRECT_WRITE_LOW(base, mask)    (*((base)+256) = 1)
+#define DIRECT_WRITE_HIGH(base, mask)   (*((base)+128) = 1)
+
+#elif defined(__MKL26Z64__)
+#define PIN_TO_BASEREG(pin)             (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint8_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         ((*((base)+16) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   (*((base)+20) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  (*((base)+20) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask)    (*((base)+8) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask)   (*((base)+4) = (mask))
+
+#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
+#define PIN_TO_BASEREG(pin)             (portOutputRegister(pin))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         ((*((base)+2) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   (*((base)+1) &= ~(mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  (*((base)+1) |= (mask))
+#define DIRECT_WRITE_LOW(base, mask)    (*((base)+34) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask)   (*((base)+33) = (mask))
+
+#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
+// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due.
+// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268
+// If you have trouble with OneWire on Arduino Due, please check the
+// status of delayMicroseconds() before reporting a bug in OneWire!
+#define PIN_TO_BASEREG(pin)             (&(digitalPinToPort(pin)->PIO_PER))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         (((*((base)+15)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   ((*((base)+5)) = (mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  ((*((base)+4)) = (mask))
+#define DIRECT_WRITE_LOW(base, mask)    ((*((base)+13)) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask)   ((*((base)+12)) = (mask))
+#ifndef PROGMEM
+#define PROGMEM
+#endif
+#ifndef pgm_read_byte
+#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
+#endif
+
+#elif defined(__PIC32MX__)
+#define PIN_TO_BASEREG(pin)             (portModeRegister(digitalPinToPort(pin)))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         (((*(base+4)) & (mask)) ? 1 : 0)  //PORTX + 0x10
+#define DIRECT_MODE_INPUT(base, mask)   ((*(base+2)) = (mask))            //TRISXSET + 0x08
+#define DIRECT_MODE_OUTPUT(base, mask)  ((*(base+1)) = (mask))            //TRISXCLR + 0x04
+#define DIRECT_WRITE_LOW(base, mask)    ((*(base+8+1)) = (mask))          //LATXCLR  + 0x24
+#define DIRECT_WRITE_HIGH(base, mask)   ((*(base+8+2)) = (mask))          //LATXSET + 0x28
+
+#elif defined(ARDUINO_ARCH_ESP8266)
+// Special note: I depend on the ESP community to maintain these definitions and
+// submit good pull requests.  I can not answer any ESP questions or help you
+// resolve any problems related to ESP chips.  Please do not contact me and please
+// DO NOT CREATE GITHUB ISSUES for ESP support.  All ESP questions must be asked
+// on ESP community forums.
+#define PIN_TO_BASEREG(pin)             ((volatile uint32_t*) GPO)
+#define PIN_TO_BITMASK(pin)             (1 << pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         ((GPI & (mask)) ? 1 : 0)    //GPIO_IN_ADDRESS
+#define DIRECT_MODE_INPUT(base, mask)   (GPE &= ~(mask))            //GPIO_ENABLE_W1TC_ADDRESS
+#define DIRECT_MODE_OUTPUT(base, mask)  (GPE |= (mask))             //GPIO_ENABLE_W1TS_ADDRESS
+#define DIRECT_WRITE_LOW(base, mask)    (GPOC = (mask))             //GPIO_OUT_W1TC_ADDRESS
+#define DIRECT_WRITE_HIGH(base, mask)   (GPOS = (mask))             //GPIO_OUT_W1TS_ADDRESS
+
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <driver/rtc_io.h>
+#define PIN_TO_BASEREG(pin)             (0)
+#define PIN_TO_BITMASK(pin)             (pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(IO_REG_TYPE pin)
+{
+    if ( pin < 32 )
+        return (GPIO.in >> pin) & 0x1;
+    else if ( pin < 40 )
+        return (GPIO.in1.val >> (pin - 32)) & 0x1;
+
+    return 0;
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(IO_REG_TYPE pin)
+{
+    if ( pin < 32 )
+        GPIO.out_w1tc = ((uint32_t)1 << pin);
+    else if ( pin < 34 )
+        GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(IO_REG_TYPE pin)
+{
+    if ( pin < 32 )
+        GPIO.out_w1ts = ((uint32_t)1 << pin);
+    else if ( pin < 34 )
+        GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(IO_REG_TYPE pin)
+{
+    if ( digitalPinIsValid(pin) )
+    {
+        uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
+
+        if ( rtc_reg ) // RTC pins PULL settings
+        {
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
+        }
+
+        if ( pin < 32 )
+            GPIO.enable_w1tc = ((uint32_t)1 << pin);
+        else
+            GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32));
+
+        uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
+        pinFunction |= FUN_IE; // input enable but required for output as well?
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+
+        ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
+
+        GPIO.pin[pin].val = 0;
+    }
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(IO_REG_TYPE pin)
+{
+    if ( digitalPinIsValid(pin) && pin <= 33 ) // pins above 33 can be only inputs
+    {
+        uint32_t rtc_reg(rtc_gpio_desc[pin].reg);
+
+        if ( rtc_reg ) // RTC pins PULL settings
+        {
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
+        }
+
+        if ( pin < 32 )
+            GPIO.enable_w1ts = ((uint32_t)1 << pin);
+        else // already validated to pins <= 33
+            GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32));
+
+        uint32_t pinFunction((uint32_t)2 << FUN_DRV_S); // what are the drivers?
+        pinFunction |= FUN_IE; // input enable but required for output as well?
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+
+        ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
+
+        GPIO.pin[pin].val = 0;
+    }
+}
+
+#define DIRECT_READ(base, pin)          directRead(pin)
+#define DIRECT_WRITE_LOW(base, pin)     directWriteLow(pin)
+#define DIRECT_WRITE_HIGH(base, pin)    directWriteHigh(pin)
+#define DIRECT_MODE_INPUT(base, pin)    directModeInput(pin)
+#define DIRECT_MODE_OUTPUT(base, pin)   directModeOutput(pin)
+// https://github.com/PaulStoffregen/OneWire/pull/47
+// https://github.com/stickbreaker/OneWire/commit/6eb7fc1c11a15b6ac8c60e5671cf36eb6829f82c
+#ifdef  interrupts
+#undef  interrupts
+#endif
+#ifdef  noInterrupts
+#undef  noInterrupts
+#endif
+#define noInterrupts() {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;portENTER_CRITICAL(&mux)
+#define interrupts() portEXIT_CRITICAL(&mux);}
+//#warning "ESP32 OneWire testing"
+
+#elif defined(ARDUINO_ARCH_STM32)
+#define PIN_TO_BASEREG(pin)             (0)
+#define PIN_TO_BITMASK(pin)             ((uint32_t)digitalPinToPinName(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin)          digitalReadFast((PinName)pin)
+#define DIRECT_WRITE_LOW(base, pin)     digitalWriteFast((PinName)pin, LOW)
+#define DIRECT_WRITE_HIGH(base, pin)    digitalWriteFast((PinName)pin, HIGH)
+#define DIRECT_MODE_INPUT(base, pin)    pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0))
+#define DIRECT_MODE_OUTPUT(base, pin)   pin_function((PinName)pin, STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0))
+
+#elif defined(__SAMD21G18A__)
+#define PIN_TO_BASEREG(pin)             portModeRegister(digitalPinToPort(pin))
+#define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, mask)         (((*((base)+8)) & (mask)) ? 1 : 0)
+#define DIRECT_MODE_INPUT(base, mask)   ((*((base)+1)) = (mask))
+#define DIRECT_MODE_OUTPUT(base, mask)  ((*((base)+2)) = (mask))
+#define DIRECT_WRITE_LOW(base, mask)    ((*((base)+5)) = (mask))
+#define DIRECT_WRITE_HIGH(base, mask)   ((*((base)+6)) = (mask))
+
+#elif defined(RBL_NRF51822)
+#define PIN_TO_BASEREG(pin)             (0)
+#define PIN_TO_BITMASK(pin)             (pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin)          nrf_gpio_pin_read(pin)
+#define DIRECT_WRITE_LOW(base, pin)     nrf_gpio_pin_clear(pin)
+#define DIRECT_WRITE_HIGH(base, pin)    nrf_gpio_pin_set(pin)
+#define DIRECT_MODE_INPUT(base, pin)    nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL)
+#define DIRECT_MODE_OUTPUT(base, pin)   nrf_gpio_cfg_output(pin)
+
+#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
+
+#include "scss_registers.h"
+#include "portable.h"
+#include "avr/pgmspace.h"
+
+#define GPIO_ID(pin)			(g_APinDescription[pin].ulGPIOId)
+#define GPIO_TYPE(pin)			(g_APinDescription[pin].ulGPIOType)
+#define GPIO_BASE(pin)			(g_APinDescription[pin].ulGPIOBase)
+#define DIR_OFFSET_SS			0x01
+#define DIR_OFFSET_SOC			0x04
+#define EXT_PORT_OFFSET_SS		0x0A
+#define EXT_PORT_OFFSET_SOC		0x50
+
+/* GPIO registers base address */
+#define PIN_TO_BASEREG(pin)		((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
+#define PIN_TO_BITMASK(pin)		pin
+#define IO_REG_TYPE			uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+    IO_REG_TYPE ret;
+    if (SS_GPIO == GPIO_TYPE(pin)) {
+        ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
+    } else {
+        ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
+    }
+    return ((ret >> GPIO_ID(pin)) & 0x01);
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+    if (SS_GPIO == GPIO_TYPE(pin)) {
+        WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)),
+			((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
+    } else {
+        MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin));
+    }
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+    if (SS_GPIO == GPIO_TYPE(pin)) {
+        WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)),
+			((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
+    } else {
+        MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin));
+    }
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+    if (SS_GPIO == GPIO_TYPE(pin)) {
+        WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base);
+    } else {
+        MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin));
+    }
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
+{
+    if (SS_GPIO == GPIO_TYPE(pin)) {
+        WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base);
+    } else {
+        MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin));
+    }
+}
+
+#define DIRECT_READ(base, pin)		directRead(base, pin)
+#define DIRECT_MODE_INPUT(base, pin)	directModeInput(base, pin)
+#define DIRECT_MODE_OUTPUT(base, pin)	directModeOutput(base, pin)
+#define DIRECT_WRITE_LOW(base, pin)	directWriteLow(base, pin)
+#define DIRECT_WRITE_HIGH(base, pin)	directWriteHigh(base, pin)
+
+#elif defined(__riscv)
+
+/*
+ * Tested on highfive1
+ *
+ * Stable results are achieved operating in the
+ * two high speed modes of the highfive1.  It
+ * seems to be less reliable in slow mode.
+ */
+#define PIN_TO_BASEREG(pin)             (0)
+#define PIN_TO_BITMASK(pin)             digitalPinToBitMask(pin)
+#define IO_REG_TYPE uint32_t
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+
+static inline __attribute__((always_inline))
+IO_REG_TYPE directRead(IO_REG_TYPE mask)
+{
+    return ((GPIO_REG(GPIO_INPUT_VAL) & mask) != 0) ? 1 : 0;
+}
+
+static inline __attribute__((always_inline))
+void directModeInput(IO_REG_TYPE mask)
+{
+    GPIO_REG(GPIO_OUTPUT_XOR)  &= ~mask;
+    GPIO_REG(GPIO_IOF_EN)      &= ~mask;
+
+    GPIO_REG(GPIO_INPUT_EN)  |=  mask;
+    GPIO_REG(GPIO_OUTPUT_EN) &= ~mask;
+}
+
+static inline __attribute__((always_inline))
+void directModeOutput(IO_REG_TYPE mask)
+{
+    GPIO_REG(GPIO_OUTPUT_XOR)  &= ~mask;
+    GPIO_REG(GPIO_IOF_EN)      &= ~mask;
+
+    GPIO_REG(GPIO_INPUT_EN)  &= ~mask;
+    GPIO_REG(GPIO_OUTPUT_EN) |=  mask;
+}
+
+static inline __attribute__((always_inline))
+void directWriteLow(IO_REG_TYPE mask)
+{
+    GPIO_REG(GPIO_OUTPUT_VAL) &= ~mask;
+}
+
+static inline __attribute__((always_inline))
+void directWriteHigh(IO_REG_TYPE mask)
+{
+    GPIO_REG(GPIO_OUTPUT_VAL) |= mask;
+}
+
+#define DIRECT_READ(base, mask)          directRead(mask)
+#define DIRECT_WRITE_LOW(base, mask)     directWriteLow(mask)
+#define DIRECT_WRITE_HIGH(base, mask)    directWriteHigh(mask)
+#define DIRECT_MODE_INPUT(base, mask)    directModeInput(mask)
+#define DIRECT_MODE_OUTPUT(base, mask)   directModeOutput(mask)
+
+#else
+#define PIN_TO_BASEREG(pin)             (0)
+#define PIN_TO_BITMASK(pin)             (pin)
+#define IO_REG_TYPE unsigned int
+#define IO_REG_BASE_ATTR
+#define IO_REG_MASK_ATTR
+#define DIRECT_READ(base, pin)          digitalRead(pin)
+#define DIRECT_WRITE_LOW(base, pin)     digitalWrite(pin, LOW)
+#define DIRECT_WRITE_HIGH(base, pin)    digitalWrite(pin, HIGH)
+#define DIRECT_MODE_INPUT(base, pin)    pinMode(pin,INPUT)
+#define DIRECT_MODE_OUTPUT(base, pin)   pinMode(pin,OUTPUT)
+#warning "OneWire. Fallback mode. Using API calls for pinMode,digitalRead and digitalWrite. Operation of this library is not guaranteed on this architecture."
+
+#endif
+
+#endif

Firmware/lib/OneWire/util/OneWire_direct_regtype.h

@@ -0,0 +1,52 @@
+#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

Firmware/lib/RFM95/RFM95.cpp

@@ -33,6 +33,11 @@ void RFM95::init()
   pinMode(_NSS, OUTPUT);
   pinMode(_DIO0, INPUT);
 
+  // Set default Datarate Config SF7BW125
+  _sf = 0x74;
+  _bw = 0x72;
+  _mc = 0x04;
+  
   // NSS for starting and stopping communication with the RFM95 module
   digitalWrite(_NSS, HIGH);
 
@@ -147,6 +152,54 @@ unsigned char RFM95::RFM_Read(unsigned char RFM_Address)
   return RFM_Data;
 }
 
+/*
+*****************************************************************************************
+* Description : Set Datarate and Spreading Factor
+*
+* Arguments   : datarate  Lora Datarate Enum (see RFM95.h)
+*****************************************************************************************
+*/
+
+void RFM95::RFM_Set_Datarate(lora_dr_t datarate) {
+  switch(datarate) {
+    case SF7BW125:
+      _sf = 0x74;
+      _bw = 0x72;
+      _mc = 0x04;
+      break;
+    case SF8BW125:
+      _sf = 0x84;
+      _bw = 0x72;
+      _mc = 0x04;
+      break;
+    case SF9BW125:
+      _sf = 0x94;
+      _bw = 0x72;
+      _mc = 0x04;
+      break;
+    case SF10BW125:
+      _sf = 0xA4;
+      _bw = 0x72;
+      _mc = 0x04;
+      break;
+    case SF11BW125:
+      _sf = 0xB4;
+      _bw = 0x72;
+      _mc = 0x0C;
+      break;
+    case SF12BW125:
+      _sf = 0xC4;
+      _bw = 0x72;
+      _mc = 0x0C;
+      break;
+    default:
+      _sf = 0x74;
+      _bw = 0x72;
+      _mc = 0x04;
+      break;
+  }
+}
+
 /*
 *****************************************************************************************
 * Description : Function for sending a package with the RFM
@@ -236,9 +289,9 @@ void RFM95::RFM_Send_Package(unsigned char *RFM_Tx_Package, unsigned char Packag
 
 
   //SF7 BW 125 kHz
-  RFM_Write(0x1E,0x74); //SF7 CRC On
-  RFM_Write(0x1D,0x72); //125 kHz 4/5 coding rate explicit header mode
-  RFM_Write(0x26,0x04); //Low datarate optimization off AGC auto on
+  RFM_Write(0x1E,_sf); //SF7 CRC On
+  RFM_Write(0x1D,_bw); //125 kHz 4/5 coding rate explicit header mode
+  RFM_Write(0x26,_mc); //Low datarate optimization off AGC auto on
 
   //Set IQ to normal values
   RFM_Write(0x33,0x27);

Firmware/lib/RFM95/RFM95.h

@@ -12,6 +12,16 @@
 
 #include "Arduino.h"
 
+typedef enum lora_dr
+{
+  SF7BW125,
+  SF8BW125,
+  SF9BW125,
+  SF10BW125,
+  SF11BW125,
+  SF12BW125,
+} lora_dr_t;
+
 class RFM95
 {
   public:
@@ -20,9 +30,11 @@ class RFM95
     void RFM_Write(unsigned char RFM_Address, unsigned char RFM_Data);
     unsigned char RFM_Read(unsigned char RFM_Address);
     void RFM_Send_Package(unsigned char *RFM_Tx_Package, unsigned char Package_Length);
+    void RFM_Set_Datarate(lora_dr_t datarate);
   private:
     int _DIO0;
     int _NSS;
+    unsigned char _sf, _bw, _mc;
 };
 
 

Firmware/platformio.ini

@@ -6,7 +6,6 @@ upload_protocol = stk500v2
 upload_flags =
     -P/dev/ttyACM0
     -b$UPLOAD_SPEED
-    -B10
 upload_speed = 19200
 monitor_speed = 9600
 board_build.f_cpu = 1000000L

Firmware/src/main.cpp

@@ -1,6 +1,6 @@
 /*
-  main.cpp - TinyLora / TinyTX Firmware
-  Copyright (c) 2019, Stefan Brand
+  main.cpp - ATTNode / TinyTX Firmware
+  Copyright (c) 2019-2020, Stefan Brand
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
@@ -31,14 +31,17 @@
 #include <Arduino.h>
 #include <avr/sleep.h>
 #include <avr/wdt.h>
+#include <avr/interrupt.h>
 #include <tinySPI.h>
 
 // secconfig.h Configures RF Module, TTN Keys / RF Networks and used Sensor
 #include "secconfig.h"
 
+// Create needed Variables and Objects for RF Module
 #ifdef RF_LORA
   // Include LoRaWAN
   #include <LoRaWAN.h>
+  #include <EEPROM.h> // For Storing  Frame Counter
   #define DIO0 PIN_B0
   #define NSS  PIN_B1
   RFM95 rfm(DIO0,NSS);
@@ -52,20 +55,47 @@
   RFM69 radio;
 #endif
 
-// Sensorclass and deepsleep interval (for measurement about every 10Min)
-#ifdef HAS_BME280
+// Create Sensor Class
+#if defined HAS_BME280 || defined HAS_BME280_BRIGHTNESS || defined HAS_BME280_ALARM
   #include <BME280.h>
   BME280 sensor;
 #endif
 
-#ifdef HAS_SHT21
+#if defined HAS_SHT21 || defined HAS_SHT21_BRIGHTNESS || defined HAS_SHT21_ALARM
   #include <SHT21.h>
   SHT21 sensor;
 #endif
 
-// Global Variable used for deep sleep
+#if defined HAS_ALARM || defined HAS_SHT21_ALARM || defined HAS_BME280_ALARM
+  volatile boolean alarm = false;
+
+  // Get the Interrupt Mask for the selected Alarm PIN
+  #if ALARM_PIN == PIN_A0
+    #define ALARM_INT PCINT0
+  #elif ALARM_PIN == PIN_A1
+    #define ALARM_INT PCINT1
+  #elif ALARM_PIN == PIN_A2
+    #define ALARM_INT PCINT2
+  #elif ALARM_PIN == PIN_A3
+    #define ALARM_INT PCINT3
+  #elif ALARM_PIN == PIN_A7
+    #define ALARM_INT PCINT7
+  #elif ALARM_PIN == PIN_B2
+    #define ALARM_INT PCINT9
+  #endif
+#endif
+
+#ifdef DS18B20_PIN
+  #include <OneWire.h> 
+  #include <DallasTemperature.h>
+  OneWire oneWire(DS18B20_PIN);
+  DallasTemperature sensors(&oneWire);
+#endif
+
+// Global Variable to Track Deep Sleep
 uint16_t sleep_interval;
 
+#ifdef LED_PIN
 void blink(uint8_t num) {
   pinMode(LED_PIN, OUTPUT);
   digitalWrite(LED_PIN, 0);
@@ -75,6 +105,34 @@ void blink(uint8_t num) {
   }
   digitalWrite(LED_PIN, 0);
 }
+#endif
+
+
+#if defined HAS_SHT21_BRIGHTNESS || defined HAS_BME280_BRIGHTNESS
+
+int16_t brightness()
+{
+  unsigned int counter;
+  // LED Anode auf OUTPUT/LOW
+  pinMode(LED_A, OUTPUT);
+  digitalWrite(LED_A, LOW);
+
+  // LED Kathode auf OUTPUT/HIGH
+  pinMode(LED_K, OUTPUT);
+  digitalWrite(LED_K, HIGH);
+  delayMicroseconds(4);
+
+  // Kathode wieder auf INPUT
+  pinMode(LED_K,INPUT);
+  digitalWrite(LED_K, LOW);
+  // In einer Schleife zählen, bis Kathode auf LOW geht
+  for ( counter = 0; counter < 65000; counter++) {
+    if (digitalRead(LED_K)==0) break;
+     delayMicroseconds(5);
+  }
+  return counter;
+}
+#endif
 
 // Setup Wakeup Interrupt Timer
 void init_wdt()
@@ -94,6 +152,12 @@ void sleep(uint16_t s)
   s = s/8;
   sleep_interval = 0;
   while (sleep_interval < s) {
+  // in case of alarm, break loop and transmit immediatly
+  #if defined HAS_ALARM || defined HAS_SHT21_ALARM || defined HAS_BME280_ALARM
+    if( alarm == true){
+      return;
+    }
+  #endif
     set_sleep_mode(SLEEP_MODE_PWR_DOWN);
     sleep_mode();
   }
@@ -110,6 +174,18 @@ ISR(WATCHDOG_vect) {
   WDTCSR = (1<<WDIE)|(1<<WDP3)|(1<<WDP0);
 }
 
+#if defined HAS_ALARM || defined HAS_SHT21_ALARM || defined HAS_BME280_ALARM
+// innterrupt handler pin change
+ISR(PCINT0_vect)
+{
+    sleep_disable();
+    #ifdef HAS_LED
+      blink(1);
+    #endif
+    alarm = true;
+}
+
+#endif
 // Get Battery Voltage
 int32_t readVcc() {
   bitClear(PRR, PRADC);
@@ -127,6 +203,22 @@ int32_t readVcc() {
   return result;
 }
 
+// Crude  Wear Leveling Algorithm to Spread the EEPROM Cell Wear Over
+// the first 64 Byte. Using this Method the Theoretical EEPROM Livetime
+// should be around 60 Years at a 10 Minute Sending Interval
+// (100000 Erase Cycles per Cell * 32 Locations / 144 Measurements a day * 365)
+//
+// Returns the Next EEPROM Address for Saving the Frame Counter
+uint8_t calcEepromAddr(uint16_t framecounter) {
+    uint8_t eeprom_addr = ((framecounter%32)*sizeof(framecounter));
+    if (eeprom_addr == 0) {
+      eeprom_addr = 62;
+    } else {
+      eeprom_addr = eeprom_addr-sizeof(framecounter);
+    }
+    return eeprom_addr;
+}
+
 void setup()
 {
   // Initialize Sleep Timer
@@ -137,9 +229,34 @@ void setup()
     // Setup LoraWAN
     rfm.init();
     lora.setKeys(NwkSkey, AppSkey, DevAddr);
+
+    // Get Framecounter from EEPROM
+    // Check if EEPROM is initialized
+    if (EEPROM.read(511) != 0x42) {
+      // Set first 64 byte to 0x00 for the wear leveling hack to work
+      for (int i = 0; i < 64; i++)
+        EEPROM.write(i, 0x00);
+      // Write the magic value so we know it's initialized
+      EEPROM.write(511, 0x42);
+    } else {
+      // Get the Last Saved (=Highest) Frame Counter
+      uint16_t Frame_Counter_Sv = 0x00000000;
+      uint8_t eeprom_addr = 0x0000;
+      EEPROM.get(eeprom_addr, Frame_Counter_Sv);
+      while (eeprom_addr < 32*sizeof(Frame_Counter_Tx)) {
+        if (Frame_Counter_Sv > Frame_Counter_Tx) {
+          Frame_Counter_Tx = Frame_Counter_Sv;
+        } else {
+            break;
+        }
+        eeprom_addr += sizeof(Frame_Counter_Tx);
+        EEPROM.get(eeprom_addr, Frame_Counter_Sv);
+      }
+    }
   #endif
 
   #ifdef RF_RFM69
+    // Setup RFM69 Module
     radio.initialize(RF69_433MHZ,RFM69_NODEID,RFM69_NETWORKID);
     #ifdef RFM69_ENCKEY
       radio.encrypt(RFM69_ENCKEY);
@@ -147,6 +264,18 @@ void setup()
     radio.setPowerLevel(RFM69_TXPOWER);
     radio.sleep();
   #endif
+
+  #if defined HAS_ALARM || defined HAS_SHT21_ALARM || defined HAS_BME280_ALARM
+    MCUCR  = (MCUCR & ~(bit(ISC01)|bit(ISC00))) | bit(ISC01);  // fallende Flanke 
+    GIMSK = (1<<PCIE0);
+    PCMSK0 = (1<<ALARM_INT);
+    pinMode(ALARM_PIN, INPUT_PULLUP);
+  #endif
+
+  #ifdef DS18B20_POWER
+    pinMode(DS18B20_POWER, OUTPUT); // set power pin for DS18B20 to output
+  #endif
+  
   // Setup LED if defined
   #ifdef LED_PIN
     pinMode(LED_PIN, OUTPUT);
@@ -154,50 +283,145 @@ void setup()
   #endif
 }
 
-
 void loop()
 {
-  // Without Sensor (Beacon Mode) just send the Battery Voltage
+  // Create Data Structure for Sensor Data
   #ifdef HAS_NO_SENSOR
-    int32_t data[1];
+    struct lora_data {
+      uint8_t bat;
+    } __attribute__ ((packed)) data; 
+  #elif defined HAS_ALARM
+      struct lora_data {
+      uint8_t bat;
+      uint8_t alarm;
+    } __attribute__ ((packed)) data; 
+  #elif defined HAS_SHT21
+    struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+    } __attribute__ ((packed)) data;
+  #elif defined HAS_SHT21_BRIGHTNESS
+    struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+      int16_t brightness;
+    } __attribute__ ((packed)) data;
+  #elif defined HAS_BME280
+    struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+      int32_t pressure;
+    } __attribute__ ((packed)) data;
+  #elif  defined HAS_BME280_BRIGHTNESS
+    struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+      int32_t pressure;
+      int16_t brightness;
+    } __attribute__ ((packed)) data;
+  #elif defined HAS_SHT21_ALARM
+    struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+      uint8_t alarm;
+    } __attribute__ ((packed)) data;       
+  #elif defined HAS_BME280_ALARM
+      struct lora_data {
+      uint8_t bat;
+      int32_t temperature;
+      int32_t humidity;
+      int32_t pressure;
+      uint8_t alarm;
+    } __attribute__ ((packed)) data;
+  #elif defined DS18B20_PIN
+   struct lora_data {
+      uint8_t bat;
+      uint8_t count; //sensor count
+      int temp1;
+      int temp2;     //fixme dynamic values via count
+    } __attribute__ ((packed)) data; 
   #endif
 
   // Get Sensor Data
-  #ifdef HAS_BME280
-    int32_t data[4] = {0, 0, 0, 0};
-    sensor.getData(&data[0], &data[1], &data[2]);
+  #if defined HAS_BME280 || defined HAS_BME280_BRIGHTNESS || defined HAS_BME280_ALARM
+    sensor.getData(&data.temperature, &data.pressure, &data.humidity);
   #endif
 
-  #ifdef HAS_SHT21
-    int32_t data[4] = {0, 0, 0, 0};
-    data[0] = (int32_t)(sensor.getTemperature()*100);
-    data[2] = (int32_t)(sensor.getHumidity()*100);
+  #if defined HAS_SHT21 || defined HAS_SHT21_BRIGHTNESS || defined HAS_SHT21_ALARM
+    data.temperature = (int32_t)(sensor.getTemperature()*100);
+    data.humidity    = (int32_t)(sensor.getHumidity()*100);
   #endif
   
-  #ifdef HAS_NO_SENSOR
-    data[0] = readVcc();
-  #else
-    data[3] = readVcc();
+  #if defined HAS_SHT21_BRIGHTNESS || defined HAS_BME280_BRIGHTNESS
+    data.brightness = (int16_t)(brightness());
   #endif
 
+  #if defined HAS_ALARM || defined HAS_SHT21_ALARM || defined HAS_BME280_ALARM
+    data.alarm = alarm;
+    alarm = false;
+  #endif
+
+  #if defined DS18B20_PIN
+
+    #ifdef DS18B20_POWER
+      digitalWrite(DS18B20_POWER, HIGH); // turn DS18B20 sensor on
+    #endif
+    delay(100);     // Allow 5ms for the sensor to be ready
+    sensors.begin(); //start up temp sensor
+    delay(100); 
+    data.count = sensors.getDeviceCount();
+    sensors.requestTemperatures(); // Get the temperature
+    data.temp1=(sensors.getTempCByIndex(0)*100); // Read first sensor and convert to integer
+    //Fixme , add more dynamic code 
+    data.temp2=(sensors.getTempCByIndex(1)*100); // Read second sensor and convert to integer
+    #ifdef DS18B20_POWER
+      digitalWrite(DS18B20_POWER, LOW); // turn DS18B20 off
+    #endif
+  #endif
+
+  // Add Battery Voltage, 20mv steps, encoded into 1 Byte
+  uint32_t batv = readVcc();
+  data.bat = (uint8_t)(batv/20);
+  if (batv % 20 > 9)
+    data.bat += 1;
+
   // LED On before Sending
-  #ifdef LED_PIN
+  #ifdef LED_ON_SEND
     digitalWrite(LED_PIN, 1);
   #endif
   
   #ifdef RF_LORA
+    #ifdef HAS_NO_SENSOR
+    // Send Packet in all 6 SFs for Beacon Mode
+    unsigned char Frame_Port =0x07;
+    for  (int i = SF7BW125; i<=SF12BW125; i++) {
+      lora_data tdata = data;
+      // Some FrameCounter Trickery to not write the value to EEPROM 6 Times but still have a working WearLeveling
+      lora.Send_Data((unsigned char *)&tdata, sizeof(tdata), i+(Frame_Counter_Tx*6), static_cast<lora_dr>(i), Frame_Port);
+      Frame_Port++;
+      delay(25);
+    }
+    #else
     // Send LoRa Packet, Increment Frame Counter
-    lora.Send_Data((unsigned char *)data, sizeof(data), Frame_Counter_Tx);
+    lora.Send_Data((unsigned char *)&data, sizeof(data), Frame_Counter_Tx, SF7BW125, 0x01);
+    #endif
+    // Save the next FrameCounter to EEPROM
     Frame_Counter_Tx++;
+    EEPROM.put(calcEepromAddr(Frame_Counter_Tx), Frame_Counter_Tx);
   #endif
 
   #ifdef RF_RFM69
-    radio.send(RFM69_GATEWAY, data, sizeof(data));
+    radio.send(RFM69_GATEWAY, &data, sizeof(data));
     radio.sleep();
   #endif
 
   // Led Off after Sending
-  #ifdef LED_PIN
+  #ifdef LED_ON_SEND
     digitalWrite(LED_PIN, 0);
   #endif
 

Firmware/src/secconfig.example.h

@@ -9,10 +9,41 @@
      #define HAS_NO_SENSOR - No Sensor, just send Battery Voltage (Beacon Mode)
      #define HAS_SHT21  - Sensirion SHT21 Temperature + Humidity Sensor
      #define HAS_BME280 - Bosch BME280 Temperature + Humidity + Pressure Sensor
+     #define HAS_SHT21_BRIGHTNESS  - SHT21 + Brightness via LED
+     #define HAS_BME280_BRIGHTNESS - BME280 + Brightness via LED
+     #define HAS_ALARM - send message when pin is triggered
+     #define HAS_SHT21_ALARM - combined Sensor with SHT21 and Alarm trigger
+     #define HAS_BME280_ALARM - combined Sensor with BME280 and Alarm trigger
 
    * LED Support
      #define LED_PIN PIN_A7 - LED is connected to ATTiny84 Pin A7 on TinyTX SMD / TinyLora
 
+   * Brightness Measurement
+     LED connected between 2 pins, switched in reverse direction for brightness measurement
+     #define LED_K PIN_A7 - LED Cathode
+     #define LED_A PIN_B2 - LED Anode
+
+   * Alarm
+     #define ALARM_PIN PIN_A0 - The pin defined here will trigger an immideate send if pulled low.
+
+   * DS18B20 
+     Attention!
+     If you want to use DS18B20 sensors, the Onewire Library requires a clock frequency of 8MHz. 
+     The value in platformio.ini must be adjusted accordingly
+
+     DS18B20 minimum operating voltage is 3V.
+     CR2032 may not be sufficient to operate the sensor.
+     Use a 3.6 V power supply if necessary
+
+     #define	DS18B20_PIN	PIN_A0 - DS18B20 Temperature sensor(s) connected on D10/ATtiny pin13  
+     
+     Currently 2 sensors are implemented, for more sensors either copy the lines or improve the code 
+     in main.cpp
+     
+     If you want to turn your sensor(s) on and off connect Vdd Pin of DS18B20 with Pin defined here
+     #define	DS18B20_POWER PIN_A1 - DS18B20 Power pin is connected on D9/ATtiny pin 12
+
+    
    * Time between Measurements
      #define SLEEP_TIME 528 - Time in Seconds between Measurements. Try it out to get a good Approximation
      Examples from my Tests::
@@ -24,8 +55,9 @@
 
 
 // LoRa RFM95 + SHT21, LED on Pin A7
+
   #define RF_LORA
-  #define HAS_SHT21
+  #define HAS_SHT32
   #define LED_PIN PIN_A7
   #define SLEEP_TIME 544
   // Information from The Things Network, device configuration ACTIVATION METHOD: ABP, msb left
@@ -33,6 +65,7 @@
   unsigned char AppSkey[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
   unsigned char DevAddr[4] = { 0x00, 0x00, 0x00, 0x00 };
 
+
 /* RFM69 + BME280, LED on Pin A7
   #define RF_RFM69
   #define HAS_BME280
@@ -43,3 +76,30 @@
   #define RFM69_TXPOWER    31 // Transmitting Power 0-31, see datasheet for details
   #define RFM69_ENCKEY    "0123456789ABCDEF" // AES encryption key, exactly 16 characters, if set messages will be encrypted using AES 128bit
 */
+
+/*
+// LoRa RFM95 + BME280 + Brightness Measurement
+  #define RF_LORA
+  #define HAS_BME280_BRIGHTNESS
+  #define LED_K PIN_A7
+  #define LED_A PIN_B2
+  #define SLEEP_TIME 544
+  */
+
+/*
+// LoRa RFM95 + Alarm
+  #define RF_LORA
+  #define HAS_ALARM
+  #define ALARM_PIN PIN_A0
+  #define LED_PIN PIN_A7
+  #define SLEEP_TIME 544 
+  */
+
+ // Lora RFM95 + DS18B20
+ /*
+  #define RF_LORA
+  #define LED_PIN PIN_A7
+  #define	DS18B20_PIN	PIN_A0 // DS18B20 Temperature sensor(s) connected on D10/ATtiny pin13  
+  #define	DS18B20_POWER PIN_A1  // DS18B20 Power pin(s) connected on D9/ATtiny pin 12
+  #define SLEEP_TIME 544
+*/

PCB_SMD/Gerber_V2/LORA_ATTINY84-B_Mask.gbs

@@ -0,0 +1,197 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Soldermask,Bot*
+G04 #@! TF.FilePolarity,Negative*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+%ADD10O,1.802000X1.802000*%
+G04 APERTURE END LIST*
+G36*
+G01*
+X87436200Y-79383601D02*
+X87436200Y-77283599D01*
+G75*
+G02*
+X87487199Y-77232600I50999J0D01*
+G01*
+X88687201Y-77232600D01*
+G75*
+G02*
+X88738200Y-77283599I0J-50999D01*
+G01*
+X88738200Y-79383601D01*
+G75*
+G02*
+X88687201Y-79434600I-50999J0D01*
+G01*
+X87487199Y-79434600D01*
+G75*
+G02*
+X87436200Y-79383601I0J50999D01*
+G01*
+G37*
+G36*
+G01*
+X90186200Y-79443000D02*
+X90186200Y-75243000D01*
+G75*
+G02*
+X90237200Y-75192000I51000J0D01*
+G01*
+X91587200Y-75192000D01*
+G75*
+G02*
+X91638200Y-75243000I0J-51000D01*
+G01*
+X91638200Y-79443000D01*
+G75*
+G02*
+X91587200Y-79494000I-51000J0D01*
+G01*
+X90237200Y-79494000D01*
+G75*
+G02*
+X90186200Y-79443000I0J51000D01*
+G01*
+G37*
+G36*
+G01*
+X84536200Y-79443000D02*
+X84536200Y-75243000D01*
+G75*
+G02*
+X84587200Y-75192000I51000J0D01*
+G01*
+X85937200Y-75192000D01*
+G75*
+G02*
+X85988200Y-75243000I0J-51000D01*
+G01*
+X85988200Y-79443000D01*
+G75*
+G02*
+X85937200Y-79494000I-51000J0D01*
+G01*
+X84587200Y-79494000D01*
+G75*
+G02*
+X84536200Y-79443000I0J51000D01*
+G01*
+G37*
+G36*
+G01*
+X78863600Y-54045400D02*
+X75263600Y-54045400D01*
+G75*
+G02*
+X75212600Y-53994400I0J51000D01*
+G01*
+X75212600Y-46894400D01*
+G75*
+G02*
+X75263600Y-46843400I51000J0D01*
+G01*
+X78863600Y-46843400D01*
+G75*
+G02*
+X78914600Y-46894400I0J-51000D01*
+G01*
+X78914600Y-53994400D01*
+G75*
+G02*
+X78863600Y-54045400I-51000J0D01*
+G01*
+G37*
+G36*
+G01*
+X78863600Y-78937400D02*
+X75263600Y-78937400D01*
+G75*
+G02*
+X75212600Y-78886400I0J51000D01*
+G01*
+X75212600Y-71786400D01*
+G75*
+G02*
+X75263600Y-71735400I51000J0D01*
+G01*
+X78863600Y-71735400D01*
+G75*
+G02*
+X78914600Y-71786400I0J-51000D01*
+G01*
+X78914600Y-78886400D01*
+G75*
+G02*
+X78863600Y-78937400I-51000J0D01*
+G01*
+G37*
+D10*
+X84378800Y-50596800D03*
+X84378800Y-48056800D03*
+X86918800Y-50596800D03*
+X86918800Y-48056800D03*
+X89458800Y-50596800D03*
+G36*
+G01*
+X88608800Y-47155800D02*
+X90308800Y-47155800D01*
+G75*
+G02*
+X90359800Y-47206800I0J-51000D01*
+G01*
+X90359800Y-48906800D01*
+G75*
+G02*
+X90308800Y-48957800I-51000J0D01*
+G01*
+X88608800Y-48957800D01*
+G75*
+G02*
+X88557800Y-48906800I0J51000D01*
+G01*
+X88557800Y-47206800D01*
+G75*
+G02*
+X88608800Y-47155800I51000J0D01*
+G01*
+G37*
+X89458800Y-54381400D03*
+X89458800Y-56921400D03*
+X89458800Y-59461400D03*
+X89458800Y-62001400D03*
+X89458800Y-64541400D03*
+X89458800Y-67081400D03*
+X89458800Y-69621400D03*
+G36*
+G01*
+X90359800Y-71311400D02*
+X90359800Y-73011400D01*
+G75*
+G02*
+X90308800Y-73062400I-51000J0D01*
+G01*
+X88608800Y-73062400D01*
+G75*
+G02*
+X88557800Y-73011400I0J51000D01*
+G01*
+X88557800Y-71311400D01*
+G75*
+G02*
+X88608800Y-71260400I51000J0D01*
+G01*
+X90308800Y-71260400D01*
+G75*
+G02*
+X90359800Y-71311400I0J-51000D01*
+G01*
+G37*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84-B_Paste.gbp

@@ -0,0 +1,23 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Paste,Bot*
+G04 #@! TF.FilePolarity,Positive*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+%ADD10R,1.350000X4.200000*%
+%ADD11R,3.600000X7.100000*%
+G04 APERTURE END LIST*
+D10*
+X90912200Y-77343000D03*
+X85262200Y-77343000D03*
+D11*
+X77063600Y-50444400D03*
+X77063600Y-75336400D03*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84-B_SilkS.gbo

@@ -0,0 +1,483 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Legend,Bot*
+G04 #@! TF.FilePolarity,Positive*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+%ADD10C,0.150000*%
+%ADD11C,0.120000*%
+%ADD12C,0.100000*%
+%ADD13O,1.802000X1.802000*%
+G04 APERTURE END LIST*
+D10*
+X67603714Y-57515714D02*
+X68270380Y-57706190D01*
+X67794190Y-57896666D01*
+X68270380Y-58087142D01*
+X67603714Y-58277619D01*
+X67603714Y-58563333D02*
+X68270380Y-58753809D01*
+X67794190Y-58944285D01*
+X68270380Y-59134761D01*
+X67603714Y-59325238D01*
+X67603714Y-59610952D02*
+X68270380Y-59801428D01*
+X67794190Y-59991904D01*
+X68270380Y-60182380D01*
+X67603714Y-60372857D01*
+X68175142Y-60753809D02*
+X68222761Y-60801428D01*
+X68270380Y-60753809D01*
+X68222761Y-60706190D01*
+X68175142Y-60753809D01*
+X68270380Y-60753809D01*
+X68270380Y-61658571D02*
+X67746571Y-61658571D01*
+X67651333Y-61610952D01*
+X67603714Y-61515714D01*
+X67603714Y-61325238D01*
+X67651333Y-61230000D01*
+X68222761Y-61658571D02*
+X68270380Y-61563333D01*
+X68270380Y-61325238D01*
+X68222761Y-61230000D01*
+X68127523Y-61182380D01*
+X68032285Y-61182380D01*
+X67937047Y-61230000D01*
+X67889428Y-61325238D01*
+X67889428Y-61563333D01*
+X67841809Y-61658571D01*
+X67603714Y-61991904D02*
+X67603714Y-62372857D01*
+X67270380Y-62134761D02*
+X68127523Y-62134761D01*
+X68222761Y-62182380D01*
+X68270380Y-62277619D01*
+X68270380Y-62372857D01*
+X67603714Y-62563333D02*
+X67603714Y-62944285D01*
+X67270380Y-62706190D02*
+X68127523Y-62706190D01*
+X68222761Y-62753809D01*
+X68270380Y-62849047D01*
+X68270380Y-62944285D01*
+X67603714Y-63277619D02*
+X68270380Y-63277619D01*
+X67698952Y-63277619D02*
+X67651333Y-63325238D01*
+X67603714Y-63420476D01*
+X67603714Y-63563333D01*
+X67651333Y-63658571D01*
+X67746571Y-63706190D01*
+X68270380Y-63706190D01*
+X68270380Y-64325238D02*
+X68222761Y-64230000D01*
+X68175142Y-64182380D01*
+X68079904Y-64134761D01*
+X67794190Y-64134761D01*
+X67698952Y-64182380D01*
+X67651333Y-64230000D01*
+X67603714Y-64325238D01*
+X67603714Y-64468095D01*
+X67651333Y-64563333D01*
+X67698952Y-64610952D01*
+X67794190Y-64658571D01*
+X68079904Y-64658571D01*
+X68175142Y-64610952D01*
+X68222761Y-64563333D01*
+X68270380Y-64468095D01*
+X68270380Y-64325238D01*
+X68175142Y-65087142D02*
+X68222761Y-65134761D01*
+X68270380Y-65087142D01*
+X68222761Y-65039523D01*
+X68175142Y-65087142D01*
+X68270380Y-65087142D01*
+X68270380Y-65991904D02*
+X67270380Y-65991904D01*
+X68222761Y-65991904D02*
+X68270380Y-65896666D01*
+X68270380Y-65706190D01*
+X68222761Y-65610952D01*
+X68175142Y-65563333D01*
+X68079904Y-65515714D01*
+X67794190Y-65515714D01*
+X67698952Y-65563333D01*
+X67651333Y-65610952D01*
+X67603714Y-65706190D01*
+X67603714Y-65896666D01*
+X67651333Y-65991904D01*
+X68222761Y-66849047D02*
+X68270380Y-66753809D01*
+X68270380Y-66563333D01*
+X68222761Y-66468095D01*
+X68127523Y-66420476D01*
+X67746571Y-66420476D01*
+X67651333Y-66468095D01*
+X67603714Y-66563333D01*
+X67603714Y-66753809D01*
+X67651333Y-66849047D01*
+X67746571Y-66896666D01*
+X67841809Y-66896666D01*
+X67937047Y-66420476D01*
+X76541380Y-58499952D02*
+X77255666Y-58499952D01*
+X77398523Y-58452333D01*
+X77493761Y-58357095D01*
+X77541380Y-58214238D01*
+X77541380Y-58119000D01*
+X77541380Y-59452333D02*
+X77541380Y-58976142D01*
+X76541380Y-58976142D01*
+X77446142Y-60357095D02*
+X77493761Y-60309476D01*
+X77541380Y-60166619D01*
+X77541380Y-60071380D01*
+X77493761Y-59928523D01*
+X77398523Y-59833285D01*
+X77303285Y-59785666D01*
+X77112809Y-59738047D01*
+X76969952Y-59738047D01*
+X76779476Y-59785666D01*
+X76684238Y-59833285D01*
+X76589000Y-59928523D01*
+X76541380Y-60071380D01*
+X76541380Y-60166619D01*
+X76589000Y-60309476D01*
+X76636619Y-60357095D01*
+X76541380Y-61071380D02*
+X77255666Y-61071380D01*
+X77398523Y-61023761D01*
+X77493761Y-60928523D01*
+X77541380Y-60785666D01*
+X77541380Y-60690428D01*
+X77541380Y-62023761D02*
+X77541380Y-61547571D01*
+X76541380Y-61547571D01*
+X77446142Y-62928523D02*
+X77493761Y-62880904D01*
+X77541380Y-62738047D01*
+X77541380Y-62642809D01*
+X77493761Y-62499952D01*
+X77398523Y-62404714D01*
+X77303285Y-62357095D01*
+X77112809Y-62309476D01*
+X76969952Y-62309476D01*
+X76779476Y-62357095D01*
+X76684238Y-62404714D01*
+X76589000Y-62499952D01*
+X76541380Y-62642809D01*
+X76541380Y-62738047D01*
+X76589000Y-62880904D01*
+X76636619Y-62928523D01*
+X76541380Y-63642809D02*
+X77255666Y-63642809D01*
+X77398523Y-63595190D01*
+X77493761Y-63499952D01*
+X77541380Y-63357095D01*
+X77541380Y-63261857D01*
+X77541380Y-64595190D02*
+X77541380Y-64119000D01*
+X76541380Y-64119000D01*
+X77446142Y-65499952D02*
+X77493761Y-65452333D01*
+X77541380Y-65309476D01*
+X77541380Y-65214238D01*
+X77493761Y-65071380D01*
+X77398523Y-64976142D01*
+X77303285Y-64928523D01*
+X77112809Y-64880904D01*
+X76969952Y-64880904D01*
+X76779476Y-64928523D01*
+X76684238Y-64976142D01*
+X76589000Y-65071380D01*
+X76541380Y-65214238D01*
+X76541380Y-65309476D01*
+X76589000Y-65452333D01*
+X76636619Y-65499952D01*
+X76541380Y-66214238D02*
+X77255666Y-66214238D01*
+X77398523Y-66166619D01*
+X77493761Y-66071380D01*
+X77541380Y-65928523D01*
+X77541380Y-65833285D01*
+X77541380Y-67166619D02*
+X77541380Y-66690428D01*
+X76541380Y-66690428D01*
+X77446142Y-68071380D02*
+X77493761Y-68023761D01*
+X77541380Y-67880904D01*
+X77541380Y-67785666D01*
+X77493761Y-67642809D01*
+X77398523Y-67547571D01*
+X77303285Y-67499952D01*
+X77112809Y-67452333D01*
+X76969952Y-67452333D01*
+X76779476Y-67499952D01*
+X76684238Y-67547571D01*
+X76589000Y-67642809D01*
+X76541380Y-67785666D01*
+X76541380Y-67880904D01*
+X76589000Y-68023761D01*
+X76636619Y-68071380D01*
+D11*
+X82610960Y-50905160D02*
+X82610960Y-48905160D01*
+X81591400Y-49916080D02*
+X83591400Y-49916080D01*
+X68713600Y-74240400D02*
+X73213600Y-74240400D01*
+X68713600Y-51540400D02*
+X73213600Y-51540400D01*
+X68713600Y-51540400D02*
+X68713600Y-74240400D01*
+X73213600Y-77440400D02*
+X74763600Y-77440400D01*
+X73213600Y-74240400D02*
+X73213600Y-77440400D01*
+X73213600Y-48340400D02*
+X74763600Y-48340400D01*
+X73213600Y-51540400D02*
+X73213600Y-48340400D01*
+X80913600Y-48340400D02*
+X79363600Y-48340400D01*
+X80913600Y-51540400D02*
+X80913600Y-48340400D01*
+X85413600Y-53340400D02*
+X83613600Y-51540400D01*
+X83613600Y-51540400D02*
+X80913600Y-51540400D01*
+X85413600Y-74240400D02*
+X85413600Y-53340400D01*
+X85413600Y-74240400D02*
+X80913600Y-74240400D01*
+X80913600Y-77440400D02*
+X79363600Y-77440400D01*
+X80913600Y-74240400D02*
+X80913600Y-77440400D01*
+D12*
+X71812028Y-49371257D02*
+X71697742Y-49409352D01*
+X71659647Y-49447447D01*
+X71621552Y-49523638D01*
+X71621552Y-49637923D01*
+X71659647Y-49714114D01*
+X71697742Y-49752209D01*
+X71773933Y-49790304D01*
+X72078695Y-49790304D01*
+X72078695Y-48990304D01*
+X71812028Y-48990304D01*
+X71735838Y-49028400D01*
+X71697742Y-49066495D01*
+X71659647Y-49142685D01*
+X71659647Y-49218876D01*
+X71697742Y-49295066D01*
+X71735838Y-49333161D01*
+X71812028Y-49371257D01*
+X72078695Y-49371257D01*
+X71316790Y-49561733D02*
+X70935838Y-49561733D01*
+X71392980Y-49790304D02*
+X71126314Y-48990304D01*
+X70859647Y-49790304D01*
+X70707266Y-48990304D02*
+X70250123Y-48990304D01*
+X70478695Y-49790304D02*
+X70478695Y-48990304D01*
+X69564409Y-49790304D02*
+X70021552Y-49790304D01*
+X69792980Y-49790304D02*
+X69792980Y-48990304D01*
+X69869171Y-49104590D01*
+X69945361Y-49180780D01*
+X70021552Y-49218876D01*
+%LPC*%
+G36*
+G01*
+X87436200Y-79383601D02*
+X87436200Y-77283599D01*
+G75*
+G02*
+X87487199Y-77232600I50999J0D01*
+G01*
+X88687201Y-77232600D01*
+G75*
+G02*
+X88738200Y-77283599I0J-50999D01*
+G01*
+X88738200Y-79383601D01*
+G75*
+G02*
+X88687201Y-79434600I-50999J0D01*
+G01*
+X87487199Y-79434600D01*
+G75*
+G02*
+X87436200Y-79383601I0J50999D01*
+G01*
+G37*
+G36*
+G01*
+X90186200Y-79443000D02*
+X90186200Y-75243000D01*
+G75*
+G02*
+X90237200Y-75192000I51000J0D01*
+G01*
+X91587200Y-75192000D01*
+G75*
+G02*
+X91638200Y-75243000I0J-51000D01*
+G01*
+X91638200Y-79443000D01*
+G75*
+G02*
+X91587200Y-79494000I-51000J0D01*
+G01*
+X90237200Y-79494000D01*
+G75*
+G02*
+X90186200Y-79443000I0J51000D01*
+G01*
+G37*
+G36*
+G01*
+X84536200Y-79443000D02*
+X84536200Y-75243000D01*
+G75*
+G02*
+X84587200Y-75192000I51000J0D01*
+G01*
+X85937200Y-75192000D01*
+G75*
+G02*
+X85988200Y-75243000I0J-51000D01*
+G01*
+X85988200Y-79443000D01*
+G75*
+G02*
+X85937200Y-79494000I-51000J0D01*
+G01*
+X84587200Y-79494000D01*
+G75*
+G02*
+X84536200Y-79443000I0J51000D01*
+G01*
+G37*
+G36*
+G01*
+X78863600Y-54045400D02*
+X75263600Y-54045400D01*
+G75*
+G02*
+X75212600Y-53994400I0J51000D01*
+G01*
+X75212600Y-46894400D01*
+G75*
+G02*
+X75263600Y-46843400I51000J0D01*
+G01*
+X78863600Y-46843400D01*
+G75*
+G02*
+X78914600Y-46894400I0J-51000D01*
+G01*
+X78914600Y-53994400D01*
+G75*
+G02*
+X78863600Y-54045400I-51000J0D01*
+G01*
+G37*
+G36*
+G01*
+X78863600Y-78937400D02*
+X75263600Y-78937400D01*
+G75*
+G02*
+X75212600Y-78886400I0J51000D01*
+G01*
+X75212600Y-71786400D01*
+G75*
+G02*
+X75263600Y-71735400I51000J0D01*
+G01*
+X78863600Y-71735400D01*
+G75*
+G02*
+X78914600Y-71786400I0J-51000D01*
+G01*
+X78914600Y-78886400D01*
+G75*
+G02*
+X78863600Y-78937400I-51000J0D01*
+G01*
+G37*
+D13*
+X84378800Y-50596800D03*
+X84378800Y-48056800D03*
+X86918800Y-50596800D03*
+X86918800Y-48056800D03*
+X89458800Y-50596800D03*
+G36*
+G01*
+X88608800Y-47155800D02*
+X90308800Y-47155800D01*
+G75*
+G02*
+X90359800Y-47206800I0J-51000D01*
+G01*
+X90359800Y-48906800D01*
+G75*
+G02*
+X90308800Y-48957800I-51000J0D01*
+G01*
+X88608800Y-48957800D01*
+G75*
+G02*
+X88557800Y-48906800I0J51000D01*
+G01*
+X88557800Y-47206800D01*
+G75*
+G02*
+X88608800Y-47155800I51000J0D01*
+G01*
+G37*
+X89458800Y-54381400D03*
+X89458800Y-56921400D03*
+X89458800Y-59461400D03*
+X89458800Y-62001400D03*
+X89458800Y-64541400D03*
+X89458800Y-67081400D03*
+X89458800Y-69621400D03*
+G36*
+G01*
+X90359800Y-71311400D02*
+X90359800Y-73011400D01*
+G75*
+G02*
+X90308800Y-73062400I-51000J0D01*
+G01*
+X88608800Y-73062400D01*
+G75*
+G02*
+X88557800Y-73011400I0J51000D01*
+G01*
+X88557800Y-71311400D01*
+G75*
+G02*
+X88608800Y-71260400I51000J0D01*
+G01*
+X90308800Y-71260400D01*
+G75*
+G02*
+X90359800Y-71311400I0J-51000D01*
+G01*
+G37*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84-Edge_Cuts.gm1

@@ -0,0 +1,34 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Profile,NP*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+G04 #@! TA.AperFunction,Profile*
+%ADD10C,0.050000*%
+G04 #@! TD*
+G04 APERTURE END LIST*
+D10*
+X92075000Y-79476600D02*
+X66065400Y-79476600D01*
+X66040000Y-45745400D02*
+X66040000Y-45897800D01*
+X92100400Y-45745400D02*
+X66040000Y-45745400D01*
+X92100400Y-45872400D02*
+X92100400Y-45745400D01*
+X66040000Y-45897800D02*
+X66040000Y-46228000D01*
+X92100400Y-46228000D02*
+X92100400Y-45872400D01*
+X92100400Y-46228000D02*
+X92075000Y-79476600D01*
+X66040000Y-46228000D02*
+X66065400Y-79476600D01*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84-F_Mask.gts

@@ -0,0 +1,887 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Soldermask,Top*
+G04 #@! TF.FilePolarity,Negative*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+%ADD10C,0.100000*%
+%ADD11O,1.802000X1.802000*%
+%ADD12O,2.102000X1.102000*%
+G04 APERTURE END LIST*
+G36*
+G01*
+X87436200Y-79383601D02*
+X87436200Y-77283599D01*
+G75*
+G02*
+X87487199Y-77232600I50999J0D01*
+G01*
+X88687201Y-77232600D01*
+G75*
+G02*
+X88738200Y-77283599I0J-50999D01*
+G01*
+X88738200Y-79383601D01*
+G75*
+G02*
+X88687201Y-79434600I-50999J0D01*
+G01*
+X87487199Y-79434600D01*
+G75*
+G02*
+X87436200Y-79383601I0J50999D01*
+G01*
+G37*
+D10*
+G36*
+X91591597Y-75187045D02*
+G01*
+X91592572Y-75187141D01*
+X91602401Y-75189099D01*
+X91603339Y-75189384D01*
+X91612540Y-75193195D01*
+X91613405Y-75193657D01*
+X91621699Y-75199192D01*
+X91622457Y-75199813D01*
+X91629587Y-75206943D01*
+X91630208Y-75207701D01*
+X91635743Y-75215995D01*
+X91636205Y-75216860D01*
+X91640016Y-75226061D01*
+X91640301Y-75226999D01*
+X91642259Y-75236828D01*
+X91642355Y-75237803D01*
+X91642600Y-75242800D01*
+X91642600Y-79442800D01*
+X91642355Y-79447797D01*
+X91642259Y-79448772D01*
+X91640301Y-79458601D01*
+X91640016Y-79459539D01*
+X91636205Y-79468740D01*
+X91635743Y-79469605D01*
+X91630208Y-79477899D01*
+X91629587Y-79478657D01*
+X91622457Y-79485787D01*
+X91621699Y-79486408D01*
+X91613405Y-79491943D01*
+X91612540Y-79492405D01*
+X91603339Y-79496216D01*
+X91602401Y-79496501D01*
+X91592572Y-79498459D01*
+X91591597Y-79498555D01*
+X91586600Y-79498800D01*
+X90236600Y-79498800D01*
+X90231603Y-79498555D01*
+X90230628Y-79498459D01*
+X90220799Y-79496501D01*
+X90219861Y-79496216D01*
+X90210660Y-79492405D01*
+X90209795Y-79491943D01*
+X90201501Y-79486408D01*
+X90200743Y-79485787D01*
+X90193613Y-79478657D01*
+X90192992Y-79477899D01*
+X90187457Y-79469605D01*
+X90186995Y-79468740D01*
+X90183184Y-79459539D01*
+X90182899Y-79458601D01*
+X90180941Y-79448772D01*
+X90180845Y-79447797D01*
+X90180600Y-79442800D01*
+X90180600Y-77298800D01*
+X89136600Y-77298800D01*
+X89131603Y-77298555D01*
+X89130628Y-77298459D01*
+X89120799Y-77296501D01*
+X89119861Y-77296216D01*
+X89110660Y-77292405D01*
+X89109795Y-77291943D01*
+X89101501Y-77286408D01*
+X89100743Y-77285787D01*
+X89093613Y-77278657D01*
+X89092992Y-77277899D01*
+X89087457Y-77269605D01*
+X89086995Y-77268740D01*
+X89083184Y-77259539D01*
+X89082899Y-77258601D01*
+X89080941Y-77248772D01*
+X89080845Y-77247797D01*
+X89080600Y-77242800D01*
+X89080600Y-75242800D01*
+X89080845Y-75237803D01*
+X89080941Y-75236828D01*
+X89082899Y-75226999D01*
+X89083184Y-75226061D01*
+X89086995Y-75216860D01*
+X89087457Y-75215995D01*
+X89092992Y-75207701D01*
+X89093613Y-75206943D01*
+X89100743Y-75199813D01*
+X89101501Y-75199192D01*
+X89109795Y-75193657D01*
+X89110660Y-75193195D01*
+X89119861Y-75189384D01*
+X89120799Y-75189099D01*
+X89130628Y-75187141D01*
+X89131603Y-75187045D01*
+X89136600Y-75186800D01*
+X91586600Y-75186800D01*
+X91591597Y-75187045D01*
+G37*
+G36*
+X87039917Y-75187045D02*
+G01*
+X87040892Y-75187141D01*
+X87050721Y-75189099D01*
+X87051659Y-75189384D01*
+X87060860Y-75193195D01*
+X87061725Y-75193657D01*
+X87070019Y-75199192D01*
+X87070777Y-75199813D01*
+X87077907Y-75206943D01*
+X87078528Y-75207701D01*
+X87084063Y-75215995D01*
+X87084525Y-75216860D01*
+X87088336Y-75226061D01*
+X87088621Y-75226999D01*
+X87090579Y-75236828D01*
+X87090675Y-75237803D01*
+X87090920Y-75242800D01*
+X87090920Y-77242800D01*
+X87090675Y-77247797D01*
+X87090579Y-77248772D01*
+X87088621Y-77258601D01*
+X87088336Y-77259539D01*
+X87084525Y-77268740D01*
+X87084063Y-77269605D01*
+X87078528Y-77277899D01*
+X87077907Y-77278657D01*
+X87070777Y-77285787D01*
+X87070019Y-77286408D01*
+X87061725Y-77291943D01*
+X87060860Y-77292405D01*
+X87051659Y-77296216D01*
+X87050721Y-77296501D01*
+X87040892Y-77298459D01*
+X87039917Y-77298555D01*
+X87034920Y-77298800D01*
+X85990920Y-77298800D01*
+X85990920Y-79442800D01*
+X85990675Y-79447797D01*
+X85990579Y-79448772D01*
+X85988621Y-79458601D01*
+X85988336Y-79459539D01*
+X85984525Y-79468740D01*
+X85984063Y-79469605D01*
+X85978528Y-79477899D01*
+X85977907Y-79478657D01*
+X85970777Y-79485787D01*
+X85970019Y-79486408D01*
+X85961725Y-79491943D01*
+X85960860Y-79492405D01*
+X85951659Y-79496216D01*
+X85950721Y-79496501D01*
+X85940892Y-79498459D01*
+X85939917Y-79498555D01*
+X85934920Y-79498800D01*
+X84584920Y-79498800D01*
+X84579923Y-79498555D01*
+X84578948Y-79498459D01*
+X84569119Y-79496501D01*
+X84568181Y-79496216D01*
+X84558980Y-79492405D01*
+X84558115Y-79491943D01*
+X84549821Y-79486408D01*
+X84549063Y-79485787D01*
+X84541933Y-79478657D01*
+X84541312Y-79477899D01*
+X84535777Y-79469605D01*
+X84535315Y-79468740D01*
+X84531504Y-79459539D01*
+X84531219Y-79458601D01*
+X84529261Y-79448772D01*
+X84529165Y-79447797D01*
+X84528920Y-79442800D01*
+X84528920Y-75242800D01*
+X84529165Y-75237803D01*
+X84529261Y-75236828D01*
+X84531219Y-75226999D01*
+X84531504Y-75226061D01*
+X84535315Y-75216860D01*
+X84535777Y-75215995D01*
+X84541312Y-75207701D01*
+X84541933Y-75206943D01*
+X84549063Y-75199813D01*
+X84549821Y-75199192D01*
+X84558115Y-75193657D01*
+X84558980Y-75193195D01*
+X84568181Y-75189384D01*
+X84569119Y-75189099D01*
+X84578948Y-75187141D01*
+X84579923Y-75187045D01*
+X84584920Y-75186800D01*
+X87034920Y-75186800D01*
+X87039917Y-75187045D01*
+G37*
+G36*
+G01*
+X70740700Y-76756506D02*
+X70740700Y-75440294D01*
+G75*
+G02*
+X71008594Y-75172400I267894J0D01*
+G01*
+X71999806Y-75172400D01*
+G75*
+G02*
+X72267700Y-75440294I0J-267894D01*
+G01*
+X72267700Y-76756506D01*
+G75*
+G02*
+X71999806Y-77024400I-267894J0D01*
+G01*
+X71008594Y-77024400D01*
+G75*
+G02*
+X70740700Y-76756506I0J267894D01*
+G01*
+G37*
+G36*
+G01*
+X67765700Y-76756506D02*
+X67765700Y-75440294D01*
+G75*
+G02*
+X68033594Y-75172400I267894J0D01*
+G01*
+X69024806Y-75172400D01*
+G75*
+G02*
+X69292700Y-75440294I0J-267894D01*
+G01*
+X69292700Y-76756506D01*
+G75*
+G02*
+X69024806Y-77024400I-267894J0D01*
+G01*
+X68033594Y-77024400D01*
+G75*
+G02*
+X67765700Y-76756506I0J267894D01*
+G01*
+G37*
+G36*
+G01*
+X75120400Y-75414894D02*
+X75120400Y-76731106D01*
+G75*
+G02*
+X74852506Y-76999000I-267894J0D01*
+G01*
+X73861294Y-76999000D01*
+G75*
+G02*
+X73593400Y-76731106I0J267894D01*
+G01*
+X73593400Y-75414894D01*
+G75*
+G02*
+X73861294Y-75147000I267894J0D01*
+G01*
+X74852506Y-75147000D01*
+G75*
+G02*
+X75120400Y-75414894I0J-267894D01*
+G01*
+G37*
+G36*
+G01*
+X78095400Y-75414894D02*
+X78095400Y-76731106D01*
+G75*
+G02*
+X77827506Y-76999000I-267894J0D01*
+G01*
+X76836294Y-76999000D01*
+G75*
+G02*
+X76568400Y-76731106I0J267894D01*
+G01*
+X76568400Y-75414894D01*
+G75*
+G02*
+X76836294Y-75147000I267894J0D01*
+G01*
+X77827506Y-75147000D01*
+G75*
+G02*
+X78095400Y-75414894I0J-267894D01*
+G01*
+G37*
+G36*
+G01*
+X69253000Y-53697894D02*
+X69253000Y-55014106D01*
+G75*
+G02*
+X68985106Y-55282000I-267894J0D01*
+G01*
+X67993894Y-55282000D01*
+G75*
+G02*
+X67726000Y-55014106I0J267894D01*
+G01*
+X67726000Y-53697894D01*
+G75*
+G02*
+X67993894Y-53430000I267894J0D01*
+G01*
+X68985106Y-53430000D01*
+G75*
+G02*
+X69253000Y-53697894I0J-267894D01*
+G01*
+G37*
+G36*
+G01*
+X72228000Y-53697894D02*
+X72228000Y-55014106D01*
+G75*
+G02*
+X71960106Y-55282000I-267894J0D01*
+G01*
+X70968894Y-55282000D01*
+G75*
+G02*
+X70701000Y-55014106I0J267894D01*
+G01*
+X70701000Y-53697894D01*
+G75*
+G02*
+X70968894Y-53430000I267894J0D01*
+G01*
+X71960106Y-53430000D01*
+G75*
+G02*
+X72228000Y-53697894I0J-267894D01*
+G01*
+G37*
+D11*
+X84378800Y-50596800D03*
+X84378800Y-48056800D03*
+X86918800Y-50596800D03*
+X86918800Y-48056800D03*
+X89458800Y-50596800D03*
+G36*
+G01*
+X88608800Y-47155800D02*
+X90308800Y-47155800D01*
+G75*
+G02*
+X90359800Y-47206800I0J-51000D01*
+G01*
+X90359800Y-48906800D01*
+G75*
+G02*
+X90308800Y-48957800I-51000J0D01*
+G01*
+X88608800Y-48957800D01*
+G75*
+G02*
+X88557800Y-48906800I0J51000D01*
+G01*
+X88557800Y-47206800D01*
+G75*
+G02*
+X88608800Y-47155800I51000J0D01*
+G01*
+G37*
+X89458800Y-54381400D03*
+X89458800Y-56921400D03*
+X89458800Y-59461400D03*
+X89458800Y-62001400D03*
+X89458800Y-64541400D03*
+X89458800Y-67081400D03*
+X89458800Y-69621400D03*
+G36*
+G01*
+X90359800Y-71311400D02*
+X90359800Y-73011400D01*
+G75*
+G02*
+X90308800Y-73062400I-51000J0D01*
+G01*
+X88608800Y-73062400D01*
+G75*
+G02*
+X88557800Y-73011400I0J51000D01*
+G01*
+X88557800Y-71311400D01*
+G75*
+G02*
+X88608800Y-71260400I51000J0D01*
+G01*
+X90308800Y-71260400D01*
+G75*
+G02*
+X90359800Y-71311400I0J-51000D01*
+G01*
+G37*
+G36*
+G01*
+X69253000Y-50611794D02*
+X69253000Y-51928006D01*
+G75*
+G02*
+X68985106Y-52195900I-267894J0D01*
+G01*
+X67993894Y-52195900D01*
+G75*
+G02*
+X67726000Y-51928006I0J267894D01*
+G01*
+X67726000Y-50611794D01*
+G75*
+G02*
+X67993894Y-50343900I267894J0D01*
+G01*
+X68985106Y-50343900D01*
+G75*
+G02*
+X69253000Y-50611794I0J-267894D01*
+G01*
+G37*
+G36*
+G01*
+X72228000Y-50611794D02*
+X72228000Y-51928006D01*
+G75*
+G02*
+X71960106Y-52195900I-267894J0D01*
+G01*
+X70968894Y-52195900D01*
+G75*
+G02*
+X70701000Y-51928006I0J267894D01*
+G01*
+X70701000Y-50611794D01*
+G75*
+G02*
+X70968894Y-50343900I267894J0D01*
+G01*
+X71960106Y-50343900D01*
+G75*
+G02*
+X72228000Y-50611794I0J-267894D01*
+G01*
+G37*
+G36*
+G01*
+X70701000Y-48791106D02*
+X70701000Y-47474894D01*
+G75*
+G02*
+X70968894Y-47207000I267894J0D01*
+G01*
+X71960106Y-47207000D01*
+G75*
+G02*
+X72228000Y-47474894I0J-267894D01*
+G01*
+X72228000Y-48791106D01*
+G75*
+G02*
+X71960106Y-49059000I-267894J0D01*
+G01*
+X70968894Y-49059000D01*
+G75*
+G02*
+X70701000Y-48791106I0J267894D01*
+G01*
+G37*
+G36*
+G01*
+X67726000Y-48791106D02*
+X67726000Y-47474894D01*
+G75*
+G02*
+X67993894Y-47207000I267894J0D01*
+G01*
+X68985106Y-47207000D01*
+G75*
+G02*
+X69253000Y-47474894I0J-267894D01*
+G01*
+X69253000Y-48791106D01*
+G75*
+G02*
+X68985106Y-49059000I-267894J0D01*
+G01*
+X67993894Y-49059000D01*
+G75*
+G02*
+X67726000Y-48791106I0J267894D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-54663100D02*
+X75640000Y-55014100D01*
+G75*
+G02*
+X75464500Y-55189600I-175500J0D01*
+G01*
+X73763500Y-55189600D01*
+G75*
+G02*
+X73588000Y-55014100I0J175500D01*
+G01*
+X73588000Y-54663100D01*
+G75*
+G02*
+X73763500Y-54487600I175500J0D01*
+G01*
+X75464500Y-54487600D01*
+G75*
+G02*
+X75640000Y-54663100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-53393100D02*
+X75640000Y-53744100D01*
+G75*
+G02*
+X75464500Y-53919600I-175500J0D01*
+G01*
+X73763500Y-53919600D01*
+G75*
+G02*
+X73588000Y-53744100I0J175500D01*
+G01*
+X73588000Y-53393100D01*
+G75*
+G02*
+X73763500Y-53217600I175500J0D01*
+G01*
+X75464500Y-53217600D01*
+G75*
+G02*
+X75640000Y-53393100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-52123100D02*
+X75640000Y-52474100D01*
+G75*
+G02*
+X75464500Y-52649600I-175500J0D01*
+G01*
+X73763500Y-52649600D01*
+G75*
+G02*
+X73588000Y-52474100I0J175500D01*
+G01*
+X73588000Y-52123100D01*
+G75*
+G02*
+X73763500Y-51947600I175500J0D01*
+G01*
+X75464500Y-51947600D01*
+G75*
+G02*
+X75640000Y-52123100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-50853100D02*
+X75640000Y-51204100D01*
+G75*
+G02*
+X75464500Y-51379600I-175500J0D01*
+G01*
+X73763500Y-51379600D01*
+G75*
+G02*
+X73588000Y-51204100I0J175500D01*
+G01*
+X73588000Y-50853100D01*
+G75*
+G02*
+X73763500Y-50677600I175500J0D01*
+G01*
+X75464500Y-50677600D01*
+G75*
+G02*
+X75640000Y-50853100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-49583100D02*
+X75640000Y-49934100D01*
+G75*
+G02*
+X75464500Y-50109600I-175500J0D01*
+G01*
+X73763500Y-50109600D01*
+G75*
+G02*
+X73588000Y-49934100I0J175500D01*
+G01*
+X73588000Y-49583100D01*
+G75*
+G02*
+X73763500Y-49407600I175500J0D01*
+G01*
+X75464500Y-49407600D01*
+G75*
+G02*
+X75640000Y-49583100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-48313100D02*
+X75640000Y-48664100D01*
+G75*
+G02*
+X75464500Y-48839600I-175500J0D01*
+G01*
+X73763500Y-48839600D01*
+G75*
+G02*
+X73588000Y-48664100I0J175500D01*
+G01*
+X73588000Y-48313100D01*
+G75*
+G02*
+X73763500Y-48137600I175500J0D01*
+G01*
+X75464500Y-48137600D01*
+G75*
+G02*
+X75640000Y-48313100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X75640000Y-47043100D02*
+X75640000Y-47394100D01*
+G75*
+G02*
+X75464500Y-47569600I-175500J0D01*
+G01*
+X73763500Y-47569600D01*
+G75*
+G02*
+X73588000Y-47394100I0J175500D01*
+G01*
+X73588000Y-47043100D01*
+G75*
+G02*
+X73763500Y-46867600I175500J0D01*
+G01*
+X75464500Y-46867600D01*
+G75*
+G02*
+X75640000Y-47043100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-47043100D02*
+X80590000Y-47394100D01*
+G75*
+G02*
+X80414500Y-47569600I-175500J0D01*
+G01*
+X78713500Y-47569600D01*
+G75*
+G02*
+X78538000Y-47394100I0J175500D01*
+G01*
+X78538000Y-47043100D01*
+G75*
+G02*
+X78713500Y-46867600I175500J0D01*
+G01*
+X80414500Y-46867600D01*
+G75*
+G02*
+X80590000Y-47043100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-48313100D02*
+X80590000Y-48664100D01*
+G75*
+G02*
+X80414500Y-48839600I-175500J0D01*
+G01*
+X78713500Y-48839600D01*
+G75*
+G02*
+X78538000Y-48664100I0J175500D01*
+G01*
+X78538000Y-48313100D01*
+G75*
+G02*
+X78713500Y-48137600I175500J0D01*
+G01*
+X80414500Y-48137600D01*
+G75*
+G02*
+X80590000Y-48313100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-49583100D02*
+X80590000Y-49934100D01*
+G75*
+G02*
+X80414500Y-50109600I-175500J0D01*
+G01*
+X78713500Y-50109600D01*
+G75*
+G02*
+X78538000Y-49934100I0J175500D01*
+G01*
+X78538000Y-49583100D01*
+G75*
+G02*
+X78713500Y-49407600I175500J0D01*
+G01*
+X80414500Y-49407600D01*
+G75*
+G02*
+X80590000Y-49583100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-50853100D02*
+X80590000Y-51204100D01*
+G75*
+G02*
+X80414500Y-51379600I-175500J0D01*
+G01*
+X78713500Y-51379600D01*
+G75*
+G02*
+X78538000Y-51204100I0J175500D01*
+G01*
+X78538000Y-50853100D01*
+G75*
+G02*
+X78713500Y-50677600I175500J0D01*
+G01*
+X80414500Y-50677600D01*
+G75*
+G02*
+X80590000Y-50853100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-52123100D02*
+X80590000Y-52474100D01*
+G75*
+G02*
+X80414500Y-52649600I-175500J0D01*
+G01*
+X78713500Y-52649600D01*
+G75*
+G02*
+X78538000Y-52474100I0J175500D01*
+G01*
+X78538000Y-52123100D01*
+G75*
+G02*
+X78713500Y-51947600I175500J0D01*
+G01*
+X80414500Y-51947600D01*
+G75*
+G02*
+X80590000Y-52123100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-53393100D02*
+X80590000Y-53744100D01*
+G75*
+G02*
+X80414500Y-53919600I-175500J0D01*
+G01*
+X78713500Y-53919600D01*
+G75*
+G02*
+X78538000Y-53744100I0J175500D01*
+G01*
+X78538000Y-53393100D01*
+G75*
+G02*
+X78713500Y-53217600I175500J0D01*
+G01*
+X80414500Y-53217600D01*
+G75*
+G02*
+X80590000Y-53393100I0J-175500D01*
+G01*
+G37*
+G36*
+G01*
+X80590000Y-54663100D02*
+X80590000Y-55014100D01*
+G75*
+G02*
+X80414500Y-55189600I-175500J0D01*
+G01*
+X78713500Y-55189600D01*
+G75*
+G02*
+X78538000Y-55014100I0J175500D01*
+G01*
+X78538000Y-54663100D01*
+G75*
+G02*
+X78713500Y-54487600I175500J0D01*
+G01*
+X80414500Y-54487600D01*
+G75*
+G02*
+X80590000Y-54663100I0J-175500D01*
+G01*
+G37*
+D12*
+X84529200Y-58267600D03*
+X84529200Y-60267600D03*
+X84529200Y-62267600D03*
+X84529200Y-64267600D03*
+X84529200Y-66267600D03*
+X84529200Y-68267600D03*
+X84529200Y-70267600D03*
+X84529200Y-72267600D03*
+X68529200Y-72267600D03*
+X68529200Y-70267600D03*
+X68529200Y-68267600D03*
+X68529200Y-66267600D03*
+X68529200Y-64267600D03*
+X68529200Y-62267600D03*
+X68529200Y-60267600D03*
+X68529200Y-58267600D03*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84-F_Paste.gtp

@@ -0,0 +1,711 @@
+G04 #@! TF.GenerationSoftware,KiCad,Pcbnew,5.1.9*
+G04 #@! TF.CreationDate,2021-03-12T19:02:00+01:00*
+G04 #@! TF.ProjectId,LORA_ATTINY84,4c4f5241-5f41-4545-9449-4e5938342e6b,rev?*
+G04 #@! TF.SameCoordinates,Original*
+G04 #@! TF.FileFunction,Paste,Top*
+G04 #@! TF.FilePolarity,Positive*
+%FSLAX46Y46*%
+G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)*
+G04 Created by KiCad (PCBNEW 5.1.9) date 2021-03-12 19:02:00*
+%MOMM*%
+%LPD*%
+G01*
+G04 APERTURE LIST*
+%ADD10C,0.100000*%
+%ADD11O,2.000000X1.000000*%
+G04 APERTURE END LIST*
+D10*
+G36*
+X91587575Y-75237896D02*
+G01*
+X91588513Y-75238181D01*
+X91589378Y-75238643D01*
+X91590136Y-75239264D01*
+X91590757Y-75240022D01*
+X91591219Y-75240887D01*
+X91591504Y-75241825D01*
+X91591600Y-75242800D01*
+X91591600Y-79442800D01*
+X91591504Y-79443775D01*
+X91591219Y-79444713D01*
+X91590757Y-79445578D01*
+X91590136Y-79446336D01*
+X91589378Y-79446957D01*
+X91588513Y-79447419D01*
+X91587575Y-79447704D01*
+X91586600Y-79447800D01*
+X90236600Y-79447800D01*
+X90235625Y-79447704D01*
+X90234687Y-79447419D01*
+X90233822Y-79446957D01*
+X90233064Y-79446336D01*
+X90232443Y-79445578D01*
+X90231981Y-79444713D01*
+X90231696Y-79443775D01*
+X90231600Y-79442800D01*
+X90231600Y-77247800D01*
+X89136600Y-77247800D01*
+X89135625Y-77247704D01*
+X89134687Y-77247419D01*
+X89133822Y-77246957D01*
+X89133064Y-77246336D01*
+X89132443Y-77245578D01*
+X89131981Y-77244713D01*
+X89131696Y-77243775D01*
+X89131600Y-77242800D01*
+X89131600Y-75242800D01*
+X89131696Y-75241825D01*
+X89131981Y-75240887D01*
+X89132443Y-75240022D01*
+X89133064Y-75239264D01*
+X89133822Y-75238643D01*
+X89134687Y-75238181D01*
+X89135625Y-75237896D01*
+X89136600Y-75237800D01*
+X91586600Y-75237800D01*
+X91587575Y-75237896D01*
+G37*
+G36*
+X87035895Y-75237896D02*
+G01*
+X87036833Y-75238181D01*
+X87037698Y-75238643D01*
+X87038456Y-75239264D01*
+X87039077Y-75240022D01*
+X87039539Y-75240887D01*
+X87039824Y-75241825D01*
+X87039920Y-75242800D01*
+X87039920Y-77242800D01*
+X87039824Y-77243775D01*
+X87039539Y-77244713D01*
+X87039077Y-77245578D01*
+X87038456Y-77246336D01*
+X87037698Y-77246957D01*
+X87036833Y-77247419D01*
+X87035895Y-77247704D01*
+X87034920Y-77247800D01*
+X85939920Y-77247800D01*
+X85939920Y-79442800D01*
+X85939824Y-79443775D01*
+X85939539Y-79444713D01*
+X85939077Y-79445578D01*
+X85938456Y-79446336D01*
+X85937698Y-79446957D01*
+X85936833Y-79447419D01*
+X85935895Y-79447704D01*
+X85934920Y-79447800D01*
+X84584920Y-79447800D01*
+X84583945Y-79447704D01*
+X84583007Y-79447419D01*
+X84582142Y-79446957D01*
+X84581384Y-79446336D01*
+X84580763Y-79445578D01*
+X84580301Y-79444713D01*
+X84580016Y-79443775D01*
+X84579920Y-79442800D01*
+X84579920Y-75242800D01*
+X84580016Y-75241825D01*
+X84580301Y-75240887D01*
+X84580763Y-75240022D01*
+X84581384Y-75239264D01*
+X84582142Y-75238643D01*
+X84583007Y-75238181D01*
+X84583945Y-75237896D01*
+X84584920Y-75237800D01*
+X87034920Y-75237800D01*
+X87035895Y-75237896D01*
+G37*
+G36*
+G01*
+X70791700Y-76723400D02*
+X70791700Y-75473400D01*
+G75*
+G02*
+X71041700Y-75223400I250000J0D01*
+G01*
+X71966700Y-75223400D01*
+G75*
+G02*
+X72216700Y-75473400I0J-250000D01*
+G01*
+X72216700Y-76723400D01*
+G75*
+G02*
+X71966700Y-76973400I-250000J0D01*
+G01*
+X71041700Y-76973400D01*
+G75*
+G02*
+X70791700Y-76723400I0J250000D01*
+G01*
+G37*
+G36*
+G01*
+X67816700Y-76723400D02*
+X67816700Y-75473400D01*
+G75*
+G02*
+X68066700Y-75223400I250000J0D01*
+G01*
+X68991700Y-75223400D01*
+G75*
+G02*
+X69241700Y-75473400I0J-250000D01*
+G01*
+X69241700Y-76723400D01*
+G75*
+G02*
+X68991700Y-76973400I-250000J0D01*
+G01*
+X68066700Y-76973400D01*
+G75*
+G02*
+X67816700Y-76723400I0J250000D01*
+G01*
+G37*
+G36*
+G01*
+X75069400Y-75448000D02*
+X75069400Y-76698000D01*
+G75*
+G02*
+X74819400Y-76948000I-250000J0D01*
+G01*
+X73894400Y-76948000D01*
+G75*
+G02*
+X73644400Y-76698000I0J250000D01*
+G01*
+X73644400Y-75448000D01*
+G75*
+G02*
+X73894400Y-75198000I250000J0D01*
+G01*
+X74819400Y-75198000D01*
+G75*
+G02*
+X75069400Y-75448000I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X78044400Y-75448000D02*
+X78044400Y-76698000D01*
+G75*
+G02*
+X77794400Y-76948000I-250000J0D01*
+G01*
+X76869400Y-76948000D01*
+G75*
+G02*
+X76619400Y-76698000I0J250000D01*
+G01*
+X76619400Y-75448000D01*
+G75*
+G02*
+X76869400Y-75198000I250000J0D01*
+G01*
+X77794400Y-75198000D01*
+G75*
+G02*
+X78044400Y-75448000I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X69202000Y-53731000D02*
+X69202000Y-54981000D01*
+G75*
+G02*
+X68952000Y-55231000I-250000J0D01*
+G01*
+X68027000Y-55231000D01*
+G75*
+G02*
+X67777000Y-54981000I0J250000D01*
+G01*
+X67777000Y-53731000D01*
+G75*
+G02*
+X68027000Y-53481000I250000J0D01*
+G01*
+X68952000Y-53481000D01*
+G75*
+G02*
+X69202000Y-53731000I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X72177000Y-53731000D02*
+X72177000Y-54981000D01*
+G75*
+G02*
+X71927000Y-55231000I-250000J0D01*
+G01*
+X71002000Y-55231000D01*
+G75*
+G02*
+X70752000Y-54981000I0J250000D01*
+G01*
+X70752000Y-53731000D01*
+G75*
+G02*
+X71002000Y-53481000I250000J0D01*
+G01*
+X71927000Y-53481000D01*
+G75*
+G02*
+X72177000Y-53731000I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X69202000Y-50644900D02*
+X69202000Y-51894900D01*
+G75*
+G02*
+X68952000Y-52144900I-250000J0D01*
+G01*
+X68027000Y-52144900D01*
+G75*
+G02*
+X67777000Y-51894900I0J250000D01*
+G01*
+X67777000Y-50644900D01*
+G75*
+G02*
+X68027000Y-50394900I250000J0D01*
+G01*
+X68952000Y-50394900D01*
+G75*
+G02*
+X69202000Y-50644900I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X72177000Y-50644900D02*
+X72177000Y-51894900D01*
+G75*
+G02*
+X71927000Y-52144900I-250000J0D01*
+G01*
+X71002000Y-52144900D01*
+G75*
+G02*
+X70752000Y-51894900I0J250000D01*
+G01*
+X70752000Y-50644900D01*
+G75*
+G02*
+X71002000Y-50394900I250000J0D01*
+G01*
+X71927000Y-50394900D01*
+G75*
+G02*
+X72177000Y-50644900I0J-250000D01*
+G01*
+G37*
+G36*
+G01*
+X70752000Y-48758000D02*
+X70752000Y-47508000D01*
+G75*
+G02*
+X71002000Y-47258000I250000J0D01*
+G01*
+X71927000Y-47258000D01*
+G75*
+G02*
+X72177000Y-47508000I0J-250000D01*
+G01*
+X72177000Y-48758000D01*
+G75*
+G02*
+X71927000Y-49008000I-250000J0D01*
+G01*
+X71002000Y-49008000D01*
+G75*
+G02*
+X70752000Y-48758000I0J250000D01*
+G01*
+G37*
+G36*
+G01*
+X67777000Y-48758000D02*
+X67777000Y-47508000D01*
+G75*
+G02*
+X68027000Y-47258000I250000J0D01*
+G01*
+X68952000Y-47258000D01*
+G75*
+G02*
+X69202000Y-47508000I0J-250000D01*
+G01*
+X69202000Y-48758000D01*
+G75*
+G02*
+X68952000Y-49008000I-250000J0D01*
+G01*
+X68027000Y-49008000D01*
+G75*
+G02*
+X67777000Y-48758000I0J250000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-54688600D02*
+X75589000Y-54988600D01*
+G75*
+G02*
+X75439000Y-55138600I-150000J0D01*
+G01*
+X73789000Y-55138600D01*
+G75*
+G02*
+X73639000Y-54988600I0J150000D01*
+G01*
+X73639000Y-54688600D01*
+G75*
+G02*
+X73789000Y-54538600I150000J0D01*
+G01*
+X75439000Y-54538600D01*
+G75*
+G02*
+X75589000Y-54688600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-53418600D02*
+X75589000Y-53718600D01*
+G75*
+G02*
+X75439000Y-53868600I-150000J0D01*
+G01*
+X73789000Y-53868600D01*
+G75*
+G02*
+X73639000Y-53718600I0J150000D01*
+G01*
+X73639000Y-53418600D01*
+G75*
+G02*
+X73789000Y-53268600I150000J0D01*
+G01*
+X75439000Y-53268600D01*
+G75*
+G02*
+X75589000Y-53418600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-52148600D02*
+X75589000Y-52448600D01*
+G75*
+G02*
+X75439000Y-52598600I-150000J0D01*
+G01*
+X73789000Y-52598600D01*
+G75*
+G02*
+X73639000Y-52448600I0J150000D01*
+G01*
+X73639000Y-52148600D01*
+G75*
+G02*
+X73789000Y-51998600I150000J0D01*
+G01*
+X75439000Y-51998600D01*
+G75*
+G02*
+X75589000Y-52148600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-50878600D02*
+X75589000Y-51178600D01*
+G75*
+G02*
+X75439000Y-51328600I-150000J0D01*
+G01*
+X73789000Y-51328600D01*
+G75*
+G02*
+X73639000Y-51178600I0J150000D01*
+G01*
+X73639000Y-50878600D01*
+G75*
+G02*
+X73789000Y-50728600I150000J0D01*
+G01*
+X75439000Y-50728600D01*
+G75*
+G02*
+X75589000Y-50878600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-49608600D02*
+X75589000Y-49908600D01*
+G75*
+G02*
+X75439000Y-50058600I-150000J0D01*
+G01*
+X73789000Y-50058600D01*
+G75*
+G02*
+X73639000Y-49908600I0J150000D01*
+G01*
+X73639000Y-49608600D01*
+G75*
+G02*
+X73789000Y-49458600I150000J0D01*
+G01*
+X75439000Y-49458600D01*
+G75*
+G02*
+X75589000Y-49608600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-48338600D02*
+X75589000Y-48638600D01*
+G75*
+G02*
+X75439000Y-48788600I-150000J0D01*
+G01*
+X73789000Y-48788600D01*
+G75*
+G02*
+X73639000Y-48638600I0J150000D01*
+G01*
+X73639000Y-48338600D01*
+G75*
+G02*
+X73789000Y-48188600I150000J0D01*
+G01*
+X75439000Y-48188600D01*
+G75*
+G02*
+X75589000Y-48338600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X75589000Y-47068600D02*
+X75589000Y-47368600D01*
+G75*
+G02*
+X75439000Y-47518600I-150000J0D01*
+G01*
+X73789000Y-47518600D01*
+G75*
+G02*
+X73639000Y-47368600I0J150000D01*
+G01*
+X73639000Y-47068600D01*
+G75*
+G02*
+X73789000Y-46918600I150000J0D01*
+G01*
+X75439000Y-46918600D01*
+G75*
+G02*
+X75589000Y-47068600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-47068600D02*
+X80539000Y-47368600D01*
+G75*
+G02*
+X80389000Y-47518600I-150000J0D01*
+G01*
+X78739000Y-47518600D01*
+G75*
+G02*
+X78589000Y-47368600I0J150000D01*
+G01*
+X78589000Y-47068600D01*
+G75*
+G02*
+X78739000Y-46918600I150000J0D01*
+G01*
+X80389000Y-46918600D01*
+G75*
+G02*
+X80539000Y-47068600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-48338600D02*
+X80539000Y-48638600D01*
+G75*
+G02*
+X80389000Y-48788600I-150000J0D01*
+G01*
+X78739000Y-48788600D01*
+G75*
+G02*
+X78589000Y-48638600I0J150000D01*
+G01*
+X78589000Y-48338600D01*
+G75*
+G02*
+X78739000Y-48188600I150000J0D01*
+G01*
+X80389000Y-48188600D01*
+G75*
+G02*
+X80539000Y-48338600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-49608600D02*
+X80539000Y-49908600D01*
+G75*
+G02*
+X80389000Y-50058600I-150000J0D01*
+G01*
+X78739000Y-50058600D01*
+G75*
+G02*
+X78589000Y-49908600I0J150000D01*
+G01*
+X78589000Y-49608600D01*
+G75*
+G02*
+X78739000Y-49458600I150000J0D01*
+G01*
+X80389000Y-49458600D01*
+G75*
+G02*
+X80539000Y-49608600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-50878600D02*
+X80539000Y-51178600D01*
+G75*
+G02*
+X80389000Y-51328600I-150000J0D01*
+G01*
+X78739000Y-51328600D01*
+G75*
+G02*
+X78589000Y-51178600I0J150000D01*
+G01*
+X78589000Y-50878600D01*
+G75*
+G02*
+X78739000Y-50728600I150000J0D01*
+G01*
+X80389000Y-50728600D01*
+G75*
+G02*
+X80539000Y-50878600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-52148600D02*
+X80539000Y-52448600D01*
+G75*
+G02*
+X80389000Y-52598600I-150000J0D01*
+G01*
+X78739000Y-52598600D01*
+G75*
+G02*
+X78589000Y-52448600I0J150000D01*
+G01*
+X78589000Y-52148600D01*
+G75*
+G02*
+X78739000Y-51998600I150000J0D01*
+G01*
+X80389000Y-51998600D01*
+G75*
+G02*
+X80539000Y-52148600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-53418600D02*
+X80539000Y-53718600D01*
+G75*
+G02*
+X80389000Y-53868600I-150000J0D01*
+G01*
+X78739000Y-53868600D01*
+G75*
+G02*
+X78589000Y-53718600I0J150000D01*
+G01*
+X78589000Y-53418600D01*
+G75*
+G02*
+X78739000Y-53268600I150000J0D01*
+G01*
+X80389000Y-53268600D01*
+G75*
+G02*
+X80539000Y-53418600I0J-150000D01*
+G01*
+G37*
+G36*
+G01*
+X80539000Y-54688600D02*
+X80539000Y-54988600D01*
+G75*
+G02*
+X80389000Y-55138600I-150000J0D01*
+G01*
+X78739000Y-55138600D01*
+G75*
+G02*
+X78589000Y-54988600I0J150000D01*
+G01*
+X78589000Y-54688600D01*
+G75*
+G02*
+X78739000Y-54538600I150000J0D01*
+G01*
+X80389000Y-54538600D01*
+G75*
+G02*
+X80539000Y-54688600I0J-150000D01*
+G01*
+G37*
+D11*
+X84529200Y-58267600D03*
+X84529200Y-60267600D03*
+X84529200Y-62267600D03*
+X84529200Y-64267600D03*
+X84529200Y-66267600D03*
+X84529200Y-68267600D03*
+X84529200Y-70267600D03*
+X84529200Y-72267600D03*
+X68529200Y-72267600D03*
+X68529200Y-70267600D03*
+X68529200Y-68267600D03*
+X68529200Y-66267600D03*
+X68529200Y-64267600D03*
+X68529200Y-62267600D03*
+X68529200Y-60267600D03*
+X68529200Y-58267600D03*
+M02*

PCB_SMD/Gerber_V2/LORA_ATTINY84.drl

@@ -0,0 +1,45 @@
+M48
+; DRILL file {KiCad 5.1.9} date Fri Mar 12 19:02:04 2021
+; FORMAT={-:-/ absolute / inch / decimal}
+; #@! TF.CreationDate,2021-03-12T19:02:04+01:00
+; #@! TF.GenerationSoftware,Kicad,Pcbnew,5.1.9
+FMAT,2
+INCH
+T1C0.0157
+T2C0.0394
+%
+G90
+G05
+T1
+X2.631Y-2.49
+X2.6964Y-2.0185
+X2.8136Y-2.14
+X2.834Y-2.314
+X2.926Y-2.26
+X3.1324Y-2.009
+X3.1324Y-2.059
+X3.1337Y-2.1603
+X3.231Y-2.241
+X3.3279Y-2.4515
+X3.355Y-2.915
+X3.392Y-2.179
+X3.424Y-2.0662
+X3.58Y-2.92
+T2
+X3.322Y-1.892
+X3.322Y-1.992
+X3.422Y-1.892
+X3.422Y-1.992
+X3.468Y-3.084
+X3.522Y-1.892
+X3.522Y-1.992
+X3.522Y-2.141
+X3.522Y-2.241
+X3.522Y-2.341
+X3.522Y-2.441
+X3.522Y-2.541
+X3.522Y-2.641
+X3.522Y-2.741
+X3.522Y-2.841
+T0
+M30

PCB_SMD/LORA_ATTINY84.sch

@@ -4,7 +4,7 @@ EELAYER END
 $Descr A4 8268 11693 portrait
 encoding utf-8
 Sheet 1 1
-Title "TinyLora"
+Title "ATTNode"
 Date "2019-08-29"
 Rev "1.1"
 Comp ""
@@ -69,7 +69,7 @@ U 1 1 5D699DFD
 P 1500 1000
 F 0 "ANT1" H 1580 989 50  0000 L CNN
 F 1 "Antenna" H 1580 898 50  0000 L CNN
-F 2 "Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical" H 1500 1000 50  0001 C CNN
+F 2 "SMA_Multi:SMA_Edge_UFL_Combo" H 1500 1000 50  0001 C CNN
 F 3 "~" H 1500 1000 50  0001 C CNN
 	1    1500 1000
 	1    0    0    -1  

PCB_SMD/LORA_ATTINY84.sch-bak

@@ -1,384 +0,0 @@
-EESchema Schematic File Version 4
-LIBS:LORA_ATTINY84-cache
-EELAYER 30 0
-EELAYER END
-$Descr A4 8268 11693 portrait
-encoding utf-8
-Sheet 1 1
-Title "TinyLora"
-Date "2019-08-29"
-Rev "1.1"
-Comp ""
-Comment1 "A ATTiny84 + RFM95W Based Lora Sensor Basenode"
-Comment2 ""
-Comment3 ""
-Comment4 ""
-$EndDescr
-$Comp
-L power:GND #PWR0101
-U 1 1 5D662E21
-P 1900 4800
-F 0 "#PWR0101" H 1900 4550 50  0001 C CNN
-F 1 "GND" H 1905 4627 50  0000 C CNN
-F 2 "" H 1900 4800 50  0001 C CNN
-F 3 "" H 1900 4800 50  0001 C CNN
-	1    1900 4800
-	1    0    0    -1  
-$EndComp
-$Comp
-L MCU_Microchip_ATtiny:ATtiny84A-SSU ATTiny84
-U 1 1 5D66342E
-P 1900 3900
-F 0 "ATTiny84" H 2050 4050 50  0000 R CNN
-F 1 "ATtiny84A-SSU" H 2150 3900 50  0001 R CNN
-F 2 "Package_SO:SOIC-14_3.9x8.7mm_P1.27mm" H 1900 3900 50  0001 C CIN
-F 3 "http://ww1.microchip.com/downloads/en/DeviceDoc/doc8183.pdf" H 1900 3900 50  0001 C CNN
-	1    1900 3900
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	2250 1900 2250 1800
-$Comp
-L power:GND #PWR0103
-U 1 1 5D68B8DB
-P 2550 1800
-F 0 "#PWR0103" H 2550 1550 50  0001 C CNN
-F 1 "GND" H 2555 1627 50  0000 C CNN
-F 2 "" H 2550 1800 50  0001 C CNN
-F 3 "" H 2550 1800 50  0001 C CNN
-	1    2550 1800
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	2550 1700 2550 1800
-$Comp
-L Connector:Conn_01x08_Male J1
-U 1 1 5D68DC89
-P 3150 3300
-F 0 "J1" H 3400 3750 50  0000 R CNN
-F 1 "J1" H 3122 3273 50  0001 R CNN
-F 2 "Connector_PinHeader_2.54mm:PinHeader_1x08_P2.54mm_Vertical" H 3150 3300 50  0001 C CNN
-F 3 "~" H 3150 3300 50  0001 C CNN
-	1    3150 3300
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	1900 2950 1900 3000
-$Comp
-L Device:Antenna ANT1
-U 1 1 5D699DFD
-P 1500 1000
-F 0 "ANT1" H 1580 989 50  0000 L CNN
-F 1 "Antenna" H 1580 898 50  0000 L CNN
-F 2 "Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical" H 1500 1000 50  0001 C CNN
-F 3 "~" H 1500 1000 50  0001 C CNN
-	1    1500 1000
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:GND #PWR0104
-U 1 1 5D6A5353
-P 3800 4600
-F 0 "#PWR0104" H 3800 4350 50  0001 C CNN
-F 1 "GND" H 3805 4427 50  0000 C CNN
-F 2 "" H 3800 4600 50  0001 C CNN
-F 3 "" H 3800 4600 50  0001 C CNN
-	1    3800 4600
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	3700 4500 3800 4500
-Wire Wire Line
-	3800 4500 3800 4600
-$Comp
-L Connector_Generic:Conn_02x03_Odd_Even PRG1
-U 1 1 5D69C5BF
-P 3400 4400
-F 0 "PRG1" H 3450 4650 50  0000 C CNN
-F 1 "PRG" H 3450 4626 50  0001 C CNN
-F 2 "Connector_PinHeader_2.54mm:PinHeader_2x03_P2.54mm_Vertical" H 3400 4400 50  0001 C CNN
-F 3 "~" H 3400 4400 50  0001 C CNN
-	1    3400 4400
-	1    0    0    -1  
-$EndComp
-Text GLabel 2500 3700 2    50   Input ~ 0
-SCK
-Text GLabel 2500 3800 2    50   Input ~ 0
-MISO
-Text GLabel 2500 3900 2    50   Input ~ 0
-MOSI
-Text GLabel 2500 4200 2    50   Input ~ 0
-DIO0
-Text GLabel 2500 4300 2    50   Input ~ 0
-NSS
-Text GLabel 2500 4500 2    50   Input ~ 0
-RST
-Text GLabel 1500 2200 3    50   Input ~ 0
-SCK
-Text GLabel 1700 2200 3    50   Input ~ 0
-MOSI
-Text GLabel 1600 2200 3    50   Input ~ 0
-MISO
-Text GLabel 1800 2200 3    50   Input ~ 0
-NSS
-Text GLabel 2200 1200 1    50   Input ~ 0
-DIO0
-Wire Wire Line
-	2400 1700 2450 1700
-Text GLabel 2500 3300 2    50   Input ~ 0
-PA0
-Text GLabel 2500 3400 2    50   Input ~ 0
-PA1
-Text GLabel 2500 3500 2    50   Input ~ 0
-PA2
-Text GLabel 2500 3600 2    50   Input ~ 0
-PA3
-Text GLabel 2500 4000 2    50   Input ~ 0
-PA7
-Text GLabel 2500 4400 2    50   Input ~ 0
-PB2
-Text GLabel 3350 3200 2    50   Input ~ 0
-PA0
-Text GLabel 3350 3300 2    50   Input ~ 0
-PA1
-Text GLabel 3350 3400 2    50   Input ~ 0
-PA2
-Text GLabel 3350 3500 2    50   Input ~ 0
-PA3
-Text GLabel 3350 3600 2    50   Input ~ 0
-PA7
-Text GLabel 3350 3700 2    50   Input ~ 0
-PB2
-$Comp
-L power:GND #PWR0102
-U 1 1 5D6F5F48
-P 3250 1650
-F 0 "#PWR0102" H 3250 1400 50  0001 C CNN
-F 1 "GND" H 3255 1477 50  0000 C CNN
-F 2 "" H 3250 1650 50  0001 C CNN
-F 3 "" H 3250 1650 50  0001 C CNN
-	1    3250 1650
-	1    0    0    -1  
-$EndComp
-$Comp
-L Device:Battery_Cell BAT1
-U 1 1 5D6F40EE
-P 3250 1550
-F 0 "BAT1" H 3368 1646 50  0000 L CNN
-F 1 "Battery_Cell" H 3368 1555 50  0001 L CNN
-F 2 "battery_holder:BatteryHolder_Keystone_1060_1x2032_Long_Pad" V 3250 1610 50  0001 C CNN
-F 3 "~" V 3250 1610 50  0001 C CNN
-	1    3250 1550
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:+3V3 #PWR0105
-U 1 1 5D6F66AA
-P 3250 1350
-F 0 "#PWR0105" H 3250 1200 50  0001 C CNN
-F 1 "+3V3" H 3265 1523 50  0000 C CNN
-F 2 "" H 3250 1350 50  0001 C CNN
-F 3 "" H 3250 1350 50  0001 C CNN
-	1    3250 1350
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:+3V3 #PWR0106
-U 1 1 5D6F6B97
-P 1100 1550
-F 0 "#PWR0106" H 1100 1400 50  0001 C CNN
-F 1 "+3V3" H 1115 1723 50  0000 C CNN
-F 2 "" H 1100 1550 50  0001 C CNN
-F 3 "" H 1100 1550 50  0001 C CNN
-	1    1100 1550
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	1100 1550 1100 1700
-$Comp
-L power:+3V3 #PWR0107
-U 1 1 5D6F753F
-P 1900 2950
-F 0 "#PWR0107" H 1900 2800 50  0001 C CNN
-F 1 "+3V3" H 1915 3123 50  0000 C CNN
-F 2 "" H 1900 2950 50  0001 C CNN
-F 3 "" H 1900 2950 50  0001 C CNN
-	1    1900 2950
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:+3V3 #PWR0108
-U 1 1 5D6F7EE7
-P 3800 4250
-F 0 "#PWR0108" H 3800 4100 50  0001 C CNN
-F 1 "+3V3" H 3815 4423 50  0000 C CNN
-F 2 "" H 3800 4250 50  0001 C CNN
-F 3 "" H 3800 4250 50  0001 C CNN
-	1    3800 4250
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	3700 4300 3800 4300
-Wire Wire Line
-	3800 4300 3800 4250
-Text GLabel 3700 4400 2    50   Input ~ 0
-MOSI
-Text GLabel 3200 4300 0    50   Input ~ 0
-MISO
-Text GLabel 3200 4400 0    50   Input ~ 0
-SCK
-Text GLabel 3200 4500 0    50   Input ~ 0
-RST
-$Comp
-L power:+3V3 #PWR0109
-U 1 1 5D6FB5F9
-P 3650 2950
-F 0 "#PWR0109" H 3650 2800 50  0001 C CNN
-F 1 "+3V3" H 3650 3100 50  0000 C CNN
-F 2 "" H 3650 2950 50  0001 C CNN
-F 3 "" H 3650 2950 50  0001 C CNN
-	1    3650 2950
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:GND #PWR0110
-U 1 1 5D6FC140
-P 3650 3200
-F 0 "#PWR0110" H 3650 2950 50  0001 C CNN
-F 1 "GND" H 3655 3027 50  0000 C CNN
-F 2 "" H 3650 3200 50  0001 C CNN
-F 3 "" H 3650 3200 50  0001 C CNN
-	1    3650 3200
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	2450 1700 2450 1600
-Connection ~ 2450 1700
-Wire Wire Line
-	2450 1700 2550 1700
-NoConn ~ 2100 1200
-NoConn ~ 2000 1200
-NoConn ~ 1900 1200
-NoConn ~ 1800 1200
-NoConn ~ 1700 1200
-NoConn ~ 2000 2200
-Wire Wire Line
-	2400 1600 2450 1600
-Wire Wire Line
-	2450 1800 2450 1700
-Wire Wire Line
-	1100 1700 1300 1700
-$Comp
-L Device:LED D1
-U 1 1 5D67F14D
-P 3600 2450
-F 0 "D1" H 3600 2200 50  0000 C CNN
-F 1 "LED" H 3600 2300 50  0000 C CNN
-F 2 "LED_SMD:LED_1206_3216Metric_Pad1.42x1.75mm_HandSolder" H 3600 2450 50  0001 C CNN
-F 3 "~" H 3600 2450 50  0001 C CNN
-	1    3600 2450
-	-1   0    0    1   
-$EndComp
-$Comp
-L power:GND #PWR0111
-U 1 1 5D67F99A
-P 3850 2550
-F 0 "#PWR0111" H 3850 2300 50  0001 C CNN
-F 1 "GND" H 3855 2377 50  0000 C CNN
-F 2 "" H 3850 2550 50  0001 C CNN
-F 3 "" H 3850 2550 50  0001 C CNN
-	1    3850 2550
-	1    0    0    -1  
-$EndComp
-$Comp
-L Device:R R1
-U 1 1 5D6827F4
-P 3300 2450
-F 0 "R1" V 3050 2450 50  0000 C CNN
-F 1 "100" V 3150 2450 50  0000 C CNN
-F 2 "Resistor_SMD:R_1206_3216Metric_Pad1.42x1.75mm_HandSolder" V 3230 2450 50  0001 C CNN
-F 3 "~" H 3300 2450 50  0001 C CNN
-	1    3300 2450
-	0    1    1    0   
-$EndComp
-Text GLabel 3150 2450 0    50   Input ~ 0
-PA7
-Wire Wire Line
-	3750 2450 3850 2450
-Wire Wire Line
-	3850 2450 3850 2550
-Wire Wire Line
-	2400 1800 2450 1800
-Wire Wire Line
-	2250 1800 2400 1800
-Connection ~ 2400 1800
-$Comp
-L RF_Module:RFM95W-868S2 RFM95
-U 1 1 5D664943
-P 1800 1700
-F 0 "RFM95" V 1800 1550 50  0000 L CNN
-F 1 "RFM95W-868S2" V 1600 2150 50  0001 L CNN
-F 2 "RFM:RFM95" H -1500 3350 50  0001 C CNN
-F 3 "https://www.hoperf.com/data/upload/portal/20181127/5bfcbea20e9ef.pdf" H -1500 3350 50  0001 C CNN
-	1    1800 1700
-	0    -1   -1   0   
-$EndComp
-$Comp
-L Device:C C2
-U 1 1 5D694E97
-P 1100 1850
-F 0 "C2" H 850 1900 50  0000 L CNN
-F 1 "100n" H 800 1800 50  0000 L CNN
-F 2 "Capacitor_SMD:C_1206_3216Metric_Pad1.42x1.75mm_HandSolder" H 1138 1700 50  0001 C CNN
-F 3 "~" H 1100 1850 50  0001 C CNN
-	1    1100 1850
-	1    0    0    -1  
-$EndComp
-Connection ~ 1100 1700
-$Comp
-L power:GND #PWR0112
-U 1 1 5D6953B6
-P 1100 2000
-F 0 "#PWR0112" H 1100 1750 50  0001 C CNN
-F 1 "GND" H 1105 1827 50  0000 C CNN
-F 2 "" H 1100 2000 50  0001 C CNN
-F 3 "" H 1100 2000 50  0001 C CNN
-	1    1100 2000
-	1    0    0    -1  
-$EndComp
-$Comp
-L Device:C C1
-U 1 1 5D696543
-P 1100 3250
-F 0 "C1" H 850 3300 50  0000 L CNN
-F 1 "100n" H 800 3200 50  0000 L CNN
-F 2 "Capacitor_SMD:C_1206_3216Metric_Pad1.42x1.75mm_HandSolder" H 1138 3100 50  0001 C CNN
-F 3 "~" H 1100 3250 50  0001 C CNN
-	1    1100 3250
-	1    0    0    -1  
-$EndComp
-$Comp
-L power:GND #PWR0113
-U 1 1 5D696B3A
-P 1100 3400
-F 0 "#PWR0113" H 1100 3150 50  0001 C CNN
-F 1 "GND" H 1105 3227 50  0000 C CNN
-F 2 "" H 1100 3400 50  0001 C CNN
-F 3 "" H 1100 3400 50  0001 C CNN
-	1    1100 3400
-	1    0    0    -1  
-$EndComp
-Wire Wire Line
-	1900 2950 1100 2950
-Wire Wire Line
-	1100 2950 1100 3100
-Connection ~ 1900 2950
-Wire Wire Line
-	3350 3100 3650 3100
-Wire Wire Line
-	3650 3100 3650 3200
-Wire Wire Line
-	3350 3000 3650 3000
-Wire Wire Line
-	3650 3000 3650 2950
-$EndSCHEMATC

PCB_SMD/README.md

@@ -1,6 +1,6 @@
-# TinyLora PCB (SMD Version)
+# ATTNode PCB (SMD Version)
 
-PCB for the TinyLora Sensor Node, SMD Version
+PCB for the ATTiny Sensor Node, SMD Version
 
 ## Parts List
 
@@ -13,6 +13,6 @@ PCB for the TinyLora Sensor Node, SMD Version
 | D1        | LED SMD 1206                | Optional, connected to pin A7                                                |
 | C1,C2     | Capacitor 100nF SMD 1206    | Bypass Capacitors for ATTiny and RFM95                                       |
 | BAT1      | CR2032 Battery Holder       | See pictures for the type I used                                             |
-| ANT1      | 868 MHz Antenna             | Connect a small coil or wire antenna for 868 MHz (or fitting frequency)      |
+| ANT1      | 868 MHz Antenna             | SMA Connector, u.fl Connector or Coil Antenna                                |
 | J1        | 1x8 Pin 2.54mm pitch header | Optional, for the Case directly solder the Sensor to the Backside of the PCB |
 | PRG1      | 2x3 Pin 2.54mm pitch header | Optional, has to be shortened from standard height to fit in the Case        |

PCB_SMD/fp-lib-table

@@ -1,4 +1,5 @@
 (fp_lib_table
   (lib (name RFM)(type KiCad)(uri ${KIPRJMOD}/kicad_libs/RFM95)(options "")(descr ""))
   (lib (name battery_holder)(type KiCad)(uri ${KIPRJMOD}/kicad_libs/battery_holder.pretty)(options "")(descr ""))
+  (lib (name SMA_Multi)(type KiCad)(uri ${KIPRJMOD}/kicad_libs/SMA_Multi.pretty)(options "")(descr ""))
 )

PCB_SMD/kicad_libs/SMA_Multi.pretty/SMA_Edge_UFL_Combo.kicad_mod

@@ -0,0 +1,73 @@
+(module SMA_Edge_UFL_Combo (layer F.Cu) (tedit 5E2D63D1)
+  (descr "Connector SMA, 0Hz to 20GHz, 50Ohm, Edge Mount (http://suddendocs.samtec.com/prints/sma-j-p-x-st-em1-mkt.pdf)")
+  (tags "SMA Straight Samtec Edge Mount")
+  (attr smd)
+  (fp_text reference ANT1 (at -2.159 -3.3528 180) (layer F.SilkS)
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_text value Antenna (at 0 13) (layer F.Fab)
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_line (start -0.25 -2.76) (end 0 -2.26) (layer F.SilkS) (width 0.12))
+  (fp_line (start 0.25 -2.76) (end -0.25 -2.76) (layer F.SilkS) (width 0.12))
+  (fp_line (start 0 -2.26) (end 0.25 -2.76) (layer F.SilkS) (width 0.12))
+  (fp_line (start 0 3.1) (end -0.64 2.1) (layer F.Fab) (width 0.1))
+  (fp_line (start 0.64 2.1) (end 0 3.1) (layer F.Fab) (width 0.1))
+  (fp_text user %R (at 0 4.79 180) (layer F.Fab) hide
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_line (start 4 2.6) (end 4 -2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 3.68 12.12) (end -3.68 12.12) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -4 2.6) (end -4 -2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -4 -2.6) (end 4 -2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 4 2.6) (end 4 -2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start 3.68 12.12) (end -3.68 12.12) (layer B.CrtYd) (width 0.05))
+  (fp_line (start -4 2.6) (end -4 -2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start -4 -2.6) (end 4 -2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start 3.165 11.62) (end -3.165 11.62) (layer F.Fab) (width 0.1))
+  (fp_line (start 3.175 -1.71) (end 3.175 11.62) (layer F.Fab) (width 0.1))
+  (fp_line (start 3.175 -1.71) (end 2.365 -1.71) (layer F.Fab) (width 0.1))
+  (fp_line (start 2.365 -1.71) (end 2.365 2.1) (layer F.Fab) (width 0.1))
+  (fp_line (start 2.365 2.1) (end -2.365 2.1) (layer F.Fab) (width 0.1))
+  (fp_line (start -2.365 2.1) (end -2.365 -1.71) (layer F.Fab) (width 0.1))
+  (fp_line (start -2.365 -1.71) (end -3.175 -1.71) (layer F.Fab) (width 0.1))
+  (fp_line (start -3.175 -1.71) (end -3.175 11.62) (layer F.Fab) (width 0.1))
+  (fp_line (start 4.1 2.1) (end -4.1 2.1) (layer Dwgs.User) (width 0.1))
+  (fp_text user "PCB Edge" (at 0 2.6) (layer Dwgs.User)
+    (effects (font (size 0.5 0.5) (thickness 0.1)))
+  )
+  (fp_line (start -3.68 2.6) (end -4 2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -3.68 12.12) (end -3.68 2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 3.68 2.6) (end 4 2.6) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 3.68 2.6) (end 3.68 12.12) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -3.68 2.6) (end -4 2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start -3.68 12.12) (end -3.68 2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start 4 2.6) (end 3.68 2.6) (layer B.CrtYd) (width 0.05))
+  (fp_line (start 3.68 2.6) (end 3.68 12.12) (layer B.CrtYd) (width 0.05))
+  (fp_line (start -1.95 2) (end -0.84 2) (layer F.SilkS) (width 0.12))
+  (fp_line (start 0.84 2) (end 1.95 2) (layer F.SilkS) (width 0.12))
+  (pad 2 smd custom (at -3.00228 -1.6002) (size 1 1) (layers F.Cu F.Paste F.Mask)
+    (zone_connect 0)
+    (options (clearance outline) (anchor rect))
+    (primitives
+      (gr_poly (pts
+         (xy -0.5 -0.5) (xy 1.95 -0.5) (xy 1.95 1.5) (xy 0.85 1.5) (xy 0.85 3.7)
+         (xy -0.5 3.7)) (width 0))
+    ))
+  (pad 2 smd custom (at 1.5494 -1.6002) (size 1 1) (layers F.Cu F.Paste F.Mask)
+    (zone_connect 0)
+    (options (clearance outline) (anchor rect))
+    (primitives
+      (gr_poly (pts
+         (xy -0.5 -0.5) (xy 1.95 -0.5) (xy 1.95 3.7) (xy 0.6 3.7) (xy 0.6 1.5)
+         (xy -0.5 1.5)) (width 0))
+    ))
+  (pad 2 smd rect (at -2.825 0) (size 1.35 4.2) (layers B.Cu B.Paste B.Mask))
+  (pad 2 smd rect (at 2.825 0) (size 1.35 4.2) (layers B.Cu B.Paste B.Mask))
+  (pad 1 thru_hole rect (at 0 0.9906) (size 1.2 2.1) (drill 1) (layers *.Cu *.Mask))
+  (model ${KISYS3DMOD}/Connector_Coaxial.3dshapes/SMA_Samtec_SMA-J-P-X-ST-EM1_EdgeMount.wrl
+    (at (xyz 0 0 0))
+    (scale (xyz 1 1 1))
+    (rotate (xyz 0 0 0))
+  )
+)

PCB_SMD/kicad_libs/battery_holder.pretty/BatteryHolder_Keystone_1060_1x2032_Long_Pad.kicad_mod

@@ -1,73 +1,73 @@
-(module BatteryHolder_Keystone_1060_1x2032_Long_Pad (layer F.Cu) (tedit 5D66CD14)
+(module BatteryHolder_Keystone_1060_1x2032_Long_Pad (layer F.Cu) (tedit 5E2D666C)
   (descr http://www.keyelco.com/product-pdf.cfm?p=726)
   (tags "CR2032 BR2032 BatteryHolder Battery")
   (attr smd)
-  (fp_text reference BAT (at -14.125 -5.3) (layer F.SilkS)
-    (effects (font (size 1 1) (thickness 0.15)))
+  (fp_text reference BAT1 (at -12.99972 -5.82676 90) (layer F.SilkS)
+    (effects (font (size 0.8 0.8) (thickness 0.1)))
   )
   (fp_text value Battery_Cell (at 0 -11.75) (layer F.Fab)
     (effects (font (size 1 1) (thickness 0.15)))
   )
-  (fp_line (start -12 6) (end -14 6) (layer F.SilkS) (width 0.12))
-  (fp_line (start -13 5) (end -13 7) (layer F.SilkS) (width 0.12))
-  (fp_text user BAT (at 0 0) (layer F.Fab)
+  (fp_circle (center 0 0) (end -10.2 0) (layer Dwgs.User) (width 0.3))
+  (fp_line (start 11 8) (end -9.4 8) (layer F.Fab) (width 0.1))
+  (fp_line (start 11 -8) (end -11 -8) (layer F.Fab) (width 0.1))
+  (fp_line (start 11 8) (end 11 3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start 11 -8) (end 11 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -11 -8) (end -11 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -11 6.4) (end -11 3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -11 3.5) (end -14.2 3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -14.2 3.5) (end -14.2 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -14.2 -3.5) (end -11 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start 11 3.5) (end 14.2 3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start 14.2 3.5) (end 14.2 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start 14.2 -3.5) (end 11 -3.5) (layer F.Fab) (width 0.1))
+  (fp_line (start -9.4 8) (end -11 6.4) (layer F.Fab) (width 0.1))
+  (fp_line (start 11.35 3.85) (end 14.55 3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start 14.55 3.85) (end 14.55 2.3) (layer F.SilkS) (width 0.12))
+  (fp_line (start 11.35 8.35) (end 11.35 3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start 11.35 8.35) (end -9.55 8.35) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.35 6.55) (end -11.35 3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start -9.55 8.35) (end -11.35 6.55) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.35 3.85) (end -14.55 3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start -14.55 3.85) (end -14.55 2.3) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.35 -3.85) (end -14.55 -3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start -14.55 -3.85) (end -14.55 -2.3) (layer F.SilkS) (width 0.12))
+  (fp_line (start 11.35 -3.85) (end 14.55 -3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start 14.55 -3.85) (end 14.55 -2.3) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.35 -8.35) (end 11.35 -8.35) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.35 -8.35) (end -11.35 -3.85) (layer F.SilkS) (width 0.12))
+  (fp_line (start 11.35 -8.35) (end 11.35 -3.85) (layer F.SilkS) (width 0.12))
+  (fp_arc (start 0 0) (end -6.5 8.5) (angle -74.81070976) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 11.5 8.5) (end 6.5 8.5) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -6.5 8.5) (end -11.5 8.5) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -11.5 4) (end -11.5 8.5) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 4) (end -11.5 4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 4) (end -14.7 2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 2.3) (end -16.45 2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -16.45 2.3) (end -16.45 -2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 -2.3) (end -16.45 -2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 -2.3) (end -14.7 -4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -14.7 -4) (end -11.5 -4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -11.5 -4) (end -11.5 -8.5) (layer F.CrtYd) (width 0.05))
+  (fp_line (start -11.5 -8.5) (end -6.5 -8.5) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 11.5 -8.5) (end 11.5 -4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 11.5 -4) (end 14.7 -4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 14.7 -4) (end 14.7 -2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 14.7 -2.3) (end 16.45 -2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 16.45 -2.3) (end 16.45 2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 16.45 2.3) (end 14.7 2.3) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 14.7 2.3) (end 14.7 4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 14.7 4) (end 11.5 4) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 11.5 4) (end 11.5 8.5) (layer F.CrtYd) (width 0.05))
+  (fp_arc (start 0 0) (end 6.5 -8.5) (angle -74.81070976) (layer F.CrtYd) (width 0.05))
+  (fp_line (start 11.5 -8.5) (end 6.5 -8.5) (layer F.CrtYd) (width 0.05))
+  (fp_text user BAT (at 0 0) (layer F.Fab) hide
     (effects (font (size 1 1) (thickness 0.15)))
   )
-  (fp_line (start 11.5 -8.5) (end 6.5 -8.5) (layer F.CrtYd) (width 0.05))
-  (fp_arc (start 0 0) (end 6.5 -8.5) (angle -74.81070976) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 11.5 4) (end 11.5 8.5) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 14.7 4) (end 11.5 4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 14.7 2.3) (end 14.7 4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 16.45 2.3) (end 14.7 2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 16.45 -2.3) (end 16.45 2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 14.7 -2.3) (end 16.45 -2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 14.7 -4) (end 14.7 -2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 11.5 -4) (end 14.7 -4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 11.5 -8.5) (end 11.5 -4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -11.5 -8.5) (end -6.5 -8.5) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -11.5 -4) (end -11.5 -8.5) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 -4) (end -11.5 -4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 -2.3) (end -14.7 -4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 -2.3) (end -16.45 -2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -16.45 2.3) (end -16.45 -2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 2.3) (end -16.45 2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 4) (end -14.7 2.3) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -14.7 4) (end -11.5 4) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -11.5 4) (end -11.5 8.5) (layer F.CrtYd) (width 0.05))
-  (fp_line (start -6.5 8.5) (end -11.5 8.5) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 11.5 8.5) (end 6.5 8.5) (layer F.CrtYd) (width 0.05))
-  (fp_arc (start 0 0) (end -6.5 8.5) (angle -74.81070976) (layer F.CrtYd) (width 0.05))
-  (fp_line (start 11.35 -8.35) (end 11.35 -3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -11.35 -8.35) (end -11.35 -3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -11.35 -8.35) (end 11.35 -8.35) (layer F.SilkS) (width 0.12))
-  (fp_line (start 14.55 -3.85) (end 14.55 -2.3) (layer F.SilkS) (width 0.12))
-  (fp_line (start 11.35 -3.85) (end 14.55 -3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -14.55 -3.85) (end -14.55 -2.3) (layer F.SilkS) (width 0.12))
-  (fp_line (start -11.35 -3.85) (end -14.55 -3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -14.55 3.85) (end -14.55 2.3) (layer F.SilkS) (width 0.12))
-  (fp_line (start -11.35 3.85) (end -14.55 3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -9.55 8.35) (end -11.35 6.55) (layer F.SilkS) (width 0.12))
-  (fp_line (start -11.35 6.55) (end -11.35 3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start 11.35 8.35) (end -9.55 8.35) (layer F.SilkS) (width 0.12))
-  (fp_line (start 11.35 8.35) (end 11.35 3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start 14.55 3.85) (end 14.55 2.3) (layer F.SilkS) (width 0.12))
-  (fp_line (start 11.35 3.85) (end 14.55 3.85) (layer F.SilkS) (width 0.12))
-  (fp_line (start -9.4 8) (end -11 6.4) (layer F.Fab) (width 0.1))
-  (fp_line (start 14.2 -3.5) (end 11 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start 14.2 3.5) (end 14.2 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start 11 3.5) (end 14.2 3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start -14.2 -3.5) (end -11 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start -14.2 3.5) (end -14.2 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start -11 3.5) (end -14.2 3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start -11 6.4) (end -11 3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start -11 -8) (end -11 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start 11 -8) (end 11 -3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start 11 8) (end 11 3.5) (layer F.Fab) (width 0.1))
-  (fp_line (start 11 -8) (end -11 -8) (layer F.Fab) (width 0.1))
-  (fp_line (start 11 8) (end -9.4 8) (layer F.Fab) (width 0.1))
-  (fp_circle (center 0 0) (end -10.2 0) (layer Dwgs.User) (width 0.3))
-  (pad 1 smd rect (at -12.446 0 180) (size 7.1 3.6) (layers F.Cu F.Paste F.Mask))
+  (fp_line (start -12.97432 4.5278) (end -12.97432 6.5278) (layer F.SilkS) (width 0.12))
+  (fp_line (start -11.98524 5.54736) (end -13.98524 5.54736) (layer F.SilkS) (width 0.12))
   (pad 2 smd rect (at 12.446 0 180) (size 7.1 3.6) (layers F.Cu F.Paste F.Mask))
+  (pad 1 smd rect (at -12.446 0 180) (size 7.1 3.6) (layers F.Cu F.Paste F.Mask))
   (model ${KISYS3DMOD}/Battery.3dshapes/BatteryHolder_Keystone_1060_1x2032.wrl
     (at (xyz 0 0 0))
     (scale (xyz 1 1 1))

PCB_THT/LORA_ATTINY84.kicad_pcb

@@ -389,6 +389,11 @@
       (net 12 MOSI))
     (pad 1 smd oval (at 0 0) (size 2 1) (layers F.Cu F.Paste F.Mask)
       (net 2 GND))
+    (model "${KIPRJMOD}/kicad_libs/RFM95/RFM95.wrl"
+      (offset (xyz 16 -14.9 0))
+      (scale (xyz 0.39 0.39 0.39))
+      (rotate (xyz -90 0 180))
+    )
   )
 
   (module Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical (layer F.Cu) (tedit 59FED5CC) (tstamp 5D66B8BC)

PCB_THT/README.md

@@ -1,6 +1,8 @@
-# TinyLora PCB (Throughole Version)
+# ATTNode PCB (Throughole Version)
 
-PCB for the TinyLora Sensor Node, Throughole Version 
+**Further Development will be for the SMD Version. At the Moment I don't plan amy further developing the THT Version**
+
+PCB for the ATTiny Sensor Node, Throughole Version 
 WARNING: Due to height might not fit into the 3D-Printed case when ATTiny is used with a Socket
 
 ## Parts List

README.md

@@ -1,59 +1,26 @@
-# TinyLoRa Sensor Node
+# ATTiny Sensor Node  (ATTNode)
 
 ## Overview
 
-A Minimalistic Sensor Node for use on TheThingsNetwork.
+A Minimalistic Sensor Node for use on TheThingsNetwork with the following Features:
 
-![Case Front](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/case_front.jpg)
-![Case Side](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/case_side.jpg)
-![Case Back](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/case_back.jpg)
-![PCB Front](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/pcb_front.jpg)
-![PCB Back BME](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/pcb_back_bme.jpg)
-![PCB Back SHT](https://www.seiichiro0185.org/git/IOT/tinylora/raw/branch/master/pcb_back_sht.jpg)
+  * Small Size, only 47x36mm (v1) / 34x26mm (v2)
+  * Based on widely available Atmel ATTiny84 MCU and RFM95W LoRa-module
+  * 6 free GPIO-Pins from the ATTiny + Power to connect sensors on a 2.54mm pitch header
+  * Optional on-board LED for status signaling
+  * Powered by a single CR2032 lithium battery
+  * Long battery runtime using the ATTinys deep sleep mode
+  * Integrated 6-Pin programming header
+  * Small component count
+  * Possibility for edge-mount SMA connector or u.fl SMD connector (v2)
 
-### Features
-
-* Small Size, only 47x36x15mm populated (SMD Version)
-* Based on widely available Atmel ATTiny84 MCU and RFM95W LoRa-module
-* 6 free GPIO-Pins from the ATTiny + Power to connect sensors on a 2.54mm pitch header
-* Optional on-board LED for status signaling (SMD Version)
-* Powered by a single CR2032 lithium battery
-* Long battery runtime using  the ATTinys deep sleep mode
-* Integrated 6-Pin programming header (SMD Version)
-* Small component count
-* Fitting 3D-Printed Case
+**You can get all up to date information as well as assembly and pogramming hints at https://www.attno.de/**
 
 ## Subdirectories In this Repository
 
 * **Case:** A 3D-Printable Case, OpenSCAD and STL Files
-* **Firmware:** Example Firmware for a BME280 Climate Sensor, PlatformIO project
+* **Firmware:** Example Firmware for a BME280/SHT21 Climate Sensor, PlatformIO project
 * **PCB_SMD:** PCB for SMD components, KiCAD project
-* **PCB_THT:** PCB with through-hole components, KiCAD project, Currently not all Features of the SMD Version
-
-## Pinouts
-
-### PRG1 Starting from Marked Top Left Pin
-
-|          |          |
-|----------|----------|
-| MISO     | 3V3      |
-| SCK      | MOSI     |
-| RST      | GND      |
-
-
-### J1 Starting from Marked Pin 1
-
-| Number | Function          | Note                           |
-|--------|-------------------|--------------------------------|
-|      1 | 3V3               | Directly connected to Battery  |
-|      2 | GND               | Directly connected to Battery  |
-|      3 | ATTiny84 PA0      | i2C SCL in Example Firmware    |
-|      4 | ATTiny84 PA1      | i2C SDA in Example Firmware    |
-|      5 | ATTiny84 PA2      |                                |
-|      6 | ATTiny84 PA3      |                                |
-|      7 | ATTiny84 PA7      | Connected to LED-Pad D1 via R1 |
-|      8 | ATTiny84 PB2      |                                |
-
 
 ## Thanks & Acknowledgements: