@@ 0,0 1,299 @@ 
+# LoRa API
+
+## Include Library
+
+```arduino
+#include <LoRa.h>
+```
+
+## Setup
+
+### Begin
+
+Initialize the library with the specified frequency.
+
+```arduino
+LoRa.begin(frequency);
+```
+ * `frequency` - frequency in Hz (`433E6`, `866E6`, `915E6`)
+
+Returns `1` on success, `0` on failure.
+
+### Set pins
+
+Override the default `NSS`, `NRESET`, and `DIO0` pins used by the library. **Must** be called before `LoRa.begin()`.
+
+```arduino
+LoRa.setPins(ss, reset, dio0);
+```
+ * `ss` - new slave select pin to use, defaults to `10`
+ * `reset` - new reset pin to use, defaults to `9`
+ * `dio0` - new DIO0 pin to use, defaults to `2`
+
+This call is optional and only needs to be used if you need to change the default pins used.
+
+### End
+
+Stop the library
+
+```arduino
+LoRa.end()
+```
+
+## Sending data
+
+### Begin packet
+
+Start the sequence of sending a packet.
+
+```arduino
+LoRa.beginPacket();
+
+LoRa.beginPacket(implicitHeader);
+```
+
+ * `implicitHeader` - (optional) `true` enables implicit header mode, `false` enables explicit header mode (default)
+
+Returns `1` on success, `0` on failure.
+
+### Writing
+
+Write data to the packet. Each packet can contain up to 255 bytes.
+
+```arduino
+LoRa.write(byte);
+
+LoRa.write(buffer, length);
+```
+* `byte` - single byte to write to packet
+
+or
+
+* `buffer` - data to write to packet
+* `length` - size of data to write
+
+Returns the number of bytes written.
+
+**Note:** Other Arduino `Print` API's can also be used to write data into the packet
+
+### End packet
+
+End the sequence of sending a packet.
+
+```arduino
+LoRa.endPacket()
+```
+
+Returns `1` on success, `0` on failure.
+
+## Receiving data
+
+### Parsing packet
+
+Check if a packet has been received.
+
+```arduino
+int packetSize = LoRa.parsePacket();
+
+int packetSize = LoRa.parsePacket(size);
+```
+
+ * `size` - (optional) if `> 0` implicit header mode is enabled with the expected a packet of `size` bytes, default mode is explicit header mode
+
+
+Returns the packet size in bytes or `0` if no packet was received.
+
+### Continuous receive mode
+
+#### Register callback
+
+Register a callback function for when a packet is received.
+
+```arduino
+LoRa.onReceive(onReceive);
+
+void onReceive(int packetSize) {
+ // ...
+}
+```
+
+ * `onReceive` - function to call when a packet is received.
+
+#### Receive mode
+
+Puts the radio in continuous receive mode.
+
+```arduino
+LoRa.receive();
+
+LoRa.receive(int size);
+```
+
+ * `size` - (optional) if `> 0` implicit header mode is enabled with the expected a packet of `size` bytes, default mode is explicit header mode
+
+The `onReceive` callback will be called when a packet is received.
+
+### Packet RSSI
+
+```arduino
+int rssi = LoRa.packetRssi();
+```
+
+Returns the RSSI of the received packet.
+
+### Packet SNR
+
+```arduino
+float snr = LoRa.packetSnr();
+```
+
+Returns the estimated SNR of the received packet in dB.
+
+### Available
+
+```arduino
+int availableBytes = LoRa.available()
+```
+
+Returns number of bytes available for reading.
+
+### Peeking
+
+Peek at the next byte in the packet.
+
+```arduino
+byte b = LoRa.peek();
+```
+
+Returns the next byte in the packet or `-1` if no bytes are available.
+
+### Reading
+
+Read the next byte from the packet.
+
+```arduino
+byte b = LoRa.read();
+```
+
+Returns the next byte in the packet or `-1` if no bytes are available.
+
+**Note:** Other Arduino [`Stream` API's](https://www.arduino.cc/en/Reference/Stream) can also be used to read data from the packet
+
+## Other radio modes
+
+### Idle mode
+
+Put the radio in idle (standby) mode.
+
+```arduino
+LoRa.idle();
+```
+
+### Sleep mode
+
+Put the radio in sleep mode.
+
+```arduino
+LoRa.sleep();
+```
+
+## Radio parameters
+
+### TX Power
+
+Change the TX power of the radio.
+
+```arduino
+LoRa.setTxPower(txPower);
+```
+ * `txPower` - TX power in dB, defaults to `17`
+
+ Supported values are between `2` and `17`.
+
+### Frequency
+
+Change the frequency of the radio.
+
+```arduino
+LoRa.setFrequency(frequency);
+```
+ * `frequency` - frequency in Hz (`433E6`, `866E6`, `915E6`)
+
+### Spreading Factor
+
+Change the spreading factor of the radio.
+
+```arduino
+LoRa.setSpreadingFactor(spreadingFactor);
+```
+ * `spreadingFactor` - spreading factor, defaults to `7`
+
+Supported values are between `6` and `12`. If a spreading factor of `6` is set, implicit header mode must be used to transmit and receive packets.
+
+### Signal Bandwidth
+
+Change the signal bandwidth of the radio.
+
+```arduino
+LoRa.setSignalBandwidth(signalBandwidth);
+```
+
+ * `signalBandwidth` - signal bandwidth in Hz, defaults to `125E3`.
+
+Supported values are `7.8E3`, `10.4E3`, `15.6E3`, `20.8E3`, `31.25E3`, `41.7E3`, `62.5E3`, `125E3`, and `250E3`.
+
+### Coding Rate
+
+Change the coding rate of the radio.
+
+```arduino
+LoRa.setCodingRate4(codingRateDenominator);
+```
+
+ * `codingRateDenominator` - denominator of the coding rate, defaults to `5`
+
+Supported values are between `5` and `8`, these correspond to coding rates of `4/5` and `4/8`. The coding rate numerator is fixed at `4`.
+
+### Preamble Length
+
+Change the preamble length of the radio.
+
+```arduino
+LoRa.setPreambleLength(preambleLength);
+```
+
+ * `preambleLength` - preamble length in symbols, defaults to `8`
+
+Supported values are between `6` and `65535`.
+
+### Sync Word
+
+Change the sync word of the radio.
+
+```arduino
+LoRa.setSyncWord(syncWord);
+```
+
+ * `syncWord` - byte value to use as the sync word, defaults to `0x34`
+
+### CRC
+
+Enable or disable CRC usage, by default a CRC is not used.
+
+```arduino
+LoRa.crc();
+
+LoRa.noCrc();
+```
+
+## Other functions
+
+### Random
+
+Generate a random byte, based on the Wideband RSSI measurement.
+
+```
+byte b = LoRa.random();
+```
+
+Returns random byte.

          

@@ 0,0 1,21 @@ 
+MIT License
+
+Copyright (c) 2016 Sandeep Mistry
+
+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.

          

@@ 0,0 1,1 @@ 
+This library is forked from "https://github.com/sandeepmistry/arduino-LoRa". The source codes under folder "AmebaLoRa" inherit the license from any license claim of "https://github.com/sandeepmistry/arduino-LoRa".
  No newline at end of file

          

@@ 0,0 1,56 @@ 
+# Arduino LoRa
+
+[![Build Status](https://travis-ci.org/sandeepmistry/arduino-LoRa.svg?branch=master)](https://travis-ci.org/sandeepmistry/arduino-LoRa)
+
+An [Arduino](http://arduino.cc/) library for sending and receiving data using [LoRa](https://www.lora-alliance.org/) radios.
+
+## Compatible Hardware
+
+ * [Semtech SX1276/77/78/79](http://www.semtech.com/apps/product.php?pn=SX1276) based boards including:
+   * [Dragino Lora Shield](http://www.dragino.com/products/module/item/102-lora-shield.html)
+   * [HopeRF](http://www.hoperf.com/rf_transceiver/lora/) [RFM95W](http://www.hoperf.com/rf_transceiver/lora/RFM95W.html), [RFM96W](http://www.hoperf.com/rf_transceiver/lora/RFM96W.html), and [RFM98W](http://www.hoperf.com/rf_transceiver/lora/RFM98W.html)
+   * [Modtronix](http://modtronix.com/) [inAir4](http://modtronix.com/inair4.html), [inAir9](http://modtronix.com/inair9.html), and [inAir9B](http://modtronix.com/inair9b.html)
+
+### Semtech SX1276/77/78/79 wiring
+
+| Semtech SX1276/77/78/79 | Arduino | Ameba |
+| :---------------------: | :------:| :----:|
+| VCC | 3.3V | 3.3V |
+| GND | GND | GND |
+| SCK | SCK | SCK |
+| MISO | MISO | MISO |
+| MOSI | MOSI | MOSI |
+| NSS | 10 | 0 | 
+| NRESET | 9 | 9 |
+| DIO0 | 2 | 3 |
+
+
+`NSS`, `NRESET`, and `DIO0` pins can be changed by using `LoRa.setPins(ss, reset, dio0)`. `DIO0` pin is optional, it is only needed for receive callback mode.
+
+## Installation
+
+### Using the Arduino IDE Library Manager
+
+1. Choose `Sketch` -> `Include Library` -> `Manage Libraries...`
+2. Type `LoRa` into the search box.
+3. Click the row to select the library.
+4. Click the `Install` button to install the library.
+
+### Using Git
+
+```sh
+cd ~/Documents/Arduino/libraries/
+git clone https://github.com/sandeepmistry/arduino-LoRa LoRa
+```
+
+## API
+
+See [API.md](API.md).
+
+## Examples
+
+See [examples](examples) folder.
+
+## License
+
+This libary is [licensed](LICENSE) under the [MIT Licence](http://en.wikipedia.org/wiki/MIT_License).

          

@@ 0,0 1,32 @@ 
+#include <SPI.h>
+#include <LoRa.h>
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  Serial.println("LoRa Receiver");
+
+  if (!LoRa.begin(915E6)) {
+    Serial.println("Starting LoRa failed!");
+    while (1);
+  }
+}
+
+void loop() {
+  // try to parse packet
+  int packetSize = LoRa.parsePacket();
+  if (packetSize) {
+    // received a packet
+    Serial.print("Received packet '");
+
+    // read packet
+    while (LoRa.available()) {
+      Serial.print((char)LoRa.read());
+    }
+
+    // print RSSI of packet
+    Serial.print("' with RSSI ");
+    Serial.println(LoRa.packetRssi());
+  }
+}

          

@@ 0,0 1,39 @@ 
+#include <SPI.h>
+#include <LoRa.h>
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  Serial.println("LoRa Receiver Callback");
+
+  if (!LoRa.begin(915E6)) {
+    Serial.println("Starting LoRa failed!");
+    while (1);
+  }
+
+  // register the receive callback
+  LoRa.onReceive(onReceive);
+
+  // put the radio into receive mode
+  LoRa.receive();
+}
+
+void loop() {
+  // do nothing
+}
+
+void onReceive(int packetSize) {
+  // received a packet
+  Serial.print("Received packet '");
+
+  // read packet
+  for (int i = 0; i < packetSize; i++) {
+    Serial.print((char)LoRa.read());
+  }
+
+  // print RSSI of packet
+  Serial.print("' with RSSI ");
+  Serial.println(LoRa.packetRssi());
+}
+

          

@@ 0,0 1,31 @@ 
+#include <SPI.h>
+#include <LoRa.h>
+
+int counter = 0;
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  Serial.println("LoRa Sender");
+
+  if (!LoRa.begin(915E6)) {
+    Serial.println("Starting LoRa failed!");
+    while (1);
+  }
+}
+
+void loop() {
+  Serial.print("Sending packet: ");
+  Serial.println(counter);
+
+  // send packet
+  LoRa.beginPacket();
+  LoRa.print("hello ");
+  LoRa.print(counter);
+  LoRa.endPacket();
+
+  counter++;
+
+  delay(5000);
+}

          

@@ 0,0 1,53 @@ 
+#######################################
+# Syntax Coloring Map For LoRa
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+LoRa	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+end	KEYWORD2
+
+beginPacket	KEYWORD2
+endPacket	KEYWORD2
+
+parsePacket	KEYWORD2
+packetRssi	KEYWORD2
+packetSnr	KEYWORD2
+
+write	KEYWORD2
+
+available	KEYWORD2
+read	KEYWORD2
+peek	KEYWORD2
+flush	KEYWORD2
+
+onReceive	KEYWORD2
+receive	KEYWORD2
+idle	KEYWORD2
+sleep	KEYWORD2
+
+setTxPower	KEYWORD2
+setFrequency	KEYWORD2
+setSpreadingFactor	KEYWORD2
+setSignalBandwidth	KEYWORD2
+setCodingRate4	KEYWORD2
+setPreambleLength	KEYWORD2
+setSyncWord	KEYWORD2
+crc	KEYWORD2
+noCrc	KEYWORD2
+
+random	KEYWORD2
+setPins	KEYWORD2
+dumpRegisters	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

          

@@ 0,0 1,10 @@ 
+name=AmebaLoRa
+version=0.1.0
+author=Realtek
+maintainer=Realtek <ameba.arduino@gmail.com>
+sentence=An Arduino library for sending and receiving data using LoRa radios.
+paragraph=Supports Semtech SX1276/77/78/79 based boards/shields.
+category=Communication
+url=http://www.amebaiot.com/ameba-arduino-peripherals-examples/
+architectures=ameba
+includes=LoRa.h

          

@@ 0,0 1,503 @@ 
+#include <LoRa.h>
+
+// registers
+#define REG_FIFO                 0x00
+#define REG_OP_MODE              0x01
+#define REG_FRF_MSB              0x06
+#define REG_FRF_MID              0x07
+#define REG_FRF_LSB              0x08
+#define REG_PA_CONFIG            0x09
+#define REG_LNA                  0x0c
+#define REG_FIFO_ADDR_PTR        0x0d
+#define REG_FIFO_TX_BASE_ADDR    0x0e
+#define REG_FIFO_RX_BASE_ADDR    0x0f
+#define REG_FIFO_RX_CURRENT_ADDR 0x10
+#define REG_IRQ_FLAGS            0x12
+#define REG_RX_NB_BYTES          0x13
+#define REG_PKT_RSSI_VALUE       0x1a
+#define REG_PKT_SNR_VALUE        0x1b
+#define REG_MODEM_CONFIG_1       0x1d
+#define REG_MODEM_CONFIG_2       0x1e
+#define REG_PREAMBLE_MSB         0x20
+#define REG_PREAMBLE_LSB         0x21
+#define REG_PAYLOAD_LENGTH       0x22
+#define REG_RSSI_WIDEBAND        0x2c
+#define REG_DETECTION_OPTIMIZE   0x31
+#define REG_DETECTION_THRESHOLD  0x37
+#define REG_SYNC_WORD            0x39
+#define REG_DIO_MAPPING_1        0x40
+#define REG_VERSION              0x42
+
+// modes
+#define MODE_LONG_RANGE_MODE     0x80
+#define MODE_SLEEP               0x00
+#define MODE_STDBY               0x01
+#define MODE_TX                  0x03
+#define MODE_RX_CONTINUOUS       0x05
+#define MODE_RX_SINGLE           0x06
+
+// PA config
+#define PA_BOOST                 0x80
+
+// IRQ masks
+#define IRQ_TX_DONE_MASK           0x08
+#define IRQ_PAYLOAD_CRC_ERROR_MASK 0x20
+#define IRQ_RX_DONE_MASK           0x40
+
+#define MAX_PKT_LENGTH           255
+
+/************For realtek ameba*************/
+#define digitalPinToInterrupt(p)  ((p) == LORA_DEFAULT_DIO0_PIN ? p : NOT_AN_INTERRUPT)	
+#define NOT_AN_INTERRUPT -1	
+/******************************************/
+
+
+LoRaClass::LoRaClass() :
+  _spiSettings(10E6, MSBFIRST, SPI_MODE0),
+  _ss(LORA_DEFAULT_SS_PIN), _reset(LORA_DEFAULT_RESET_PIN), _dio0(LORA_DEFAULT_DIO0_PIN),
+  _frequency(0),
+  _packetIndex(0),
+  _implicitHeaderMode(0),
+  _onReceive(NULL)
+{
+}
+
+int LoRaClass::begin(long frequency)
+{
+  // setup pins
+  pinMode(_ss, OUTPUT);
+  pinMode(_reset, OUTPUT);
+
+  // perform reset
+  digitalWrite(_reset, LOW);
+  delay(10);
+  digitalWrite(_reset, HIGH);
+  delay(10);
+
+  // set SS high
+  digitalWrite(_ss, HIGH);
+	
+  // start SPI
+  SPI.begin();
+	
+  // check version
+  uint8_t version = readRegister(REG_VERSION);
+  if (version != 0x12) {
+    return 0;
+  }
+
+  // put in sleep mode
+  sleep();
+
+  // set frequency
+  setFrequency(frequency);
+
+  // set base addresses
+  writeRegister(REG_FIFO_TX_BASE_ADDR, 0);
+  writeRegister(REG_FIFO_RX_BASE_ADDR, 0);
+
+  // set LNA boost
+  writeRegister(REG_LNA, readRegister(REG_LNA) | 0x03);
+
+  // set output power to 17 dBm
+  setTxPower(17);
+
+  // put in standby mode
+  idle();
+
+  return 1;
+}
+
+void LoRaClass::end()
+{
+  // put in sleep mode
+  sleep();
+
+  // stop SPI
+  SPI.end();
+}
+
+int LoRaClass::beginPacket(int implicitHeader)
+{
+  // put in standby mode
+  idle();
+
+  if (implicitHeader) {
+    implicitHeaderMode();
+  } else {
+    explicitHeaderMode();
+  }
+
+  // reset FIFO address and paload length
+  writeRegister(REG_FIFO_ADDR_PTR, 0);
+  writeRegister(REG_PAYLOAD_LENGTH, 0);
+
+  return 1;
+}
+
+int LoRaClass::endPacket()
+{
+  // put in TX mode
+  writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_TX);
+
+  // wait for TX done
+  while((readRegister(REG_IRQ_FLAGS) & IRQ_TX_DONE_MASK) == 0);
+
+  // clear IRQ's
+  writeRegister(REG_IRQ_FLAGS, IRQ_TX_DONE_MASK);
+
+  return 1;
+}
+
+int LoRaClass::parsePacket(int size)
+{
+  int packetLength = 0;
+  int irqFlags = readRegister(REG_IRQ_FLAGS);
+
+  if (size > 0) {
+    implicitHeaderMode();
+
+    writeRegister(REG_PAYLOAD_LENGTH, size & 0xff);
+  } else {
+    explicitHeaderMode();
+  }
+
+  // clear IRQ's
+  writeRegister(REG_IRQ_FLAGS, irqFlags);
+
+  if ((irqFlags & IRQ_RX_DONE_MASK) && (irqFlags & IRQ_PAYLOAD_CRC_ERROR_MASK) == 0) {
+    // received a packet
+    _packetIndex = 0;
+
+    // read packet length
+    if (_implicitHeaderMode) {
+      packetLength = readRegister(REG_PAYLOAD_LENGTH);
+    } else {
+      packetLength = readRegister(REG_RX_NB_BYTES);
+    }
+
+    // set FIFO address to current RX address
+    writeRegister(REG_FIFO_ADDR_PTR, readRegister(REG_FIFO_RX_CURRENT_ADDR));
+
+    // put in standby mode
+    idle();
+  } else if (readRegister(REG_OP_MODE) != (MODE_LONG_RANGE_MODE | MODE_RX_SINGLE)) {
+    // not currently in RX mode
+
+    // reset FIFO address
+    writeRegister(REG_FIFO_ADDR_PTR, 0);
+
+    // put in single RX mode
+    writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_SINGLE);
+  }
+
+  return packetLength;
+}
+
+int LoRaClass::packetRssi()
+{
+  return (readRegister(REG_PKT_RSSI_VALUE) - (_frequency < 868E6 ? 164 : 157));
+}
+
+float LoRaClass::packetSnr()
+{
+  return ((int8_t)readRegister(REG_PKT_SNR_VALUE)) * 0.25;
+}
+
+size_t LoRaClass::write(uint8_t byte)
+{
+  return write(&byte, sizeof(byte));
+}
+
+size_t LoRaClass::write(const uint8_t *buffer, size_t size)
+{
+  int currentLength = readRegister(REG_PAYLOAD_LENGTH);
+
+  // check size
+  if ((currentLength + size) > MAX_PKT_LENGTH) {
+    size = MAX_PKT_LENGTH - currentLength;
+  }
+
+  // write data
+  for (size_t i = 0; i < size; i++) {
+    writeRegister(REG_FIFO, buffer[i]);
+  }
+
+  // update length
+  writeRegister(REG_PAYLOAD_LENGTH, currentLength + size);
+
+  return size;
+}
+
+int LoRaClass::available()
+{
+  return (readRegister(REG_RX_NB_BYTES) - _packetIndex);
+}
+
+int LoRaClass::read()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  _packetIndex++;
+
+  return readRegister(REG_FIFO);
+}
+
+int LoRaClass::peek()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  // store current FIFO address
+  int currentAddress = readRegister(REG_FIFO_ADDR_PTR);
+
+  // read
+  uint8_t b = readRegister(REG_FIFO);
+
+  // restore FIFO address
+  writeRegister(REG_FIFO_ADDR_PTR, currentAddress);
+
+  return b;
+}
+
+void LoRaClass::flush()
+{
+}
+
+void LoRaClass::onReceive(void(*callback)(int))
+{
+  _onReceive = callback;
+
+  if (callback) {
+    writeRegister(REG_DIO_MAPPING_1, 0x00);
+
+    attachInterrupt(digitalPinToInterrupt(_dio0), LoRaClass::onDio0Rise, RISING);
+  } else {
+    detachInterrupt(digitalPinToInterrupt(_dio0));
+  }
+}
+
+void LoRaClass::receive(int size)
+{
+  if (size > 0) {
+    implicitHeaderMode();
+
+    writeRegister(REG_PAYLOAD_LENGTH, size & 0xff);
+  } else {
+    explicitHeaderMode();
+  }
+
+  writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_CONTINUOUS);
+}
+
+void LoRaClass::idle()
+{
+  writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_STDBY);
+}
+
+void LoRaClass::sleep()
+{
+  writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_SLEEP);
+}
+
+void LoRaClass::setTxPower(int level)
+{
+  if (level < 2) {
+    level = 2;
+  } else if (level > 17) {
+    level = 17;
+  }
+
+  writeRegister(REG_PA_CONFIG, PA_BOOST | (level - 2));
+}
+
+void LoRaClass::setFrequency(long frequency)
+{
+  _frequency = frequency;
+
+  uint64_t frf = ((uint64_t)frequency << 19) / 32000000;
+
+  writeRegister(REG_FRF_MSB, (uint8_t)(frf >> 16));
+  writeRegister(REG_FRF_MID, (uint8_t)(frf >> 8));
+  writeRegister(REG_FRF_LSB, (uint8_t)(frf >> 0));
+}
+
+void LoRaClass::setSpreadingFactor(int sf)
+{
+  if (sf < 6) {
+    sf = 6;
+  } else if (sf > 12) {
+    sf = 12;
+  }
+
+  if (sf == 6) {
+    writeRegister(REG_DETECTION_OPTIMIZE, 0xc5);
+    writeRegister(REG_DETECTION_THRESHOLD, 0x0c);
+  } else {
+    writeRegister(REG_DETECTION_OPTIMIZE, 0xc3);
+    writeRegister(REG_DETECTION_THRESHOLD, 0x0a);
+  }
+
+  writeRegister(REG_MODEM_CONFIG_2, (readRegister(REG_MODEM_CONFIG_2) & 0x0f) | ((sf << 4) & 0xf0));
+}
+
+void LoRaClass::setSignalBandwidth(long sbw)
+{
+  int bw;
+
+  if (sbw <= 7.8E3) {
+    bw = 0;
+  } else if (sbw <= 10.4E3) {
+    bw = 1;
+  } else if (sbw <= 15.6E3) {
+    bw = 2;
+  } else if (sbw <= 20.8E3) {
+    bw = 3;
+  } else if (sbw <= 31.25E3) {
+    bw = 4;
+  } else if (sbw <= 41.7E3) {
+    bw = 5;
+  } else if (sbw <= 62.5E3) {
+    bw = 6;
+  } else if (sbw <= 125E3) {
+    bw = 7;
+  } else if (sbw <= 250E3) {
+    bw = 8;
+  } else /*if (sbw <= 250E3)*/ {
+    bw = 9;
+  }
+
+  writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0x0f) | (bw << 4));
+}
+
+void LoRaClass::setCodingRate4(int denominator)
+{
+  if (denominator < 5) {
+    denominator = 5;
+  } else if (denominator > 8) {
+    denominator = 8;
+  }
+
+  int cr = denominator - 4;
+
+  writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0xf1) | (cr << 1));
+}
+
+void LoRaClass::setPreambleLength(long length)
+{
+  writeRegister(REG_PREAMBLE_MSB, (uint8_t)(length >> 8));
+  writeRegister(REG_PREAMBLE_LSB, (uint8_t)(length >> 0));
+}
+
+void LoRaClass::setSyncWord(int sw)
+{
+  writeRegister(REG_SYNC_WORD, sw);
+}
+
+void LoRaClass::crc()
+{
+  writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) | 0x04);
+}
+
+void LoRaClass::noCrc()
+{
+  writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) & 0xfb);
+}
+
+byte LoRaClass::random()
+{
+  return readRegister(REG_RSSI_WIDEBAND);
+}
+
+void LoRaClass::setPins(int ss, int reset, int dio0)
+{
+  _ss = ss;
+  _reset = reset;
+  _dio0 = dio0;
+}
+
+void LoRaClass::dumpRegisters(Stream& out)
+{
+  for (int i = 0; i < 128; i++) {
+    out.print("0x");
+    out.print(i, HEX);
+    out.print(": 0x");
+    out.println(readRegister(i), HEX);
+  }
+}
+
+void LoRaClass::explicitHeaderMode()
+{
+  _implicitHeaderMode = 0;
+
+  writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) & 0xfe);
+}
+
+void LoRaClass::implicitHeaderMode()
+{
+  _implicitHeaderMode = 1;
+
+  writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) | 0x01);
+}
+
+void LoRaClass::handleDio0Rise()
+{
+  int irqFlags = readRegister(REG_IRQ_FLAGS);
+
+  // clear IRQ's
+  writeRegister(REG_IRQ_FLAGS, irqFlags);
+
+  if ((irqFlags & IRQ_PAYLOAD_CRC_ERROR_MASK) == 0) {
+    // received a packet
+    _packetIndex = 0;
+
+    // read packet length
+    int packetLength = _implicitHeaderMode ? readRegister(REG_PAYLOAD_LENGTH) : readRegister(REG_RX_NB_BYTES);
+
+    // set FIFO address to current RX address
+    writeRegister(REG_FIFO_ADDR_PTR, readRegister(REG_FIFO_RX_CURRENT_ADDR));
+
+    if (_onReceive) {
+      _onReceive(packetLength);
+    }
+
+    // reset FIFO address
+    writeRegister(REG_FIFO_ADDR_PTR, 0);
+  }
+}
+
+uint8_t LoRaClass::readRegister(uint8_t address)
+{
+  return singleTransfer(address & 0x7f, 0x00);
+}
+
+void LoRaClass::writeRegister(uint8_t address, uint8_t value)
+{
+  singleTransfer(address | 0x80, value);
+}
+
+uint8_t LoRaClass::singleTransfer(uint8_t address, uint8_t value)
+{
+  uint8_t response;
+
+  digitalWrite(_ss, LOW);
+
+  SPI.beginTransaction(_spiSettings);
+  SPI.transfer(address);
+  response = SPI.transfer(value);
+  SPI.endTransaction();
+
+  digitalWrite(_ss, HIGH);
+
+  return response;
+}
+
+void LoRaClass::onDio0Rise()
+{
+  LoRa.handleDio0Rise();
+}
+
+LoRaClass LoRa;

          

