init

.gitignore

@@ -0,0 +1,3 @@
+# Files git should ignore
+*.swp
+.idea

Examples/changeName/changeName.ino

@@ -0,0 +1,104 @@
+/*
+ * Change the BT device name
+ *
+ * This works with a Bluetooth terminal. The user is prompted for a new
+ * name which is then written to HC-05.
+ *
+ */
+#include <Arduino.h>
+#include "HC05.h"
+
+/*
+ * Configure this sketch to work with either a software or a hardware
+ * serial port, as configured in HC05.h
+ */
+#ifdef HC05_SOFTWARE_SERIAL
+#include <SoftwareSerial.h>
+HC05 btSerial = HC05(A2, A5, A3, A4);  // cmd, state, rx, tx
+#else
+HC05 btSerial = HC05(3, 2);  // cmd, state
+#endif
+
+/*
+ * See the ITeadStudio HC-05 datasheet for a full list of commands.
+ */
+String NewNameCmd("AT+NAME=");
+
+
+void setup()
+{
+  btSerial.findBaud();
+}
+
+
+void loop(){
+  char buffer[32];
+  size_t recvd = 0;
+  bool waiting = true;
+  String newName;
+
+  btSerial.println("");
+  btSerial.print("New name? ");
+
+  // Use a timeout that will give reasonablly quick response to the user.
+  btSerial.setTimeout(100);
+  while (waiting)
+  {
+    if (btSerial.available())
+    {
+      recvd = btSerial.readBytes(buffer, 32);
+      for (size_t i = 0; i < recvd; i++)
+      {
+        if (buffer[i] != '\n')
+        {
+          newName += buffer[i];
+          btSerial.print(buffer[i]);
+        }
+        else
+        {
+          btSerial.println(" ");
+          waiting = false;
+          break;
+        }
+      }
+    }
+    delay(100);
+  }
+
+  newName.toCharArray(buffer, 32);
+  newName = NewNameCmd + newName;
+  newName.toCharArray(buffer, 32);
+
+  // make sure there is no pending output to interfere with commands
+  btSerial.flush();
+
+  // The name change command takes extra time.
+  // 1000ms is large enough, but arbitrary.
+  if (btSerial.cmd(buffer,1000))
+  {
+    btSerial.println("Name changed.");
+    btSerial.println("Reconnect or rescan to see the result.");
+    btSerial.println("Disconnecting...");
+    btSerial.flush();
+    btSerial.cmd("AT+DISC", 1000);
+  }
+  else
+  {
+    btSerial.println("Name NOT changed.");
+  }
+  
+  // Send a count to the port just to indicate activity.
+  // This will appear after the connection is re-established, or
+  // immediately if the name change command fails.
+  for (uint8_t i = 0; true; i++)
+  {
+    if (i == 0)
+    {
+      btSerial.println("");
+    }
+    btSerial.print(i);
+    btSerial.print('\r');
+    delay(1000);
+  }
+}
+

Examples/echo/echo.ino

@@ -0,0 +1,36 @@
+/*
+ * echo - echo characters back to bluetooth device
+ *
+ * Waits for a connection and then echos each charater received.
+ *
+ * Debugging is enabled, so if you open the 'Serial Monitor' you can see
+ * the search for the HC05 baud and the wait for the BT connection.
+ */
+#include <Arduino.h>
+#include "HC05.h"
+
+#ifdef HC05_SOFTWARE_SERIAL
+#include <SoftwareSerial.h>
+HC05 btSerial = HC05(A2, A5, A3, A4);  // cmd, state, rx, tx
+#else
+HC05 btSerial = HC05(3, 2);  // cmd, state
+#endif
+
+void setup()
+{
+  DEBUG_BEGIN(57600);
+  btSerial.findBaud();
+}
+
+void loop()
+{
+  btSerial.println("Echo Server- type something");
+
+  while (btSerial.connected())
+  {
+    if (btSerial.available())
+    {
+      btSerial.write(btSerial.read());
+    }
+  }
+}

Examples/findBaudTest/findBaudTest.ino

