v1.08

• Timers API changed: now, timer callback TN_TimerFunc is called
  with global interrupts enabled.
• Fix for pic24/dspic: previously, initial value of PSVPAG for new tasks
  was always 0, but it is not necessarily the case. This might cause troubles
  with constants in program space. Now, when initializing stack for new task,
  current value of PSVPAG is used.
• Fixed round robin:
  • Even though the tasks were flipped in the runnable tasks queue, the
    actual context switch wasn't performed;
  • Tasks were switched with a requested period + 1 tick.
• Added an option TN_FORCED_INLINE
• Added an option TN_MAX_INLINE

v1.07

• Fix: project was unable to build with TN_CHECK_PARAM set to 0
• Fix: Cortex-M0/M0+ port didn't work if there is some on-context-switch
  handler (TN_PROFILER or TN_STACK_OVERFLOW_CHECK)
• Added support of C++ compiler (experimental)
• Added an option TN_INIT_INTERRUPT_STACK_SPACE
• Added services to get count of free and used memory blocks
  (tn_fmem_free_blocks_cnt_get() / tn_fmem_used_blocks_cnt_get()) and
  items in the queue (tn_queue_free_items_cnt_get() /
  tn_queue_used_items_cnt_get()).
• Removed some checks from tn_tick_int_processing(), since they aren't too
  useful there, but they add overhead (See
  bitbucket issue #2
  )
• Added functions for disabling/enabling scheduler: tn_sched_dis_save() /
  tn_sched_restore().
• Id fields of objects (enum TN_ObjId) are moved to the beginning of
  object structures, to make memory corruptions detected earlier.
• Idle task is now created with name "Idle" specified.

v1.06

• Cortex-M0/M0+/M1/M3/M4/M4F architectures are now supported.

  • The following compilers are tested:
    • ARMCC (Keil RealView)
    • GCC
  • Should work but not tested carefully:
    • clang
    • IAR

• Software task stack overflow check (optionally), see
  TN_STACK_OVERFLOW_CHECK for details.

• Dynamic tick, or tickless (optionally): refer to the page \ref time_ticks for details.

• Profiler (optionally): allows to see how much time task was running, how much
  time it was waiting and for what it was waiting, and so on. Refer to the
  documentation of struct TN_TaskTiming for details.

• Old TNKernel events compatibility mode, see TN_OLD_EVENT_API for
  details.

• Event groups: added TN_EVENTGRP_WMODE_AUTOCLR flag which allows to
  clear event bits atomically when task successfully finishes waiting for
  these event bits.

• PIC24/dsPIC: little optimization: ffs (find-first-set bit) is implemented
  in an efficient PIC24/dsPIC-specific way, so finding next task to run
  now works a bit faster.

• Added run-time check which ensures that build-time options for the kernel
  match ones for the application. For details, refer to the option
  TN_CHECK_BUILD_CFG. Note: in your existing project that uses
  TNeo as a separate library, you need either:

  • Include the file <tneo_path>/src/tn_app_check.c to the
    application project (recommended);
  • In your tn_cfg.h file, set TN_CHECK_BUILD_CFG to 0 and rebuild
    the kernel with the new configuration (not recommended).

  But if you build TNeo together with the application, this option
  is useless, so then just set TN_CHECK_BUILD_CFG to 0.

• MPLABX projects for PIC32 and PIC24/dsPIC moved to lib_project
  directory. If you use these library projects from the repository
  directly in your application, you need to modify path to the library
  project in your application project.

• The project's name is shortened to TNeo.

v1.04

• Added PIC24/dsPIC support;
• PIC32: Core Software Interrupt is now handled by the kernel completely,
  application shouldn't set it up anymore. Refer to the page \ref
  pic32_details.
• Refactor: the following symbols: NULL, BOOL, TRUE, FALSE now have
  the TN_ prefix: TN_NULL, TN_BOOL, TN_TRUE, TN_FALSE. This is
  because non-prefixed symbols may be defined by some other program module,
  which leads to conflicts. The easiest and robust way is to add unique
  prefix.
• Refactor: PIC32 MPLABX project renamed from tneo.X to
  tneo_pic32.X.
• Refactor: PIC32 ISR macros renamed: tn_soft_isr() ->
  tn_p32_soft_isr(), tn_srs_isr() -> tn_p32_srs_isr(). It is much
  easier to maintain documentation for different macros if they have
  different names; more, the signature of these macros is
  architecture-dependent. Old names are also available for backward
  compatibility.

v1.03

• Added a capability to connect an event group to other
  system objects, particularly to the data queue. This offers a
  way to wait for messages from multiple queues with just a single system
  call. Example
  project that demonstrates that technique is also available:
  examples/queue_eventgrp_conn.
• PIC32 Interrupts: this isn't a mandatory anymore to use kernel-provided macros
  tn_p32_soft_isr() or tn_p32_srs_isr(): interrupts can be defined with standard
  way too: this particular ISR will use task's stack instead of interrupt
  stack, therefore it takes much more RAM and works a bit faster. There are
  no additional constraints on ISR defined without kernel-provided macro: in
  either ISR, you can call the same set of kernel services. Refer
  to the page \ref interrupts for details.
• Priority 0 is now allowed to use by application (in the original TNKernel,
  it was reserved for the timer task, but TNeo does not have timer task)
• Application is now available to specify how many priority levels does it
  need, it helps to save a bit of RAM. See
  TN_PRIORITIES_CNT.
• Added example project examples/queue that demonstrates the pattern on
  how to use data queue together with fixed memory pool effectively.

v1.02

• Added timers: kernel objects that are used to ask the
  kernel to call some user-provided function at a particular time in the
  future;
• Removed tn_sys_time_set() function, because now TNeo uses internal
  system tick count for timers, and modifying system tick counter by user
  is a really bad idea.

v1.01

• FIX: tn_queue_receive() and tn_fmem_get() : if non-zero timeout
  is in effect, then TN_RC_TIMEOUT is returned, but user-provided pointer
  is altered anyway (some garbage data is written there). This bug was
  inherited from TNKernel.
• Added tn_task_state_get()
• tn_sem_acquire() and friends are renamed to tn_sem_wait() and friends.
  More on this read \ref tnkernel_diff_api_rename_sem "here".
  Old name is still available through tn_oldsymbols.h.

v1.0

• Initial stable version of TNeo. Lots of work done: thorough review
  and re-implementation of TNKernel 2.7, implemented detailed unit tests, and
  so on.