diff --git a/adafruit_ble/advertising.py b/adafruit_ble/advertising.py
index 363de06..e507061 100644
--- a/adafruit_ble/advertising.py
+++ b/adafruit_ble/advertising.py
@@ -31,8 +31,8 @@
 
 import struct
 
-class AdvertisingData:
-    """Build up a BLE advertising data packet."""
+class AdvertisingPacket:
+    """Build up a BLE advertising data or scan response packet."""
     # BR/EDR flags not included here, since we don't support BR/EDR.
     FLAG_LIMITED_DISCOVERY = 0x01
     """Discoverable only for a limited time period."""
@@ -53,7 +53,7 @@ class AdvertisingData:
     """Complete list of 128 bit service UUIDs."""
     SHORT_LOCAL_NAME = 0x08
     """Short local device name (shortened to fit)."""
-    COMPLETE_LOCALNAME = 0x09
+    COMPLETE_LOCAL_NAME = 0x09
     """Complete local device name."""
     TX_POWER = 0x0A
     """Transmit power level"""
@@ -81,32 +81,151 @@ class AdvertisingData:
     MAX_DATA_SIZE = 31
     """Data size in a regular BLE packet."""
 
-    def __init__(self, flags=(FLAG_GENERAL_DISCOVERY | FLAG_LE_ONLY), max_length=MAX_DATA_SIZE):
-        """Initalize an advertising packet, with the given flags, no larger than max_length."""
-        self.data = bytearray((2, self.FLAGS, flags))
+    def __init__(self, data=None, *, max_length=MAX_DATA_SIZE):
+        """Create an advertising packet, no larger than max_length.
+
+        :param buf data: if not supplied (None), create an empty packet
+          if supplied, create a packet with supplied data. This is usually used
+          to parse an existing packet.
+        :param int max_length: maximum length of packet
+        """
+        self._packet_bytes = bytearray(data) if data else bytearray()
         self._max_length = max_length
         self._check_length()
 
+    @property
+    def packet_bytes(self):
+        """The raw packet bytes."""
+        return self._packet_bytes
+
+    @packet_bytes.setter
+    def packet_bytes(self, value):
+        self._packet_bytes = value
+
+    def __getitem__(self, element_type):
+        """Return the bytes stored in the advertising packet for the given element type.
+
+        :param int element_type: An integer designating an advertising element type.
+           A number of types are defined in `AdvertisingPacket`,
+           such as `AdvertisingPacket.TX_POWER`.
+        :returns: bytes that are the value for the given element type.
+           If the element type is not present in the packet, raise KeyError.
+        """
+        i = 0
+        adv_bytes = self.packet_bytes
+        while i < len(adv_bytes):
+            item_length = adv_bytes[i]
+            if  element_type != adv_bytes[i+1]:
+                # Type doesn't match: skip to next item.
+                i += item_length + 1
+            else:
+                return adv_bytes[i + 2:i + 1 + item_length]
+        raise KeyError
+
+    def get(self, element_type, default=None):
+        """Return the bytes stored in the advertising packet for the given element type,
+        returning the default value if not found.
+        """
+        try:
+            return self.__getitem__(element_type)
+        except KeyError:
+            return default
+
+    @property
+    def bytes_remaining(self):
+        """Number of bytes still available for use in the packet."""
+        return self._max_length - len(self._packet_bytes)
+
     def _check_length(self):
-        if len(self.data) > self._max_length:
-            raise IndexError("Advertising data exceeds max_length")
+        if len(self._packet_bytes) > self._max_length:
+            raise IndexError("Advertising data too long")
 
     def add_field(self, field_type, field_data):
         """Append an advertising data field to the current packet, of the given type.
         The length field is calculated from the length of field_data."""
-        self.data.append(1 + len(field_data))
-        self.data.append(field_type)
-        self.data.extend(field_data)
+        self._packet_bytes.append(1 + len(field_data))
+        self._packet_bytes.append(field_type)
+        self._packet_bytes.extend(field_data)
         self._check_length()
 
+    def add_flags(self, flags=(FLAG_GENERAL_DISCOVERY | FLAG_LE_ONLY)):
+        """Add default or custom advertising flags."""
+        self.add_field(self.FLAGS, struct.pack("<B", flags))
+
     def add_16_bit_uuids(self, uuids):
         """Add a complete list of 16 bit service UUIDs."""
-        self.add_field(self.ALL_16_BIT_SERVICE_UUIDS, bytes(uuid.uuid16 for uuid in uuids))
+        for uuid in uuids:
+            self.add_field(self.ALL_16_BIT_SERVICE_UUIDS, struct.pack("<H", uuid.uuid16))
 
     def add_128_bit_uuids(self, uuids):
         """Add a complete list of 128 bit service UUIDs."""
