Fix some indentation issues.
Strip trailing spaces.
Replace tabs with spaces.
Add a frame structure for each message.
The frame consists of a header, the payload size and a message payload.

This structure is only a helper struct for lib internals, to be able to use dynamic payload sizes.
Over the air only the header and the payload (without the payload size) are transmitted.
Extendend the frame struct to allow setting payload.
Define MAX_FRAME_SIZE as a makro with value of '32' (Bytes).
Use the RF24NetworkFrame type for internal management of frames
Changes in code:
    - internally use the introuduced RF24NetworkFrame type to describe and manage header and payload.
    - keep the write and read API for backward compatibility.
    - make needed changes in some functions to be able to use the RF24NetworkFrame and circular buffer.
    - extend the circular buffer class with some functions
        - front()
        - isEmpty()
        - isFull()
    - update copyrith

TODO:
    - check if the code is supported in arduino
    - check for memory lecks
    - check for memory space usage (arduino)
    - implement automatic fragmentation and reassembly of large payloads
    - two independent tx and rx (circular buffer) FIFOs
    - clean up code
        - remove not need parts
Many changes in the fragmentation

FIXME: problems with reassembly data structure
Change isEmpty test
Delete not needed data structure
Fully functional fragmentation implementation for large payloads.
Fragmentation is transparent to caller application.

TODO:
        - multicast fragmentation
        - test with multiple nodes in a larger network
        - use a circular queue for the frame_queue data structure
        - use a LRUCache data structure for the frame reassembly
        - lower memory consumption
        - arduino porting
        - cleanup code
        - remove redundant and innecessary code

- Based on IPv4 fragmentation https://tools.ietf.org/html/rfc791.
- Tested only on Raspberry Pi, may not work in Arduinos due to memory usage
  Tested only with two raspberris using NRF24L01+ 10 meters appart.
- The lib is capable to detect if the message payload is bigger than frame_size-sizeof(Header)
  and split the payload into chuncks and send them separately.
- This commit introduces two new flag types:
        - NETWORK_MORE_FRAGMENTS
        - NETWORK_LAST_FRAGMENT
- As of IPv4 fragmention this flags are used to mark the frames to notify the receiver if more
  fragments will come or this is the last fragment.
- The previous _write() function to transmit the frames is used.
- Changes in payload size management were made to allow dynamic payload sizes without the need
  to define a field in the header.
- Introduce a new struct type "RF24NetworkFrame" for better frame handling inside the lib.
  This type encapsulates the header, the current size of the payload and a (fixed size) array
  containing the payload.
- The frame_buffer data structure was changes in favor of a std::queue for better handling.
- Make some changes renaming variables and defining the values.
- Use a std::map with double key (header.to_from,header.id) to identify the incoming fragments,
  allowing the reassembly of multiple transmission simultaneously.
- The reassembly of frames hapens in the enqueue(frame) function.
  Based on the fragment_id and header.id the fragments are handled diffently and in the end
  the completely assembled frames are queued in the frame_queue presenting them to the calling
  application.
- Introduce a new debug flag to print fragmentation debug messages.
- Use definitions for static values like frame size or payload max size.
- Strip trailing spaces and fix some indentation issues.
Fully functional fragmentation and reassembly implementation for large payloads.
Fragmentation is transparent to calling application.

TODO:
        - multicast fragmentation
        - test with multiple nodes in a larger network
        - use a circular queue for the frame_queue data structure
        - use a LRUCache data structure for the frame reassembly
        - lower memory consumption
        - arduino porting
        - cleanup code
        - remove redundant and unnecessary code

- Based on IPv4 fragmentation https://tools.ietf.org/html/rfc791.
- Tested only on Raspberry Pi, may not work in Arduinos due to memory usage
  Tested only with two raspberries using NRF24L01+ 10 meters apart.
- The lib is capable to detect if the message payload is bigger than frame_size-sizeof(Header)
  and split the payload into chucks and send them separately.