@@ -0,0 +1,83 @@
+/*
+ * findBaudTest - Test all supported baud settings
+ *
+ * The progress and results are printed to Serial, so open the 'Serial
+ * Montitor'.
+ *
+ * The progress and results will be easier to read if you disable the
+ * debugging (comment out or delete the "#define DEBUG_HC05" line in
+ * HC05.h.
+ */
+#include <Arduino.h>
+#include "HC05.h"
+
+#ifdef HC05_SOFTWARE_SERIAL
+#include <SoftwareSerial.h>
+HC05 btSerial = HC05(A2, A5, A3, A4);  // cmd, state, rx, tx
+#else
+HC05 btSerial = HC05(3, 2);  // cmd, state
+#endif
+
+void setup()
+{
+  DEBUG_BEGIN(57600);
+  Serial.begin(57600);
+  Serial.println("---------- Setup ----------");
+  btSerial.findBaud();
+  btSerial.setBaud(4800);
+  Serial.println("---------- Starting test ----------");
+}
+
+void loop()
+{
+  int numTests = 0;
+  int failed = 0;
+  unsigned long rate = 0;
+  unsigned long rates[] = {4800,9600,19200,38400,57600,115200};
+
+  for (int i = 0; i < 6; i++)
+  {
+    for (int j = 0; j < 6; j++)
+    {
+      numTests++;
+      Serial.print(rates[i]);
+      btSerial.setBaud(rates[i]);
+      rate = btSerial.findBaud();
+      if (rate != rates[i])
+      {
+        Serial.print(" FAILED: found rate ");
+        Serial.println(rate);
+        failed++;
+      }
+      else
+      {
+        Serial.print("->");
+        Serial.print(rates[j]);
+        btSerial.setBaud(rates[j]);
+        rate = btSerial.findBaud();
+        if (rate != rates[j])
+        {
+          Serial.print("FAILED: found rate ");
+          Serial.println(rate);
+          failed++;
+        }
+        else
+        {
+          Serial.println(" PASSED");
+        }
+      }
+    }
+  }
+
+  Serial.println("--------- Tests Complete ----------");
+  Serial.print("Results: ");
+  Serial.print(failed);
+  Serial.print(" of ");
+  Serial.print(numTests);
+  Serial.println(" tests failed.");
+
+  while (true)
+  {
+     ;
+  }
+}

Examples/hc05_test/hc05_test.ino

@@ -0,0 +1,46 @@
+/*
+ * hc05_test - Test the disconnect command
+ *
+ * When the main loop detects that a bluetooth device is connected it
+ * disconnects the device.
+ *
+ * Montor the progress using the debug port.
+ */
+#include <Arduino.h>
+#include "HC05.h"
+
+#ifdef HC05_SOFTWARE_SERIAL
+#include <SoftwareSerial.h>
+HC05 btSerial = HC05(A2, A5, A3, A4);  // cmd, state, rx, tx
+#else
+HC05 btSerial = HC05(3, 2);  // cmd, state
+#endif
+
+#ifdef DEBUG_HC05
+#ifdef DEBUG_SW_PORT
+  extern SoftwareSerial DEBUG_PORT;
+#endif
+#endif
+
+void setup()
+{
+  DEBUG_BEGIN(57600);
+  DEBUG_PRINTLN("Setup");
+  delay(3000);  // this delay is for debugging convenience only
+  DEBUG_PRINTLN("DelayComplete");
+  btSerial.println(btSerial.findBaud());
+  
+}
+
+void loop()
+{
+  if (btSerial.connected()){
+    DEBUG_PRINTLN("Connected");
+    btSerial.cmd("AT+DISC", 1000);
+  }
+  else
+  {
+    DEBUG_PRINTLN("Disconnected");
+  }
+  delay(1000);
+}

Examples/recover/recover.ino

