muos/doc/muos.txt:7::
  document that functions must disable interrupts

muos/stepper.c:178::
  refine configstore errors

muos/stepper.c:188::
  phase correction for UP steppers

muos/stepper.c:399::
  refine configstore errors

muos/sm.c:169::
  wait for 2 elements free, locked wait

muos/configstore.c:148::
  simple non redundant version for now

muos/configstore.c:171::
  DEAD not as state but error, let states only reflect the state in memory

muos/lib/spriq.c:23::
  schedule with when = 1 doesn't work

muos/stepper.h:407::
  done -> plan

muos/hw/atmel/avr/atmega.h:27::
  HW() config

muos/doc/WEB.pdoc:30::
  mob repository

muos/doc/WEB.pdoc:39::
  contact/mailinglist

muos/doc/MAIN.pdoc:25::
  document git repository/submodules

muos/doc/MAIN.pdoc:26::
  cooperation, mob repository, coding style, docs

muos/doc/MAIN.pdoc:27::
  development workflow

muos/doc/MAIN.pdoc:28::
  usage workflow

muos/stepper.c:30::
  API for setting each axis and then start all together

muos/stepper.c:405::
  fast return only out_steps w/o fast or slope

muos/serial.c:94::
  calculate timeout baudrate for txbuffer characters

muos/error.c:26::
  no need to store muos_error_success, array one bit smaller, fix indexing

muos/muos.c:45::
  select sleep mode depending on active hardware (adc, usart)

muos/muos.c:183::
  how to init all muos structures .. #define MUOS_EXPLICIT_INIT

muos/configstore.c:48::
  calculate type from array capacity

muos/clpq.c:79::
  return error instead async

muos/clpq.c:101::
  return when already compmatch or disable compmatch when time is too short

muos/clpq.c:103::
  new implementation

muos/lineedit.c:299::
  suspend lineedit until the callback is finished (w/ wraper)

muos/lineedit.c:300::
  push callback on bgq

muos/hw/atmel/avr/stepper.c:174::
   case MUOS_STEPPER_STOPPING: */                                                           {git_blame_context ()}

muos/hw/atmel/avr/stepper.c:329::
  set pin to defined state

muos/hw/atmel/avr/stepper.c:416::
  dirpol for unipolar

muos/hw/atmel/avr/stepper.c:445::
  conditional for different parts

muos/hw/atmel/avr/stepper.c:446::
  progmem

muos/hw/atmel/avr/serial.c:71::
  disable error checks depending on config (no parity etc)

muos/io.h:51::
  I/O and interrupt safety

muos/pp.h:25::
  DOCME

muos/configstore.h:127::
  add callback when config gets changed for reinitializeing dependencies

muos/configstore.h:128::
  document implicit config_size

muos/pptest.h:56::
  check state

muos/stepper.h:34::
  startall()

muos/stepper.h:35::
  sync moves

muos/stepper.h:144::
  unimplemented

muos/stepper.h:165::
  calculate for maxslope

muos/stepper.h:337::
  what helper functions are needed foor low level configuration? zigzag etc.

muos/stepper.h:475::
  implement slope_load() (doing get, copy, commit)

muos/stepper.h:530::
  slope_load w/ fixing destination

muos/stepper.h:569::
  implement me

muos/stepper.h:572::
  implement me

muos/stepper.h:650::
   backlash compensation

muos/error.h:39::
  conditional error generation depending on what drivers are enabled

muos/sm.h:227::
  improper api, needs to be improved

muos/muos.h:56::
  use GPIO register

muos/muos.h:132::
  document me

muos/hw/atmel/avr/attiny84.h:81::
   DDRB = 0;

muos/hw/atmel/avr/attiny84.h:82::
   DDRC = 0;

muos/hw/atmel/avr/attiny84.h:83::
   DDRD = 0;

muos/hw/atmel/avr/avr.h:94::
  configureable mode

muos/muos.mk:103::
  document init system

muos/doc/PLANNED.txt:1::
  macros for Hz kHz


muos/doc/PLANNED.txt:3::
  different timebase, stable timing etc



muos/doc/PLANNED.txt:6::
  return continutations and schedule them in the schedulers



muos/doc/PLANNED.txt:9::
  docme MAKEFILE include  muos/muos.mk