@@ 0,0 1,93 @@ 
+#ifndef LORA_H
+#define LORA_H
+
+#include <Arduino.h>
+#include <SPI.h>
+
+#if defined(BOARD_RTL8195A)
+
+#define LORA_DEFAULT_SS_PIN    0	//for realtek ameba 
+#define LORA_DEFAULT_RESET_PIN 9
+#define LORA_DEFAULT_DIO0_PIN  3	//for realtek ameba
+
+#elif defined(BOARD_RTL8710)
+
+#define LORA_DEFAULT_SS_PIN    5	//for realtek ameba 
+#define LORA_DEFAULT_RESET_PIN 2
+#define LORA_DEFAULT_DIO0_PIN  17	//for realtek ameba
+
+#else
+#endif
+
+class LoRaClass : public Stream {
+public:
+  LoRaClass();
+
+  int begin(long frequency);
+  void end();
+
+  int beginPacket(int implicitHeader = false);
+  int endPacket();
+
+  int parsePacket(int size = 0);
+  int packetRssi();
+  float packetSnr();
+
+  // from Print
+  virtual size_t write(uint8_t byte);
+  virtual size_t write(const uint8_t *buffer, size_t size);
+
+  // from Stream
+  virtual int available();
+  virtual int read();
+  virtual int peek();
+  virtual void flush();
+
+  void onReceive(void(*callback)(int));
+
+  void receive(int size = 0);
+  void idle();
+  void sleep();
+
+  void setTxPower(int level);
+  void setFrequency(long frequency);
+  void setSpreadingFactor(int sf);
+  void setSignalBandwidth(long sbw);
+  void setCodingRate4(int denominator);
+  void setPreambleLength(long length);
+  void setSyncWord(int sw);
+  void crc();
+  void noCrc();
+
+  byte random();
+
+  void setPins(int ss = LORA_DEFAULT_SS_PIN, int reset = LORA_DEFAULT_RESET_PIN, int dio0 = LORA_DEFAULT_DIO0_PIN);
+
+  void dumpRegisters(Stream& out);
+
+private:
+  void explicitHeaderMode();
+  void implicitHeaderMode();
+
+  void handleDio0Rise();
+
+  uint8_t readRegister(uint8_t address);
+  void writeRegister(uint8_t address, uint8_t value);
+  uint8_t singleTransfer(uint8_t address, uint8_t value);
+
+  static void onDio0Rise();
+
+private:
+  SPISettings _spiSettings;
+  int _ss;
+  int _reset;
+  int _dio0;
+  int _frequency;
+  int _packetIndex;
+  int _implicitHeaderMode;
+  void (*_onReceive)(int);
+};
+
+extern LoRaClass LoRa;
+
+#endif

          