@@ -0,0 +1,72 @@
+/*
+ * recover - recover from forgotten serial settings
+ *
+ * Uses cmdMode2 to set the HC05 to 19200 baud, no parity, ones stop bit
+ * (19200N1). 19200N1 is supported by both the hardware and software
+ * serial ports on the Arduino.
+ *
+ * Debugging is enabled, so if you open the 'Serial Monitor' you can see
+ * the process. Note that if you don't get the 'Serial Monitor' open
+ * before the 'AT+UART=' command is issued, you will not really see the
+ * old settings. There is a three second delay at the beginning to give
+ * you a chance to get the serial monitor running.
+ *
+ * The `Serial Monitor` should be set to 57600 baud.
+ *
+ */
+#include <Arduino.h>
+#include "HC05.h"
+
+#ifdef HC05_SOFTWARE_SERIAL
+#include <SoftwareSerial.h>
+HC05 btSerial = HC05(A2, A5, A3, A4);  // cmd, state, rx, tx
+#else
+HC05 btSerial = HC05(3, 2);  // cmd, state
+#endif
+
+int powerPin = 7;
+
+void setup()
+{
+  DEBUG_BEGIN(57600);
+  DEBUG_PRINTLN("Starting recovery in 3 seconds.");
+  btSerial.cmdMode2Start(powerPin);
+
+  // Provide some time for the user to start the serial monitor
+  delay(3000);
+
+  // For curiosity's sake, ask for the old settings
+  btSerial.cmd("AT+UART?");
+
+  // Now set the baud to 19200N1
+  btSerial.cmd("AT+UART=19200,0,0");
+
+  // Exit command mode and switch to the new baud setting
+  btSerial.cmd("AT+RESET");
+  btSerial.cmdMode2End();
+}
+
+
+void loop()
+{
+  int c;
+  unsigned long rate;
+  rate = btSerial.findBaud();
+
+  DEBUG_PRINTLN("");
+
+  if (rate == 19200)
+  {
+    DEBUG_PRINTLN("Recovery successful. HC05 serial settings = 19200N1");
+  }
+  else
+  {
+    DEBUG_PRINT("Recovery failed. Did you connect HC05 power to pin ");
+    DEBUG_PRINT(powerPin);
+    DEBUG_PRINTLN("?");
+  }
+  while (true)
+  {
+    ;
+  }
+}

HC05.cpp