muos/doc/PLANNED.txt:10::
  docme  All hardware macro and functions have the prefix 'MUOS_HW_' or 'muos_hw_'


muos/doc/PLANNED.txt:12::
  rtpq realtime priority queue

runs direct in timer interrupt, exact timing, wakes up a little earlier
spins to exact time. Serve from clpq, tag functions as hard-rt and dont
reenable interrupts then.

muos/doc/PLANNED.txt:17::
  ltpq long time queue

. uses longer, absolute time format (muos_clock or muos_fullclock)
. needs more memory
. handled from the clpq (one regular job at each cycles moves elements
  form ltpq to clpq)
. optional only needed for 'calendar' like events, may be short, only as
much long time events the program uses at most
. persistent timers stored in EEPROM when RTC is present

muos/doc/PLANNED.txt:26::
  -mint8 compatible


muos/doc/PLANNED.txt:28::
  library for rationals


muos/doc/PLANNED.txt:30::
  Testing


muos/doc/PLANNED.txt:32::
  Stack checks


muos/doc/PLANNED.txt:34::
  watchdog

timeout for rtq, bgq
how to detect timeouts on clq?

muos/doc/PLANNED.txt:38::
  Indirect jump tables for queues

register all 'callable' functions in one array. The queues can then
index this table by uint8_t or shorter.

muos/doc/PLANNED.txt:42::
  Interrupt hooks? adding interrupt handlers dynamically



muos/doc/PLANNED.txt:45::
  *lineedit* load/save commandline from api (configuration settings)

muos/doc/PLANNED.txt:46::
  *lineedit* block lineedit when TX is stalled

muos/doc/PLANNED.txt:47::
  *lineedit* implement txqueue ._R variants to print from lineedit buffer

muos/doc/PLANNED.txt:48::
  *lineedit* history

muos/doc/PLANNED.txt:49::
  *lineedit* completion

- tab for text
- pgup/pgdown for values
muos/doc/PLANNED.txt:52::
  *uart* rxsync when line is idle for some frames




muos/doc/PLANNED.txt:56::
  *driver* gpio

configure (in out pullup)
set, clear, toggle
sequencer


muos/doc/PLANNED.txt:62::
  *driver* Buttons w/ debounce


muos/doc/PLANNED.txt:64::
  *driver* Encoder


muos/doc/PLANNED.txt:66::
  *driver* PWM

muos/doc/PLANNED.txt:67::
  *driver* Flash

muos/doc/PLANNED.txt:68::
  *driver* Fuses

muos/doc/PLANNED.txt:69::
  *driver* Watchdog


muos/doc/PLANNED.txt:71::
  *driver* USB

muos/doc/PLANNED.txt:72::
  *driver* bangbus

muos/doc/PLANNED.txt:73::
  *driver* onewire

muos/doc/PLANNED.txt:74::
  *driver* DCF77

muos/doc/PLANNED.txt:75::
  *driver* logfs

muos/doc/PLANNED.txt:76::
  *driver* PID++

muos/doc/PLANNED.txt:77::
  *driver* power interface depending on active components

muos/doc/PLANNED.txt:78::
  *driver* Debug tools


muos/doc/PLANNED.txt:80::
  Debugger

over serial
only few commands, most logic on host side

. peek
. debug() function
. debug interrupt

muos/doc/PLANNED.txt:88::
  . F_OSC for oscillator clock

automatic prescale setting etc

muos/doc/PLANNED.txt:91::
  random generator

byte queue
quality
sources
- poll
- interrupt
- push
quality limit low/high

muos/doc/PLANNED.txt:100::
   Reorganization

Split config hierarchically
config.h
- how to depend on used config vars only?

muos/muos.h -> main header
muos/muos.c -> main program

muos/config.h -> configuration management

muos/$feature.h -> header for subsystem
muos/$feature.c -> portable subsystem interface implementaton
muos/hw/$vendor/$architecture/$feature.h|c hardware specific

Resource management at compiletime


The Stepper driver does not provide any means of moving multiple axis
exactly synchronized, but it is possible to arrange it that the axis
doing the shorter move wait for completion all other axis and then
continue with the operation. Together with matched max_speed for each
move, reasonable synchronized moves are possible.


==== States

Each stepper motor can be in one of the following states.

MUOS_STEPPER_UNKNOWN;;
  - no initialized yet