@@ 0,0 1,190 @@ 
+#include "Car2wd.h"
+#include "Arduino.h"
+
+#define CAR_ACTION_CHANGE 0x01
+#define CAR_SPEED_CHANGE  0x02
+
+/* The pwm output to enA and enB of L28N can only output to motoer with 2.5V~3V.
+ * It cannot make signaficantly forward right/left.
+ * We use solution that make the slow moter run a little then stop.
+ **/
+#define DELAY_TURN (1)
+
+// A thread which handle car's actions without interfear main thread.
+void carTask(const void *arg) {
+
+    Car2wd *pCar = (Car2wd *) arg;
+    os_event_t evt;
+
+    uint32_t dfactor;
+    uint32_t dport;
+    uint32_t dbitmask;
+
+    while(1) {
+        // wait signal for infinite timeout
+        evt = os_signal_wait(0, 0xFFFFFFFF);
+
+        if (evt.status != OS_EVENT_SIGNAL) {
+            continue;
+        }
+
+        if (evt.value.signals & CAR_SPEED_CHANGE) {
+            analogWrite(pCar->enA, pCar->currentSpeed);
+            analogWrite(pCar->enB, pCar->currentSpeed);
+
+            /* only apply to forward right/left and backward right/left
+             * The motor run time is 20ms, and stop time is 20ms~360ms.
+             *                           speed - min_speed
+             *     dfactor = 20 + 360 * -------------------
+             *                            255 - min_speed
+             */ 
+            dfactor = 20 + (360 * (pCar->currentSpeed - CAR_MIN_SPEED))/(255 - CAR_MIN_SPEED);
+        }
+
+        if (evt.value.signals & CAR_ACTION_CHANGE) {
+            switch(pCar->currentAction) {
+                case CAR_STOP:
+                    *portOutputRegister(pCar->in1_port) &= ~(pCar->in1_bitmask);
+                    *portOutputRegister(pCar->in2_port) &= ~(pCar->in2_bitmask);
+                    *portOutputRegister(pCar->in3_port) &= ~(pCar->in3_bitmask);
+                    *portOutputRegister(pCar->in4_port) &= ~(pCar->in4_bitmask);
+                    break;
+                case CAR_FORWARD:
+                case CAR_FORWARD_RIGHT:
+                case CAR_FORWARD_LEFT:
+                    *portOutputRegister(pCar->in1_port) |=  (pCar->in1_bitmask);
+                    *portOutputRegister(pCar->in2_port) &= ~(pCar->in2_bitmask);
+                    *portOutputRegister(pCar->in3_port) |=  (pCar->in3_bitmask);
+                    *portOutputRegister(pCar->in4_port) &= ~(pCar->in4_bitmask);
+                    if (pCar->currentAction == CAR_FORWARD_RIGHT) {
+                        dport = pCar->in3_port;
+                        dbitmask = pCar->in3_bitmask;
+                    }
+                    if (pCar->currentAction == CAR_FORWARD_LEFT) {
+                        dport = pCar->in1_port;
+                        dbitmask = pCar->in1_bitmask;
+                    }
+                    break;
+                case CAR_BACKWARD:
+                case CAR_BACKWARD_RIGHT:
+                case CAR_BACKWARD_LEFT:
+                    *portOutputRegister(pCar->in1_port) &= ~(pCar->in1_bitmask);
+                    *portOutputRegister(pCar->in2_port) |=  (pCar->in2_bitmask);
+                    *portOutputRegister(pCar->in3_port) &= ~(pCar->in3_bitmask);
+                    *portOutputRegister(pCar->in4_port) |=  (pCar->in4_bitmask);
+                    if (pCar->currentAction == CAR_BACKWARD_RIGHT) {
+                        dport = pCar->in4_port;
+                        dbitmask = pCar->in4_bitmask;
+                    }
+                    if (pCar->currentAction == CAR_BACKWARD_LEFT) {
+                        dport = pCar->in2_port;
+                        dbitmask = pCar->in2_bitmask;
+                    }
+                    break;
+                case CAR_ROTATE_RIGHT:
+                    *portOutputRegister(pCar->in1_port) |=  (pCar->in1_bitmask);
+                    *portOutputRegister(pCar->in2_port) &= ~(pCar->in2_bitmask);
+                    *portOutputRegister(pCar->in3_port) &= ~(pCar->in3_bitmask);
+                    *portOutputRegister(pCar->in4_port) |=  (pCar->in4_bitmask);
+                    break;
+                case CAR_ROTATE_LEFT:
+                    *portOutputRegister(pCar->in1_port) &= ~(pCar->in1_bitmask);
+                    *portOutputRegister(pCar->in2_port) |=  (pCar->in2_bitmask);
+                    *portOutputRegister(pCar->in3_port) |=  (pCar->in3_bitmask);
+                    *portOutputRegister(pCar->in4_port) &= ~(pCar->in4_bitmask);
+                    break;
+            }
+        }
+        if (pCar->currentAction >= CAR_FORWARD_RIGHT && pCar->currentAction <= CAR_BACKWARD_LEFT) {
+#if DELAY_TURN
+            while(1) {
+                *portOutputRegister(dport) |=  dbitmask;
+                evt = os_signal_wait(0, 20);
+                if (evt.status == OS_EVENT_SIGNAL) {
+                    os_signal_set(pCar->tid, evt.value.signals);
+                    break;
+                }
+
+                *portOutputRegister(dport) &= ~dbitmask;
+                evt = os_signal_wait(0, dfactor);
+                if (evt.status == OS_EVENT_SIGNAL) {
+                    *portOutputRegister(dport) |=  dbitmask;
+                    os_signal_set(pCar->tid, evt.value.signals);
+                    break;
+                }
+            }
+#else
+            *portOutputRegister(dport) &= ~dbitmask;
+#endif
+        }
+    }
+}
+
+Car2wd::Car2wd(int _enA, int _in1, int _in2, int _in3, int _in4, int _enB) {
+    enA = _enA;
+    in1 = _in1;
+    in2 = _in2;
+    in3 = _in3;
+    in4 = _in4;
+    enB = _enB;
+
+    currentAction = CAR_STOP;
+}
+
+Car2wd::~Car2wd() {
+    end();
+}
+
+void Car2wd::begin() {
+    // set all the motor control pins to outputs with value 0
+    pinMode(enA, OUTPUT);
+    analogWrite(enA, 0);
+    pinMode(enB, OUTPUT);
+    analogWrite(enB, 0);
+
+    pinMode(in1, OUTPUT);
+    pinMode(in2, OUTPUT);
+    pinMode(in3, OUTPUT);
+    pinMode(in4, OUTPUT);
+
+    // cache each pin's port and bit mask for faster gpio control
+    in1_port = digitalPinToPort(in1);
+    in1_bitmask = digitalPinToBitMask(in1);
+    in2_port = digitalPinToPort(in2);
+    in2_bitmask = digitalPinToBitMask(in2);
+    in3_port = digitalPinToPort(in3);
+    in3_bitmask = digitalPinToBitMask(in3);
+    in4_port = digitalPinToPort(in4);
+    in4_bitmask = digitalPinToBitMask(in4);
+
+    // create a thread to control the car
+    tid = os_thread_create(carTask, this, OS_PRIORITY_REALTIME, 1024);
+}
+
+void Car2wd::end() {
+    os_thread_terminate(tid);
+}
+
+void Car2wd::setAction(unsigned char action, unsigned char speed) {
+
+    int32_t sig = 0;
+
+    if (currentAction != action) {
+        currentAction = action;
+        sig |= CAR_ACTION_CHANGE;
+    }
+    if (currentSpeed != speed) {
+        currentSpeed = speed;
+        sig |= CAR_SPEED_CHANGE;
+    }
+    if (sig != 0) {
+        // send signal to car thread
+        os_signal_set(tid, sig);
+    }
+}
+
+void Car2wd::stop() {
+    setAction(CAR_STOP, currentSpeed);
+}
+
+

          

@@ 0,0 1,58 @@ 
+#ifndef _CAR2WD_H_
+#define _CAR2WD_H_
+
+#include <stdint.h>
+#include "wiring_os.h"
+
+// The min pwm value. If value lower than this, then the motor won't move.
+#define CAR_MIN_SPEED 150
+
+#define CAR_STOP           0x00
+#define CAR_FORWARD        0x01
+#define CAR_BACKWARD       0x02
+#define CAR_ROTATE_RIGHT   0x03
+#define CAR_ROTATE_LEFT    0x04
+#define CAR_FORWARD_RIGHT  0x05
+#define CAR_FORWARD_LEFT   0x06
+#define CAR_BACKWARD_RIGHT 0x07
+#define CAR_BACKWARD_LEFT  0x08
+
+class Car2wd {
+public:
+    // These pins correspond pins of L298N brige. "_enA" and "_enB" has to be PWM pin.
+	Car2wd(int _enA, int _in1, int _in2, int _in3, int _in4, int _enB);
+    ~Car2wd();
+
+	void begin();
+    void end();
+
+    void setAction(unsigned char action, unsigned char speed=200);
+    void stop();
+
+    friend void carTask(const void *arg);
+
+private:
+    int enA;
+    int in1;
+    int in2;
+    int in3;
+    int in4;
+    int enB;
+
+    uint32_t in1_port;
+    uint32_t in1_bitmask;
+    uint32_t in2_port;
+    uint32_t in2_bitmask;
+    uint32_t in3_port;
+    uint32_t in3_bitmask;
+    uint32_t in4_port;
+    uint32_t in4_bitmask;
+
+    uint32_t tid;
+
+    unsigned char currentAction;
+    int           currentSpeed;
+};
+
+#endif
+

          

@@ 0,0 1,3 @@ 
+This library provide examples of how to use L298N to control motors.
+It also applied to 2WD cars which includes the way to adding thread,
+thread signaling, register level gpio output, pwm control.
  No newline at end of file

          

@@ 0,0 1,39 @@ 
+/*
+ *  This sketch shows how to use Car2wd class to control L298N on 2WD car
+ *
+ **/
+
+#include "Car2wd.h"
+
+Car2wd car(8,9,10,11,12,13);
+
+void setup() {
+  car.begin();
+}
+
+void loop() {
+  car.setAction(CAR_FORWARD);
+  delay(2000);
+  car.setAction(CAR_STOP);
+  delay(1000);
+  car.setAction(CAR_BACKWARD);
+  delay(2000);
+  car.setAction(CAR_STOP);
+  delay(1000);
+  car.setAction(CAR_FORWARD_RIGHT);
+  delay(2000);  
+  car.setAction(CAR_STOP);
+  delay(1000);
+  car.setAction(CAR_FORWARD_LEFT);
+  delay(2000);  
+  car.setAction(CAR_STOP);
+  delay(1000);
+  car.setAction(CAR_BACKWARD_LEFT);
+  delay(2000);  
+  car.setAction(CAR_STOP);
+  delay(1000);
+  car.setAction(CAR_BACKWARD_RIGHT);
+  delay(2000);  
+  car.setAction(CAR_STOP);
+  delay(1000);
+}
  No newline at end of file

          

