feeling/seatalk-autopilot-remote-control
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add files via upload

Browse Source
This commit is contained in:
AK-Homberger
2019-07-21 10:42:44 +02:00
committed by GitHub
parent 78feeccaf3
commit f40e3de9dc
5 changed files with 871 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
AP-Remote-Software/ArduinoPilotMicro433WindNG/ArduinoPilotMicro433WindNG.ino Normal file
View File

@@ -0,0 +1,206 @@
#include <avr/pgmspace.h>
#include <RCSwitch.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
RCSwitch mySwitch = RCSwitch();
const long unsigned int Key1 PROGMEM = 0000001; // Change values to individual values programmed to remote control
const long unsigned int Key2 PROGMEM = 0000002;
const long unsigned int Key3 PROGMEM = 0000003;
const long unsigned int Key4 PROGMEM = 0000004;
// Seatalk datagrams
const PROGMEM uint16_t ST_NMEA_BridgeID[] = { 0x190, 0x00, 0xA3 };
const PROGMEM uint16_t ST_Minus_1[] = { 0x186, 0x21, 0x05, 0xFA };
const PROGMEM uint16_t ST_Minus_10[] = { 0x186, 0x21, 0x06, 0xF9 };
const PROGMEM uint16_t ST_Plus_1[] = { 0x186, 0x21, 0x07, 0xF8 };
const PROGMEM uint16_t ST_Plus_10[] = { 0x186, 0x21, 0x08, 0xF7 };
const PROGMEM uint16_t ST_BeepOn[] = { 0x1A8, 0x53, 0x80, 0x00, 0x00, 0xD3 };
const PROGMEM uint16_t ST_BeepOff[] = { 0x1A8, 0x43, 0x80, 0x00, 0x00, 0xC3 };
boolean blink = true;
long unsigned int timer=0;
long unsigned int timer1=0;
long unsigned int timer2=0;
boolean sendDatagram(const uint16_t data[]) {
int i = 0; int j = 0;
boolean ok = true;
int bytes;
unsigned int inbyte;
unsigned int outbyte;
bytes = (pgm_read_byte_near(data + 1) & 0x0f) + 3; // Messege length is minimum 3, additional bytes in nibble 4
while (j < 5 ) { // CDMA/CD 5 tries
while (Serial1.available ()) { // Wait for silence on the bus
inbyte = (Serial1.read());
delay(3);
}
ok = true;
for (i = 0; (i < bytes) & (ok == true); i++) { // Write and listen to detect collisions
outbyte = pgm_read_word_near(data + i);
Serial1.write(outbyte);
delay(3);
if (Serial1.available ()) {
inbyte = Serial1.read(); // Not what we sent, collision!
if (inbyte != outbyte) ok = false;
}
else ok = false; // Nothing received
}
if ( ok )return ok;
j++; // Collision detected
// Serial.println("CD");
// Display("Collision", 2);
delay(random(2, 50)); // Random wait for next try
}
Display("Send Error", 2);
return false;
}
void Display(char *string, int size)
{
display.clearDisplay();
display.setTextSize(size);
display.setCursor(0, 0);
display.println(string);
display.display();
timer = 0;
}
int checkWind(char * AWS) // Receice apparent wind speed from bus
{
unsigned int xx;
unsigned int y;
unsigned int inbyte;
int wind = -1;
if (Serial1.available ()) {
inbyte = Serial1.read();
if (inbyte == 0x111) { // AWS Seatalk command - See reference from Thomas Knauf
delay(3);
inbyte = Serial1.read();
if (inbyte == 0x01) { // AWS Setalk command
delay(3);
xx = Serial1.read();
delay(3);
y = Serial1.read();
wind = (xx & 0x7f) + (y / 10); // Wind speed
if (wind < 100) itoa (wind , AWS, 10); // Greater 100 must be a receive error
}
}
}
return wind;
}
void setup()
{
Serial.begin( 9600 ); // Serial out put for function checks with PC
Serial1.begin( 4800, SERIAL_9N1 ); // Set the Seatalk modus - 9 bit
Serial1.setTimeout(5);
mySwitch.enableReceive(4); // RF Receiver on inerrupt 4 => that is pin 7 on Micro
pinMode(9, OUTPUT); // LED to show if keys are received
digitalWrite(9, HIGH);
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3C (for the 128x64 from Conrad else 3D)
display.setTextColor(WHITE);
Display("Start", 4);
sendDatagram(ST_NMEA_BridgeID); // Send NMEA Seatakl BridgeID to make Seatalk to Seatalk NG converter happy
}
void loop()
{
int i;
char AWS[4] = "";
timer++;timer1++;timer2++;
if (timer > 200000 ) {
Display("---", 7); // Show --- after about two seconds when no wind data is received
timer = 0;
}
if (timer1 > 300000 ) {
sendDatagram(ST_BeepOff); // Additional Beep off after three seconds
timer1 = 0;
}
if (timer2 > 1000000 ) {
sendDatagram(ST_NMEA_BridgeID); // Send NMEA Seatakl BridgeID every 10 seconds to make Seatalk to Seatalk NG converter happy
timer2 = 0;
}
if (checkWind(AWS) > -1) Display(AWS, 7);
if (mySwitch.available()) {
long unsigned int value = mySwitch.getReceivedValue();
digitalWrite(9, blink); // LED on/off
blink = !blink; // Toggle LED to show received key
mySwitch.resetAvailable();
if (value == Key1) {
Display("-1", 7);
sendDatagram(ST_Minus_1);
sendDatagram(ST_BeepOn);
delay(150);
sendDatagram(ST_BeepOff);
}
if (value == Key2) {
Display("+1", 7);
sendDatagram(ST_Plus_1);
sendDatagram(ST_BeepOn);
delay(150);
sendDatagram(ST_BeepOff);
}
if (value == Key3) {
Display("-10", 7);
sendDatagram(ST_Minus_10);
sendDatagram(ST_BeepOn);
delay(150);
sendDatagram(ST_BeepOff);
}
if (value == Key4) {
Display("+10", 7);
sendDatagram(ST_Plus_10);
sendDatagram(ST_BeepOn);
delay(150);
sendDatagram(ST_BeepOff);
}
i = 0;
while (mySwitch.available() && i < 2) {
mySwitch.resetAvailable();
delay (150);
i++;
}
}
}

