Current development version (BETA)

no changes yet

v1.09

Release date: 2024-12-28

Most of the changes are various bugfixes provided by the community. Thanks a lot guys, I really appreciate the time and effort you spent on making this project better!

Fix: at least on ARM Cortex-M7, and probably also on M3, M4 and some other ARMs, sometimes the context switch did not happen in time, and it was causing issues in e.g. tn_eventgrp_wait, where the waiting result was wrong. Thanks to Anatol Shiro for identifying and fixing this bug;
Fix: when the system is recovering from a deadlock (when one of the tasks stopped waiting after a timeout), the kernel was stuck in an endless loop. Thanks to Travis Griggs for identifying and fixing this bug, as part of his effort to implement an even better set of tests for TNeo;
Fix: when creating a higher-priority task from a lower-priority task, and the TN_TASK_CREATE_OPT_START flag was set, the kernel should switch context to the new task right away, but it wasn't happening. Again, thanks to Travis Griggs for this fix;
Fix: the project was unable to build for 64-bit platforms where unsigned long int and int have different sizes. Thanks to alecoding for the fix;
Fix: the project was unable to build without #TN_USE_MUTEXES or #TN_MUTEX_DEADLOCK_DETECT;
Added support of -pedantic mode for Cortex-M architectures.

v1.08

Release date: 2017-02-25

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

Release date: 2015-03-17

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

Release date: 2015-01-02.

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 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

Release date: 2014-11-04.

Added PIC24/dsPIC support, refer to the page PIC24/dsPIC port details;
PIC32: Core Software Interrupt is now handled by the kernel completely, application shouldn't set it up anymore. Refer to the page PIC32 port 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

Release date: 2014-10-20.

Added a capability to connect an event group to other system objects, particularly to the queue. This offers a way to wait for messages from multiple queues with just a single system call. Refer to the section Connecting an event group to other system objects for details. 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 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 for, it helps to save a bit of RAM. For details, refer to #TN_PRIORITIES_CNT.
Added example project examples/queue that demonstrates the pattern on how to use queue together with fixed memory pool effectively.

v1.02

Release date: 2014-10-14.

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

Release date: 2014-10-09.

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 here. Old name is still available through tn_oldsymbols.h.

v1.0

Release date: 2014-10-01.

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.

Table of Contents