add PPMDecoder fork

PPMDecoder/.gitattributes

+# Auto detect text files and perform LF normalization
+* text=auto

PPMDecoder/LICENSE

+MIT License
+
+Copyright (c) 2020 Victor Glekler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PPMDecoder/README.md

+![PROJECT_PHOTO](https://github.com/VICLER/PPMDecoder/blob/master/ppm_img.PNG)
+
+<h3 align="center">PPM Decoder</h3>
+<p align="center">Arduino library for decoding PPM receiver signal</p>
+
+<!-- FEAUTURES -->
+## Features
+* Small size and easy to use
+* Non-Blocking operation using interrupts
+* Precise resolution of signal measuring (+- 0.5us)
+* Fast PPM to PWM (0-255) and Servo (544-2400us) conversion
+* Compatible with all ATMega328 16Mhz or 8Mhz Arduino boards
+
+## How to use
+```C++
+#include<PPM.h>                        // include library
+```
+```C++
+void begin(PPM_PIN, MAX_CHANNELS);     // init in void setup() // works only with pin 2(PD2) or pin 3(PD3)
+```
+```C++
+bool available();                     // returns 0 if there is no valid pulses from receiver
+```
+```C++
+uint16_t get(CHANNEL_NUMBER);            // get channel value in us
+```
+```C++
+uint8_t getPWM(CHANNEL_NUMBER);        // get pwm (0-255) channel value
+```
+```C++
+uint16_t getServo_us(CHANNEL_NUMBER);  // get Servo value (0-180)deg for using with Servo.writeMicroseconds() in range (544-2400)us
+```
+## Example
+```C++
+#include <PPM.h>
+
+#define CHANNELS 8    // max ppm channels
+#define PPM_PIN 2    // receiver ppm pin
+
+void setup() {
+  ppm.begin(PPM_PIN, CHANNELS);
+  Serial.begin(115200);
+}
+
+void loop() {
+
+  for (uint8_t i = 1; i <= CHANNELS; i++) // print all channel values
+  {
+    Serial.print(ppm.get(i));
+    Serial.print('\t');
+  }
+  Serial.println();
+  delay(10);
+
+}
+```

PPMDecoder/examples/PPM-PWM-Servo/PPM-PWM-Servo.ino

+#include <PPM.h>
+#include <Servo.h>
+
+#define SERVO_PIN 9    // servo signal pin
+#define CHANNELS 8    // max ppm channels
+#define PPM_PIN 2    // receiver ppm pin
+#define LED 5       // led pin
+
+Servo servo;
+
+void setup() {
+  ppm.begin(PPM_PIN, CHANNELS);
+  servo.attach(SERVO_PIN);
+  pinMode(LED, OUTPUT);
+  Serial.begin(115200);
+}
+
+void loop() {
+
+  //servo.writeMicroseconds(ppm.getServo_us(1)); // write in range from (544 - 2400)us -> (0 - 180)deg. This is much faster than servo.write(0 - 180)
+  servo.writeMicroseconds(ppm.get(1));          // write raw PPM value to servo (1000 - 2000)us
+  analogWrite(LED, ppm.getPWM(3));             // write PWM value from channel 3 to led
+
+}

PPMDecoder/examples/PPM_Read/PPM_Read.ino

+#include <PPM.h>
+
+#define CHANNELS 8   // max ppm channels
+#define PPM_PIN 2   // receiver ppm pin
+
+
+void setup() {
+  ppm.begin(PPM_PIN, CHANNELS);
+  Serial.begin(115200);
+}
+
+void loop() {
+  
+  for (uint8_t i = 1; i <= CHANNELS; i++) // print all channel values
+  {
+    Serial.print(ppm.get(i));
+    Serial.print('\t');
+  }
+  Serial.println();
+  delay(10);
+  
+}

PPMDecoder/keywords.txt

+#######################################
+# Syntax Coloring Map PPM
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+ppm     KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin       KEYWORD2
+get         KEYWORD2
+getPWM      KEYWORD2
+getServo_us KEYWORD2

PPMDecoder/library.properties

+name=PPM
+version=1.2.0
+author=VICLER
+maintainer=VICLER
+sentence=Arduino library for Decoding PPM signal
+paragraph=For All PPM compatible receivers
+url=*
+category=Other
+architectures=*

PPMDecoder/src/PPM.cpp

+/* Arduino library for decoding PPM receiver signal
+ *
+ * Copyright (c) 2020 Victor Glekler
+ *
+ * MIT License
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "PPM.h"
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+PPM ppm;
+
+ISR(INT1_vect)
+{
+	//PORTB ^= (1 << PB5);
+	ppm.process();
+}
+
+ISR(TIMER2_OVF_vect)
+{
+	ppm.increment_ovf_count();
+}
+
+void PPM::begin(uint8_t max_channels = MAX_CHANNELS)
+{
+	//pinMode(inputPort, INPUT);
+	//pinMode(3, INPUT);
+	pinMode(3, INPUT_PULLUP);
+
+	//attachInterrupt(digitalPinToInterrupt(inputPort), ISR_PPM, FALLING);
+	cli();
+	// D3 / PD3 / INT1 for PPM input hard-coded
+	EICRA &= ~((1 << ISC11) | (1 << ISC10));
+	EICRA |= (1 << ISC11); // falling
+	//EICRA |= (1 << ISC11) | (1 << ISC10); // rising
+	EIMSK |= (1 << INT1);
+
+	_max_channels = max_channels;
+	for (uint8_t i = 0; i < MAX_CHANNELS; i++)
+		_channels[i] = 0;
+
+	_ovf_count = 0;
+	_micros_count = 0;
+
+	TCCR2B = (TCCR2B & 0b11111000) | (1 << CS21); 	// 8 prescaler
+	TIMSK2 |= 0b00000001;				 		   // enable TIMER2 overflow interrupt
+	TCCR2A &= 0b11111100;
+	TCCR2B &= 0b11110111;
+
+	sei();
+}
+
+uint32_t PPM::_micros()
+{
+	uint8_t SREG_old = SREG;
+	cli();
+	uint8_t tcnt2 = TCNT2;
+	bool flag_save = bitRead(TIFR2, 0);
+	if (flag_save)
+	{
+		tcnt2 = TCNT2;
+		_ovf_count++;
+		TIFR2 |= 0b00000001;
+	}
+	_micros_count = (_ovf_count << 8) | tcnt2 ;
+	SREG = SREG_old;
+#if (F_CPU == 16000000)
+	return _micros_count >> 1;
+#elif (F_CPU == 8000000)
+	return _micros_count;
+#endif
+}
+
+void PPM::increment_ovf_count()
+{
+	_ovf_count++;
+}
+
+void PPM::process()
+{
+	static uint8_t _channel_index = _max_channels;
+	static uint32_t _lastTime = 0, _currentTime = 0;
+
+	_currentTime = _micros();
+	int16_t pulse_us = _currentTime - _lastTime;
+	_lastTime = _currentTime;
+
+	if (pulse_us > 3000 && pulse_us < 12000) // sync
+	{
+		_channel_index = 0;
+		_available = true;
+		return;
+	}
+	else if (pulse_us > 12000)
+		_available = false;
+
+	if (_channel_index < _max_channels)
+		_channels[_channel_index++] = constrain(pulse_us, MIN_PULSE, MAX_PULSE);
+}
+
+uint16_t PPM::get(uint8_t channel)
+{
+	return (_channels[channel - 1]);
+}
+
+uint8_t PPM::getPWM(uint8_t channel)
+{
+	return (_channels[channel - 1] - MIN_PULSE) * 0.255f;
+}
+
+uint16_t PPM::getServo_us(uint8_t channel){
+	return ( (_channels[channel - 1] - 706.89655) * 1.856 ); // range 0 -> 180 using WriteMicroseconds
+}
+
+bool PPM::available()
+{
+	return _available;
+}

PPMDecoder/src/PPM.h

+/* Arduino library for decoding PPM receiver signal
+ *
+ * Copyright (c) 2020 Victor Glekler
+ *
+ * MIT License
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * @file PPM.h
+ * @brief Base class for PPM Decoder
+ * @author Victor Glekler
+ * Contact: victor.glekler@gmail.com
+ * https://github.com/VICLER
+*/
+
+#pragma once
+
+#include "Arduino.h"
+
+#define MAX_CHANNELS 8 	  // the maximum channel number
+#define MIN_PULSE 1000	 // min valid impulse us
+#define MAX_PULSE 2000	// max valid impulse us
+
+class PPM
+{
+public:
+	void begin(uint8_t max_channels);
+	uint16_t get(uint8_t channel);
+	uint8_t getPWM(uint8_t channel);
+	uint16_t getServo_us(uint8_t channel);
+	void increment_ovf_count();
+	bool available();
+	void process();
+	
+private:
+	uint16_t _channels[MAX_CHANNELS];
+	volatile uint32_t _ovf_count;
+	uint8_t _max_channels;
+	uint32_t _micros_count;
+	uint32_t _micros();
+	bool _available;
+};
+
+extern PPM ppm;