MUOS_STEPPER_OFF;;
  - stepper not energized
  - position unknown
MUOS_STEPPER_ON;;
  - stepper energized
  - position unknown, only raw movements
MUOS_STEPPER_HOLD;;
  - stepper energized
  - position unknown
  - only relative movements
MUOS_STEPPER_ARMED;;
  - stepper energized
  - position known
  - all kinds of movements allowed
MUOS_STEPPER_WAIT;;
  - stepper energized
  - position known
  - done moving, waiting for sync/continuation
MUOS_STEPPER_RAW;;
  - stepper moving
  - position unknown
  - no configuration necessary
  - dangerous/invalid moves possible!
MUOS_STEPPER_SLOW_CAL;;
  - stepper moving slower than slow_speed
  - position unknown
  - can be stopped instantly without loosing steps
MUOS_STEPPER_SLOW_REL;;
  - stepper moving slower than slow_speed
  - position known
  - can be stopped instantly without loosing steps
MUOS_STEPPER_SLOW;;
  - stepper moving slower than slow_speed
  - position known
  - can be stopped instantly without loosing steps
MUOS_STEPPER_SLOPE;;
  - stepper moving, accelerating or decelerating on slope parameters
  - position known
MUOS_STEPPER_FAST;;
  - stepper moving faster than slow_speed
  - position known
  - must decelerate for stopping w/o loosing steps.
MUOS_STEPPER_STOPPING;;
  - stepper moving faster than slow_speed, braking
  - position known
  - Controlled brake to a slow_speed, then stop





//TODO: muos/doc/stepper.txt:97::
  document hardware indexing


// prescale       prescaler setting
// cal_speed      slow speed for calibration (zeroing)
//                starting from min speed, that could be the speed where it can reverse
//                direction w/o loosing steps with some safety marigin (25%)
// min_speed      fastest speed which can be accelerated/decelerated from/to zero w/o
//                loosing steps with some safety marigin (10%)
// max_speed      maximum speed the motors run stable w/ loosing steps (after acceleration)
// accel          acceleration factor
// decel          deceleration factor
//
// conf_valid     bitfield, which values are known good

//    Cares only for stepper control/positioning
//    End switches are not handled here but rather engage/disengage the stepper via api.
//
//    But all movements are contrained within the configured limits.
//
//    * constant speed api
//      for slow movements (calibration), relative movements
//
//    * position api
//      absolute positioning which honors accel/decel and backlash and max speed settings
//      Movement is defined by up to 3 phases
//
// ----
// Stepper accelerates, reached max_speed then decelerates
//            _________
//           /         \
//          /           \
//         /             \
//     ___/               \____
//
//
// Distance is too short to reach max_speed, after acceleration it directly decelerates
//
//           /\
//     _____/  \____
// ----
//
// *** Features to implement
//
//    * Variable frequency generation
//    * Direction signal
//    * Motor arming
//    * keep counter for position
//    * callbacks on position
//    * machine properties -> higher level
//      * linear (steps per meter)
//      * rotary (steps per rotation)
//    * calibration values
//      * max speed
//      * min speed (we still need to reach a destionation even when we are close by)
//      * acceleration
//        linear and proportional part
//      * decelerarion
//        linear and proportional part
//      * accel/decel are functions over the distance traveled
//      * 2x backlash compensation
//        * offset
//        * speed
//    * later: have a small queue for planning ahead that allows smooth
//      movements without stopping
//
//
// **** Backlash compensation
//
//      Two possible strategies:
//
//      1. speed=0
//         Offset is used directly as distance to the current position.
//         Can be inaccurate but is fast
//
//      2. speed!=0
//         Overshoot by offset steps, then move back offset steps with 'speed'
//         Slow but accurate
//
//
// *** API
//
//     disclaimer: function and type names below are just for functional description
//
//
// **** Types
//      typedef int32_t position;  // steps from origin
//      typedef int32_t offset;    // relative steps
//      typedef int32_t speed;     // TBD -> translate directly into timer overflow
//
// **** Configuration structure
//      defined in source, values are directly written there
//
//      * axis limits
//      * max speed change for constant speed movements
//      * max speed
//      * backlash compensation values
//
// **** State structure
//      defined in source, values are directly written there
//
//      * position
//      * position valid flag
//      * arming state
//      * current speed -> derrived from frequency generator register
//      * movement phase?
//
// **** Configuration commands
//      zero_axis(offset)
//         sets the axis zero to offset from the current position
//
// **** Arming
//
//      Arming states:
//
//      * OFF motors disenganged
//      * HOLD position hold, but no movents allowed
//      * ARMED movements allowed
//
//      arm (state)
//      state arm_get()
//
//
// **** Constant speed commands
//      move_const(speed)
//        move at constant seed w/o limit, negative speed for reverse
//
//      move_rel(offset, speed)
//        for slow adjustment/calibration movements
//
//
// **** Positioning commands
//
//      time move_abs_estimate(position)
//        calculate how long it will take to reach position
//
//      move_abs(position, speed_factor)
//        move to position, speed_factor to slow the movement
//        speed_factor gets ignored on first version
//
//      later one can make diagonal moves where both axis reach their
//      position at roughly the same time by matching the faster one to
//      the slower ones speed. This will reduce vibration and wear.
//
//
// **** callback/query
//
//      set_callback_at (position, function)
//        calls function when position is touched (w/o backlash compensation)
//
//      set_callback (function)
//        calls function absolute positioning is done (w/ backlash commpensation)
//
//      position query_position ()
//      position query_speed ()