@@ 0,0 1,199 @@ 
+/*
+ * This sketch shows how to use L298N to control 2 wheels car (or 4 wheels by 2 phases)
+ *
+ * Materials needed:
+ *     L298N x 1
+ *     Car kit:
+ *         car body x 1
+ *         DC motors x 2 (or x 4)
+ *         wheels x 2 (or x4)
+ *
+ * L298N has 6 input controls pins:
+ *     ENA - control the strength of motor A
+ *     IN1 - control line of motor A
+ *     IN2 - control line of motor A
+ *     IN3 - control line of motor B
+ *     IN4 - control line of motor B
+ *     ENA - control the strength of motor B
+ *
+ * IN1:1 IN2:0 - motor clockwise rotation
+ * IN1:0 IN2:1 - motor counter-clockwirse rotation
+ * IN1:0 IN2:0 - motor stops
+ * 
+ * The wheel may have poor grip or the motors has poor sensibility.
+ * It makes "forward right" cannot performed by makeing 2 motors with different 
+ * motor rotating speed. To achieve "forward right" we can just make right 
+ * wheels work in partial of times.
+ **/
+
+// motor left
+int enA = 8;
+int in1 = 9;
+int in2 = 10;
+
+// motor right
+int in3 = 11;
+int in4 = 12;
+int enB = 13;
+
+uint32_t in1_port, in1_bitmask;
+uint32_t in2_port, in2_bitmask;
+uint32_t in3_port, in3_bitmask;
+uint32_t in4_port, in4_bitmask;
+
+void initMotor()
+{
+  // set all the motor control pins to outputs with value 0
+  pinMode(enA, OUTPUT);
+  analogWrite(enA, 0);
+  pinMode(enB, OUTPUT);
+  analogWrite(enB, 0);
+
+  pinMode(in1, OUTPUT);
+  digitalWrite(in1, LOW);
+  pinMode(in2, OUTPUT);
+  digitalWrite(in2, LOW);
+  pinMode(in3, OUTPUT);
+  digitalWrite(in3, LOW);
+  pinMode(in4, OUTPUT);
+  digitalWrite(in4, LOW);
+
+  in1_port = digitalPinToPort(in1);
+  in1_bitmask = digitalPinToBitMask(in1);
+  in2_port = digitalPinToPort(in2);
+  in2_bitmask = digitalPinToBitMask(in2);
+  in3_port = digitalPinToPort(in3);
+  in3_bitmask = digitalPinToBitMask(in3);
+  in4_port = digitalPinToPort(in4);
+  in4_bitmask = digitalPinToBitMask(in4);
+}
+
+void motorsControl(int speedLeft, int speedRight) {
+  analogWrite(enA, abs(speedLeft));
+  analogWrite(enB, abs(speedRight));
+
+  if (speedLeft > 0) {
+    *portOutputRegister(in1_port) |=  in1_bitmask;
+    *portOutputRegister(in2_port) &= ~in2_bitmask;
+  } else if (speedLeft < 0) {
+    *portOutputRegister(in1_port) &= ~in1_bitmask;
+    *portOutputRegister(in2_port) |=  in2_bitmask;
+  } else {
+    *portOutputRegister(in1_port) &= ~in1_bitmask;
+    *portOutputRegister(in2_port) &= ~in2_bitmask;
+  }
+
+  if (speedRight > 0) {
+    *portOutputRegister(in3_port) |=  in3_bitmask;
+    *portOutputRegister(in4_port) &= ~in4_bitmask;
+  } else if (speedRight < 0) {
+    *portOutputRegister(in3_port) &= ~in3_bitmask;
+    *portOutputRegister(in4_port) |=  in4_bitmask;
+  } else {
+    *portOutputRegister(in3_port) &= ~in3_bitmask;
+    *portOutputRegister(in4_port) &= ~in4_bitmask;
+  }
+}
+
+void forward() {
+  motorsControl(200,200);
+}
+
+void backward() {
+  motorsControl(-200,-200);
+}
+
+void stop() {
+  motorsControl(0,0);
+}
+
+void rotateRight() {
+  motorsControl(200,-200);
+}
+
+void rotateLeft() {
+  motorsControl(-200,200);
+}
+
+void setup()
+{
+  initMotor();
+}
+
+void demo1() {
+  forward();
+  delay(2000);
+  stop();
+  delay(1000);
+
+  backward();
+  delay(2000);
+  stop();
+  delay(1000);
+
+  rotateRight();
+  delay(2000);
+  stop();
+  delay(1000);
+
+  rotateLeft();
+  delay(2000);
+  stop();
+  delay(1000);
+}
+
+void demo2() {
+  /*  This function demo "forward right", "forward left", "backward left", "backward right".
+   *  If the motors on the car have good sensitiy on input signal and high grip on the ground, 
+   *  then you can just adjust the ratio of 2 pwm values.
+   *    Ex. motorControl(255,150) makes car forward right.
+   *  Otherwise, we can just adjust the working ratio of tire.
+   *    Ex. work 20ms, then stop 80ms, ...
+   **/
+
+  forward();
+  // forward right
+  for (int i=0; i<40; i++) {
+    *portOutputRegister(in3_port) |=  in3_bitmask;
+    delay(20);
+    *portOutputRegister(in3_port) &= ~in3_bitmask;
+    delay(80);
+  }
+  *portOutputRegister(in3_port) |=  in3_bitmask;
+  // forward left
+  for (int i=0; i<40; i++) {
+    *portOutputRegister(in1_port) |=  in1_bitmask;
+    delay(20);
+    *portOutputRegister(in1_port) &= ~in1_bitmask;
+    delay(80);
+  }
+  *portOutputRegister(in1_port) |=  in1_bitmask;
+  stop();
+  delay(1000);
+
+  backward();
+  // backward left
+  for (int i=0; i<40; i++) {
+    *portOutputRegister(in2_port) |=  in2_bitmask;
+    delay(20);
+    *portOutputRegister(in2_port) &= ~in2_bitmask;
+    delay(80);
+  }
+  *portOutputRegister(in2_port) |=  in2_bitmask;
+  // backward right
+  for (int i=0; i<40; i++) {
+    *portOutputRegister(in4_port) |=  in4_bitmask;
+    delay(20);
+    *portOutputRegister(in4_port) &= ~in4_bitmask;
+    delay(80);
+  }
+  *portOutputRegister(in4_port) |=  in4_bitmask;
+  stop();
+  delay(1000);
+}
+
+void loop()
+{
+  demo1();
+  demo2();
+}
  No newline at end of file

          

@@ 0,0 1,195 @@ 
+/*
+ * This sketch use mobile phone to control car
+ *
+ * This sketch bring up wifi in AP mode.
+ * User can change mobile phone's wifi AP with correspond ssid.
+ * Device open TCP socket on port 5001, and mobile app connect to
+ * it on default AP IP 192.168.1.1
+ * Mobile app send raw data when control data is changed.
+ * The Raw data has these format:
+ *     <direction>:<speed>
+ *
+ *     Y:12
+ *     It's forward with max speed. (Speed has range -12~12)
+ *
+ *     Y:-6
+ *     It's backward with half speed.
+ *
+ *     X:12
+ *     It's right rotate with max speed.
+ *
+ *     Y:12
+ *     X:-6
+ *     It's forward left with max speed. (When X and Y has speed value, use Y speed only)
+ *     
+ **/
+
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <Car2wd.h>
+
+char ssid[] = "mycar";        // Set the AP's SSID
+char pass[] = "12345678";     // Set the AP's password
+char channel[] = "6";         // Set the AP's channel
+int status = WL_IDLE_STATUS;  // the Wifi radio's status
+
+Car2wd car(8,9,10,11,12,13);
+
+int port_ctrl = 5001;
+//#define CTRL_USE_TCP
+#ifdef CTRL_USE_TCP
+WiFiServer server(port_ctrl);
+WiFiClient client;
+#else
+WiFiUDP udp;
+#endif
+
+uint8_t buffer[256];
+
+void setup() {
+  car.begin();
+
+  status = WiFi.status();
+
+  // attempt to start AP:
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to start AP with SSID: ");
+    Serial.println(ssid);
+    status = WiFi.apbegin(ssid, pass, channel);
+    if (status == WL_CONNECTED) {
+      break;
+    }
+    delay(10000);
+  }
+  //AP MODE already started:
+  Serial.println("AP mode already started");
+
+#ifdef CTRL_USE_TCP
+  server.begin();
+#else
+  udp.begin(port_ctrl);
+#endif
+}
+
+#ifdef CTRL_USE_TCP
+void tcpHandler() {
+  int len;
+  if (!client.connected()) {
+    client = server.available();
+  }
+  while (client.connected()) {
+    memset(buffer, 0, 256);
+    len = client.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      printf("[TCP]:%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+  }
+  Serial.println("control socket broken");
+  memset(buffer, 0, 256);
+  handleData((const char *)buffer);
+  delay(1000);  
+}
+#else
+void udpHandler() {
+  int len;
+  while(1) {
+    memset(buffer, 0, sizeof(buffer));
+    len = udp.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      printf("[UDP]:%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+    delay(100);
+  }
+}
+#endif
+
+void loop() {
+#ifdef CTRL_USE_TCP
+  tcpHandler();
+#else
+  udpHandler();
+#endif
+}
+
+int speedMapping(int rawspeed) {
+  /* Original data range: -12 ~ + 12
+   * Convert it to PWM range: 150~255
+   **/
+  if (rawspeed == 0) {
+    return 0;
+  } else {
+    return (rawspeed * 105) / 12 + ((rawspeed > 0) ? 150 : -150);
+  }
+}
+
+int lastXspeed = 0;
+int lastYspeed = 0;
+void handleData(const char *buf) {
+  int len;
+  bool xchange = false, ychange = false;;
+  int xspeed = 0, yspeed = 0;
+
+  if (buf[0] != '\0') {
+    len = strlen(buf);
+    for (int i=0; i<len; i++) {
+      if (buf[i] == 'X') {
+        xspeed = lastXspeed = speedMapping(parseSpeed(&buf[i+2]));
+        xchange = true;
+      }
+      if (buf[i] == 'Y') {
+        yspeed = lastYspeed = speedMapping(parseSpeed(&buf[i+2]));
+        ychange = true;
+      }
+    }
+    if (xchange == false) {
+      xspeed = lastXspeed;
+    }
+    if (ychange == false) {
+      yspeed = lastYspeed;
+    }
+  } else {
+    xspeed = lastXspeed = 0;
+    yspeed = lastYspeed = 0;
+  }
+
+  if (xspeed == 0 && yspeed == 0) {
+    car.stop();
+  } else if (xspeed == 0 && yspeed > 0) {
+    car.setAction(CAR_FORWARD, abs(yspeed));
+  } else if (xspeed == 0 && yspeed < 0) {
+    car.setAction(CAR_BACKWARD, abs(yspeed));
+  } else if (xspeed > 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_RIGHT, abs(yspeed));
+  } else if (xspeed > 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_RIGHT, abs(xspeed));
+  } else if (xspeed > 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_RIGHT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_LEFT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_LEFT, abs(xspeed));
+  } else if (xspeed < 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_LEFT, abs(yspeed));
+  }
+}
+
+int parseSpeed(const char *buf) {
+  int s = 0;
+  if (buf[0] == '-') {
+    s = buf[1] - '0';
+    if (buf[2] >= '0' && buf[2] <= '9') {
+      s = s * 10 + (buf[2] - '0');
+    }
+    s = -s;
+  } else {
+    s = buf[0] - '0';
+    if (buf[1] >= '0' && buf[1] <= '9') {
+      s = s * 10 + (buf[1] - '0');
+    }
+  }
+  return s;
+}

          

@@ 0,0 1,198 @@ 
+/*
+  This sketch use mobile phone to control car with streaming video.
+
+  At first Ameba connect to AP.
+  Then Ameba open UVC service.
+  After UVC service is enabled, user can use rtsp player and open streaming with address:
+    rtsp://192.168.1.123/test.sdp
+  (NOTE: the IP address depends on Ameba's IP")
+
+  For car related control method, please refer example car2wd_mobile_control
+*/
+
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <Car2wd.h>
+#include <UVC.h>
+
+char ssid[] = "mycar";        // Set the AP's SSID
+char pass[] = "12345678";     // Set the AP's password
+char channel[] = "6";         // Set the AP's channel
+int status = WL_IDLE_STATUS;  // the Wifi radio's status
+
+Car2wd car(8,9,10,11,12,13);
+
+int port_ctrl = 5001;
+#define CTRL_USE_TCP
+#ifdef CTRL_USE_TCP
+WiFiServer server(port_ctrl);
+WiFiClient client;
+#else
+WiFiUDP udp;
+#endif
+
+uint8_t buffer[256];
+
+void setup() {
+  car.begin();
+
+  status = WiFi.status();
+
+  // attempt to start AP:
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to start AP with SSID: ");
+    Serial.println(ssid);
+    status = WiFi.apbegin(ssid, pass, channel);
+    if (status == WL_CONNECTED) {
+      break;
+    }
+    delay(10000);
+  }
+
+  //AP MODE already started:
+  Serial.println("AP mode already started");
+
+  // Default setting is motion jpeg with 320x240 resolution and frame rate is 30fps
+  UVC.begin();
+  // Try below setting if you want better resolution
+  //UVC.begin(UVC_MJPEG, 640, 480, 30, 0);
+
+  // wait until UVC is ready for streaming
+  while (!UVC.available()) {
+    delay(100);
+  }
+  Serial.println("UVC is ready");
+  Serial.println("Open your rtsp player with this address:");
+  Serial.print("\trtsp://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/test.sdp");
+
+#ifdef CTRL_USE_TCP
+  server.begin();
+#else
+  udp.begin(port_ctrl);
+#endif
+}
+
+#ifdef CTRL_USE_TCP
+void tcpHandler() {
+  int len;
+  if (!client.connected()) {
+    client = server.available();
+  }
+  while (client.connected()) {
+    memset(buffer, 0, 256);
+    len = client.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      printf("[TCP]:%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+  }
+  Serial.println("control socket broken");
+  memset(buffer, 0, 256);
+  handleData((const char *)buffer);
+  delay(1000);  
+}
+#else
+void udpHandler() {
+  int len;
+  while(1) {
+    memset(buffer, 0, sizeof(buffer));
+    len = udp.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      printf("[UDP]:%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+    delay(100);
+  }
+}
+#endif
+
+void loop() {
+#ifdef CTRL_USE_TCP
+  tcpHandler();
+#else
+  udpHandler();
+#endif
+}
+
+int speedMapping(int rawspeed) {
+  /* Original data range: -12 ~ + 12
+   * Convert it to PWM range: 150~255
+   **/
+  if (rawspeed == 0) {
+    return 0;
+  } else {
+    return (rawspeed * 105) / 12 + ((rawspeed > 0) ? 150 : -150);
+  }
+}
+
+int lastXspeed = 0;
+int lastYspeed = 0;
+void handleData(const char *buf) {
+  int len;
+  bool xchange = false, ychange = false;;
+  int xspeed = 0, yspeed = 0;
+
+  if (buf[0] != '\0') {
+    len = strlen(buf);
+    for (int i=0; i<len; i++) {
+      if (buf[i] == 'X') {
+        xspeed = lastXspeed = speedMapping(parseSpeed(&buf[i+2]));
+        xchange = true;
+      }
+      if (buf[i] == 'Y') {
+        yspeed = lastYspeed = speedMapping(parseSpeed(&buf[i+2]));
+        ychange = true;
+      }
+    }
+    if (xchange == false) {
+      xspeed = lastXspeed;
+    }
+    if (ychange == false) {
+      yspeed = lastYspeed;
+    }
+  } else {
+    xspeed = lastXspeed = 0;
+    yspeed = lastYspeed = 0;
+  }
+
+  if (xspeed == 0 && yspeed == 0) {
+    car.stop();
+  } else if (xspeed == 0 && yspeed > 0) {
+    car.setAction(CAR_FORWARD, abs(yspeed));
+  } else if (xspeed == 0 && yspeed < 0) {
+    car.setAction(CAR_BACKWARD, abs(yspeed));
+  } else if (xspeed > 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_RIGHT, abs(yspeed));
+  } else if (xspeed > 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_RIGHT, abs(xspeed));
+  } else if (xspeed > 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_RIGHT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_LEFT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_LEFT, abs(xspeed));
+  } else if (xspeed < 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_LEFT, abs(yspeed));
+  }
+}
+
+int parseSpeed(const char *buf) {
+  int s = 0;
+  if (buf[0] == '-') {
+    s = buf[1] - '0';
+    if (buf[2] >= '0' && buf[2] <= '9') {
+      s = s * 10 + (buf[2] - '0');
+    }
+    s = -s;
+  } else {
+    s = buf[0] - '0';
+    if (buf[1] >= '0' && buf[1] <= '9') {
+      s = s * 10 + (buf[1] - '0');
+    }
+  }
+  return s;
+}
  No newline at end of file

          

