Another work progress

7 files changed, 0 insertions, 428 deletions

diff --git a/docs/modules/ioport.md b/docs/modules/ioport.md
deleted file mode 100644
index e777e0c..0000000
--- a/docs/modules/ioport.md
+++ /dev/null
@@ -1,153 +0,0 @@
-IO port
-=======
-To use include: `ioport.md`  
-And define: `CONFIG_IOE_IOPORT`
-
-Defines simple access to io ports. This allows runtime access to any pin with just
-serialized identifier.
-
-Most of the functions has group and mask arguments. Group is letter, but in this
-library is represented as number and exact number is defined as macro definition.
-Mask is one shifted by index number(use \_BV macro). This way can be
-addressed all IO ports. Exact identification consult with datasheet. You can also
-use more than one index number and control more ports in single group with single
-command.
-
-WARNING: No check is implemented for right group number. Usage of unsupported
-value is undefined (write to other parts of memory can happen).
-
-## References
-### For output
-#### Function io_setout
-```C
-static inline void io_setout(uint8_t group, uint8_t mask)
-```
-Configures port of `group` with `mask` as output.  
-Parameters:
-    group - Character specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-#### Function io_hight
-```C
-static inline void io_hight(uint8_t group, uint8_t mask)
-```
-Sets output port to hight (also can be called as 1).  
-WARNING: Invoke this only if io_setout is called before.  
-Parameters:
-    group - Character specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-#### Function io_low
-```C
-static inline void io_low(uint8_t group, uint8_t mask)
-```
-Sets output port to low (also called as 0).  
-WARNING: Invoke this only if io_setout is called before.  
-Parameters:
-    group - Number specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-#### Function io_set
-```C
-static inline void io_set(uint8_t group, uint8_t mask, int8_t val)
-```
-Sets output port to value passed as argument.  
-WARNING: Invoke this only if io_setout is called before.  
-Parameters:
-    group - Number specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-### For input
-#### Function io_setin
-```C
-static inline void io_setin(uint8_t group, uint8_t mask,
-                                enum ioeIOInResistor resistor)
-```
-Configures port of `group` with `mask` as input with specified pull-up/down
-resistor.  
-Parameters:
-    group - Number specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-#### Function io_get
-```C
-static inline int8_t io_get(uint8_t group, uint8_t mask)
-```
-Returns current value of port. Note that you can use this also if port is
-configured as output.  
-Parameters:
-    group - Number specifying exact port group
-    mask  - Binary shifted 1. Shift is equal to port index in specified group.
-
-#### Enum ioeIOInResistor
-```C
-enum ioeIOInResistor {
-    IOE_IO_PULLUP,
-    IOE_IO_PULLDOWN
-};
-```
-This enum is used as argument for io_setin. Names should be self explanatory
-in this case.
-
-### Pin change interrupts
-#### Function io_change_sethook
-```C
-int8_t io_change_sethook(uint8_t group, uint8_t mask, uint8_t edge,
-                           void (*change) (uint8_t group, uint8_t mask))
-```
-Registers function `change` as hook for pin change interrupt. `group` and `mask`
-specifies port and edge specifies on what edge should hook be called. `edge` can
-be IO_RISING or IO_FALLING or their binary combination with operator
-`|`.  
-WARNING: `change` call is call during interrupt handling. You shouldn't be
-blocking execution for long time.  
-Parameters:  
-    group  - Number specifying exact port group
-    mask   - Binary shifted 1. Shift is equal to port index in specified group.
-    edge   - Signals on what edge should be hook called.
-    change - Pointer to function used as interupt hook
-
-#### Function io_change_remhook
-```C
-int8_t io_change_remhook(void (*change) (uint8_t group, uint8_t mask))
-```
-Removes `change` hook.  
-Parameters:  
-    change - Pointer to function used as hook
-
-### Others
-#### Definitions IO_{GROUP}
-This defines exact numbers related to data-sheet groups. Always use these
-definition not direct numbers, you can ensure cross MCU support this way.
-
-#### Definitions IO_{GROUP}{INDEX}
-Because specifying group and mask as separate parameters is not always optimal,
-mcu support file should define all ports in form of single line definition in
-format `IOE_IO_{GROUP}{INDEX}`. Disadvantage is that with these definitions you
-can't use binary conjunction and so only one pin can be controlled with it.
-
-## Relevant examples
-* blink
-* pcinterrupt
-
-## Adding support
-For more information on how add support, see `doc/add_support.md`.
-Main definition is `MCUSUPPORT_IOPORT`. Define it to enable support.
-
-### IO_{GROUP}
-This should define any number that is handy for implementation of `IOE_IOE_PIN`,
-`IOE_IO_DDR` and `IOE_IO_PORT`.
-
-### IO_{PIN/DDR/PORT}
-These should calculate exact pointers to register `PORT{GROUP}` for PORT variant
-and likewise for others with group as argument. Common implementation would be
-like this:
-```C
-#define IOE_IO_PIN(GROUP)  (* (volatile uint8_t *)(PINB + 0x3*GROUP))
-```
-### IO_{GROUP}{INDEX}
-This should be pair of group and one binary shifted to left relative to index.
-
-### MCUSUPPORT_PCINT{NUM}
-This defines that MCU supports specific pin change interrupt group. Also it
-defines value that is number of pins in group.
diff --git a/docs/modules/spi.md b/docs/modules/spi.md
deleted file mode 100644
index 3ae730c..0000000
--- a/docs/modules/spi.md
+++ /dev/null
@@ -1,69 +0,0 @@
-Serial peripheral interface
-===========================
-This interface is link to MOSI and MISO pins. Also SS pin is used when slave mode initialized.
-
-## References
-### spi\_init
-```C
-static inline void spi_init(enum spiMode mode)
-```
-Initializes SPI interface.  
-Parameters:  
-    mode - Specify mode of SPI interface  
-  
-NOTE: Global interrupts must be enabled for right function of SPI.
-
-### spi\_busy
-```C
-static inline int8_t spi_busy(void)
-```
-Returns NULL when device is not busy.  
-When device is busy return values in non-zero.
-
-### spi\_join    
-```C
-static inline void spi_join(void)
-```
-Blocks processor until device is not busy.
-
-### spi\_send
-```C
-static inline uint8_t spi_send(uint8_t data)
-```
-Swap bytes with slave over SPI.  
-This function blocks execution until device isn't busy (transfer completed).  
-WARNING: Invoke this only when interface is initialized in MASTER mode.
-
-### spi\_transfer
-```C
-static inline void spi_transfer(uint8_t data)
-```
-Transfer byte to slave over SPI.  
-This function isn't blocking execution until transfer is complete.  
-Always call spi\_join before this function when called outside of spi\_receive().  
-WARNING: Invoke this only when interface is initialized in MASTER mode.
-
-### spi\_expose
-```C
-static inline void spi_expose(uint8_t data)
-```
-Expose data for next master request.
-Please don't use this when device is busy.
-Best place to call this is spi\_receive().  
-WARNING: Invoke this only when interface is initialized in SLAVE mode.
-
-## Function pointer spi\_receive
-```C
-extern void (*spi_receive)(uint8_t data)
-```
-This function is called every time transfer is finished.
-And until return from this function interrupts are disabled.
-
-## Enum spiMode
-```C
-enum spiMode {
-    SPI_MODE_MASTER,
-    SPI_MODE_SLAVE
-};
-```
-This is used as parameter for spi\_init function.
diff --git a/docs/modules/tasks.md b/docs/modules/tasks.md
deleted file mode 100644
index 0078f00..0000000
--- a/docs/modules/tasks.md
+++ /dev/null
@@ -1,37 +0,0 @@
-Tasks
-=====
-Tasks allows separate jobs.
-
-## Functions
-### tasks_run
-```C
-int8_t tasks_run(void)
-```
-This function starts tasks execution. Should be called after all task slots are
-prepared and at least one task is started. This function exits if no task exist or
-all existing tasks exited.
-
-### task_init
-
-## Structures
-### Task
-```C
-typedef struct {
-    uint8_t flags;
-    void (*func) (void);
-} Task;
-```
-
-### TaskSlot
-```C
-typedef struct {
-    uint8_t flags;
-    Task *task;
-    uint8_t stack_size;
-    uint8_t stack[];
-} TaskSlot;
-```
-
-### Mutex
-
-### Semaphore
diff --git a/docs/modules/timer.md b/docs/modules/timer.md
deleted file mode 100644
index e69de29..0000000
--- a/docs/modules/timer.md
+++ /dev/null
diff --git a/docs/modules/usart.md b/docs/modules/usart.md
deleted file mode 100644
index e69de29..0000000
--- a/docs/modules/usart.md
+++ /dev/null
diff --git a/docs/modules/utils/buffer.md b/docs/modules/utils/buffer.md
deleted file mode 100644
index 4365c25..0000000
--- a/docs/modules/utils/buffer.md
+++ /dev/null
@@ -1,105 +0,0 @@
-buffer
-======
-In whole project are used ring buffers. This is so common that handling them is
-exported to separated header file. In fact it contains two implementations of
-buffers. One implementation is defined using preprocessor macros. Another one is
-plain C code.
-
-## Preprocessor implementation
-Preprocessor implementation is expected to be faster and less memory intense. Also
-more suitable for buffers of simple types (such us int). But this buffer has to be
-defined with known size at compile time and can't be resized. All this makes it
-good implementation for IO devices input and output buffers, but less for more
-complicated tasks containing for example sorting.
-
-### Macros
-#### IOEBUFFER
-```C
-IOEBUFFER(type, name, size)
-```
-This macro defines buffer. Use it to define new buffer.
-##### Parameters
-| type | Specify type of elements in buffer. Can be any valid C type |
-| name | Name of buffer. This is C variable name.                    |
-| size | Numerical value of buffer size                              |
-
-#### IOEBUFFER_INIT
-```C
-IOEBUFFER_INIT(name, size)
-```
-Use this to initialize buffer. Parameter `size` must be same as for IOEBUFFER
-(definition of buffer). You can use this also to reset buffer (remove all data
-from buffer).
-##### Parameters
-| name | Name if buffer. This is C variable name. |
-| size | Numerical value of buffer size           |
-
-#### IOEBUFFER_PUT
-```C
-IOEBUFFER_PUT(name, size, data, mode)
-```
-Use this macro to add new data to buffer.
-##### Parameters
-| name | Name of buffer. This is C variable name. |
-| size | Numerical value of buffer size           |
-| data | Data to be stored to buffer              |
-| mode | This specifies action if buffer is full. |
-##### Modes
-| IOEBUFFER_MODE_BLOCK     | Block execution until buffer has some free space. |
-| IOEBUFFER_MODE_OVERWRITE | Overwrites oldest added (fist to be read)         |
-| IOEBUFFER_MODE_DROP      | New data won't be stored to buffer if full        |
-
-#### IOEBUFFER_GET
-```C
-IOEBUFFER_GET(name, size, variable)
-```
-Get value from buffer. Value is stored in `variable` (it is variable of same type
-as buffer data, not pointer to variable of same type). If no data is in buffer,
-variable is set to NULL.
-##### Parameters
-| name     | Name of buffer. This is C variable name.  |
-| size     | Numerical value of buffer size.           |
-| variable | Variable in which data will be stored in. |
-
-#### IOEBUFFER_CNT
-```C
-IOEBUFFER_CNT(name, size, variable)
-```
-Counts number of data entries in buffer and saves value to variable.
-##### Parameters
-| name     | Name of buffer. This is C variable name.                    |
-| size     | Numerical value of buffer size.                             |
-| variable | Int/Unsigned type variable where data count will be stored. |
-
-## C implementation
-C implementation is more general. Size is defined by calling initialization
-function. But it is using general pointers, so it is only able store pointers.
-
-As buffer identification is used defined type `IOEBuffer`. All functions takes
-pointer to this type as parameter. Because of this, it won't be described for
-every function.
-
-### Functions
-#### ioebuffer_init
-```C
-int8_t ioebuffer_init(IOEBuffer *buf, uint8_t size, uint8_t flags)
-```
-Initialized buffer and allocates required resources.
-##### Parameters
-| size  | Number of elements to be maximally stored in buffer |
-| flags | TODO
-##### Flags
-TODO
-
-#### ioebuffer_uninit
-```C
-void ioebuffer_uninit(IOEBuffer *buf)
-```
-Frees all resources allocated during initialization of buffer. Use this every time
-you are freeing buffer.
-
-#### ioebuffer_put
-```C
-int8_t ioebuffer_put(IOEBuffer *buf, void *data)
-```
-Add `data` to buffer
diff --git a/docs/modules/utils/narray.md b/docs/modules/utils/narray.md
deleted file mode 100644
index 3e64f67..0000000
--- a/docs/modules/utils/narray.md
+++ /dev/null
@@ -1,64 +0,0 @@
-narray.h
-========
-This implements some helping functions for null terminated arrays. Null terminated
-arrays are used across whole project because they are simple and don't waste
-memory space.  Their disadvantage is more complicated implementation of utility
-functions and much longer adding time (they are reallocated every time new data
-are added).
-
-This implementation is limited to only contains 255 elements(limited by uint8_t
-type). But it should be enough for basic usage. If you need store more than that,
-you should use different approach. Also only pointers can be stored.
-
-To define null terminated array just define pointer to you required pointer and set
-it to NULL. Such narray is handled as empty. Example:
-```C
-int **narray = 0;
-```
-After adding some data (in example case data of type `int*`) you can access them
-same as if you would working with simple array (`narray[i]`). Last element it such
-array is `NULL`. No more valid data are stored after `NULL` (This also means that
-`NULL` can't be stored to narray).
-
-All functions are taking as parameter `void ***array`, which is pointer to null
-terminated array. This parameter won't be described in functions.
-
-## Functions and macros
-### narray_add
-```C
-void narray_add(void ***array, void *data)
-```
-Add data to end of the array. This increases size of the array by one (two bytes).
-#### Parameters
-| data | data to be stored to array |
-
-### narray_remove
-```C
-void narray_remove(void ***array, void *data)
-```
-Remove specified data from array. This effectively decreases size of the array by
-one (two bytes).
-#### Parameters
-| data | data to be removed from array |
-
-### narray_size
-```C
-size_t narray_size(void ***array)
-```
-Returns size of array.
-
-### narray_free
-```C
-inline void narray_free(void ***array)
-```
-Frees whole array if allocated.
-
-### fornarray
-```C
-#define fornarray(array, i, data) for (i = 0; (data = array[i]) != 0; i++)
-```
-This is macro. It implements simple foreach cycle.
-#### Parameters
-| array | array it self (void ** not pointer)        |
-| i     | unsigned integer (uint8_t)                 |
-| data  | variable which will be used to access data |