- This commit introduces two new flag types:
        - NETWORK_MORE_FRAGMENTS
        - NETWORK_LAST_FRAGMENT
- As of IPv4 fragmentation this flags are used to mark the frames to notify the receiver if more
  fragments will come or this is the last fragment.
- The previous _write() function to transmit the frames is used.
- Changes in payload size management were made to allow dynamic payload sizes without the need
  to define a field in the header.
- Introduce a new struct type "RF24NetworkFrame" for better frame handling inside the lib.
  This type encapsulates the header, the current size of the payload and a (fixed size) array
  containing the payload.
- The frame_buffer data structure was changes in favor of a std::queue for better handling.
- Make some changes renaming variables and defining the values.
- Use a std::map with double key (header.to_from,header.id) to identify the incoming fragments,
  allowing the reassembly of multiple transmission simultaneously.
- The reassembly of frames happens in the enqueue(frame) function.
  Based on the fragment_id and header.id the fragments are handled differently and in the end
  the completely assembled frames are queued in the frame_queue presenting them to the calling
  application.
- Introduce a new debug flag to print fragmentation debug messages.
- Use definitions for static values like frame size or payload max size.
- Strip trailing spaces and fix some indentation issues.
Merge branch 'feature/fragmentation_v2' of https://github.com/reixd/RF24Network into feature/fragmentation_v2
Remove not needed CircularBuffer data structure
Fix for ATTiny in IDE 1.5.7
Merge pull request #13 from reixd/feature/fragmentation_v2

Merge Pull request from https://github.com/reixd 
Feature(s): Extended support for very long payloads with fragmentation/reassembly
Fixes/Workarounds for fragmentation support

Fixes for https://github.com/TMRh20/RF24Network/pull/13

- modify txTimeout value
- detect 0 payload length due to corrupt dynamic payload
- detect and clear un-finished fragmented payloads
- detect and clear frames that exceed MAX_PAYLOAD_SIZE (due to duplicate
payloads, etc)
- add auto-adjusted delay after writes to account for timing issues
- adjust includes in examples to prevent compile errors
Arduino support for routing fragmented payloads

- Arduino enableDynamicPayloads()
- Added RF24Network support for routing of fragmented payloads on
Arduino ( Only fully supported on RPi currently)
-  Added delay after detecting corrupt dynamic payloads
Per #14 add first/last fragment, debugging cleanup

Per #14 and
https://github.com/TMRh20/RF24Network/commit/e34a39472ba06ecf867aace81be4098d29c878d8#commitcomment-7727886
added NETWORK_FIRST_FRAGMENT
- Add total_fragments to RF24NetworkFrame
- Add error checking per discussion
- Modify debug to include FRG for fragment handling messages and RT for
routed messages
- Add SERIAL_DEBUG_MINIMAL to be changed as required for debugging new
features in RF24NetworkDEV
#15 Fix user-defined header types w/fragmentation

Since a fragment_id and fragment type is sent, we can include and
restore the user-defined header type with fragmented payloads by
including it with the final fragment, since we know its expected
fragment_id and that this should be the last expected fragment.
#15 #14 Improve fragmentation and transfer speed

Notes:
- May require updating the RF24 driver (radio.rxFifoFull())

- Continue buffering data if a Network Ack is received and there is data
in the FIFO
- Fragmented payload handling improvements
- Repair and tested non-fragmented and fragmented data transfers with
user-defined header types
- Handling for data sent to self
- Stop listening during fragmented data transfers, speeds up data rates
(more to come)
- Adjusted frag_delay.
- Thanks to https://github.com/reixd and rRF24toTUN for making testing
things a lot easier
Cleanup code.

 - Remove commented code, it is bad practice.
 - Use a C++ indent style
 - Set indent witdth to 2 spaces and no tabs
 - Change some code to improve readability
 - Add more comments to the code
 - Define variables C++ like stlye, in the header and the constructor
Set MAX_USER_DEFINED_HEADER_TYPE for better readibility.