@@ -0,0 +1,260 @@
+#include <Arduino.h>
+#include <HC05.h>
+
+#ifdef DEBUG_SW_PORT
+SoftwareSerial DEBUG_SW_PORT;
+#endif
+
+#ifdef HC05_SOFTWARE_SERIAL
+HC05::HC05(int cmdPin, int statePin, uint8_t rx, uint8_t tx):_btSerial(rx,tx,0)
+#else
+#define _btSerial HC05_HW_SERIAL_PORT
+HC05::HC05(int cmdPin, int statePin)
+#endif
+{
+    pinMode(cmdPin, OUTPUT);
+    _cmdPin = cmdPin;
+    cmdMode = false;
+#ifdef HC05_STATE_PIN
+    pinMode(statePin, INPUT);
+    _statePin = statePin;
+#endif
+    _bufsize = sizeof(_buffer)/sizeof(char);
+}
+
+static const unsigned long rates[] =
+    {4800,9600,19200,38400,57600,115200};
+
+unsigned long HC05::findBaud()
+{
+    const int bt_rx = 4;
+    const int bt_tx = 5;
+    int numRates = sizeof(rates)/sizeof(unsigned long);
+    int response = false;
+    int recvd = 0;
+    //char _buffer[128];
+
+    DEBUG_PRINTLN("findBaud");
+    setCmdPin(HIGH);
+    delay(100);
+    for(int rn = 0; rn < numRates; rn++)
+    {
+        _btSerial.begin(rates[rn]);
+        _btSerial.setTimeout(100);
+        _btSerial.flush();
+        DEBUG_WRITE("Trying ");
+        DEBUG_PRINT(rates[rn]);
+        DEBUG_WRITE("... ");
+        _btSerial.write("AT\r\n");
+        recvd = _btSerial.readBytes(_buffer,_bufsize);
+        if (recvd > 0)
+        {
+            DEBUG_PRINTLN("Found.");
+            // FIXME: refactor to a single return
+            setCmdPin(LOW);
+            return(rates[rn]);
+        }
+        else
+        {
+            DEBUG_PRINTLN("x");
+        }
+    }
+    setCmdPin(LOW);
+    DEBUG_WRITE("\r\nNo connection\r\n");
+    return(0);
+}
+int HC05::cmd(String cmd, unsigned long timeout)
+{
+    char raw[cmd.length() + 1];
+    cmd.toCharArray(raw, sizeof(raw));
+    return this->cmd(raw, timeout);
+}
+
+int HC05::cmd(const char* cmd, unsigned long timeout)
+{
+    int recvd = 0;
+    DEBUG_PRINTLN(cmd);
+
+    setCmdPin(HIGH);
+    // No spec for how long it takes to enter command mode, but 100ms
+    // seems to work- assuming the output has been drained.
+    delay(100);
+    _btSerial.write(cmd);
+    _btSerial.write("\r\n");
+    _btSerial.setTimeout(timeout);
+    do
+    {
+        // ATTENTION: At least through Arduino v1.0.3, it is not possible
+        //            to tell the difference between a timeout and
+        //            receiving only the termination character (NL in this
+        //            case), because the termination character is not
+        //            returned and timeout is not returned as a unique
+        //            indication.
+        //            In this case the result would be an early return
+        //            of a multiline response before the OK is received.
+        //            The return would incorrectly indicate an error (no
+        //            OK response).
+        recvd = _btSerial.readBytesUntil('\n',_buffer,_bufsize);
+        if (recvd > 0)
+        {
+            DEBUG_WRITE((uint8_t *)_buffer,recvd);
+            DEBUG_WRITE('\n');
+        }
+        else
+        {
+            DEBUG_PRINTLN("timeout 1");
+        }
+    }
+    while ((recvd > 0) && (_buffer[0] != 'O' || _buffer[1] != 'K'));
+
+    setCmdPin(LOW);
+
+    // Empirically determined that it takes some time to reliably exit
+    // command mode. The appeared to be a baud rate dependency and with
+    // >100ms required at 9600 baud.
+    delay(150);
+    return((_buffer[0] == 'O' && _buffer[1] == 'K'));
+}
+
+
+/*
+ * If setBaud() is called while the HC-05 is connected, then
+ * it will be disconnected when AT+RESET command is issued, and
+ * it may take 2 (or more?) connection attempts to reconnect. The extra
+ * connect attempts may be a host side issue and not specific to the
+ * HC-05 module.
+ */
+void HC05::setBaud(unsigned long baud, unsigned long stopbits, unsigned long parity)
+{
+    int recvd = 0;
+    setCmdPin(HIGH);
+    delay(200);
+    DEBUG_WRITE("AT+UART=");
+    _btSerial.write("AT+UART=");
+    DEBUG_PRINT(baud);
+    _btSerial.print(baud);
+
+    DEBUG_PRINT(",");
+    _btSerial.print(",");
+
+    DEBUG_PRINT(stopbits);
+    _btSerial.print(stopbits);
+
+    DEBUG_PRINT(",");
+    _btSerial.print(",");
+
+    DEBUG_PRINT(parity);
+    _btSerial.print(parity);
+
+    DEBUG_WRITE("\r\n");
+    _btSerial.write("\r\n");
+
+    recvd = _btSerial.readBytes(_buffer,_bufsize);
+    if (recvd > 0)
+    {
+        DEBUG_WRITE((uint8_t *)_buffer,recvd);
+    }
+    else
+    {
+        DEBUG_PRINTLN("timeout 2");
+    }
+    cmd("AT+RESET");
+    setCmdPin(LOW);
+    _btSerial.begin(baud);
+    delay(1000);
+}
+
+// Usually parity is none, and there is only one stop bit, so this
+// simpler call will do the job.
+void HC05::setBaud(unsigned long baud)
+{
+    setBaud(baud, 0, 0);
+}
+
+
+int HC05::available()
+{
+    _btSerial.available();
+}
+
+int HC05::peek()
+{
+    _btSerial.peek();
+}
+
+void HC05::flush()
+{
+    _btSerial.flush();
+}
+
+int HC05::read()
+{
+    _btSerial.read();
+}
+
+void HC05::begin(unsigned long baud)
+{
+    _btSerial.begin(baud);
+}
+
+#ifndef HC05_SOFTWARE_SERIAL
+// only hardware serial ports support parity/stop bit configuration
+void HC05::begin(unsigned long baud, uint8_t config)
+{
+    _btSerial.begin(baud, config);
+}
+#endif
+
+#ifdef HC05_STATE_PIN
+bool HC05::connected()
+{
+    return(digitalRead(_statePin)?true:false);
+}
+#endif
+
+size_t HC05::write(uint8_t byte)
+{
+#ifdef HC05_STATE_PIN
+    // The down side of this check is that the status gets checked for
+    // every byte written out. That doesn't seem efficient.
+    if (digitalRead(_statePin) != HIGH)
+    {
+        DEBUG_PRINT("No Connection, waiting...");
+        while (digitalRead(_statePin) == LOW)
+        {
+            delay(100);
+        }
+        DEBUG_PRINTLN("OK");
+    }
+#endif
+    _btSerial.write(byte);
+}
+
+
+void HC05::cmdMode2Start(int pwrPin)
+{
+    pinMode(pwrPin, OUTPUT);
+    digitalWrite(pwrPin, LOW);
+    delay(250);  // off or reset time
+    digitalWrite(_cmdPin, HIGH);
+    digitalWrite(pwrPin, HIGH);
+    cmdMode = true;
+    _btSerial.begin(38400);
+    delay(1500);  // time for the HC05 to initialize
+}
+
+
+void HC05::cmdMode2End(void)
+{
+    digitalWrite(_cmdPin, LOW);
+    cmdMode = false;
+    delay(1000);
+}
+
+void HC05::setCmdPin(bool state)
+{
+    if (cmdMode == false)
+    {
+        digitalWrite(_cmdPin, state);
+    }
+}