312
AP-Remote-Software/NewHWSworking/HardwareSerial.cpp Normal file
View File

@@ -0,0 +1,312 @@
/*
HardwareSerial.cpp - Hardware serial library for Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
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.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 23 November 2006 by David A. Mellis
Modified 28 September 2010 by Mark Sproul
Modified 14 August 2012 by Alarus
Modified 3 December 2013 by Matthijs Kooijman
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"
#include "HardwareSerial.h"
#include "HardwareSerial_private.h"
// this next line disables the entire HardwareSerial.cpp,
// this is so I can support Attiny series and any other chip without a uart
#if defined(HAVE_HWSERIAL0) || defined(HAVE_HWSERIAL1) || defined(HAVE_HWSERIAL2) || defined(HAVE_HWSERIAL3)
// SerialEvent functions are weak, so when the user doesn't define them,
// the linker just sets their address to 0 (which is checked below).
// The Serialx_available is just a wrapper around Serialx.available(),
// but we can refer to it weakly so we don't pull in the entire
// HardwareSerial instance if the user doesn't also refer to it.
#if defined(HAVE_HWSERIAL0)
void serialEvent() __attribute__((weak));
bool Serial0_available() __attribute__((weak));
#endif
#if defined(HAVE_HWSERIAL1)
void serialEvent1() __attribute__((weak));
bool Serial1_available() __attribute__((weak));
#endif
#if defined(HAVE_HWSERIAL2)
void serialEvent2() __attribute__((weak));
bool Serial2_available() __attribute__((weak));
#endif
#if defined(HAVE_HWSERIAL3)
void serialEvent3() __attribute__((weak));
bool Serial3_available() __attribute__((weak));
#endif
void serialEventRun(void)
{
#if defined(HAVE_HWSERIAL0)
if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
#endif
#if defined(HAVE_HWSERIAL1)
if (Serial1_available && serialEvent1 && Serial1_available()) serialEvent1();
#endif
#if defined(HAVE_HWSERIAL2)
if (Serial2_available && serialEvent2 && Serial2_available()) serialEvent2();
#endif
#if defined(HAVE_HWSERIAL3)
if (Serial3_available && serialEvent3 && Serial3_available()) serialEvent3();
#endif
}
// Actual interrupt handlers //////////////////////////////////////////////////////////////
void HardwareSerial::_tx_udr_empty_irq(void)
{
// If interrupts are enabled, there must be more data in the output
// buffer. Send the next byte
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is configured for 9 bit mode
unsigned char mb = _tx_buffer[_tx_buffer_tail];
unsigned char c = _tx_buffer[_tx_buffer_tail + 1];
_tx_buffer_tail = (_tx_buffer_tail + 2) % SERIAL_TX_BUFFER_SIZE;
if(mb & 0x01) {
sbi(*_ucsrb, TXB80);
} else {
cbi(*_ucsrb, TXB80);
}
*_udr = c;
} else {
// UART is configured for 5 to 8 bit modes
unsigned char c = _tx_buffer[_tx_buffer_tail];
_tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE;
*_udr = c;
}
// clear the TXC bit -- "can be cleared by writing a one to its bit
// location". This makes sure flush() won't return until the bytes
// actually got written
sbi(*_ucsra, TXC0);
if (_tx_buffer_head == _tx_buffer_tail) {
// Buffer empty, so disable interrupts
cbi(*_ucsrb, UDRIE0);
}
}
// Public Methods //////////////////////////////////////////////////////////////
void HardwareSerial::begin(unsigned long baud, uint16_t config)
{
// Try u2x mode first
uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
*_ucsra = 1 << U2X0;
// hardcoded exception for 57600 for compatibility with the bootloader
// shipped with the Duemilanove and previous boards and the firmware
// on the 8U2 on the Uno and Mega 2560. Also, The baud_setting cannot
// be > 4095, so switch back to non-u2x mode if the baud rate is too
// low.
if (((F_CPU == 16000000UL) && (baud == 57600)) || (baud_setting >4095))
{
*_ucsra = 0;
baud_setting = (F_CPU / 8 / baud - 1) / 2;
}
// assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register)
*_ubrrh = baud_setting >> 8;
*_ubrrl = baud_setting;
_written = false;
//set the data bits, parity, and stop bits
#if defined(__AVR_ATmega8__)
config |= 0x80; // select UCSRC register (shared with UBRRH)
#endif
if(config & 0x100) {
sbi(*_ucsrb, UCSZ02);
}
*_ucsrc = (uint8_t) config;
sbi(*_ucsrb, RXEN0);
sbi(*_ucsrb, TXEN0);
sbi(*_ucsrb, RXCIE0);
cbi(*_ucsrb, UDRIE0);
}
void HardwareSerial::end()
{
// wait for transmission of outgoing data
while (_tx_buffer_head != _tx_buffer_tail)
;
cbi(*_ucsrb, RXEN0);
cbi(*_ucsrb, TXEN0);
cbi(*_ucsrb, RXCIE0);
cbi(*_ucsrb, UDRIE0);
// clear any received data
_rx_buffer_head = _rx_buffer_tail;
}
int HardwareSerial::available(void)
{
unsigned int a = (unsigned int) (SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail) % SERIAL_RX_BUFFER_SIZE;
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is in 9 bit mode return only the half, because we use two bytes per 9 bit "byte".
return a / 2;
}
else {
// For 5 - 8 bit modes simply return the number
return a;
}
}
int HardwareSerial::peek(void)
{
if (_rx_buffer_head == _rx_buffer_tail) {
return -1;
} else {
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is in 9 bit mode read two bytes and merge them
return (_rx_buffer[_rx_buffer_tail] << 8) | _rx_buffer[_rx_buffer_tail + 1 % SERIAL_RX_BUFFER_SIZE];
} else {
return _rx_buffer[_rx_buffer_tail];
}
}
}
int HardwareSerial::read(void)
{
// if the head isn't ahead of the tail, we don't have any characters
if (_rx_buffer_head == _rx_buffer_tail) {
return -1;
} else {
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is in 9 bit mode read two bytes and merge them
unsigned char mb = _rx_buffer[_rx_buffer_tail];
unsigned char c = _rx_buffer[_rx_buffer_tail + 1];
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 2) % SERIAL_RX_BUFFER_SIZE;
return ((mb << 8) | c);
} else {
unsigned char c = _rx_buffer[_rx_buffer_tail];
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
return c;
}
}
}
int HardwareSerial::availableForWrite(void)
{
#if (SERIAL_TX_BUFFER_SIZE>256)
uint8_t oldSREG = SREG;
cli();
#endif
tx_buffer_index_t head = _tx_buffer_head;
tx_buffer_index_t tail = _tx_buffer_tail;
#if (SERIAL_TX_BUFFER_SIZE>256)
SREG = oldSREG;
#endif
if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
return tail - head - 1;
}
void HardwareSerial::flush()
{
// If we have never written a byte, no need to flush. This special
// case is needed since there is no way to force the TXC (transmit
// complete) bit to 1 during initialization
if (!_written)
return;
while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
// Interrupts are globally disabled, but the DR empty
// interrupt should be enabled, so poll the DR empty flag to
// prevent deadlock
if (bit_is_set(*_ucsra, UDRE0))
_tx_udr_empty_irq();
}
// If we get here, nothing is queued anymore (DRIE is disabled) and
// the hardware finished tranmission (TXC is set).
}
size_t HardwareSerial::write(uint16_t c)
{
// If the buffer and the data register is empty, just write the byte
// to the data register and be done. This shortcut helps
// significantly improve the effective datarate at high (>
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
if(bit_is_set(*_ucsrb, UCSZ02)) {
// in 9 bit mode set TXB8 bit if necessary
if(c & 0x100) {
sbi(*_ucsrb, TXB80);
} else {
cbi(*_ucsrb, TXB80);
}
}
*_udr = (uint8_t) c;
sbi(*_ucsra, TXC0);
return 1;
}
tx_buffer_index_t i;
if(bit_is_set(*_ucsrb, UCSZ02)) {
i = ((_tx_buffer_head + 2) % SERIAL_TX_BUFFER_SIZE);
} else {
i = ((_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE);
}
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
while (i == _tx_buffer_tail) {
if (bit_is_clear(SREG, SREG_I)) {
// Interrupts are disabled, so we'll have to poll the data
// register empty flag ourselves. If it is set, pretend an
// interrupt has happened and call the handler to free up
// space for us.
if(bit_is_set(*_ucsra, UDRE0))
_tx_udr_empty_irq();
} else {
// nop, the interrupt handler will free up space for us
}
}
if(bit_is_set(*_ucsrb, UCSZ02)) {
_tx_buffer[_tx_buffer_head] = (uint8_t) (c >> 8) & 0x01;
_tx_buffer[_tx_buffer_head + 1] = (uint8_t) c;
} else {
_tx_buffer[_tx_buffer_head] = (uint8_t) c;
}
_tx_buffer_head = i;
sbi(*_ucsrb, UDRIE0);
_written = true;
return 1;
}
#endif // whole file

161
AP-Remote-Software/NewHWSworking/HardwareSerial.h Normal file
View File

@@ -0,0 +1,161 @@
/*
HardwareSerial.h - Hardware serial library for Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
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.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 28 September 2010 by Mark Sproul
Modified 14 August 2012 by Alarus
Modified 3 December 2013 by Matthijs Kooijman
*/
#ifndef HardwareSerial_h
#define HardwareSerial_h
#include <inttypes.h>
#include "Stream.h"
// Define constants and variables for buffering incoming serial data. We're
// using a ring buffer (I think), in which head is the index of the location
// to which to write the next incoming character and tail is the index of the
// location from which to read.
#if !(defined(SERIAL_TX_BUFFER_SIZE) && defined(SERIAL_RX_BUFFER_SIZE))
#if (RAMEND < 1000)
#define SERIAL_TX_BUFFER_SIZE 16
#define SERIAL_RX_BUFFER_SIZE 16
#else
#define SERIAL_TX_BUFFER_SIZE 64
#define SERIAL_RX_BUFFER_SIZE 64
#endif
#endif
#if (SERIAL_TX_BUFFER_SIZE>256)
typedef uint16_t tx_buffer_index_t;
#else
typedef uint8_t tx_buffer_index_t;
#endif
#if (SERIAL_RX_BUFFER_SIZE>256)
typedef uint16_t rx_buffer_index_t;
#else
typedef uint8_t rx_buffer_index_t;
#endif
// Define config for Serial.begin(baud, config);
#define SERIAL_5N1 0x000 //0b000000000
#define SERIAL_6N1 0x002 //0b000000010
#define SERIAL_7N1 0x004 //0b000000100
#define SERIAL_8N1 0x006 //0b000000110
#define SERIAL_9N1 0x106 //0b100000110
#define SERIAL_5N2 0x008 //0b000001000
#define SERIAL_6N2 0x00A //0b000001010
#define SERIAL_7N2 0x00C //0b000001100
#define SERIAL_8N2 0x00E //0b000001110
#define SERIAL_9N2 0x10E //0b100001110
#define SERIAL_5E1 0x020 //0b000100000
#define SERIAL_6E1 0x022 //0b000100010
#define SERIAL_7E1 0x024 //0b000100100
#define SERIAL_8E1 0x026 //0b000100110
#define SERIAL_9E1 0x126 //0b100100110
#define SERIAL_5E2 0x028 //0b000101000
#define SERIAL_6E2 0x02A //0b000101010
#define SERIAL_7E2 0x02C //0b000101100
#define SERIAL_8E2 0x02E //0b000101110
#define SERIAL_9E2 0x12E //0b100101110
#define SERIAL_5O1 0x030 //0b000110000
#define SERIAL_6O1 0x032 //0b000110010
#define SERIAL_7O1 0x034 //0b000110100
#define SERIAL_8O1 0x036 //0b000110110
#define SERIAL_9O1 0x136 //0b100110110
#define SERIAL_5O2 0x038 //0b000111000
#define SERIAL_6O2 0x03A //0b000111010
#define SERIAL_7O2 0x03C //0b000111100
#define SERIAL_8O2 0x03E //0b000111110
#define SERIAL_9O2 0x13E //0b100111110
class HardwareSerial : public Stream
{
protected:
volatile uint8_t * const _ubrrh;
volatile uint8_t * const _ubrrl;
volatile uint8_t * const _ucsra;
volatile uint8_t * const _ucsrb;
volatile uint8_t * const _ucsrc;
volatile uint8_t * const _udr;
// Has any byte been written to the UART since begin()
bool _written;
volatile rx_buffer_index_t _rx_buffer_head;
volatile rx_buffer_index_t _rx_buffer_tail;
volatile tx_buffer_index_t _tx_buffer_head;
volatile tx_buffer_index_t _tx_buffer_tail;
// Don't put any members after these buffers, since only the first
// 32 bytes of this struct can be accessed quickly using the ldd
// instruction.
unsigned char _rx_buffer[SERIAL_RX_BUFFER_SIZE];
unsigned char _tx_buffer[SERIAL_TX_BUFFER_SIZE];
public:
inline HardwareSerial(
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
volatile uint8_t *ucsrc, volatile uint8_t *udr);
void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }
void begin(unsigned long, uint16_t);
void end();
virtual int available(void);
virtual int peek(void);
virtual int read(void);
int availableForWrite(void);
virtual void flush(void);
virtual size_t write(uint16_t);
inline size_t write(unsigned long n) { return write((uint16_t)n); }
inline size_t write(long n) { return write((uint16_t)n); }
inline size_t write(int n) { return write((uint16_t)n); }
inline size_t write(int8_t n) { return write((uint16_t)n); }
inline size_t write(uint8_t n) { return write((uint16_t)n); }
using Print::write; // pull in write(str) and write(buf, size) from Print
operator bool() { return true; }
// Interrupt handlers - Not intended to be called externally
inline void _rx_complete_irq(void);
void _tx_udr_empty_irq(void);
};
#if defined(UBRRH) || defined(UBRR0H)
extern HardwareSerial Serial;
#define HAVE_HWSERIAL0
#endif
#if defined(UBRR1H)
extern HardwareSerial Serial1;
#define HAVE_HWSERIAL1
#endif
#if defined(UBRR2H)
extern HardwareSerial Serial2;
#define HAVE_HWSERIAL2
#endif
#if defined(UBRR3H)
extern HardwareSerial Serial3;
#define HAVE_HWSERIAL3
#endif
extern void serialEventRun(void) __attribute__((weak));
#endif

