diff --git a/AP-Remote-Software/ArduinoPilotMicro433WindNG/ArduinoPilotMicro433WindNG.ino b/AP-Remote-Software/ArduinoPilotMicro433WindNG/ArduinoPilotMicro433WindNG.ino new file mode 100644 index 0000000..50070b2 --- /dev/null +++ b/AP-Remote-Software/ArduinoPilotMicro433WindNG/ArduinoPilotMicro433WindNG.ino @@ -0,0 +1,206 @@ +#include +#include +#include +#include +#include +#include + +#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++; + } + } +} + diff --git a/AP-Remote-Software/NewHWSworking/HardwareSerial.cpp b/AP-Remote-Software/NewHWSworking/HardwareSerial.cpp new file mode 100644 index 0000000..682833c --- /dev/null +++ b/AP-Remote-Software/NewHWSworking/HardwareSerial.cpp @@ -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 +#include +#include +#include +#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 diff --git a/AP-Remote-Software/NewHWSworking/HardwareSerial.h b/AP-Remote-Software/NewHWSworking/HardwareSerial.h new file mode 100644 index 0000000..6d1dc6b --- /dev/null +++ b/AP-Remote-Software/NewHWSworking/HardwareSerial.h @@ -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 + +#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 diff --git a/AP-Remote-Software/NewHWSworking/HardwareSerial_private.h b/AP-Remote-Software/NewHWSworking/HardwareSerial_private.h new file mode 100644 index 0000000..59b1ab6 --- /dev/null +++ b/AP-Remote-Software/NewHWSworking/HardwareSerial_private.h @@ -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 diff --git a/AP-Remote-Software/_433_Programming/_433_Programming.ino b/AP-Remote-Software/_433_Programming/_433_Programming.ino new file mode 100644 index 0000000..fa37917 --- /dev/null +++ b/AP-Remote-Software/_433_Programming/_433_Programming.ino @@ -0,0 +1,44 @@ +/* + Example for different sending methods + + http://code.google.com/p/rc-switch/ + +*/ + +#include + +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); + + +}