===== API


.Switching steppers on and off, stopping

'muos_stepper_enable_all ()' tries to switch on all steppers.
When successful muos_success is returned.
The steppers are energized and in state 'MUOS_STEPPER_ON' which
allows only raw movements.

.On error following values are returned:
+muos_warn_sched_depth+;;
+muos_error_stepper_state+;;
  Steppers are externally disabled, uninitialized or otherwise unavailable.

'muos_stepper_disable_all ()' switches all steppers off.
No matter of the state, the steppers will be disabled afterwards.
States 'MUOS_STEPPER_UNKNOWN' will stay, otherwise the new state will be MUOS_STEPPER_OFF.
Turning the steppers off will loose their position and free the configuration lock.

'muos_stepper_stop (hw)' stops movement of a single stepper, but keeps it energized.
For steppers which were running faster than 'MUOS_STEPPER_SLOW' the position will
be invalidated and the state becomes 'MUOS_STEPPER_HOLD'. They need to be re-zeroed
after a stop. For Steppers running at 'MUOS_STEPPER_SLOW' or slower the position is
kept valid and the state becomes 'MUOS_STEPPER_ARMED'.

'muos_stepper_all_stop ()' is the same as 'muos_stepper_stop (hw)' but for all Steppers.

Stopping and turning steppers off will never fail nor return an error code.
Only the resulting state may differ depending on the initial state.


.Locking the config

All higher level stepper movements need to place a read lock on the configuration. For this
The steppers must be first turned into ON state with 'muos_stepper_enable_all()'. Then the
'muos_stepper_lock_all()' will put them in HOLD state. From there calibration movements and
zeroing becomes possible.

'muos_stepper_unlock_all()' stops all steppers, releases the configuration lock, and puts them
back into ON state.

.Axis zeroing

+hw+;;
  Stepper to control.
+offset+;;
  Offset to the current position.

Zeros the step counter to the given offset.
Only available when the stepper is in HOLD state. Zeroing puts a stepper
in ARMED state which allows fast movements.


.Raw Movements

+hw+;;
  Stepper to control.
+offset+;;
  Distance and direction to travel.
+speed+;;
+prescale+;;
+done+;;
  Function to be scheduled when done
  Repetitions.

Raw movement bypassing the normal logic and being functional even when there is no
configuration available yet.

The 'prescale' parameter has the greatest effect on speeds and should be used with
uttermost care. The actual values are hardware implementation dependent.

WARNING: wrong use of this functions can damage the hardware.

Raw movements are used to probe stepper configuration and find maximum speeds, acceleration
and deceleration factors.

muos_stepper_move_raw;;
  Moves for 'offset' steps at 'speed', negative values  reverse the direction.


.Calibration Movements

+hw+;;
  Stepper to control.
+offset+;;
  Distance and direction to travel.
+speed+;;
+done+;;
  Function to be scheduled when done

Calibration movement is needs basic machine configuration and is restricted to 'stepper_calspeed'.
This should be used to find end switch positions and zero the axis.


.Relative Movements