-        self.add_field(self.ALL_128_BIT_SERVICE_UUIDS, bytes(uuid.uuid128 for uuid in uuids))
+        for uuid in uuids:
+            self.add_field(self.ALL_128_BIT_SERVICE_UUIDS, uuid.uuid128)
 
     def add_mfr_specific_data(self, mfr_id, data):
         """Add manufacturer-specific data bytes."""
         self.add_field(self.MANUFACTURER_SPECIFIC_DATA, struct.pack('<H', mfr_id) + data)
+
+
+class ServerAdvertisement:
+    """
+    Data to advertise a peripheral's services.
+
+    The advertisement consists of an advertising data packet and an optional scan response packet,
+    The scan response packet is created only if there is not room in the
+    advertising data packet for the complete peripheral name.
+
+    :param peripheral Peripheral the Peripheral to advertise. Use its services and name
+    :param int tx_power: transmit power in dBm at 0 meters (8 bit signed value). Default 0 dBm
+    """
+
+    def __init__(self, peripheral, *, tx_power=0):
+        self._peripheral = peripheral
+
+        packet = AdvertisingPacket()
+        packet.add_flags()
+        self._scan_response_packet = None
+
+        # Need to check service.secondary
+        uuids_16_bits = [service.uuid for service in peripheral.services
+                         if service.uuid.size == 16 and not service.secondary]
+        if uuids_16_bits:
+            packet.add_16_bit_uuids(uuids_16_bits)
+
+        uuids_128_bits = [service.uuid for service in peripheral.services
+                          if service.uuid.size == 128 and not service.secondary]
+        if uuids_128_bits:
+            packet.add_128_bit_uuids(uuids_128_bits)
+
+        packet.add_field(AdvertisingPacket.TX_POWER, struct.pack("<b", tx_power))
+
+        # 2 bytes needed for field length and type.
+        bytes_available = packet.bytes_remaining - 2
+        if bytes_available <= 0:
+            raise IndexError("No room for name")
+
+        name_bytes = bytes(peripheral.name, 'utf-8')
+        if bytes_available >= len(name_bytes):
+            packet.add_field(AdvertisingPacket.COMPLETE_LOCAL_NAME, name_bytes)
+        else:
+            packet.add_field(AdvertisingPacket.SHORT_LOCAL_NAME, name_bytes[:bytes_available])
+            self._scan_response_packet = AdvertisingPacket()
+            try:
+                self._scan_response_packet.add_field(AdvertisingPacket.COMPLETE_LOCAL_NAME,
+                                                     name_bytes)
+            except IndexError:
+                raise IndexError("Name too long")
+
+        self._advertising_data_packet = packet
+
+    @property
+    def advertising_data_bytes(self):
+        """The raw bytes for the initial advertising data packet."""
+        return self._advertising_data_packet.packet_bytes
+
+    @property
+    def scan_response_bytes(self):
+        """The raw bytes for the scan response packet. None if there is no response packet."""
+        if self._scan_response_packet:
+            return self._scan_response_packet.packet_bytes
+        return None
diff --git a/adafruit_ble/beacon.py b/adafruit_ble/beacon.py
index c5a9e3b..c7891cd 100644
--- a/adafruit_ble/beacon.py
+++ b/adafruit_ble/beacon.py
@@ -32,26 +32,29 @@
 import struct
 import bleio
 
-from .advertising import AdvertisingData
+from .advertising import AdvertisingPacket
 
 class Beacon:
     """Base class for Beacon advertisers."""
-    def __init__(self, advertising_data, interval=1.0):
-        """Set up a beacon with the given AdvertisingData.
+    def __init__(self, advertising_packet):
+        """Set up a beacon with the given AdvertisingPacket.
 
-        :param AdvertisingData advertising_data: The advertising packet
-        :param float interval: Advertising interval in seconds
+        :param AdvertisingPacket advertising_packet
         """
-        self.broadcaster = bleio.Broadcaster(interval)
-        self.advertising_data = advertising_data
+        self._broadcaster = bleio.Peripheral(name=None)
+        self._advertising_packet = advertising_packet
+
+    def start(self, interval=1.0):
+        """Turn on beacon.
 
-    def start(self):
-        """Turn on beacon."""
-        self.broadcaster.start_advertising(self.advertising_data.data)
+        :param float interval: Advertising interval in seconds
+        """
+        self._broadcaster.start_advertising(self._advertising_packet.packet_bytes,
+                                            interval=interval)
 
     def stop(self):
         """Turn off beacon."""
-        self.broadcaster.stop_advertising()
+        self._broadcaster.stop_advertising()
 
 
 
@@ -60,7 +63,7 @@ class LocationBeacon(Beacon):
     Used for Apple iBeacon, Nordic nRF Beacon, etc.
     """
     # pylint: disable=too-many-arguments