@@ 0,0 1,304 @@ 
+/*
+   This sketch shows how to use control car with MPU6050 6 axis gyro/accelerometer,
+   and send out results via UDP
+
+   This sketch requires library include Ameba version of I2Cdev and MPU6050
+
+   We enable MPU (Motion Processing Tech) of MPU6050 that it can trigger interrupt with correspond sample rate.
+   And then gather the data from fifo and convert it to yaw/pitch/poll values.
+   We only need pitch and poll, convert it to car data format and send out via UDP.
+
+   To start control car, you need roll Ameba twice within 3 seconds.
+
+   The correspond car use Ameba example "car2wd_mobile_control".
+
+ **/
+
+#include <WiFi.h>
+#include "I2Cdev.h"
+#include "MPU6050_6Axis_MotionApps20.h"
+#include "Wire.h"
+
+/* WiFi related variables*/
+char ssid[] = "mycar";          // mycar ssid
+char pass[] = "12345678";       // mycar password
+IPAddress server(192,168,1,1);  // numeric IP for mycar AP mode
+int status = WL_IDLE_STATUS;
+
+WiFiClient client;
+char sendbuf[12];
+
+/* MPU6050 related variables */
+MPU6050 mpu;
+
+// MPU control/status vars
+bool dmpReady = false;  // set true if DMP init was successful
+uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
+uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
+uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
+uint16_t fifoCount;     // count of all bytes currently in FIFO
+uint8_t fifoBuffer[64]; // FIFO storage buffer
+
+// orientation/motion vars
+Quaternion q;           // [w, x, y, z]         quaternion container
+VectorFloat gravity;    // [x, y, z]            gravity vector
+float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector
+
+/* car control variable */
+int carx = 0, cary = 0;
+int prev_carx = 0, prev_cary = 0;
+uint32_t timestamp = 0, last_send_timestamp = 0;
+
+volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
+void dmpDataReady() {
+    mpuInterrupt = true;
+}
+
+void setup() {
+  checkAndReconnectServer();
+  initMPU6050();
+}
+
+void loop() {
+  if (!dmpReady) return; // if programming failed, don't try to do anything
+
+  safeWaitMPU6050();
+  mpuIntStatus = mpu.getIntStatus();
+  fifoCount = mpu.getFIFOCount();
+
+  if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
+    mpu.resetFIFO();
+    Serial.println(F("FIFO overflow!"));
+  } else if (mpuIntStatus & 0x02 && fifoCount >= packetSize) {
+    while (fifoCount >= packetSize){
+      mpu.getFIFOBytes(fifoBuffer, packetSize);
+      fifoCount -= packetSize;
+    }
+
+    // get Euler angles
+    mpu.dmpGetQuaternion(&q, fifoBuffer);
+    mpu.dmpGetGravity(&gravity, &q);
+    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
+
+    if (hasStarted(ypr[1], ypr[2])) {
+      mapPitchRolltoXY(ypr[1], ypr[2], &carx, &cary);
+    } else {
+      carx = cary = 0;
+    }
+  
+    memset(sendbuf, 0, 12);
+    timestamp = millis();
+    if ((timestamp - last_send_timestamp) > 500 || (carx != prev_carx && cary != prev_cary)) {
+      // If there is no value changed after 500ms, then send command to keepalive.
+      sprintf(sendbuf, "X:%dY:%d", carx, cary);
+    } else if (carx != prev_carx) {
+      sprintf(sendbuf, "X:%d", carx);
+    } else if (cary != prev_cary) {
+      sprintf(sendbuf, "Y:%d", cary);
+    }
+    if (strlen(sendbuf) > 0) {
+      if (checkAndReconnectServer()) {
+        safeResetMPU6050();
+      }
+      client.write(sendbuf, strlen(sendbuf));
+      last_send_timestamp = timestamp;
+      delay(10);
+
+      // ignore previous interrupt
+    }
+    prev_carx = carx;
+    prev_cary = cary;
+
+    mpuInterrupt = false;
+  }
+}
+
+#define CAR_STATE_OFF             0
+#define CAR_STATE_OFF_FIRST_ROLL  1
+#define CAR_STATE_OFF_FIRST_FLAT  2
+#define CAR_STATE_OFF_SECOND_ROLL 3
+#define CAR_STATE_ON              4
+
+// If user cannot complete action within 3s, then break to init state
+#define CAR_STATE_BREAK_TIMEOUT 3000
+
+int carState = CAR_STATE_OFF;
+uint32_t initChangeStateTimestamp = 0;
+
+int isFlat(float pitch, float roll) {
+  return (pitch < 24 && pitch > -24 && roll < 24 && roll > -24);
+}
+
+int isRoll(float pitch, float roll) {
+  return (pitch > 70 || pitch < -70 || roll > 70 || roll < -70);
+}
+
+// return 1 if we can control car
+int hasStarted(float pitch, float roll) {
+  int ret = 0;
+  pitch = pitch * 180 / M_PI;
+  roll = roll * 180 / M_PI;
+  switch(carState) {
+    case CAR_STATE_OFF:
+      if (isRoll(pitch, roll)) {
+        carState = CAR_STATE_OFF_FIRST_ROLL;
+        initChangeStateTimestamp = millis();
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_FIRST_ROLL:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+      } else {
+        if (isFlat(pitch, roll)) {
+          carState = CAR_STATE_OFF_FIRST_FLAT;
+        }
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_FIRST_FLAT:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+      } else {
+        if (isRoll(pitch, roll)) {
+          carState = CAR_STATE_OFF_SECOND_ROLL;
+        }
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_SECOND_ROLL:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+        ret = 0;
+      } else {
+        if (isFlat(pitch, roll)) {
+          carState = CAR_STATE_ON;
+          Serial.println("ON");
+          ret = 1;
+        } else {
+          ret = 0;
+        }
+      }
+      break;
+    case CAR_STATE_ON:
+      ret = 1;
+      break;
+  }
+
+  return ret;
+}
+
+int mapRange(float angle) {
+  /* Here is the mapping table.
+   * Pitch/Roll(degree): -48...-24...24...48
+   * Car:                -12.....0....0...12
+   */
+  if (angle < -48) {
+    return -12;
+  } else if ( angle >= -48 && angle < -24) {
+    return ((angle + 24)) / 2;
+  } else if ( angle > 24 && angle <= 48) {
+    return (angle - 24) / 2;
+  } else if (angle > 48) {
+    return 12;
+  } else {
+    return 0;
+  }
+}
+
+void mapPitchRolltoXY(float pitch, float roll, int *carx, int *cary) {
+  pitch = pitch * 180 / M_PI;
+  roll = roll * 180 / M_PI;
+  *carx = -mapRange(pitch);
+  *cary = -mapRange(roll);
+}
+
+int checkAndReconnectServer() {
+  int ret = 0;
+  status = WiFi.status();
+  if (status != WL_CONNECTED) {
+    while (status != WL_CONNECTED) {
+      Serial.print("Attempting to connect to SSID: ");
+      Serial.println(ssid);
+      // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+      status = WiFi.begin(ssid, pass);
+      if (status == WL_CONNECTED) {
+        break;
+      }
+      Serial.println("Reconnect to wifi...");
+      delay(1000);
+    }
+    Serial.println("Connected to wifi");
+    ret = 1;
+  }
+  if ( !client.connected()) {
+    while (!client.connect(server, 5001)) {
+      Serial.println("reconnect to server...");
+      delay(1000);
+    }
+    Serial.println("connected to server");  
+    ret = 1;
+  }
+  return ret;
+}
+
+void initMPU6050() {
+  Wire.begin();
+  Wire.setClock(400000); // 400kHz I2C clock (200kHz if CPU is 8MHz).
+
+  Serial.println(F("Initializing I2C devices..."));
+  mpu.initialize();
+
+  Serial.println(F("Testing device connections..."));
+  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));
+
+  Serial.println(F("Initializing DMP..."));
+  devStatus = mpu.dmpInitialize();
+
+  // make sure it worked (returns 0 if so)
+  if (devStatus == 0) {
+    // turn on the DMP, now that it's ready
+    Serial.println(F("Enabling DMP..."));
+    mpu.setDMPEnabled(true);
+
+    // enable Arduino interrupt detection
+    Serial.println(F("Enabling interrupt detection (Ameba D16 pin)..."));
+    attachInterrupt(16, dmpDataReady, RISING);
+    mpuIntStatus = mpu.getIntStatus();
+
+    // set our DMP Ready flag so the main loop() function knows it's okay to use it
+    Serial.println(F("DMP ready! Waiting for first interrupt..."));
+    dmpReady = true;
+
+    // get expected DMP packet size for later comparison
+    packetSize = mpu.dmpGetFIFOPacketSize();
+
+    mpu.setRate(5); // 1khz / (1 + 5) = 166 Hz
+  } else {
+    // ERROR!
+    // 1 = initial memory load failed
+    // 2 = DMP configuration updates failed
+    // (if it's going to break, usually the code will be 1)
+    Serial.print(F("DMP Initialization failed (code "));
+    Serial.print(devStatus);
+    Serial.println(F(")"));
+  }  
+}
+
+void safeWaitMPU6050() {
+  while (!mpuInterrupt) {
+    os_thread_yield(); // without yield, the empty busy loop might make CPU behave un-expected
+  }  
+  mpuInterrupt = false;
+}
+
+void safeResetMPU6050() {
+  /* If dmp interrupt happends at I2C send/recv, then MPU6050 would hang and can only recover by plug out/in VCC.
+   * To avoid this happen we wait next interrupt and then reset buffer */
+  mpuInterrupt = false;
+    while (!mpuInterrupt) {
+    os_thread_yield(); // without yield, the empty busy loop might make CPU behave un-expected
+  }
+  mpu.resetFIFO();
+  mpuInterrupt = false;
+}
  No newline at end of file

          

@@ 0,0 1,111 @@ 
+/*
+ * This sketch shows how to control car on web page (via http protocol)
+ *
+ * At first we connect device to AP, start a web server at port 80.
+ * In client side we input device's IP at browser, and a page is show up.
+ * There are several buttons which can control the car.
+ * As we type one of these buttons, a request is append at the hyper link.
+ * And device parse the link and do correspond actions.
+ * 
+ * The web control part reference from http://www.instructables.com/id/Internet-Controlled-RC-Car/
+ */
+
+#include <WiFi.h>
+#include "Car2wd.h"
+
+char ssid[] = "yourNetwork";      // your network SSID (name)
+char pass[] = "secretPassword";   // your network password
+int keyIndex = 0;                 // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS;
+WiFiServer server(80);
+
+Car2wd car(8,9,10,11,12,13);
+
+void setup() {
+  car.begin();
+
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);
+
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+    status = WiFi.begin(ssid, pass);
+    if (status == WL_CONNECTED) {
+      break;
+    }
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+
+  server.begin();
+}
+
+char buffer[1024];
+void loop() {
+  WiFiClient client = server.available();
+  while (client.connected()) {
+    int n = client.read((uint8_t*)(&buffer[0]), sizeof(buffer));
+
+    client.println("HTTP/1.1 200 OK"); 
+    client.println("Content-Type: text/html");
+    client.println();
+    client.println("<HTML>");
+    client.println("<HEAD>");
+    client.println("<TITLE>Internet Controlled 2WD Car</TITLE>");
+    client.println("<STYLE>");
+    client.println("body{margin:50px 0px; padding:0px; text-align:center;}");
+    client.println("h1{text-align: center; font-family:\"Trebuchet MS\",Arial, Helvetica, sans-serif; font-size:24px;}");
+    client.println("a{text-decoration:none; width:75px; height:50px; border-color:black; font-family:\"Trebuchet MS\",Arial, Helvetica, sans-serif; padding:6px; background-color:#aaaaaa; text-align:center; border-radius:10px 10px 10px; font-size:24px;}");
+    client.println("a:link {color:white;}");
+    client.println("a:visited {color:white;}");
+    client.println("a:hover {color:red;}");
+    client.println("a:active {color:white;}");
+    client.println("</STYLE>");
+    client.println("</HEAD>");
+    client.println("<BODY>");
+    client.println("<H1>Internet Controlled 2WD Car</H1>");
+    client.println("<br />");
+    client.println("<br />");        
+    client.println("<a href=\"/?forwardLeft\"\">FORWARD LEFT</a>");
+    client.println(" ");
+    client.println("<a href=\"/?forward\"\">FORWARD</a>");  
+    client.println(" ");      
+    client.println("<a href=\"/?forwardRight\"\">FORWARD RIGHT</a>");
+    client.println("<br />");
+    client.println("<br />");
+    client.println("<br />");
+    client.println("<a href=\"/?stop\"\">STOP</a>");
+    client.println("<br />");
+    client.println("<br />");
+    client.println("<br />");
+    client.println("<a href=\"/?backwardLeft\"\">BACKWARD LEFT</a>");
+    client.println(" ");
+    client.println("<a href=\"/?backward\"\">BACK</a>");
+    client.println(" ");  
+    client.println("<a href=\"/?backwardRight\"\">BACKWARD RIGHT</a>");
+    client.println("</BODY>");
+    client.println("</HTML>");
+
+    //Stop loading the website     
+    delay(1);
+    client.stop();
+
+    if(strstr(buffer, "?stop") != NULL) {
+      car.stop();
+    } else if(strstr(buffer, "?forwardLeft") != NULL) {
+      car.setAction(CAR_FORWARD_LEFT);
+    } else if(strstr(buffer, "?forwardRight") != NULL) {
+      car.setAction(CAR_FORWARD_RIGHT);
+    } else if(strstr(buffer, "?backwardLeft") != NULL) {
+      car.setAction(CAR_BACKWARD_LEFT);
+    } else if(strstr(buffer, "?backwardRight") != NULL) {
+      car.setAction(CAR_BACKWARD_RIGHT);
+    } else if(strstr(buffer, "?forward") != NULL) {
+      car.setAction(CAR_FORWARD);
+    } else if(strstr(buffer, "?backward") != NULL) {
+      car.setAction(CAR_BACKWARD);
+    }
+  }
+}
  No newline at end of file

          

