Compare commits

...

40 Commits
v1.2 ... master

Author SHA1 Message Date
seiichiro 990434b673 Use secconfig.example.h, ignore secconfig.h 2023-12-20 17:50:20 +01:00
seiichiro 7e2b35eb19 PCB: Make Gerber Files pcbs.io Compatible 2021-03-12 19:17:11 +01:00
seiichiro ea3233b9f7 Project Renamed to ATTNode 2020-09-10 16:37:54 +02:00
seiichiro 453851d1df Fix Typos, Add DS18B20 Decoder 2020-07-08 18:24:40 +02:00
andreask b0767682cc debug blink removed 2020-06-27 13:50:10 +02:00
andreask 52858f8d18 DS18B20 added 2020-06-27 13:47:41 +02:00
andreask 59aefd4928 DS18B20 added 2020-06-27 13:37:15 +02:00
seiichiro 9a51210f38 [Firmware] Adapt Decoder for Climate+Alarm Sensors 2020-06-21 21:35:40 +02:00
seiichiro 4e25baf91e [Firmware] Add Combined Alarm and Climate Functionality 2020-06-21 21:29:24 +02:00
seiichiro a4c40b1b5d Typo Correction in Payload Function 2020-06-13 16:13:18 +02:00
seiichiro e9a12cb02b Add Alarm Function to Example Decoder 2020-06-13 11:02:51 +02:00
andreask 58f24c54c1 alarm function 2020-06-12 22:48:22 +02:00
seiichiro 2ff0e5f79e Add Brightness Measurement Decoding to Payload Decoder 2020-05-10 10:09:29 +02:00
andreask ab3c84e259 brightness measurement via LED 2020-05-09 20:23:58 +02:00
andreask 3cc9d2b6c1 projectpath to 3dshapes 2020-04-26 11:29:14 +02:00
seiichiro 4fdf8db082 RFM69: Disable Resends 2020-04-26 10:10:30 +02:00
andreask d69f7086c1 RFM95 3d model added 2020-04-25 20:43:33 +02:00
andreask aa17034437 RFM95 3D Model added 2020-04-25 20:39:45 +02:00
seiichiro f338cce56d Beaconmode FrameCounter Persistance Fix Part 2 2020-04-21 21:39:34 +02:00
seiichiro a37dba6ae9 Fix FrameCounter Read from EEPROM for Beacon Mode 2020-04-21 18:08:35 +02:00
seiichiro 12bed1f861 Update Readme for Persistent Frame Counter 2020-04-21 08:13:10 +02:00
seiichiro 361f8e0b85 Firmware: Persist FrameCounter in EEPROM 2020-04-21 07:57:23 +02:00
seiichiro 31063b01d2 Add Firmware License 2020-04-19 11:13:31 +02:00
seiichiro c0e9ad81e0 Some Cleanup, Website as Primary Reference 2020-04-19 10:49:48 +02:00
seiichiro d0c953949a TinyLoRa v2 Case Added 2020-04-13 19:20:14 +02:00
seiichiro 10b2a5f861 [Firmware] Add Retry for RFM69 2020-03-03 05:55:29 +01:00
seiichiro ed1114488c [PCB] Small Optimizations for v2 PCB 2020-03-03 05:54:41 +01:00
seiichiro 966b9c1fe8 [Firmware] Decoder Parentheses Correction 2020-02-13 05:44:11 +01:00
seiichiro 0987f880a4 [Firmware] Make LED on Sending Configurable 2020-02-08 17:43:35 +01:00
seiichiro 163fd13d51 [Firmware] Fix Copy-Paste Error in Decoder 2020-02-07 08:24:17 +01:00
seiichiro 10611e377f Merge branch 'bake_v2'
PCB v2, new optimized Payload Format, better Beacon Mode
2020-01-26 17:17:10 +01:00
seiichiro 1aac8c9f15 [Firmware] Adapt Decoder for Optimized Payload Format 2020-01-26 17:14:12 +01:00
seiichiro 6a6c97a01d [SMD] Optimization for fitting the lid - Thanks André for the fix 2020-01-26 17:02:09 +01:00
seiichiro 9ff916ee52 [SMD] Added SMA/UFL Combo Antenna Port 2020-01-26 11:46:47 +01:00
seiichiro d511b700e3 [SMD] Tinylora PCB V2 2020-01-23 21:37:08 +01:00
andreask b6f37aef62 different ports for spreading factors 2020-01-22 22:25:07 +01:00
seiichiro a552d95c6d New Beacon Mode 2020-01-20 19:24:40 +01:00
seiichiro 6d84856416 Blank Line Fix 2020-01-20 14:55:42 +01:00
seiichiro c4cd51a791 Payload Format Changes 2020-01-20 14:33:10 +01:00
seiichiro 68697a4b19 Add ability to set Datarate 2020-01-20 13:43:37 +01:00
65 changed files with 181371 additions and 63020 deletions

2
.gitignore vendored Normal file
View File

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

View File

@ -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]);
}

96
Case/ATTNode_v2.scad Normal file
View File

@ -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);
}
}

View File

@ -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

File diff suppressed because it is too large Load Diff

1
Firmware/.gitignore vendored
View File

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

View File

@ -1,7 +1,10 @@
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
]
}
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
],
"unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack"
]
}

24
Firmware/LICENSE Normal file
View File

@ -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.

View File

@ -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)

View File

@ -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

View File

@ -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

View File

@ -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);