-    def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
+    def __init__(self, company_id, uuid, major, minor, rssi):
         """Create a beacon with the given values.
 
         :param int company_id: 16-bit company id designating beacon specification owner
@@ -69,7 +72,6 @@ def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
         :param int major: 16-bit major number, such as a store number
         :param int minor: 16-bit minor number, such as a location within a store
         :param int rssi: Signal strength in dBm at 1m (signed 8-bit value)
-        :param float interval: Advertising interval in seconds
 
     Example::
 
@@ -81,8 +83,9 @@ def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
         b.start()
         """
 
-        adv_data = AdvertisingData()
-        adv_data.add_mfr_specific_data(
+        adv = AdvertisingPacket()
+        adv.add_flags()
+        adv.add_mfr_specific_data(
             company_id,
             b''.join((
                 # 0x02 means a beacon. 0x15 (=21) is length (16 + 2 + 2 + 1)
@@ -91,8 +94,8 @@ def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
                 # iBeacon and similar expect big-endian UUIDS. Usually they are little-endian.
                 bytes(reversed(uuid.uuid128)),
                 # major and minor are big-endian.
-                struct.pack(">HHB", major, minor, rssi))))
-        super().__init__(adv_data, interval=interval)
+                struct.pack(">HHb", major, minor, rssi))))
+        super().__init__(adv)
 
 
 class EddystoneURLBeacon(Beacon):
@@ -126,16 +129,16 @@ class EddystoneURLBeacon(Beacon):
         '.gov',
     )
 
-    def __init__(self, url, tx_power=0, interval=1.0):
+    def __init__(self, url, tx_power=0):
         """Create a URL beacon with an encoded version of the url and a transmit power.
 
         :param url URL to encode. Must be short enough to fit after encoding.
         :param int tx_power: transmit power in dBm at 0 meters (8 bit signed value)
-        :param float interval: Advertising interval in seconds
         """
 
-        adv_data = AdvertisingData()
-        adv_data.add_field(AdvertisingData.ALL_16_BIT_SERVICE_UUIDS, self._EDDYSTONE_ID)
+        adv = AdvertisingPacket()
+        adv.add_flags()
+        adv.add_field(AdvertisingPacket.ALL_16_BIT_SERVICE_UUIDS, self._EDDYSTONE_ID)
         short_url = None
         for idx, prefix in enumerate(self._URL_SCHEMES):
             if url.startswith(prefix):
@@ -148,9 +151,9 @@ def __init__(self, url, tx_power=0, interval=1.0):
             short_url = short_url.replace(subst + '/', chr(code))
         for code, subst in enumerate(self._SUBSTITUTIONS, 7):
             short_url = short_url.replace(subst, chr(code))