HC05.h

@@ -0,0 +1,118 @@
+/*
+ * HC05.h - interface definitions for the HC05 library
+ *
+ * Select hardware or software serial port:
+ *   Define HC05_SOFTWARE_SERIAL to select a SoftwareSerial port, then
+ *   initialize the HC05 class with either two arguments, for a hardware port,
+ *   or four arguments for a software serial port:
+ *
+ *     HC05(cmdPin, statePin)
+ *     or
+ *     HC05(cmdPin, statePin, rxPin, txPin)
+ *
+ * Specify an alternate hardware serial port by changing the
+ * HC05_HW_SERIAL_PORT define.
+ *
+ * Define DEBUG_HC05 to enable debugging messages and use the
+ * DEBUG_BEGIN() macro in the sketch setup() function.
+ * By default, debugging messages go to the harware serial port, Serial.
+ * Change that by defining DEBUG_SW_PORT.
+ *
+ */
+#ifndef HC05_h
+#define HC05_h
+
+#include <inttypes.h>
+#include <Stream.h>
+#include <SoftwareSerial.h>
+
+/*
+ * Comment the following define line if you aren't using the State pin or
+ * if your HC05 does not have such a pin.  You still must specify a
+ * statePin to initialize the HC05 class, but the pin will not be used.
+ */
+#define HC05_STATE_PIN
+
+/*
+ * This macro must be defined even if you are using a software serial
+ * port. You can change this to any serial port supported by your
+ * Arduino (i.e, Serial1, Serial2, etc.)
+ */
+#define HC05_HW_SERIAL_PORT Serial
+
+
+/*
+ * Optional macros, define as needed
+ */
+#define HC05_SOFTWARE_SERIAL
+#define DEBUG_HC05
+//#define DEBUG_SW_PORT swserial(4,5)
+
+#ifdef DEBUG_HC05
+#ifdef DEBUG_SW_PORT
+#define DEBUG_PORT swserial
+#else
+#define DEBUG_PORT Serial
+#endif
+
+#define DEBUG_BEGIN(baud) DEBUG_PORT.begin(baud)
+#define DEBUG_WRITE(...) DEBUG_PORT.write(__VA_ARGS__)
+#define DEBUG_PRINT(...) DEBUG_PORT.print(__VA_ARGS__)
+#define DEBUG_PRINTLN(...) DEBUG_PORT.println(__VA_ARGS__)
+
+#else
+#define DEBUG_BEGIN(baud)
+#define DEBUG_WRITE(...)
+#define DEBUG_PRINT(...)
+#define DEBUG_PRINTLN(...)
+
+#endif  // DEBUG_HC05
+
+class HC05 : public Stream
+{
+public:
+    HC05(int cmdPin, int statePin);
+    HC05(int cmdPin, int statePin, uint8_t rx, uint8_t tx);
+    unsigned long findBaud();
+    void setBaud(unsigned long baud);  // always no parity, one stop bit
+    void setBaud(unsigned long baud, unsigned long stopbits, unsigned long parity);
+
+    // cmd(): 100ms default timeout covers simple commands, but commands
+    // that manage the connection are likely to take much longer.
+    int cmd(String cmd, unsigned long timeout=100);
+    int cmd(const char* cmd, unsigned long timeout=100);
+
+    // HC05 cmdMode2 forces 38400, no parity, one stop bit
+    // Entering cmdMode2 uses a pin to turn the HC05 power on and off
+    // with the cmdPin high. cmdPin must remain high to stay in
+    // cmdMode2, so use cmdMode2End() to exit.
+    void cmdMode2Start(int pwrPin);
+    void cmdMode2End(void);
+
+#ifdef HC05_STATE_PIN
+    bool connected(void);
+#endif
+    virtual int available(void);
+    virtual void begin(unsigned long);
+    virtual int peek(void);
+    virtual int read(void);
+    virtual void flush(void);
+    virtual size_t write(uint8_t);
+    using Print::write;
+#ifdef HC05_SOFTWARE_SERIAL
+    SoftwareSerial _btSerial;
+#endif
+
+private:
+    bool cmdMode;
+    int _cmdPin;
+#ifdef HC05_STATE_PIN
+    int _statePin;
+#endif
+    int _bufsize;
+    char _buffer[32];
+    void setCmdPin(bool state);
+};
+
+extern HC05 btSerial;
+#endif  // HC05_h

LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2013 J.Dunmire
+
+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.
+

README.md

@@ -0,0 +1,155 @@
+HC05
+====
+Forked from https://github.com/jdunmire/HC05/
+
+An Arduino library for the HC-05 Bluetooth ITead Studio HC-05 Serial
+Port Module.
+
+See the `LICENSE` file for copyright and license information.
+
+The serial port can be configured as any supported Serial port or
+a SoftwareSerial port.
+
+Includes a demonstration program that can be uses to change the name
+reported by an HC-05 module.
+
+Additional information is available as an
+[exercise](http://rockingdlabs.dunmire.org/exercises-experiments/hc05-bluetooth)
+at [RockingD Labs](http://rockingdlabs.dunmire.org).
+
+
+Components
+----------
+`HC05`
+    A class for controlling and communicating through an ITead Studio
+    HC-05 Serial Port Module. This class inherits from the Stream class.
+
+
+###Methods:
+The Stream class is extended with the following methods.
+
+`findBaud()`
+    Determine HC-05 communications speed. Make this call in setup()
+    instead of `begin()`. `begin()` is still avaialble and can be used
+    inplace of `findBaud()` if you know the HC-05 communications speed.
+
+`setBaud(unsigned long rate)`
+    Specify the HC-05 communications speed. The speed is non-volatile so
+    call this only when the rate returned by findBaud() is not the one
+    you require.
+
+`setBaud(unsigned long rate, unsigned long parity, unsigned long stopbits)`
+    Use this method when you need something besides the default no
+    parity, one stop bit settings that are the default.
+    __CAUTION!__ The HC-05 supports many serial configurations that are not
+    compatible with an Arduino. For example, the Arduino software serial
+    port port supports only no parity, one stop bit settings.
+
+`cmd()`
+    Send a command to the module. The 'key' (cmdPin) pin is activated to
+    put the module in command mode where 'AT' commands are recognized.
+
+`cmdMode2Start(int pwrPin)`
+   This is an alternate command mode. This 2nd command mode has the
+   advantage forcing the HC-05 into a know communications speed: 38400.
+   However, entering this 2nd command mode requires switching the power
+   to the HC-05.
+
+`cmdMode2End()`
+   Exits the alternate command mode, leaving the power to the HC-05 on.
+
+`connected()` (Only if HC05_STATE_PIN is defined in `HC05.h`)
+    Returns true when a BT connection has been established.
+
+`write()`
+`print*()`
+    The write(), and print*(), methods block until there is a BT
+    connection.
+
+Example Programs
+----------------
+The default library configuration uses a software serial port. The
+example programs will work with either a hardware or a software serial
+port. The configuration is changed by modifying the `HC05.h` file.
+
+See the `SoftwareSerial.fzz` file for the proper default connections.
+(`.fzz` files can be read by the free program available from
+[Fritzing](http://fritzing.org/home/))
+
+`changeName`
+    This application is one of the reasons I wrote this library. I
+    wanted to be able to change the name reported by the HC-05 because I
+    have multiple HC-05 modules that I kept mixing up. With this program
+    you can set the name of the HC-05 module to reflect something
+    physically identifying (or anything else that helps you tell your
+    modules apart).
+
+`echo`
+    Echo characters as they are received.
+
+`hc05_test`
+    Tests the disconnect command (AT+DISC). This was something I used
+    during development and probably is not of general interest.
+
+`recover`
+    This example used the 2nd command mode to _recover_ the HC-05 when
+    its serial port settings are incompatible with the Arduino serial
+    ports. Power to HC-05 must be controlled by an Arduino pin.
+    See the `Recovery.fzz` diagram for suitable connections.
+
+`findBaudTest`
+    Tests both setBaud() and findBaud() by trying every combination of
+    supported rates. The output from this example looks best if
+    DEBUG_HC05 is not defined. (Simply comment out that line in HC05.h).
+
+
+Installation
+------------
+###Option 1: Git (Recommended)
+* Follow this [GitHub repository](https://github.com/jdunmire/HC05)
+  and use `git` to track your own changes by cloning:
+
+    $ cd ~/sketchbook/libraries
+    $ git clone https://github.com/jdunmire/HC05.git
+
+* Start the Arduino IDE and you should find `HC05` in the
+  libraries section.
+
+###Option 2: Source only
+* Download a ZIP file. The ZIP button at
+  [GitHub](https://github.com/jdunmire/HC05) will always get the
+  latest version, but you may prefer one of the
+  [tagged](https://github.com/jdunmire/HC05/tags) versions.
+
+* Unpack the zip file into your sketchbook library directory
+  (`~/sketchbook/libraries` on Linux).
+
+* Rename the resulting directory (or create a symlink) to
+  ~/sketchbook/libraries/HC05
+
+* Start the Arduino IDE and you should find `HC05` in the libraries
+  section.
+
+### Configuration
+By default the library is configured for a software serial port and
+debugging output to the hardware serial port (Serial) is turned on. You
+will need to edit the HC05.h file if you want to change those settings.
+
+See the `SoftwareSerial.fzz` file for the proper default connections.
+The `HardwareSerial.fzz` shows the hardware port alternative. The files
+can be read by the free program available from
+[Fritzing](http://fritzing.org/home/)
+
+The Bluetooth port is `btSerial` and must be setup as shown at the top
+of the Example sketches. If debugging output is enabled in HC05.h (it is
+by default) then your sketch must include a DEBUG_BEGIN(baud) command to
+initialize the debug output port and set it's baud rate.
+
+#### Hardware Serial Port Issues for UNO
+Using the hardware serial port on the UNO comes with some caveats:
+
+  * You will have to disconnect the HC-05 module to upload a sketch.
+  * If you use the Arduino `Serial Monitor` you will see the traffic to
+    and from the HC-05 serial port. If you type in the `Serial Monitor`
+    it will interfere with the HC-05 traffic.
+

keywords.txt

@@ -0,0 +1,21 @@
+#
+# Syntax coloring for HC05 Library
+#
+
+# Datatypes (Classes)
+HC05	KEYWORD1
+
+# Methods and functions
+cmd	KEYWORD2
+findBaud	KEYWORD2
+setBaud	KEYWORD2
+connected	KEYWORD2
+available	KEYWORD2
+peek	KEYWORD2
+read	KEYWORD2
+flush	KEYWORD2
+write	KEYWORD2
+
+# Constants (Macros in this case)
+DEBUG_HC05	LITERAL1
+HC05_SOFTWARE_SERIAL	LITERAL1