Cleanup for JavaScript major

* remove comments
* fix broken doc link

Author: fmgrafikdesign

README.md

@@ -1,4 +1,82 @@
-# Simple Web Serial
-_Work in progress!_
 
-Check out https://fmgrafikdesign.gitbook.io/simplewebserial/ for a project overview and installation guide.
+
+# SimpleWebSerial
+
+SimpleWebSerial helps you to connect a web application with your Arduino, in
+seconds. Get started now by taking a look at the [documentation](https://fmgrafikdesign.gitbook.io/simplewebserial/)! This is the Arduino library of the project. You can find the JavaScript part [here](https://github.com/fmgrafikdesign/SimpleWebSerialJS).
+
+## What is this library?
+
+This library allows you to connect your website in the browser with an Arduino microcontroller. This effectively means the real world can influence your web application, and vice versa. The library consists of two parts, the [JavaScript part](https://github.com/fmgrafikdesign/SimpleWebSerialJS) which runs in the browser, and the [Arduino part](https://github.com/fmgrafikdesign/simplewebserial-arduino-library) which is installed on your Arduino device. Together, they allow you to write simple, event-driven code both in JavaScript and on the Arduino, enabling two-way communication.
+
+Under the hood, it uses the [Web Serial API](https://wicg.github.io/serial/). It handles repetitive setup steps and offers an event-driven style of listening to and sending data. The goal is to allow as many people as possible to explore the possibilities of connecting physical devices to web applications.
+
+## Code Style Summary
+
+This library employs an event-driven code style. You can register event listeners with callback functions, and send events to the other device. Here's a brief idea how working with the library looks like in the browser and on the Arduino:
+
+### JavaScript
+```javascript
+// Import
+import { setupSerialConnection } from 'simple-web-serial';
+
+// Set up the serial connection
+const connection = setupSerialConnection({ requestAccessOnPageLoad: true });
+
+// React to incoming events
+connection.on('event-from-arduino', function(data) {
+    console.log('Received event "event-from-arduino" with parameter ' + data)
+});
+
+// Send named events to the Arduino with a number, string, array or json object
+connection.send('event-to-arduino', "Hello there, Arduino");
+```
+
+### Arduino
+```cpp
+// Include the library
+#include <SimpleWebSerial.h>
+
+// Create an instance of the library
+SimpleWebSerial WebSerial;
+
+void setup() {
+  // Initialize serial communication
+  Serial.begin(57600);
+  
+  // Define events to listen to and their callback
+  WebSerial.on("event-to-arduino", eventCallback); 
+  
+  // Send named events to browser with a number, string, array or json object
+  WebSerial.send("event-from-arduino", 123);
+}
+
+void eventCallback(JSONVar data) {
+    // Do something, even sending events right back!
+    WebSerial.send("event-from-arduino", data);
+});
+
+void loop() {
+  // Check for new serial data every loop
+  WebSerial.check();
+  delay(5);
+}
+```
+
+## Why this library?
+
+The new [Web Serial API](https://wicg.github.io/serial/) is a great way to connect serial devices like the Arduino directly to your web application. It lets your website communicate with the real world, and opens up a lot of possibilities for web developers! However, working with it is cumbersome and very technical. You're left to deal with things like byte-arrays and parsing data. This library makes connecting your web application with an Arduino a breeze, and lets you get up and running in minutes.
+
+## Who is this for?
+
+This library is for creative minds and developers who like to experiment and create prototypes, but do not necessarily care how something works on the technical level.
+
+Do you know your way around web development? Basic concepts like HTML, JavaScript? Then you can use this without problems.
+
+Do you like experimenting with new web technologies, maybe learn a new thing or two? This library will give you an idea what's possible when we integrate websites with the real world.
+
+## Getting Started
+
+Get started by installing the JavaScript library and the Arduino library. You can find a quick setup in the [documentation](https://fmgrafikdesign.gitbook.io/simplewebserial/).
+
+Alternatively you can check out the JavaScript repository and have a look at the examples folder. Be aware, you will need an Arduino for all of them, and some parts (LEDs, potentiometer etc) for most of them.

library.properties

@@ -1,10 +1,10 @@
 name=Simple Web Serial
-version=0.1.5
+version=1.0.0
 author=Fabian Mohr
-maintainer=Fabian Mohr,amazon@fmgrafikdesign.de
+maintainer=Fabian Mohr,dev@fmgrafikdesign.de
 sentence=A library to simplify connecting Arduino to your web applications, using the Web Serial API.
 paragraph=This library is aimed at web developers interested in connecting their web applications to the physical world, with an Arduino. Listen to and send events in JavaScript fashion, without worrying about parsing incoming serial data.
 category=Communication
-url=https://app.gitbook.com/@fmgrafikdesign/s/simplewebserial/
+url=https://fmgrafikdesign.gitbook.io/simplewebserial/
 architectures=*
 depends=Arduino_JSON

src/SimpleWebSerial.cpp

@@ -30,11 +30,10 @@ void SimpleWebSerial::check() {
                 bufferIndex = BufferSize - 1;
             }
         }
-            // When we receive the endMarker, terminate the string and set parseData to true
+        // When we receive the endMarker, terminate the string and set parseData to true
         else {
-            receivedChars[bufferIndex] = '\0'; // terminate the string
+            receivedChars[bufferIndex] = '\0';
             parseData = true;
-            // Serial.println(bufferIndex);
             bufferIndex = 0;
         }
     }
@@ -44,18 +43,11 @@ void SimpleWebSerial::check() {
         // It is to be assumed that receivedChars will be stringified JSON once it's complete.
         JSONVar parsed = JSON.parse(receivedChars);
 
-        // If I comment this out, JSON.typeof(parsed) is never undefined. Why?
-        // Serial.println(receivedChars);
-
-        // Why is this only undefined when I print the received Chars? Nobody knows!
         if (JSON.typeof(parsed) == "undefined") {
             this->warn("Parsing input failed! Malformed data sent or buffer overflow.");
             return;
         }
 
-        //Serial.println(JSON.stringify(parsed));
-        //Serial.println(JSON.typeof(parsed));
-
         // Find out if it's an named event
         bool namedEvent = false;
         int isPureData = strcmp("_d", (const char *) parsed[0]);
@@ -70,48 +62,11 @@ void SimpleWebSerial::check() {
         }
 
         if (parsed.length() > 1 && JSON.typeof(parsed[0]) == "string") {
-            // Serial.println("Received array has more than 1 element and its first element is string. Assuming named event!");
-
-            // Parse object 1 level deep
-            /*
-            if(JSON.typeof(parsed[1]) == "object") {
-                parsed[1] = JSON.parse(parsed[1]);
-                Serial.println("Parsed received data because it was an object.");
-            }
-             */
-
             for (int i = 0; i < ARRAYSIZE(eventNames); i++) {
                 if (eventNames[i][0] == '\0') continue;
 
-                //Serial.print("Comparing ");
-                //Serial.print((const char *) parsed[0]);
-                //Serial.print(" to ");
-                //Serial.println(eventNames[i]);
-
                 int compare_result = strcmp(eventNames[i], (const char *) parsed[0]);
-                //Serial.println(compare_result);
-                //Serial.print("first character in eventNames:");
-                //Serial.println(eventNames[_index][0]);
-
-                //Serial.print("first character in received event:");
-                //Serial.println(eventName[0]);
-
-                // Serial.println(compare_result);
                 if (compare_result == 0) {
-                    /*
-                    Serial.print("Found event named ");
-                    Serial.print(parsed[0]);
-                    Serial.println(" in registered eventNames");
-                    Serial.print("Trying to call callback with index ");
-                    Serial.println(i);
-                     */
-                    //Serial.println((*callbacks[i]));
-
-                    // (*callbacks[i])((JSONVar) parsed[1]);
-                    // (*_callback)();
-
-                    //Serial.print("Calling callback with parameters: ");
-                    //Serial.println(parsed[1]);
                     (*callbacks[i])(parsed[1]);
 
                     namedEvent = true;
@@ -123,33 +78,23 @@ void SimpleWebSerial::check() {
                 Serial.print(parsed[0]);
                 Serial.println("' in the registered eventNames");
             }
-
         } else if (parsed.length() > 1 && JSON.typeof(parsed[0]) != "string"){
-            //Serial.println("Received array has more than 1 element but its first element is not a string. Malformed data?");
             this->warn("Received array has more than 1 element but its first element is not a string. Malformed data?");
         } else {
             Serial.println("Received array has only 1 element.");
         }
-
-        // If it's a named event, find out its name
-
-        // Loop through registered eventNames
-
     }
 
 }
 
 void SimpleWebSerial::on(const char *name, void (*callback)(JSONVar data)) {
-    // TODO show warning if you're using more events than allowed. Check if you can do that w/ Arduino compiler
-
     strcpy(eventNames[_index], name);
     callbacks[_index] = callback;
 
     Serial.print(eventNames[_index]);
     Serial.print(" has been defined as an event with index ");
     Serial.println(_index);
 
-    // callbacks[_index](data);
     _index++;
 }
 
@@ -161,7 +106,6 @@ void SimpleWebSerial::listEvents() {
         Serial.print("- ");
         Serial.println(eventNames[i]);
     }
-    // Serial.println(eventName);
 }
 
 void SimpleWebSerial::sendData(JSONVar data) {
@@ -184,12 +128,6 @@ void SimpleWebSerial::setCallback(void (*callback)()) {
     _callback = callback;
 }
 
-void SimpleWebSerial::onData() {
-    // look for the next valid integer in the incoming serial stream:
-
-    //(*_callback)();
-}
-
 void SimpleWebSerial::warn(const char *message) {
     this->send("_w", message);
 }

src/SimpleWebSerial.h

@@ -31,7 +31,6 @@ class SimpleWebSerial {
     SimpleWebSerial();
     void check(); // Makes the library check for serial data
     void on(const char* name, void (*callback)(JSONVar data)); // Event name, callback
-    void onData(); // callback
     void sendEvent(const char* name); // Only event name
     void sendData(JSONVar data); // Only data
     void send(const char* name, JSONVar data); // Event name + data or just data