Move some content to technology section, add doc for specific classes

Author: Donatien Garnier

docs/reference/api/connectivity/nfc/NDEF.md

@@ -0,0 +1,106 @@
+### NDEF API
+
+We provide API to construct and parse NDEF messages which is the common data format exchange for NFC messages.
+
+A NDEF message is a collection of separate NDEF records where each of these records is defined by a type such as URI, Mime, Text that identifies what is contained in the record and a payload.
+
+#### Parsing
+
+The class `mbed::nfc::ndef::MessageParser` parses a buffer of data in input and produces parsing events that are forwarded to its delegate. To help developers we offer a more integrated parser (`mbed::nfc::ndef::common::SimpleMessageParser`) that parses well known NFC types records such as Text, URI or Mime records and produces usable objects out of the box.
+
+```
+#include "nfc/ndef/common/SimpleMessageParser.h"
+
+using mbed::nfc::ndef::Record;
+using mbed::nfc::ndef::RecordType;
+using mbed::nfc::ndef::RecordID;
+using mbed::nfc::ndef::MessageParser;
+using mbed::nfc::ndef::common::Text;
+using mbed::nfc::ndef::common::URI;
+using mbed::nfc::ndef::common::Mime;
+
+using mbed::nfc::ndef::common::SimpleMessageParser;
+
+void parse_ndef_message(const Span<const uint8_t> &buffer) {
+    SimpleMessageParser parser;
+    struct : SimpleMessageParser::Delegate {
+        virtual void on_parsing_started() {
+            printf("parsing started\r\n");
+        }
+
+        virtual void on_text_parsed(const Text &text, const RecordID &) {
+            printf("Text record parsed.\r\n");
+            printf(
+                "\tlanguage: %.*s\r\n",
+                text.get_language_code().size(), text.get_language_code().data()
+            );
+            printf("\ttext: %.*s\r\n",  text.get_text().size(), text.get_text().data());
+        }
+
+        virtual void on_uri_parsed(const URI &uri, const RecordID &) {
+            printf("URI parsed.\r\n");
+            printf("\tid: %d\r\n", uri.get_id());
+            printf("\tvalue: %.*s\r\n",  uri.get_uri_field().size(), uri.get_uri_field().data());
+        }
+
+        virtual void on_mime_parsed(const Mime &mime, const RecordID &) {
+            printf("Mime object parsed.\r\n");
+            printf("\ttype: %.*s\r\n", mime.get_mime_type().size(), mime.get_mime_type().data());
+            printf("\tcontent size: %d\r\n", mime.get_mime_content().size());
+        }
+
+        virtual void on_unknown_record_parsed(const Record &record) {
+            printf("Unknown record parsed.\r\n");
+            printf(
+                "\ttype: %d, type_value: %.*s\r\n",
+                record.type.tnf, record.type.value.size(), record.type.value.data()
+            );
+            printf(
+                "\tpayload size: %d, payload: %.*s\r\n",
+                record.payload.size(), record.payload.size(), record.payload.data()
+            );
+        }
+
+        virtual void on_parsing_terminated() {
+            printf("parsing terminated\r\n");
+        }
+
+        virtual void on_parsing_error(MessageParser::error_t error) {
+            printf("Parsing error: %d\r\n", error);
+        }
+    } delegate;
+
+    parser.set_delegate(&delegate);
+    parser.parse(buffer);
+}
+```
+
+An application can extend capabilities of `SimpleMessageParser` by adding new record parsers (`mbed::nfc::ndef::RecordParser`) at runtime.
+
+[![View code](https://www.mbed.com/embed/?type=library)](http://os-doc-builder.test.mbed.com/docs/development/mbed-os-api-doxy/FIXME)
+
+#### Construction
+
+The class `mbed::nfc::ndef::MessageBuilder` builds a NDEF message into a user provided buffer. `URI`, `Text` and `Mime` type can be serialized in the builder with the help of the member function `append_as_record`.
+
+```
+#include "nfc/ndef/MessageBuilder.h"
+
+using mbed::nfc::ndef::MessageBuilder;
+using mbed::nfc::ndef::common::Text;
+using mbed::nfc::ndef::common::URI;
+
+size_t build_ndef_message(const Span<uint8_t> &buffer) {
+    MessageBuilder builder(buffer);
+
+    URI uri(URI::HTTPS_WWW, span_from_cstr("mbed.com"));
+    Text text(Text::UTF8, span_from_cstr("en-US"), span_from_cstr("Mbed website"));
+
+    uri.append_as_record(builder);
+    text.append_as_record(builder, /* last record */ true);
+
+    return builder.get_message().size();
+}
+```
+
+[![View code](https://www.mbed.com/embed/?type=library)](http://os-doc-builder.test.mbed.com/docs/development/mbed-os-api-doxy/FIXME)

docs/reference/api/connectivity/nfc/NFC.md

@@ -0,0 +1,49 @@
+## NFC Controller
+
+To use a NFC controller, you must initiate the instance with a driver instance, an event queue and a scratch buffer for NDEF messages.
+
+### NFC Controller Class Reference
+
+[![View code](https://www.mbed.com/embed/?type=library)](http://os-doc-builder.test.mbed.com/docs/development/mbed-os-api-doxy/FIXME)
+
+### NFC Controller Example
+
+```cpp
+#include "stdint.h"
+
+#include "NFC.h"
+#include "events/EventQueue.h"
+#include "nfc/controllers/PN512Driver.h"
+#include "nfc/controllers/PN512SPITransportDriver.h"
+
+static uint8_t ndef_buffer[1024] = {0};
+
+int main() {
+    mbed::nfc::PN512SPITransportDriver pn512_transport(D11, D12, D13, D10, A1, A0);
+    mbed::nfc::PN512Driver pn512_driver(&pn512_transport);
+    events::EventQueue queue;
+    mbed::nfc::NFCController nfc(&pn512_driver, &queue, ndef_buffer);
+
+    ...
+}
+```
+
+A delegate mechanism handles events throughout the API.
+
+For instance, a delegate for a NFC controller can look similar to this:
+
+```cpp
+struct NFCDelegate : mbed::nfc::NFCController::Delegate {
+    virtual void on_discovery_terminated(nfc_discovery_terminated_reason_t reason) {
+        printf("Discovery terminated:\r\n");
+        if(reason != nfc_discovery_terminated_completed) {
+            nfc_ptr->start_discovery(); // Error, restart discovery
+        }
+    }
+    virtual void on_nfc_initiator_discovered(const SharedPtr< mbed::nfc::NFCRemoteInitiator> &nfc_initiator) {
+        printf("Remote inititator detected\r\n");
+        nfc_initiator->set_delegate(nfc_initiator_delegate_ptr);
+        nfc_initiator->connect(); // Connect to the initiator
+    }
+};
+```