@@ 0,0 1,222 @@ 
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <Car2wd.h>
+#include <UVC.h>
+
+#define NO_CONTROLLER  0
+#define CONTROLLER_1   1
+#define CONTROLLER_2   2
+
+char ssid[] = "mycar";        // Set the AP's SSID
+char pass[] = "12345678";     // Set the AP's password
+char channel[] = "11";        // Set the AP's channel
+int status = WL_IDLE_STATUS;  // the Wifi radio's status
+
+/* control 1 */
+int port_ctrl1 = 5001;
+//#define CTRL1_USE_TCP
+#ifdef CTRL1_USE_TCP
+WiFiServer server(port_ctrl1);
+#else
+// Use UDP in control 1
+WiFiUDP udp1;
+#endif
+
+/* control 2 */
+WiFiUDP udp2;
+int port_ctrl2 = 5002;
+
+Car2wd car(8,9,10,11,12,13);
+
+#define DBG (1)
+
+void setup() {
+
+  car.begin();
+
+  status = WiFi.status();
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to start AP with SSID: ");
+    Serial.println(ssid);
+    status = WiFi.apbegin(ssid, pass, channel);
+    if (status == WL_CONNECTED) break;
+    delay(1000);
+  }
+  Serial.println("AP mode already started");
+
+  UVC.begin();
+  while (!UVC.available()) delay(1000);
+  Serial.println("UVC is ready");
+
+#ifdef CTRL1_USE_TCP
+  server.begin();
+  os_thread_create(tcp_ctrl_task, NULL, OS_PRIORITY_REALTIME, 2048);
+#else
+  udp1.begin(port_ctrl1);
+  os_thread_create(udp1_ctrl_task, NULL, OS_PRIORITY_REALTIME, 2048);
+#endif
+
+  udp2.begin(port_ctrl2);
+  os_thread_create(udp2_ctrl_task, NULL, OS_PRIORITY_REALTIME, 2048);
+
+}
+
+#ifdef CTRL1_USE_TCP
+uint8_t tcpbuf[256];
+void tcp_ctrl_task(const void *argument) {
+  int len;
+  WiFiClient client;
+  while (1) {
+    if (!client.connected()) {
+      client = server.available();
+    }
+    while (client.connected()) {
+      client.setRecvTimeout(1800);
+      memset(tcpbuf, 0, sizeof(tcpbuf));
+      len = client.read(tcpbuf, sizeof(tcpbuf)-1);
+      if (len > 0) {
+        if (DBG) printf("[TCP]:%s\r\n", tcpbuf);
+        tcpbuf[len] = '\0';
+      }
+      handleData((const char *)tcpbuf, CONTROLLER_1);
+    }
+    delay(100);
+  }
+}
+#else
+uint8_t udpbuf1[256];
+void udp1_ctrl_task(const void *argument) {
+  int len;
+  while(1) {
+    memset(udpbuf1, 0, sizeof(udpbuf1));
+    len = udp1.read(udpbuf1, sizeof(udpbuf1)-1);
+    if (len > 0) {
+      if (DBG) printf("[UDP1]:%s\r\n", udpbuf1);
+      udpbuf1[len] = '\0';
+    }
+    handleData((const char *)udpbuf1, CONTROLLER_1);
+    delay(100);
+  }
+}
+#endif
+
+uint8_t udpbuf2[256];
+void udp2_ctrl_task(const void *argument) {
+  int len;
+  while(1) {
+    memset(udpbuf2, 0, sizeof(udpbuf2));
+    len = udp2.read(udpbuf2, sizeof(udpbuf2)-1);
+    if (len > 0) {
+      if (DBG) printf("[UDP2]:%s\r\n", udpbuf2);
+      udpbuf2[len] = '\0';
+    }
+    handleData((const char *)udpbuf2, CONTROLLER_2);
+    delay(100);
+  }
+}
+
+void loop() {
+  delay(1000);
+}
+
+int speedMapping(int rawspeed) {
+  /* Original data range: -12 ~ + 12
+   * Convert it to PWM range: 150~255
+   **/
+  if (rawspeed == 0) {
+    return 0;
+  } else {
+    return (rawspeed * 105) / 12 + ((rawspeed > 0) ? 150 : -150);
+  }
+}
+
+#define NO_CONTROL_TIMEOUT 2000
+int currentController = NO_CONTROLLER;
+uint32_t lastActionTimestamp = 0;
+int lastXspeed = 0;
+int lastYspeed = 0;
+void handleData(const char *buf, int controller) {
+
+  int len;
+  bool xchange = false, ychange = false;;
+  int xspeed = 0, yspeed = 0;
+  uint32_t currentTimestamp;
+
+  currentTimestamp = millis();
+
+  if ((currentController != NO_CONTROLLER) && (currentController != controller)) {
+    if (currentTimestamp - lastActionTimestamp > NO_CONTROL_TIMEOUT) {
+      // There is other controller, but there is no action for a while. Switch control to current controller.
+      currentController = controller;
+    } else {
+      return;
+    }
+  }
+
+  if (buf[0] != '\0') {
+    len = strlen(buf);
+    for (int i=0; i<len; i++) {
+      if (buf[i] == 'X') {
+        xspeed = lastXspeed = speedMapping(parseSpeed(&buf[i+2]));
+        xchange = true;
+      }
+      if (buf[i] == 'Y') {
+        yspeed = lastYspeed = speedMapping(parseSpeed(&buf[i+2]));
+        ychange = true;
+      }
+    }
+    if (xchange == false) xspeed = lastXspeed;
+    if (ychange == false) yspeed = lastYspeed;
+  } else {
+    xspeed = lastXspeed = 0;
+    yspeed = lastYspeed = 0;
+  }
+
+  if (xspeed != 0 || yspeed != 0) {
+    lastActionTimestamp = currentTimestamp;
+    if (currentController == NO_CONTROLLER) {
+      currentController = controller;
+    }
+  } else {
+    if (currentTimestamp - lastActionTimestamp > NO_CONTROL_TIMEOUT) {
+      currentController = NO_CONTROLLER;
+    }
+  }
+
+  if (xspeed == 0 && yspeed == 0) {
+    car.stop();
+  } else if (xspeed == 0 && yspeed > 0) {
+    car.setAction(CAR_FORWARD, abs(yspeed));
+  } else if (xspeed == 0 && yspeed < 0) {
+    car.setAction(CAR_BACKWARD, abs(yspeed));
+  } else if (xspeed > 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_RIGHT, abs(yspeed));
+  } else if (xspeed > 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_RIGHT, abs(xspeed));
+  } else if (xspeed > 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_RIGHT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed < 0 ) {
+    car.setAction(CAR_BACKWARD_LEFT, abs(yspeed));
+  } else if (xspeed < 0 && yspeed == 0) {
+    car.setAction(CAR_ROTATE_LEFT, abs(xspeed));
+  } else if (xspeed < 0 && yspeed > 0 ) {
+    car.setAction(CAR_FORWARD_LEFT, abs(yspeed));
+  }
+}
+
+int parseSpeed(const char *buf) {
+  int s = 0;
+  if (buf[0] == '-') {
+    s = buf[1] - '0';
+    if (buf[2] >= '0' && buf[2] <= '9') {
+      s = s * 10 + (buf[2] - '0');
+    }
+    s = -s;
+  } else {
+    s = buf[0] - '0';
+    if (buf[1] >= '0' && buf[1] <= '9') {
+      s = s * 10 + (buf[1] - '0');
+    }
+  }
+  return s;
+}
  No newline at end of file

          

@@ 0,0 1,284 @@ 
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include "I2Cdev.h"
+#include "MPU6050_6Axis_MotionApps20.h"
+#include "Wire.h"
+
+/* WiFi related variables*/
+char ssid[] = "mycar";          // mycar ssid
+char pass[] = "12345678";       // mycar password
+IPAddress server(192,168,1,1);  // numeric IP for mycar AP mode
+int udpport = 5002;
+int status = WL_IDLE_STATUS;
+
+WiFiUDP udp;
+char sendbuf[12];
+
+/* MPU6050 related variables */
+MPU6050 mpu;
+
+// MPU control/status vars
+bool dmpReady = false;  // set true if DMP init was successful
+uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
+uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
+uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
+uint16_t fifoCount;     // count of all bytes currently in FIFO
+uint8_t fifoBuffer[64]; // FIFO storage buffer
+
+// orientation/motion vars
+Quaternion q;           // [w, x, y, z]         quaternion container
+VectorFloat gravity;    // [x, y, z]            gravity vector
+float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector
+
+/* car control variable */
+int carx = 0, cary = 0;
+int prev_carx = 0, prev_cary = 0;
+uint32_t timestamp = 0, last_send_timestamp = 0;
+
+volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
+void dmpDataReady() {
+    mpuInterrupt = true;
+}
+
+void setup() {
+  checkAndReconnectServer();
+  initMPU6050();
+}
+
+void loop() {
+  if (!dmpReady) return; // if programming failed, don't try to do anything
+
+  safeWaitMPU6050();
+  mpuIntStatus = mpu.getIntStatus();
+  fifoCount = mpu.getFIFOCount();
+
+  if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
+    mpu.resetFIFO();
+    Serial.println(F("FIFO overflow!"));
+  } else if (mpuIntStatus & 0x02 && fifoCount >= packetSize) {
+    while (fifoCount >= packetSize){
+      mpu.getFIFOBytes(fifoBuffer, packetSize);
+      fifoCount -= packetSize;
+    }
+
+    // get Euler angles
+    mpu.dmpGetQuaternion(&q, fifoBuffer);
+    mpu.dmpGetGravity(&gravity, &q);
+    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
+
+    if (hasStarted(ypr[1], ypr[2])) {
+      mapPitchRolltoXY(ypr[1], ypr[2], &carx, &cary);
+    } else {
+      carx = cary = 0;
+    }
+  
+    memset(sendbuf, 0, 12);
+    timestamp = millis();
+    if ((timestamp - last_send_timestamp) > 500 || (carx != prev_carx && cary != prev_cary)) {
+      // If there is no value changed after 500ms, then send command to keepalive.
+      sprintf(sendbuf, "X:%dY:%d", carx, cary);
+    } else if (carx != prev_carx) {
+      sprintf(sendbuf, "X:%d", carx);
+    } else if (cary != prev_cary) {
+      sprintf(sendbuf, "Y:%d", cary);
+    }
+    if (strlen(sendbuf) > 0) {
+      if (checkAndReconnectServer()) {
+        safeResetMPU6050();
+      }
+      udp.beginPacket(server, udpport);
+      udp.write(sendbuf, strlen(sendbuf));
+      udp.endPacket();
+      last_send_timestamp = timestamp;
+      delay(10);
+
+    }
+    prev_carx = carx;
+    prev_cary = cary;
+
+    // ignore previous interrupt
+    mpuInterrupt = false;
+  }
+}
+
+#define CAR_STATE_OFF             0
+#define CAR_STATE_OFF_FIRST_ROLL  1
+#define CAR_STATE_OFF_FIRST_FLAT  2
+#define CAR_STATE_OFF_SECOND_ROLL 3
+#define CAR_STATE_ON              4
+
+// If user cannot complete action within 3s, then break to init state
+#define CAR_STATE_BREAK_TIMEOUT 3000
+
+int carState = CAR_STATE_OFF;
+uint32_t initChangeStateTimestamp = 0;
+
+int isFlat(float pitch, float roll) {
+  return (pitch < 24 && pitch > -24 && roll < 24 && roll > -24);
+}
+
+int isRoll(float pitch, float roll) {
+  return (pitch > 70 || pitch < -70 || roll > 70 || roll < -70);
+}
+
+// return 1 if we can control car
+int hasStarted(float pitch, float roll) {
+  int ret = 0;
+  pitch = pitch * 180 / M_PI;
+  roll = roll * 180 / M_PI;
+  switch(carState) {
+    case CAR_STATE_OFF:
+      if (isRoll(pitch, roll)) {
+        carState = CAR_STATE_OFF_FIRST_ROLL;
+        initChangeStateTimestamp = millis();
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_FIRST_ROLL:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+      } else {
+        if (isFlat(pitch, roll)) {
+          carState = CAR_STATE_OFF_FIRST_FLAT;
+        }
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_FIRST_FLAT:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+      } else {
+        if (isRoll(pitch, roll)) {
+          carState = CAR_STATE_OFF_SECOND_ROLL;
+        }
+      }
+      ret = 0;
+      break;
+    case CAR_STATE_OFF_SECOND_ROLL:
+      if (millis() - initChangeStateTimestamp > CAR_STATE_BREAK_TIMEOUT) {
+        carState = CAR_STATE_OFF;
+        ret = 0;
+      } else {
+        if (isFlat(pitch, roll)) {
+          carState = CAR_STATE_ON;
+          Serial.println("ON");
+          ret = 1;
+        } else {
+          ret = 0;
+        }
+      }
+      break;
+    case CAR_STATE_ON:
+      ret = 1;
+      break;
+  }
+
+  return ret;
+}
+
+int mapRange(float angle) {
+  /* Here is the mapping table.
+   * Pitch/Roll(degree): -48...-24...24...48
+   * Car:                -12.....0....0...12
+   */
+  if (angle < -48) {
+    return -12;
+  } else if ( angle >= -48 && angle < -24) {
+    return ((angle + 24)) / 2;
+  } else if ( angle > 24 && angle <= 48) {
+    return (angle - 24) / 2;
+  } else if (angle > 48) {
+    return 12;
+  } else {
+    return 0;
+  }
+}
+
+void mapPitchRolltoXY(float pitch, float roll, int *carx, int *cary) {
+  pitch = pitch * 180 / M_PI;
+  roll = roll * 180 / M_PI;
+  *carx = -mapRange(pitch);
+  *cary = -mapRange(roll);
+}
+
+int checkAndReconnectServer() {
+  int ret = 0;
+  status = WiFi.status();
+  if (status != WL_CONNECTED) {
+    while (status != WL_CONNECTED) {
+      Serial.print("Attempting to connect to SSID: ");
+      Serial.println(ssid);
+      // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+      status = WiFi.begin(ssid, pass);
+      if (status == WL_CONNECTED) {
+        break;
+      }
+      Serial.println("Reconnect to wifi...");
+      delay(1000);
+    }
+    Serial.println("Connected to wifi");
+    ret = 1;
+  }
+  return ret;
+}
+
+void initMPU6050() {
+  Wire.begin();
+  Wire.setClock(400000); // 400kHz I2C clock (200kHz if CPU is 8MHz).
+
+  Serial.println(F("Initializing I2C devices..."));
+  mpu.initialize();
+
+  Serial.println(F("Testing device connections..."));
+  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));
+
+  Serial.println(F("Initializing DMP..."));
+  devStatus = mpu.dmpInitialize();
+
+  // make sure it worked (returns 0 if so)
+  if (devStatus == 0) {
+    // turn on the DMP, now that it's ready
+    Serial.println(F("Enabling DMP..."));
+    mpu.setDMPEnabled(true);
+
+    // enable Arduino interrupt detection
+    Serial.println(F("Enabling interrupt detection (Ameba D16 pin)..."));
+    attachInterrupt(16, dmpDataReady, RISING);
+    mpuIntStatus = mpu.getIntStatus();
+
+    // set our DMP Ready flag so the main loop() function knows it's okay to use it
+    Serial.println(F("DMP ready! Waiting for first interrupt..."));
+    dmpReady = true;
+
+    // get expected DMP packet size for later comparison
+    packetSize = mpu.dmpGetFIFOPacketSize();
+
+    mpu.setRate(5); // 1khz / (1 + 5) = 166 Hz
+  } else {
+    // ERROR!
+    // 1 = initial memory load failed
+    // 2 = DMP configuration updates failed
+    // (if it's going to break, usually the code will be 1)
+    Serial.print(F("DMP Initialization failed (code "));
+    Serial.print(devStatus);
+    Serial.println(F(")"));
+  }  
+}
+
+void safeWaitMPU6050() {
+  while (!mpuInterrupt) {
+    os_thread_yield(); // without yield, the empty busy loop might make CPU behave un-expected
+  }  
+  mpuInterrupt = false;
+}
+
+void safeResetMPU6050() {
+  /* If dmp interrupt happends at I2C send/recv, then MPU6050 would hang and can only recover by plug out/in VCC.
+   * To avoid this happen we wait next interrupt and then reset buffer */
+  mpuInterrupt = false;
+    while (!mpuInterrupt) {
+    os_thread_yield(); // without yield, the empty busy loop might make CPU behave un-expected
+  }
+  mpu.resetFIFO();
+  mpuInterrupt = false;
+}
  No newline at end of file

          