148
AP-Remote-Software/NewHWSworking/HardwareSerial_private.h Normal file
View File

@@ -0,0 +1,148 @@
/*
HardwareSerial_private.h - Hardware serial library for Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
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.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 23 November 2006 by David A. Mellis
Modified 28 September 2010 by Mark Sproul
Modified 14 August 2012 by Alarus
*/
#include "wiring_private.h"
// this next line disables the entire HardwareSerial.cpp,
// this is so I can support Attiny series and any other chip without a uart
#if defined(HAVE_HWSERIAL0) || defined(HAVE_HWSERIAL1) || defined(HAVE_HWSERIAL2) || defined(HAVE_HWSERIAL3)
// Ensure that the various bit positions we use are available with a 0
// postfix, so we can always use the values for UART0 for all UARTs. The
// alternative, passing the various values for each UART to the
// HardwareSerial constructor also works, but makes the code bigger and
// slower.
#if !defined(TXC0)
#if defined(TXC)
// Some chips like ATmega8 don't have UPE, only PE. The other bits are
// named as expected.
#if !defined(UPE) && defined(PE)
#define UPE PE
#endif
// On ATmega8, the uart and its bits are not numbered, so there is no TXC0 etc.
#define TXC0 TXC
#define RXEN0 RXEN
#define TXEN0 TXEN
#define RXCIE0 RXCIE
#define UDRIE0 UDRIE
#define U2X0 U2X
#define UPE0 UPE
#define UDRE0 UDRE
#define UCSZ02 UCSZ2
#define TXB80 TXB8
#define RXB80 RXB8
#elif defined(TXC1)
// Some devices have uart1 but no uart0
#define TXC0 TXC1
#define RXEN0 RXEN1
#define TXEN0 TXEN1
#define RXCIE0 RXCIE1
#define UDRIE0 UDRIE1
#define U2X0 U2X1
#define UPE0 UPE1
#define UDRE0 UDRE1
#define UCSZ02 UCSZ12
#define TXB80 TXB81
#define RXB80 RXB81
#else
#error No UART found in HardwareSerial.cpp
#endif
#endif // !defined TXC0
// Check at compiletime that it is really ok to use the bit positions of
// UART0 for the other UARTs as well, in case these values ever get
// changed for future hardware.
#if defined(TXC1) && (TXC1 != TXC0 || RXEN1 != RXEN0 || RXCIE1 != RXCIE0 || \
UDRIE1 != UDRIE0 || U2X1 != U2X0 || UPE1 != UPE0 || \
UDRE1 != UDRE0 || UCSZ12 != UCSZ02 || TXB81 != TXB80 || RXB81 != RXB80)
#error "Not all bit positions for UART1 are the same as for UART0"
#endif
#if defined(TXC2) && (TXC2 != TXC0 || RXEN2 != RXEN0 || RXCIE2 != RXCIE0 || \
UDRIE2 != UDRIE0 || U2X2 != U2X0 || UPE2 != UPE0 || \
UDRE2 != UDRE0 || UCSZ22 != UCSZ02 || TXB82 != TXB80 || RXB82 != RXB80)
#error "Not all bit positions for UART2 are the same as for UART0"
#endif
#if defined(TXC3) && (TXC3 != TXC0 || RXEN3 != RXEN0 || RXCIE3 != RXCIE0 || \
UDRIE3 != UDRIE0 || U3X3 != U3X0 || UPE3 != UPE0 || \
UDRE3 != UDRE0 || UCSZ32 != UCSZ02 || TXB83 != TXB80 || TXB83 != TXB80)
#error "Not all bit positions for UART3 are the same as for UART0"
#endif
// Constructors ////////////////////////////////////////////////////////////////
HardwareSerial::HardwareSerial(
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
volatile uint8_t *ucsrc, volatile uint8_t *udr) :
_ubrrh(ubrrh), _ubrrl(ubrrl),
_ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc),
_udr(udr),
_rx_buffer_head(0), _rx_buffer_tail(0),
_tx_buffer_head(0), _tx_buffer_tail(0)
{
}
// Actual interrupt handlers //////////////////////////////////////////////////////////////
void HardwareSerial::_rx_complete_irq(void)
{
if (bit_is_clear(*_ucsra, UPE0)) {
// No Parity error, read byte and store it in the buffer if there is
// room
rx_buffer_index_t i;
unsigned char mb;
unsigned char c;
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is configured for 9 bit mode
i = (unsigned int)(_rx_buffer_head + 2) % SERIAL_RX_BUFFER_SIZE;
mb = (*_ucsrb >> RXB80) & 0x01;
c = *_udr;
} else {
// UART is configured for 5 to 8 bit modes
i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
c = *_udr;
}
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if (i != _rx_buffer_tail) {
if(bit_is_set(*_ucsrb, UCSZ02)) {
// If Uart is configured for 9 bit mode
_rx_buffer[_rx_buffer_head] = mb;
_rx_buffer[_rx_buffer_head + 1] = c;
} else {
// UART is configured for 5 to 8 bit modes
_rx_buffer[_rx_buffer_head] = c;
}
_rx_buffer_head = i;
}
} else {
// Parity error, read byte but discard it
*_udr;
};
}
#endif // whole file

44
AP-Remote-Software/_433_Programming/_433_Programming.ino Normal file
View File

@@ -0,0 +1,44 @@
/*
Example for different sending methods
http://code.google.com/p/rc-switch/
*/
#include <RCSwitch.h>
long unsigned int Key1 = 0000001; / Cange to individual (random) values
long unsigned int Key2 = 0000002;
long unsigned int Key3 = 0000003;
long unsigned int Key4 = 0000004;
RCSwitch mySwitch = RCSwitch();
void setup() {
Serial.begin(9600);
// Transmitter is connected to Arduino Pin #10
mySwitch.enableTransmit(10);
// Optional set pulse length.
// mySwitch.setPulseLength(320);
// Optional set protocol (default is 1, will work for most outlets)
// mySwitch.setProtocol(2);
// Optional set number of transmission repetitions.
// mySwitch.setRepeatTransmit(15);
}
void loop() {
/* Same switch as above, but using decimal code */
mySwitch.send(Key1, 24); // use key 1 to key 4 to program remote control (key A to D)
delay(100);
}