-        adv_data.add_field(AdvertisingData.SERVICE_DATA_16_BIT_UUID,
-                           b''.join((self._EDDYSTONE_ID,
-                                     b'\x10',
-                                     struct.pack("<BB", tx_power, url_scheme_num),
-                                     bytes(short_url, 'ascii'))))
-        super().__init__(adv_data, interval)
+        adv.add_field(AdvertisingPacket.SERVICE_DATA_16_BIT_UUID,
+                      b''.join((self._EDDYSTONE_ID,
+                                b'\x10',
+                                struct.pack("<bB", tx_power, url_scheme_num),
+                                bytes(short_url, 'ascii'))))
+        super().__init__(adv)
diff --git a/adafruit_ble/scanner.py b/adafruit_ble/scanner.py
new file mode 100644
index 0000000..d11b804
--- /dev/null
+++ b/adafruit_ble/scanner.py
@@ -0,0 +1,167 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Dan Halbert for Adafruit Industries
+#
+# 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.
+"""
+`adafruit_ble.scanner`
+====================================================
+
+Scan for nearby BLE Devices
+
+* Author(s): Dan Halbert for Adafruit Industries
+
+"""
+import struct
+
+import bleio
+
+from .advertising import AdvertisingPacket
+
+class Scanner:
+    """
+    Scan for BLE device advertisements for a period of time. Return what was received.
+
+    Example::
+
+        from adafruit_ble.scanner import Scanner
+        scanner = Scanner()
+        scan_entries = scanner.scan(3)  # scan for 3 seconds
+    """
+
+    def __init__(self):
+        self._scanner = bleio.Scanner()
+
+    def scan(self, timeout, *, interval=0.1, window=0.1):
+        """Scan for advertisements from BLE devices. Suppress duplicates
+        in returned `ScanEntry` objects, so there is only one entry per address (device).
+
+        :param int timeout: how long to scan for (in seconds)
+        :param float interval: the interval (in seconds) between the start
+           of two consecutive scan windows.
+           Must be in the range 0.0025 - 40.959375 seconds.
+        :param float window: the duration (in seconds) to scan a single BLE channel.
+          `window` must be <= `interval`.
+        :returns a list of `adafruit_ble.ScanEntry` objects.
+
+        """
+        return ScanEntry.unique_devices(self.raw_scan(timeout, interval=interval, window=window))
+
+    def raw_scan(self, timeout, *, interval=0.1, window=0.1):
+        """Scan for advertisements from BLE devices. Include every scan entry,
+        even duplicates.
+
+        :param int timeout: how long to scan for (in seconds)
+        :param float interval: the interval (in seconds) between the start
+           of two consecutive scan windows.
+           Must be in the range 0.0025 - 40.959375 seconds.
+        :param float window: the duration (in seconds) to scan a single BLE channel.
+          `window` must be <= `interval`.
+        :returns a list of `adafruit_ble.ScanEntry` objects.
+
+        """
+        return [ScanEntry(e) for e in self._scanner.scan(timeout, interval=interval, window=window)]
+
+class ScanEntry:
+    """
+    Information about an advertising packet from a BLE device received by a `Scanner`.
+
+    :param bleio.ScanEntry scan_entry: lower-level ScanEntry returned from `bleio.Scanner`.
+      This constructor is normally used only by `Scanner`.
+    """
+
+    def __init__(self, scan_entry):
+        self._rssi = scan_entry.rssi
+        self._address = scan_entry.address
+        self._packet = AdvertisingPacket(scan_entry.advertisement_bytes)
+
+    @property
+    def advertisement_packet(self):
+        """The received advertising packet."""
+        return self._packet
+
+    @property
+    def rssi(self):
+        """The signal strength of the device at the time of the scan. (read-only)."""
+        return self._rssi
+
+    @property
+    def address(self):
+        """The address of the device. (read-only)."""
+        return self._address
+
+    @property
+    def name(self):
+        """The name of the device. (read-only)"""
+        name = self._packet.get(AdvertisingPacket.COMPLETE_LOCAL_NAME)
+        return name if name else self._packet.get(AdvertisingPacket.SHORT_LOCAL_NAME)
+
+    @property
+    def service_uuids(self):
+        """List of all the service UUIDs in the advertisement."""
+        uuid_values = []
+
+        concat_uuids = self._packet.get(AdvertisingPacket.ALL_16_BIT_SERVICE_UUIDS)
+        concat_uuids = concat_uuids if concat_uuids else self._packet.get(
+            AdvertisingPacket.SOME_16_BIT_SERVICE_UUIDS)
+
+        if concat_uuids:
+            for i in range(0, len(concat_uuids), 2):
+                uuid_values.extend(struct.unpack("<H", concat_uuids[i:i+2]))
+
+        concat_uuids = self._packet.get(AdvertisingPacket.ALL_128_BIT_SERVICE_UUIDS)
+        concat_uuids = concat_uuids if concat_uuids else self._packet.get(
+            AdvertisingPacket.SOME_128_BIT_SERVICE_UUIDS)
+
+        if concat_uuids:
+            for i in range(0, len(concat_uuids), 16):
+                uuid_values.append(concat_uuids[i:i+16])
+
+        return [bleio.UUID(value) for value in uuid_values]
+
+    @property
+    def manufacturer_specific_data(self):
+        """Manufacturer-specific data in the advertisement, returned as bytes."""
+        return self._packet.get(AdvertisingPacket.MANUFACTURER_SPECIFIC_DATA)
+
+    def same_device(self, other):
+        """True if two scan entries appear to be from the same device. Their
+        addresses and advertisement must match.
+        """
+        return (self.address == other.address and
+                self.advertisement_packet.packet_bytes ==
+                other.advertisement_packet.packet_bytes)
+
+    @staticmethod
+    def with_service_uuid(scan_entries, service_uuid):
+        """Return all scan entries advertising the given service_uuid."""
+        return [se for se in scan_entries if service_uuid in se.service_uuids]
+
+    @staticmethod
+    def unique_devices(scan_entries):
+        """Discard duplicate scan entries that appear to be from the same device.
+
+        :param sequence scan_entries: ScanEntry objects
+        :returns list: list with duplicates removed
+        """
+        unique = []
+        for entry in scan_entries:
+            if not any(entry.same_device(unique_entry) for unique_entry in unique):
+                unique.append(entry)
+        return unique
diff --git a/adafruit_ble/uart.py b/adafruit_ble/uart.py
index 6639104..f891358 100644
--- a/adafruit_ble/uart.py
+++ b/adafruit_ble/uart.py
@@ -1,6 +1,6 @@
 # The MIT License (MIT)
 #