@@ 0,0 1,219 @@ 
+/*
+
+ This sketch require these items:
+   - Ameba x 1
+   - PCA9685 x 1
+   - Thunder Tiger Jackal car x 1
+
+ There are 2 components need to be control in Thunder Tiger.
+ One is direction servo. This servo require a 6V power source. And the servo working level is 3.3V.
+ The servo works at 54Hz, and the range of pulse width is 1ms~2ms.
+ The other is motor control. The power line provide 6V power source.
+ The signal line use pwm with same property as direction servo.
+
+ The PCA9685 is for smooth the action.
+
+ The direction servo may drain power from low to high rapidly. So we need a 100uF capacity.
+ So the whole connection is as below:
+
+    Motor power line --- Ameba 5V pin --- 100uF capacity positive side --- direction servo power line
+    Motor GND --- Ameba GND --- 100uF capacity negative side --- direction servo GND
+
+    Ameba 3.3V pin --- PCA9685 VCC
+    Ameba GND --- PCA9685 GND
+    Ameba SDA --- PCA9685 SDA
+    Ameba SCL --- PCA9685 SCL
+
+    PCA9685 PWM 0 signal --- Motor signal line
+    PCA9685 PWM 1 signal --- direction servo signal line
+
+ */
+
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <UVC.h>
+#include <Wire.h>
+#include <Adafruit_PWMServoDriver.h>
+
+#define DBG (1)
+//#define CTRL_USE_TCP
+#define ENABLE_UVC
+
+char ssid[] = "myJackal";     // Set the AP's SSID
+char pass[] = "12345678";     // Set the AP's password
+char channel[] = "6";         // Set the AP's channel
+int status = WL_IDLE_STATUS;  // the Wifi radio's status
+
+int port_ctrl = 5001;
+#ifdef CTRL_USE_TCP
+WiFiServer server(port_ctrl);
+WiFiClient client;
+#else
+WiFiUDP udp;
+#endif
+
+#define PWM_THR 0
+#define PWM_STR 1
+Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
+
+const int ctrl_range_min = -127;
+const int ctrl_range_max = +127;
+
+const int xspeed_min  = 221; // 4096 *  5.383 / 100
+const int xspeed_stop = 307; // 4096 *  8.013 / 100
+const int xspeed_max  = 439; // 4096 * 10.724 / 100
+
+const int yspeed_break  = 213; // 4096 *  5.190 / 100 (Full Speed)
+const int yspeed_min  = 300; // (Limited Speed)
+//const int yspeed_min  = 213; // 4096 *  5.190 / 100 (Full Speed)
+const int yspeed_stop = 328; // 4096 *  8.018 / 100
+const int yspeed_max  = 354; // (Limited Speed)
+//const int yspeed_max  = 434; // 4096 * 10.600 / 100 (Full Speed)
+
+uint8_t buffer[256];
+
+void setup() {
+  pwm.begin();
+  pwm.setPWMFreq(54);
+  pwm.setPWM(PWM_THR, 0, yspeed_stop);
+  pwm.setPWM(PWM_STR, 1, xspeed_stop);
+
+  status = WiFi.status();
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to start AP with SSID: ");
+    Serial.println(ssid);
+    status = WiFi.apbegin(ssid, pass, channel);
+    if (status == WL_CONNECTED) break;
+    delay(1000);
+  }
+  Serial.println("AP mode already started");
+
+#ifdef CTRL_USE_TCP
+  server.begin();
+#else
+  udp.begin(port_ctrl);
+#endif
+
+#ifdef ENABLE_UVC
+  UVC.begin();
+  while (!UVC.available()) delay(100);
+  Serial.println("UVC is ready");
+#endif
+}
+
+#ifdef CTRL_USE_TCP
+void tcpHandler() {
+  int len;
+  if (!client.connected()) {
+    client = server.available();
+  }
+  while (client.connected()) {
+    memset(buffer, 0, 256);
+    len = client.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      if (DBG) printf("%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+  }
+  Serial.println("control socket broken");
+  memset(buffer, 0, 256);
+  handleData((const char *)buffer);
+  delay(1000);  
+}
+#else
+void udpHandler() {
+  int len;
+  while(1) {
+    memset(buffer, 0, sizeof(buffer));
+    len = udp.read(buffer, sizeof(buffer)-1);
+    if (len > 0) {
+      if (DBG) printf("%s\r\n", buffer);
+      buffer[len] = '\0';
+    }
+    handleData((const char *)buffer);
+  }
+}
+#endif
+
+void loop() {
+#ifdef CTRL_USE_TCP
+  tcpHandler();
+#else
+  udpHandler();
+#endif
+}
+
+int thrMapping(int rawspeed) {
+  if (rawspeed == 0) {
+    return yspeed_stop;
+  } else {
+    return yspeed_min + (rawspeed - ctrl_range_min) * (yspeed_max - yspeed_min) / (ctrl_range_max - ctrl_range_min);
+  }
+}
+
+int strMapping(int rawspeed) {
+  return xspeed_min + (rawspeed - ctrl_range_min) * (xspeed_max - xspeed_min) / (ctrl_range_max - ctrl_range_min);
+}
+
+int lastXspeed = xspeed_stop;
+int lastYspeed = yspeed_stop;
+int breakCounter = 0;
+void handleData(const char *buf) {
+  int len;
+  bool xchange = false, ychange = false;;
+  int xspeed = lastXspeed;
+  int yspeed = yspeed_stop;
+
+  if (buf[0] != '\0') {
+    len = strlen(buf);
+
+    if (strcmp(buf, "R?") == 0) {
+      char rangebuf[64];
+      sprintf(rangebuf, "R=X:%d,%d;Y%d,%d", ctrl_range_min, ctrl_range_max, ctrl_range_min, ctrl_range_max);
+#ifdef CTRL_USE_TCP
+      client.write(rangebuf, strlen(rangebuf));
+#else
+      udp.beginPacket(udp.remoteIP(), udp.remotePort());
+      udp.write(rangebuf, strlen(rangebuf));
+      udp.endPacket();
+#endif
+      return;
+    }
+
+    for (int i=0; i<len; i++) {
+      if (buf[i] == 'X') {
+        xspeed = lastXspeed = strMapping(atoi(&buf[i+2]));
+        xchange = true;
+      }
+      if (buf[i] == 'Y') {
+        yspeed = lastYspeed = thrMapping(atoi(&buf[i+2]));
+        ychange = true;
+      }
+    }
+    if (xchange == false) {
+      xspeed = lastXspeed;
+    }
+    if (ychange == false) {
+      yspeed = lastYspeed;
+    }
+  } else {
+    yspeed = lastYspeed = yspeed_stop;
+  }
+
+  if (yspeed == yspeed_min && lastYspeed > yspeed_stop + 10) {
+    breakCounter = 3;
+  }
+  if (breakCounter > 0) {
+    if (yspeed == yspeed_min) {
+      yspeed = yspeed_break;
+      breakCounter--;
+    } else {
+      breakCounter = 0;
+    }
+  }
+
+  if (DBG) printf("(%d,%d)\r\n", xspeed, yspeed);
+  pwm.setPWM(PWM_THR, 0, yspeed);
+  pwm.setPWM(PWM_STR, 0, xspeed);
+}
  No newline at end of file

          

@@ 0,0 1,33 @@ 
+#######################################
+# Syntax Coloring Map for Motors
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Car2wd	KEYWORD1	Car2wd
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+end	KEYWORD2
+setAction	KEYWORD2
+stop	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+CAR_MIN_SPEED	LITERAL1
+CAR_STOP	LITERAL1
+CAR_FORWARD	LITERAL1
+CAR_BACKWARD	LITERAL1
+CAR_ROTATE_RIGHT	LITERAL1
+CAR_ROTATE_LEFT	LITERAL1
+CAR_FORWARD_RIGHT	LITERAL1
+CAR_FORWARD_LEFT	LITERAL1
+CAR_BACKWARD_RIGHT	LITERAL1
+CAR_BACKWARD_LEFT	LITERAL1
  No newline at end of file

          

@@ 0,0 1,10 @@ 
+name=AmebaMotors
+version=1.0.1
+author=Realtek
+maintainer=Realtek <ameba.arduino@gmail.com>
+sentence=With this library you can find useful ditial application.
+paragraph=
+category=Signal Input/Output
+url=http://www.amebaiot.com/ameba-arduino-peripherals-examples/
+architectures=ameba
+

          

@@ 0,0 1,218 @@ 
+/*
+ * DS1307RTC.h - library for DS1307 RTC
+  
+  Copyright (c) Michael Margolis 2009
+  This library is intended to be uses with Arduino Time library functions
+
+  The 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
+  
+  30 Dec 2009 - Initial release
+  5 Sep 2011 updated for Arduino 1.0
+ */
+
+
+#if defined (__AVR_ATtiny84__) || defined(__AVR_ATtiny85__) || (__AVR_ATtiny2313__)
+#include <TinyWireM.h>
+#define Wire TinyWireM
+#else
+#include <Wire.h>
+#endif
+#include "DS1307RTC.h"
+
+#define DS1307_CTRL_ID 0x68 
+
+DS1307RTC::DS1307RTC()
+{
+  Wire.begin();
+}
+  
+// PUBLIC FUNCTIONS
+time_t DS1307RTC::get()   // Aquire data from buffer and convert to time_t
+{
+  tmElements_t tm;
+  if (read(tm) == false) return 0;
+  return(makeTime(tm));
+}
+
+bool DS1307RTC::set(time_t t)
+{
+  tmElements_t tm;
+  breakTime(t, tm);
+  return write(tm); 
+}
+
+// Aquire data from the RTC chip in BCD format
+bool DS1307RTC::read(tmElements_t &tm)
+{
+  uint8_t sec;
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x00); 
+#else
+  Wire.send(0x00);
+#endif  
+  if (Wire.endTransmission() != 0) {
+    exists = false;
+    return false;
+  }
+  exists = true;
+
+  // request the 7 data fields   (secs, min, hr, dow, date, mth, yr)
+  Wire.requestFrom(DS1307_CTRL_ID, tmNbrFields);
+  if (Wire.available() < tmNbrFields) return false;
+#if ARDUINO >= 100
+  sec = Wire.read();
+  tm.Second = bcd2dec(sec & 0x7f);   
+  tm.Minute = bcd2dec(Wire.read() );
+  tm.Hour =   bcd2dec(Wire.read() & 0x3f);  // mask assumes 24hr clock
+  tm.Wday = bcd2dec(Wire.read() );
+  tm.Day = bcd2dec(Wire.read() );
+  tm.Month = bcd2dec(Wire.read() );
+  tm.Year = y2kYearToTm((bcd2dec(Wire.read())));
+#else
+  sec = Wire.receive();
+  tm.Second = bcd2dec(sec & 0x7f);   
+  tm.Minute = bcd2dec(Wire.receive() );
+  tm.Hour =   bcd2dec(Wire.receive() & 0x3f);  // mask assumes 24hr clock
+  tm.Wday = bcd2dec(Wire.receive() );
+  tm.Day = bcd2dec(Wire.receive() );
+  tm.Month = bcd2dec(Wire.receive() );
+  tm.Year = y2kYearToTm((bcd2dec(Wire.receive())));
+#endif
+  if (sec & 0x80) return false; // clock is halted
+  return true;
+}
+
+bool DS1307RTC::write(tmElements_t &tm)
+{
+  // To eliminate any potential race conditions,
+  // stop the clock before writing the values,
+  // then restart it after.
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x00); // reset register pointer  
+  Wire.write((uint8_t)0x80); // Stop the clock. The seconds will be written last
+  Wire.write(dec2bcd(tm.Minute));
+  Wire.write(dec2bcd(tm.Hour));      // sets 24 hour format
+  Wire.write(dec2bcd(tm.Wday));   
+  Wire.write(dec2bcd(tm.Day));
+  Wire.write(dec2bcd(tm.Month));
+  Wire.write(dec2bcd(tmYearToY2k(tm.Year))); 
+#else  
+  Wire.send(0x00); // reset register pointer  
+  Wire.send(0x80); // Stop the clock. The seconds will be written last
+  Wire.send(dec2bcd(tm.Minute));
+  Wire.send(dec2bcd(tm.Hour));      // sets 24 hour format
+  Wire.send(dec2bcd(tm.Wday));   
+  Wire.send(dec2bcd(tm.Day));
+  Wire.send(dec2bcd(tm.Month));
+  Wire.send(dec2bcd(tmYearToY2k(tm.Year)));   
+#endif
+  if (Wire.endTransmission() != 0) {
+    exists = false;
+    return false;
+  }
+  exists = true;
+
+  // Now go back and set the seconds, starting the clock back up as a side effect
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x00); // reset register pointer  
+  Wire.write(dec2bcd(tm.Second)); // write the seconds, with the stop bit clear to restart
+#else  
+  Wire.send(0x00); // reset register pointer  
+  Wire.send(dec2bcd(tm.Second)); // write the seconds, with the stop bit clear to restart
+#endif
+  if (Wire.endTransmission() != 0) {
+    exists = false;
+    return false;
+  }
+  exists = true;
+  return true;
+}
+
+unsigned char DS1307RTC::isRunning()
+{
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x00); 
+#else
+  Wire.send(0x00);
+#endif  
+  Wire.endTransmission();
+
+  // Just fetch the seconds register and check the top bit
+  Wire.requestFrom(DS1307_CTRL_ID, 1);
+#if ARDUINO >= 100
+  return !(Wire.read() & 0x80);
+#else
+  return !(Wire.receive() & 0x80);
+#endif  
+}
+
+void DS1307RTC::setCalibration(char calValue)
+{
+  unsigned char calReg = abs(calValue) & 0x1f;
+  if (calValue >= 0) calReg |= 0x20; // S bit is positive to speed up the clock
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x07); // Point to calibration register
+  Wire.write(calReg);
+#else  
+  Wire.send(0x07); // Point to calibration register
+  Wire.send(calReg);
+#endif
+  Wire.endTransmission();  
+}
+
+char DS1307RTC::getCalibration()
+{
+  Wire.beginTransmission(DS1307_CTRL_ID);
+#if ARDUINO >= 100  
+  Wire.write((uint8_t)0x07); 
+#else
+  Wire.send(0x07);
+#endif  
+  Wire.endTransmission();
+
+  Wire.requestFrom(DS1307_CTRL_ID, 1);
+#if ARDUINO >= 100
+  unsigned char calReg = Wire.read();
+#else
+  unsigned char calReg = Wire.receive();
+#endif
+  char out = calReg & 0x1f;
+  if (!(calReg & 0x20)) out = -out; // S bit clear means a negative value
+  return out;
+}
+
+// PRIVATE FUNCTIONS
+
+// Convert Decimal to Binary Coded Decimal (BCD)
+uint8_t DS1307RTC::dec2bcd(uint8_t num)
+{
+  return ((num/10 * 16) + (num % 10));
+}
+
+// Convert Binary Coded Decimal (BCD) to Decimal
+uint8_t DS1307RTC::bcd2dec(uint8_t num)
+{
+  return ((num/16 * 10) + (num % 16));
+}
+
+bool DS1307RTC::exists = false;
+
+DS1307RTC RTC = DS1307RTC(); // create an instance for the user
+

          