+hw+;;
  Stepper to control.
+offset+;;
  Distance and direction to travel.
+speed+;;
+done+;;
  Function to be scheduled when done


.Absolute Movements

+hw+;;
  Stepper to control.
+slope_gen+;;
  Function to be scheduled to generate then next move



.Slope Calculations

Fast movements require a slope for acceleration and deceleration to be prepared.
Such a slope starts at speed_in, accelerates to max_speed (when there is enough
distance to travel), keeps the max_speed for some distance, then decelerates to
speed_out and finally does some 'out_steps' at constant speed_out.

The stepper state itself keeps 2 such slopes internally, one as the active slope for the
current movement the other for preparing a slope in the background for the next move.
When a move completes it swaps buffers and executes the next move. While scheduling
a job to prepare the slope for the next movement.

Besides this 2 internal buffers it is also possible for a user to prepare slope for common
movements which can be copied in place instead recalculating them for every move.


'muos_stepper_slope_get()' returns a handle to the inactive slope buffer for the next move.
This buffer can then be initialized with 'muos_stepper_slope_prep()' or loaded with
an already prepared slope. When done, the buffer needs to be committed to tell the driver
that the slope is ready to use.

'muos_stepper_slope_get()' will return NULL if either the stepper is not in a state >= ARMED or did
not consume the previous slope yet. Zeroing/Arming invalidates the slope buffer and makes it
ready to load new slopes (Those error's wont happen with the slope callback).
When it is not possible to generate new slopes in a timely manner,the stepper driver will
call 'muos_stepper_stop_all()' and error out.

'muos_stepper_slope_prep()' initializes a slope buffer. This calculation is somewhat expensive.
Slope calculation is over a distance to travel, while there is a destination position stored
within the slope structure this gets only be set when the slope is commited or loaded.
+hw+;;
  Stepper for which the slope is.
+slope+;;
  The slope buffer to be initialized.
+distance+;;
  The absolute amounts of steps to travel (direction doesn't matter).
+speed_in+;;
  The starting speed, either less than 'stepper_slowspeed' or the speed the stepper is already
  moving.
+max_speed+;;
  Maximum speed for the fastest part of the slope
+speed_out+;;
  The speed at the end of the slope. must be less than 'stepper_slowspeed' when the slope is not
  followed by another movement in the same direction.
+out_steps+;;
  Steps done at the end at 'speed_out'.


.Actions at Positions

Define actions to take when the stepper reaches a position. These are bit values
which can be or'ed together.

MUOS_STEPPER_ACTION_PERMANENT;;
  Keep the registered action. execute it always again on that position.
MUOS_STEPPER_ACTION_2ND;;
  Exceute the registered action when the stepper hits the position the second time.
  Incompatible with MUOS_STEPPER_ACTION_PERMANENT. Used for backlash compensation.
  Implementation detail: This flag gets deleted on first hit.
MUOS_STEPPER_ACTION_STOP;;
  Immediately stop the stepper at the position.
MUOS_STEPPER_ACTION_SYNC;;
  Together with STOP: stops the stepper and puts it in WAIT state
  Without STOP: wakes all waiting steppers.
MUOS_STEPPER_HPQ_FRONT;;
  Use the provided argument as function to push it to the front of the hpq. This gives the
  highest possible priority.
MUOS_STEPPER_HPQ_BACK;;
  Use the provided argument as function to push it to the back of the hpq.

+hw+;;
  Stepper to address.
+position+;;
  Position which triggers the action.
+action+;;
  Action flags or'ed together.
+arg+;;
  Argument to the action, callback function for the hpq for example.

Register or remove and action to be done when the stepper hits a position.
Action must be at least one or more of the action flags above or'ed together.
Optionally a pointer to a function which gets pushed to the HPQ can be supplied.

Actions can only be registered or removed while the stepper is not moving.

Removing an action needs the exact same arguments as given registering it. Only one
instance gets removed even when the action was registered multiple times.

Returning +muos_success+ when everything worked well or one of the following errors:
+muos_error_nohw+;;
  'hw' out of range.
+muos_error_stepper_state+;;
  Tried to register/remove an action while the steppers are moving.
+muos_error_stepper_noslot+;;
  'register_action':: no more slots free to register an action.
  'remove_action':: no action found with the given parameters.


===== configuration


MUOS_STEPPER::
Enable the Stepper motor driver

MUOS_STEPPER_ACTION_SLOTS::
Number of slots for callback actions per stepper.

MUOS_STEPPER_COUNT::
How many stepper motors.

MUOS_STEPPER_DIR_HW::
Pin used for direction control

MUOS_STEPPER_DIR_NS::
min nanoseconds the direction signal must be ahead of starting pulsing

MUOS_STEPPER_ENABLEALL_INOUT_HW::
Pin used for global enabling/disabling the stepper motors.
Disable is pin LOW, either generated on the mcu or externally pulled down.
Enable is pin as input, externally pulled up.

MUOS_STEPPER_ENABLE_NS::
min nanoseconds the enable signal must be ahead of DIR

MUOS_STEPPER_HW::
Define the type and which hardware (timers) are bound to stepper motors.

MUOS_STEPPER_SLOPE_MULTIPLIER::
Factor to stretch the time for accel/decel.

MUOS_STEPPER_SLOPE_YIELDS::
Number of yields for slope-prep.
Needs MUOS_SCHED_DEPTH

MUOS_STEPPER_SLOPE_YIELDS_ITER::
When set then yield per iteration, otherwise only after
the loops.
Needs MUOS_SCHED_DEPTH

MUOS_STEPPER_STEP_NS::
min nanoseconds for the step pulse signals.

MUOS_STEPPER_UPTABLES::
 Defines which outputs need to be driven for unipolar steppers motor with
 IO pins directly controlling the windings.
 (name, values..)





muos/doc/library.txt:35::
  rename to fqueue

muos/doc/development.txt:13::
  'master' branch will have no open FIXME, TODO

muos/doc/development.txt:14::
  'devel' branch will have no open FIXME

muos/doc/MAIN.pdoc:32::
  note about this documentation, define what terms are used

muos/doc/MAIN.pdoc:50::
  example/howto

muos/doc/MAIN.pdoc:51::
  project structure structure

muos/txqueue.c:39::
  transaction support with commit/abort

muos/txqueue.c:53::
  store index of the last tag, can be used to patch up the tag and append data

muos/txqueue.c:190::
  64 bit support

muos/txqueue.c:654::
  fix overprovisioning again MUOS_CBUFFER_RPOP (muos_txqueue);

muos/serial.c:125::
  muos_serial_tx_avail (void)

muos/serial.c:214::
  muos_serial_rx_avail (void)

muos/sm.c:152::
  intptr_t* muos_queue_reserve(num, init) for reserving elements on a queue (hpq)

muos/muos.c:31::
  stash muos_now_ away on recursive mainloops

muos/muos.c:32::
  make ERRORFN optional

muos/muos.c:33::
  ignoremask for ERRORFN for errors handled elsewhere

muos/muos.c:34::
  instead disabling interrupts have a mutex and temp buffer for work queues

muos/muos.c:35::
  finer locking in mainloop instead interrupt disable, per queue

muos/muos.c:63::
  document and implement

muos/configstore.c:44::
  on the fly

muos/configstore.c:113::
  configstore_revert revert to an earlier config

muos/configstore.c:155::
  later, journaled

muos/configstore.c:211::
  later, journaled

muos/clpq.c:30::
  realtime in interrupt function calls

muos/clpq.c:31::
  sorting before normal functions

muos/clpq.c:32::
  possibly add a small 'boost' (MUOS_CLOCK_LATENCY/2) for sorting them earlier (sorting only)

muos/lineedit.c:38::
  strategy on input errors, desync?

muos/lineedit.c:39::
  full line overflow, because lineedit buffer > txqueue, needs some strategy (blocking_io/atomic_io)

muos/lineedit.c:135::
  history

muos/lineedit.c:154::
  history

muos/lineedit.c:232::
  completion

muos/lineedit.c:244::
  completion

muos/lineedit.c:293::
  completion

muos/io.c:34::
  fixed point for integers and mille delimiters

muos/hw/atmel/avr/stepper.c:36::
  dynamic prescaler change to increase range and resolution

muos/hw/atmel/avr/stepper.c:216::
  see if steppers run smoother when using filtered speed

muos/hw/atmel/avr/stepper.c:433::
  busy loop for very short delays, eventually we need muos function for this

muos/hw/atmel/avr/stepper.c:434::
  only delay when direction was changed

muos/hw/atmel/avr/stepper.c:457::
  abstract F_CPU for timers running on other clock sources

muos/hw/atmel/avr/eeprom.c:103::
  batching?

muos/hw/atmel/avr/eeprom.c:138::
  implement batching

muos/hw/atmel/avr/debug.c:26::
  generic macros -> muos.h INPUT, OUTPUT, PULLUP, PULLDOWN, NOP

muos/hw/atmel/avr/serial.c:102::
  sync when line is idle

muos/hw/atmel/avr/cppm.c:56::
  compile time check that hwclock and icp match

muos/hw/atmel/avr/cppm.c:118::
  pcint implementation

muos/io.h:29::
  #define MUOS_IO .. if undefined then avr-libc stdio, check size requirement if it makes sense

muos/io.h:87::
   OUTPUTFN(commit) /* */

muos/io.h:88::
   OUTPUTFN(abort) /* */

muos/io.h:89::
   OUTPUTFN(commitnl) /* */

muos/io.h:92::
   OUTPUTFN(float_R) /* */

muos/io.h:93::
   OUTPUTFN(ifmt, uint8_t, uint8_t) /* */

muos/io.h:94::
   OUTPUTFN(ffmt, char) /* */

muos/io.h:95::
   OUTPUTFN(pifmt, uint8_t, uint8_t) /* */

muos/io.h:96::
   OUTPUTFN(pffmt, char) /* */

muos/io.h:97::
   OUTPUTFN(ctrl, uint8_t, uint8_t, uint8_t) /* */

muos/clock.h:28::
  dont inline clock functions

muos/clock.h:30::
  macros compensating drift over long timespans; using rationals thereof

muos/clock.h:32::
  make it possible to configure muos w/o a clock

muos/serial.h:30::
  lowwater/highwater generic

muos/serial.h:105::
  muos_cbuffer_index muos_serial_tx_avail (void);

muos/serial.h:177::
  muos_cbuffer_index muos_serial_rx_avail (void);

muos/configstore.h:53::
  interleaved/wraparound configstore

muos/stepper.h:36::
  budget/cost for each movement

muos/stepper.h:53::
  axis length/limit switches

muos/stepper.h:237::
  api for braking to stop

muos/stepper.h:402::
  use out_steps of slope, no extra state

muos/stepper.h:576::
    MUOS_STEPPER_MERGE = (1<<7),

muos/stepper.h:622::
  muos_stepper_remove_all_actions(hw)

muos/error.h:127::
  do we need a muos_error_again in case a error was already set?

muos/sm.h:240::
  state change callback

muos/muos.h:127::
  add priority, which queues to schedule

muos/eeprom.h:37::
  MUOS_EEPROM_READ_BLOCKING,           // eeprom -> memory blocking read

muos/eeprom.h:47::
  MUOS_EEPROM_REFRESH,          // eeprom <- eeprom, read, erase, write to refresh content

muos/eeprom.h:51::
  MUOS_EEPROM_ERASESECURE,       // eeprom <- ^eeprom, eeprom <- 0x00, erase, secure erase (equivalent wear)

muos/eeprom.h:56::
  MUOS_EEPROM_CRC8,       // crc8 over the given range

muos/eeprom.h:322::
  query current position (ram? eeprom?)

muos/hw/atmel/avr/attiny85.h:69::
  proper shutdown, needs user definition and/or weak symbol or hook

muos/hw/atmel/avr/avr.h:49::
  cleanup macros when to use arguments, when tuple

muos/hw/atmel/avr/avr.h:51::
  HW() for all hardware specific stuff (s. Makefile)

muos/hw/atmel/avr/avr.h:53::
  generic macros -> muos.h INPUT, OUTPUT, PULLUP, PULLDOWN, NOP, ANALOG

muos/hw/atmel/avr/avr.h:59::
  also GPIO_SET for input states (config + set)

Makefile:21::
  branch a 'tests' from example with permanent test code/suite +
  _tidy up the example code_ +
  Christian Thäter Mon Nov 19 14:25:00 2018 +
  +82c6b3749fa966593e04423a0bb6ddef5c439032+

muos/muos.mk:104::
  make a complete header? not including drivers from muos.c

muos/prg_micronucleus.mk:21::
  generate images in another target specific makefile?