-# Copyright (c) 2018 Dan Halbert for Adafruit Industries
+# Copyright (c) 2019 Dan Halbert for Adafruit Industries
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,110 +23,16 @@
 `adafruit_ble.uart`
 ====================================================
 
-UART-style communication.
+BLE UART-style communication. Common definitions.
 
 * Author(s): Dan Halbert for Adafruit Industries
 
 """
-from bleio import UUID, Characteristic, Service, Peripheral, CharacteristicBuffer
-
-
-class UARTServer:
-    """
-    Provide UART-like functionality via the Nordic NUS service.
-
-    :param int timeout:  the timeout in seconds to wait
-      for the first character and between subsequent characters.
-    :param int buffer_size: buffer up to this many bytes.
-      If more bytes are received, older bytes will be discarded.
-
-    Example::
-
-        from adafruit_ble.uart import UARTServer
-        uart = UARTServer()
-        uart.start_advertising()
-
-        # Wait for a connection.
-        while not uart.connected:
-            pass
-
-        uart.write('abc')
-    """
-
-    NUS_SERVICE_UUID = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
-    NUS_RX_CHAR_UUID = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
-    NUS_TX_CHAR_UUID = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")
-
-    def __init__(self, timeout=1.0, buffer_size=64):
-        """Define the NUS service and start advertising it."""
-        self._nus_tx_char = Characteristic(self.NUS_TX_CHAR_UUID, notify=True)
-        self._nus_rx_char = Characteristic(self.NUS_RX_CHAR_UUID,
-                                           write=True, write_no_response=True)
-
-        nus_uart_service = Service(self.NUS_SERVICE_UUID, (self._nus_tx_char, self._nus_rx_char))
-
-        self._periph = Peripheral((nus_uart_service,))
-        self._rx_buffer = CharacteristicBuffer(self._nus_rx_char,
-                                               timeout=timeout, buffer_size=buffer_size)
-
-    def start_advertising(self):
-        """Start advertising the service. When a client connects, advertising will stop.
-        When the client disconnects, restart advertising by calling ``start_advertising()`` again.
-        """
-        self._periph.start_advertising()
-
-    def stop_advertising(self):
-        """Stop advertising the service."""
-        self._periph.stop_advertising()
-
-    @property
-    def connected(self):
-        """True if someone connected to the server."""
-        return self._periph.connected
-
-    def read(self, nbytes=None):
-        """
-        Read characters. If ``nbytes`` is specified then read at most that many bytes.
-        Otherwise, read everything that arrives until the connection times out.
-        Providing the number of bytes expected is highly recommended because it will be faster.
-
-        :return: Data read
-        :rtype: bytes or None
-        """
-        return self._rx_buffer.read(nbytes)
-
-    def readinto(self, buf, nbytes=None):
-        """
-        Read bytes into the ``buf``. If ``nbytes`` is specified then read at most
-        that many bytes. Otherwise, read at most ``len(buf)`` bytes.
-
-        :return: number of bytes read and stored into ``buf``
-        :rtype: int or None (on a non-blocking error)
-        """
-        return self._rx_buffer.readinto(buf, nbytes)
-
-    def readline(self):
-        """
-        Read a line, ending in a newline character.
-
-        :return: the line read
-        :rtype: int or None
-        """
-        return self._rx_buffer.readline()
-
-    @property
-    def in_waiting(self):
-        """The number of bytes in the input buffer, available to be read."""
-        return self._rx_buffer.in_waiting
-
-    def reset_input_buffer(self):
-        """Discard any unread characters in the input buffer."""
-        self._rx_buffer.reset_input_buffer()
-
-    def write(self, buf):
-        """Write a buffer of bytes."""
-        # We can only write 20 bytes at a time.
-        offset = 0
-        while offset < len(buf):
-            self._nus_tx_char.value = buf[offset:offset+20]
-            offset += 20
+from bleio import UUID
+
+NUS_SERVICE_UUID = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
+"""Nordic UART Service UUID"""
+NUS_RX_CHAR_UUID = UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
+"""Nordic UART Service RX Characteristic UUID"""
+NUS_TX_CHAR_UUID = UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E")
+"""Nordic UART Service TX Characteristic UUID"""
diff --git a/adafruit_ble/uart_client.py b/adafruit_ble/uart_client.py
new file mode 100644
index 0000000..dd505e6
--- /dev/null
+++ b/adafruit_ble/uart_client.py
@@ -0,0 +1,165 @@
+ # The MIT License (MIT)
+#
+# Copyright (c) 2019 Dan Halbert for Adafruit Industries
+#
+# 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.
+"""
+`adafruit_ble.uart_client`
+====================================================
+
+UART-style communication by a Central as a GATT Client
+
+* Author(s): Dan Halbert for Adafruit Industries
+
+"""
+from bleio import Central, CharacteristicBuffer
+from .uart import NUS_SERVICE_UUID, NUS_RX_CHAR_UUID, NUS_TX_CHAR_UUID
+from .scanner import Scanner, ScanEntry
+
+class UARTClient:
+    """
+    Provide UART-like functionality via the Nordic NUS service.
+
+    :param int timeout:  the timeout in seconds to wait
+      for the first character and between subsequent characters.
+    :param int buffer_size: buffer up to this many bytes.
+      If more bytes are received, older bytes will be discarded.
+    :param str name: Name to advertise for server. If None, use default Peripheral name.
+
+    Example::
+
+        from adafruit_ble.uart_client import UARTClient
+
+        uart_client = UARTClient()
+        uart_addresses = uart_client.scan()
+        if uart_addresses:
+            uart_client.connect(uarts[0].address, 5,
+                                service_uuids_whitelist=(UART.NUS_SERVICE_UUID,))
+        else:
+            raise Error("No UART servers found.")
+
+        uart_client.write('abc')
+    """
+
+    def __init__(self, *, timeout=1.0, buffer_size=64):
+        self._buffer_size = buffer_size
+        self._timeout = timeout
+        self._read_char = self._write_char = self._read_buffer = None
+        self._central = Central()
+
+    def connect(self, address, timeout):
+        """Try to connect to the peripheral at the given address.
+
+        :param bleio.Address address: The address of the peripheral to connect to
+        :param float/int timeout: Try to connect for ``timeout`` seconds.
+           Not related to the timeout passed to ``UARTClient()``.
+        """
+        self._central.connect(address, timeout, service_uuids_whitelist=(NUS_SERVICE_UUID,))
+
+        # Connect succeeded. Get the remote characteristics we need, which were
+        # found during discovery.
+
+        for characteristic in self._central.remote_services[0].characteristics:
+            # Since we're remote we receive on tx and send on rx.
+            # The names are from the point of view of the server.
+            if characteristic.uuid == NUS_RX_CHAR_UUID:
+                self._write_char = characteristic
+            elif characteristic.uuid == NUS_TX_CHAR_UUID:
+                self._read_char = characteristic
+        if not self._write_char or not self._read_char:
+            raise OSError("Remote UART missing needed characteristic")
+
+        # Enable notifications from the server (the peripheral).
+        self._read_char.set_cccd(notify=True)
+        self._read_buffer = CharacteristicBuffer(self._read_char,
+                                                 timeout=self._timeout,
+                                                 buffer_size=self._buffer_size)
+
+    @staticmethod
+    def scan(scanner=None, scan_time=2):
+        """Scan for Peripherals advertising the Nordic UART Service,
+        and return their addresses.
+
+        :param int scanner: Scanner to use. If not supplied, a local one will
+          be created.
+        :param float scan_time: scan for this many seconds.
+        :return list of Address objects, or an empty list, if none found
+        """
+        if not scanner:
+            scanner = Scanner()
+
+        return [se.address for se in
+                ScanEntry.with_service_uuid(scanner.scan(scan_time), NUS_SERVICE_UUID)]
+
+    def disconnect(self):
+        """Disconnect from the peripheral."""
+        self._central.disconnect()
+        self._read_char = self._write_char = self._read_buffer = None
+
+    @property
+    def connected(self):
+        """True if we are connected to a peripheral."""
+        return self._central.connected
+
+    def read(self, nbytes=None):
+        """
+        Read characters. If ``nbytes`` is specified then read at most that many bytes.
+        Otherwise, read everything that arrives until the connection times out.
+        Providing the number of bytes expected is highly recommended because it will be faster.
+
+        :return: Data read
+        :rtype: bytes or None
+        """
+        return self._read_buffer.read(nbytes)
+
+    def readinto(self, buf, nbytes=None):
+        """
+        Read bytes into the ``buf``. If ``nbytes`` is specified then read at most
+        that many bytes. Otherwise, read at most ``len(buf)`` bytes.
+
+        :return: number of bytes read and stored into ``buf``
+        :rtype: int or None (on a non-blocking error)
+        """
+        return self._read_buffer.readinto(buf, nbytes)
+
+    def readline(self):
+        """
+        Read a line, ending in a newline character.
+
+        :return: the line read
+        :rtype: int or None
+        """
+        return self._read_buffer.readline()
+
+    @property
+    def in_waiting(self):
+        """The number of bytes in the input buffer, available to be read."""
+        return self._read_buffer.in_waiting
+
+    def reset_input_buffer(self):
+        """Discard any unread characters in the input buffer."""
+        self._read_buffer.reset_input_buffer()
+
+    def write(self, buf):
+        """Write a buffer of bytes."""
+        # We can only write 20 bytes at a time.
+        offset = 0
+        while offset < len(buf):
+            self._write_char.value = buf[offset:offset+20]
+            offset += 20
diff --git a/adafruit_ble/uart_server.py b/adafruit_ble/uart_server.py
new file mode 100644
index 0000000..d7e1c9f
--- /dev/null
+++ b/adafruit_ble/uart_server.py
@@ -0,0 +1,130 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2018 Dan Halbert for Adafruit Industries
+#
+# 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.
+"""
+`adafruit_ble.uart_server`
+====================================================
+
+UART-style communication: Peripheral acting as a GATT Server.
+
+* Author(s): Dan Halbert for Adafruit Industries
+
+"""
+from bleio import Characteristic, CharacteristicBuffer, Peripheral, Service
+from .advertising import ServerAdvertisement
+from .uart import NUS_SERVICE_UUID, NUS_RX_CHAR_UUID, NUS_TX_CHAR_UUID
+
+class UARTServer:
+    """
+    Provide UART-like functionality via the Nordic NUS service.
+
+    :param int timeout:  the timeout in seconds to wait
+      for the first character and between subsequent characters.
+    :param int buffer_size: buffer up to this many bytes.
+      If more bytes are received, older bytes will be discarded.
+    :param str name: Name to advertise for server. If None, use default Peripheral name.
+
+    Example::
+
+        from adafruit_ble.uart_server import UARTServer
+        uart = UARTServer()
+        uart.start_advertising()
+
+        # Wait for a connection.
+        while not uart.connected:
+            pass
+
+        uart.write('abc')
+    """
+
+    def __init__(self, *, timeout=1.0, buffer_size=64, name=None):
+        self._read_char = Characteristic(NUS_RX_CHAR_UUID, write=True, write_no_response=True)
+        self._write_char = Characteristic(NUS_TX_CHAR_UUID, notify=True)
+        self._read_buffer = CharacteristicBuffer(self._read_char,
+                                                 timeout=timeout, buffer_size=buffer_size)
+
+        nus_uart_service = Service(NUS_SERVICE_UUID, (self._read_char, self._write_char))
+
+        self._periph = Peripheral((nus_uart_service,), name=name)
+        self._advertisement = ServerAdvertisement(self._periph)
+
+    def start_advertising(self):
+        """Start advertising the service. When a client connects, advertising will stop.
+        When the client disconnects, restart advertising by calling ``start_advertising()`` again.
+        """
+        self._periph.start_advertising(self._advertisement.advertising_data_bytes,
+                                       scan_response=self._advertisement.scan_response_bytes)
+
+    def stop_advertising(self):
+        """Stop advertising the service."""
+        self._periph.stop_advertising()
+
+    @property
+    def connected(self):
+        """True if someone connected to the server."""
+        return self._periph.connected
+
+    def read(self, nbytes=None):
+        """
+        Read characters. If ``nbytes`` is specified then read at most that many bytes.
+        Otherwise, read everything that arrives until the connection times out.
+        Providing the number of bytes expected is highly recommended because it will be faster.
+
+        :return: Data read
+        :rtype: bytes or None
+        """
+        return self._read_buffer.read(nbytes)
+
+    def readinto(self, buf, nbytes=None):
+        """
+        Read bytes into the ``buf``. If ``nbytes`` is specified then read at most
+        that many bytes. Otherwise, read at most ``len(buf)`` bytes.
+
+        :return: number of bytes read and stored into ``buf``
+        :rtype: int or None (on a non-blocking error)
+        """
+        return self._read_buffer.readinto(buf, nbytes)
+
+    def readline(self):
+        """
+        Read a line, ending in a newline character.
+
+        :return: the line read
+        :rtype: int or None
+        """
+        return self._read_buffer.readline()
+
+    @property
+    def in_waiting(self):
+        """The number of bytes in the input buffer, available to be read."""
+        return self._read_buffer.in_waiting
+
+    def reset_input_buffer(self):
+        """Discard any unread characters in the input buffer."""
+        self._read_buffer.reset_input_buffer()
+
+    def write(self, buf):
+        """Write a buffer of bytes."""
+        # We can only write 20 bytes at a time.
+        offset = 0
+        while offset < len(buf):
+            self._write_char.value = buf[offset:offset+20]
+            offset += 20
diff --git a/adafruit_ble/uuid.py b/adafruit_ble/uuid.py
new file mode 100644
index 0000000..96805ee
--- /dev/null
+++ b/adafruit_ble/uuid.py
@@ -0,0 +1,35 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Dan Halbert for Adafruit Industries
+#
+# 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.
+"""
+`adafruit_ble.uuid`
+====================================================
+
+BLE UUIDs
+
+* Author(s): Dan Halbert for Adafruit Industries
+
+"""
+
+from bleio import UUID as bleio_UUID
+
+UUID = bleio_UUID
+"""`adafruit_ble.UUID` is the same as `bleio.UUID`"""
diff --git a/examples/ble_demo_central.py b/examples/ble_demo_central.py
new file mode 100644
index 0000000..54b72c3
--- /dev/null
+++ b/examples/ble_demo_central.py
@@ -0,0 +1,48 @@
+"""
+Demonstration of a Bluefruit BLE Central. Connects to the first BLE UART peripheral it finds.
+Sends Bluefruit ColorPackets, read from three potentiometers, to the peripheral.
+"""
+
+import time
+
+import board
+from analogio import AnalogIn
+
+#from adafruit_bluefruit_connect.packet import Packet
+# Only the packet classes that are imported will be known to Packet.
+from adafruit_bluefruit_connect.color_packet import ColorPacket
+
+from adafruit_ble.scanner import Scanner
+from adafruit_ble.uart_client import UARTClient
+
+def scale(value):
+    """Scale an value from 0-65535 (AnalogIn range) to 0-255 (RGB range)"""
+    return int(value / 65535 * 255)
+
+scanner = Scanner()
+uart_client = UARTClient()
+uart_addresses = []
+
+# Keep trying to find a UART peripheral
+while not uart_addresses:
+    uart_addresses = uart_client.scan(scanner)
+
+a0 = AnalogIn(board.A0)
+a1 = AnalogIn(board.A1)
+a2 = AnalogIn(board.A2)
+
+while True:
+    uart_client.connect(uart_addresses[0], 5)
+    while uart_client.connected:
+        r = scale(a0.value)
+        g = scale(a1.value)
+        b = scale(a2.value)
+
+        color = (r, g, b)
+        print(color)
+        color_packet = ColorPacket(color)
+        try:
+            uart_client.write(color_packet.to_bytes())
+        except OSError:
+            pass
+        time.sleep(0.3)
diff --git a/examples/ble_demo_periph.py b/examples/ble_demo_periph.py
new file mode 100644
index 0000000..83bb610
--- /dev/null
+++ b/examples/ble_demo_periph.py
@@ -0,0 +1,36 @@
+"""
+Used with ble_demo_central.py. Receives Bluefruit LE ColorPackets from a central,
+and updates a NeoPixel FeatherWing to show the history of the received packets.
+"""
+
+import board
+import neopixel
+
+from adafruit_ble.uart_server import UARTServer
+from adafruit_bluefruit_connect.packet import Packet
+# Only the packet classes that are imported will be known to Packet.
+from adafruit_bluefruit_connect.color_packet import ColorPacket
+
+uart_server = UARTServer()
+
+NUM_PIXELS = 32
+np = neopixel.NeoPixel(board.D10, NUM_PIXELS, brightness=0.1)
+next_pixel = 0
+
+def mod(i):
+    """Wrap i to modulus NUM_PIXELS."""
+    return i % NUM_PIXELS
+
+while True:
+    # Advertise when not connected.
+    uart_server.start_advertising()
+    while not uart_server.connected:
+        pass
+
+    while uart_server.connected:
+        packet = Packet.from_stream(uart_server)
+        if isinstance(packet, ColorPacket):
+            print(packet.color)
+            np[next_pixel] = packet.color
+            np[mod(next_pixel + 1)] = (0, 0, 0)
+        next_pixel = (next_pixel + 1) % NUM_PIXELS
diff --git a/examples/ble_uart_echo_test.py b/examples/ble_uart_echo_test.py
index 40f1173..82bec77 100644
--- a/examples/ble_uart_echo_test.py
+++ b/examples/ble_uart_echo_test.py
@@ -1,4 +1,4 @@
-from adafruit_ble.uart import UARTServer
+from adafruit_ble.uart_server import UARTServer
 
 uart = UARTServer()