@@ 0,0 1,40 @@ 
+/*
+ * DS1307RTC.h - library for DS1307 RTC
+ * This library is intended to be uses with Arduino Time library functions
+ */
+
+#ifndef DS1307RTC_h
+#define DS1307RTC_h
+
+#include <TimeLib.h>
+
+// library interface description
+class DS1307RTC
+{
+  // user-accessible "public" interface
+  public:
+    DS1307RTC();
+    static time_t get();
+    static bool set(time_t t);
+    static bool read(tmElements_t &tm);
+    static bool write(tmElements_t &tm);
+    static bool chipPresent() { return exists; }
+    static unsigned char isRunning();
+    static void setCalibration(char calValue);
+    static char getCalibration();
+
+  private:
+    static bool exists;
+    static uint8_t dec2bcd(uint8_t num);
+    static uint8_t bcd2dec(uint8_t num);
+};
+
+#ifdef RTC
+#undef RTC // workaround for Arduino Due, which defines "RTC"...
+#endif
+
+extern DS1307RTC RTC;
+
+#endif
+ 
+

          

@@ 0,0 1,1 @@ 
+The Time library is forked from works at "http://www.pjrc.com/teensy/td_libs_DS1307RTC.html". The source codes under folder "Time" inherit the license from any license claim of "http://www.pjrc.com/teensy/td_libs_DS1307RTC.html".
  No newline at end of file

          

@@ 0,0 1,49 @@ 
+#include <Wire.h>
+#include <TimeLib.h>
+#include <DS1307RTC.h>
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial) ; // wait for serial
+  delay(200);
+  Serial.println("DS1307RTC Read Test");
+  Serial.println("-------------------");
+}
+
+void loop() {
+  tmElements_t tm;
+
+  if (RTC.read(tm)) {
+    Serial.print("Ok, Time = ");
+    print2digits(tm.Hour);
+    Serial.write(':');
+    print2digits(tm.Minute);
+    Serial.write(':');
+    print2digits(tm.Second);
+    Serial.print(", Date (D/M/Y) = ");
+    Serial.print(tm.Day);
+    Serial.write('/');
+    Serial.print(tm.Month);
+    Serial.write('/');
+    Serial.print(tmYearToCalendar(tm.Year));
+    Serial.println();
+  } else {
+    if (RTC.chipPresent()) {
+      Serial.println("The DS1307 is stopped.  Please run the SetTime");
+      Serial.println("example to initialize the time and begin running.");
+      Serial.println();
+    } else {
+      Serial.println("DS1307 read error!  Please check the circuitry.");
+      Serial.println();
+    }
+    delay(9000);
+  }
+  delay(1000);
+}
+
+void print2digits(int number) {
+  if (number >= 0 && number < 10) {
+    Serial.write('0');
+  }
+  Serial.print(number);
+}

          

@@ 0,0 1,75 @@ 
+#include <Wire.h>
+#include <TimeLib.h>
+#include <DS1307RTC.h>
+
+const char *monthName[12] = {
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+tmElements_t tm;
+
+void setup() {
+  bool parse=false;
+  bool config=false;
+
+  // get the date and time the compiler was run
+  if (getDate(__DATE__) && getTime(__TIME__)) {
+    parse = true;
+    // and configure the RTC with this info
+    if (RTC.write(tm)) {
+      config = true;
+    }
+  }
+
+  Serial.begin(9600);
+  while (!Serial) ; // wait for Arduino Serial Monitor
+  delay(200);
+  if (parse && config) {
+    Serial.print("DS1307 configured Time=");
+    Serial.print(__TIME__);
+    Serial.print(", Date=");
+    Serial.println(__DATE__);
+  } else if (parse) {
+    Serial.println("DS1307 Communication Error :-{");
+    Serial.println("Please check your circuitry");
+  } else {
+    Serial.print("Could not parse info from the compiler, Time=\"");
+    Serial.print(__TIME__);
+    Serial.print("\", Date=\"");
+    Serial.print(__DATE__);
+    Serial.println("\"");
+  }
+}
+
+void loop() {
+}
+
+bool getTime(const char *str)
+{
+  int Hour, Min, Sec;
+
+  if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3) return false;
+  tm.Hour = Hour;
+  tm.Minute = Min;
+  tm.Second = Sec;
+  return true;
+}
+
+bool getDate(const char *str)
+{
+  char Month[12];
+  int Day, Year;
+  uint8_t monthIndex;
+
+  if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3) return false;
+  for (monthIndex = 0; monthIndex < 12; monthIndex++) {
+    if (strcmp(Month, monthName[monthIndex]) == 0) break;
+  }
+  if (monthIndex >= 12) return false;
+  tm.Day = Day;
+  tm.Month = monthIndex + 1;
+  tm.Year = CalendarYrToTm(Year);
+  return true;
+}
+

          

@@ 0,0 1,147 @@ 
+/*
+ * Example showing RTC sync from NTP time source
+ *
+ */
+
+#include <Wire.h>
+#include <TimeLib.h>
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <DS1307RTC.h>
+
+int status = WL_IDLE_STATUS;
+char ssid[] = "yourNetwork";          // your network SSID (name)
+char pass[] = "secretPassword";       // your network password
+
+// NTP Servers:
+IPAddress timeServer(132, 163, 4, 101); // time-a.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 102); // time-b.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 103); // time-c.timefreq.bldrdoc.gov
+
+const int timeZone = 8;     // Beijing Time, Taipei Time
+//const int timeZone = 1;   // Central European Time
+//const int timeZone = -5;  // Eastern Standard Time (USA)
+//const int timeZone = -4;  // Eastern Daylight Time (USA)
+//const int timeZone = -8;  // Pacific Standard Time (USA)
+//const int timeZone = -7;  // Pacific Daylight Time (USA)
+
+// A UDP instance to let us send and receive packets over UDP
+WiFiUDP Udp;
+unsigned int localPort = 2390;  // local port to listen for UDP packets
+
+void setup() 
+{
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+    status = WiFi.begin(ssid, pass);
+    if (status == WL_CONNECTED) break;
+    // wait 1 seconds for retry
+    delay(1000);
+  }
+
+  Udp.begin(localPort);
+  Serial.println("waiting for sync");
+  setSyncProvider(getNtpTime);
+
+  // calibrate RTC time from NTP time
+  if (timeStatus() != timeNotSet) {
+    tmElements_t tm;
+    tm.Hour = hour();
+    tm.Minute = minute();
+    tm.Second = second();
+    tm.Day = day();
+    tm.Month = month();
+    tm.Year = CalendarYrToTm(year());
+    // configure RTC time
+    RTC.write(tm);
+  }
+}
+
+
+void loop()
+{
+  tmElements_t tm;
+
+  if (RTC.read(tm)) {
+    Serial.print("Ok, Time = ");
+    print2digits(tm.Hour);
+    Serial.write(':');
+    print2digits(tm.Minute);
+    Serial.write(':');
+    print2digits(tm.Second);
+    Serial.print(", Date (D/M/Y) = ");
+    Serial.print(tm.Day);
+    Serial.write('/');
+    Serial.print(tm.Month);
+    Serial.write('/');
+    Serial.print(tmYearToCalendar(tm.Year));
+    Serial.println();
+  } else {
+    if (RTC.chipPresent()) {
+      Serial.println("The DS1307 is stopped.  Please run the SetTime");
+      Serial.println("example to initialize the time and begin running.");
+      Serial.println();
+    } else {
+      Serial.println("DS1307 read error!  Please check the circuitry.");
+      Serial.println();
+    }
+    delay(9000);
+  }
+  delay(1000);
+}
+
+void print2digits(int number) {
+  if (number >= 0 && number < 10) {
+    Serial.write('0');
+  }
+  Serial.print(number);
+}
+
+/*-------- NTP code ----------*/
+
+const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
+byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
+
+time_t getNtpTime()
+{
+  Serial.println("Transmit NTP Request");
+  Udp.setRecvTimeout(1500);
+  sendNTPpacket(timeServer);
+  if ( Udp.read(packetBuffer, NTP_PACKET_SIZE) > 0 ) {
+      unsigned long secsSince1900;
+      // convert four bytes starting at location 40 to a long integer
+      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
+      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
+      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
+      secsSince1900 |= (unsigned long)packetBuffer[43];
+      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
+  } else {
+    Serial.println("No NTP Response :-(");
+    return 0; // return 0 if unable to get the time
+  }
+}
+
+// send an NTP request to the time server at the given address
+void sendNTPpacket(IPAddress &address)
+{
+  // set all bytes in the buffer to 0
+  memset(packetBuffer, 0, NTP_PACKET_SIZE);
+  // Initialize values needed to form NTP request
+  // (see URL above for details on the packets)
+  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
+  packetBuffer[1] = 0;     // Stratum, or type of clock
+  packetBuffer[2] = 6;     // Polling Interval
+  packetBuffer[3] = 0xEC;  // Peer Clock Precision
+  // 8 bytes of zero for Root Delay & Root Dispersion
+  packetBuffer[12]  = 49;
+  packetBuffer[13]  = 0x4E;
+  packetBuffer[14]  = 49;
+  packetBuffer[15]  = 52;
+  // all NTP fields have been given values, now
+  // you can send a packet requesting a timestamp:                 
+  Udp.beginPacket(address, 123); //NTP requests are to port 123
+  Udp.write(packetBuffer, NTP_PACKET_SIZE);
+  Udp.endPacket();
+}