forked from FreeRTOS/FreeRTOS
/
History.txt
2894 lines (2432 loc) · 142 KB
/
History.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
Documentation and download available at https://www.FreeRTOS.org/
Changes between FreeRTOS 202112.00 and FreeRTOS 202212.00 released December 2022
+ Released LTS 2.0 versions of FreeRTOS Kernel, FreeRTOS+TCP, coreMQTT, corePKCS11,
coreHTTP, coreJSON, AWS IoT Over-the-air-Updates (OTA), AWS IoT Device Shadow, AWS IoT Jobs,
AWS IoT Device Defender, Backoff Algorithm, AWS IoT Fleet Provisioning, coreSNTP,
SigV4, and FreeRTOS Cellular Interface libraries
- FreeRTOS Kernel V10.5.1
- FreeRTOS+TCP V3.1.0
- coreMQTT v2.1.1
- corePKCS11 v3.5.0
- coreJSON v3.2.0
- AWS IoT Over-the-air (OTA) Update v3.4.0
- AWS IoT Device Shadow v1.3.0
- AWS IoT Jobs v1.3.0
- AWS IoT Device Defender v1.3.0
- Backoff Algorithm v1.3.0
- AWS IoT Fleet Provisioning v1.1.0
- coreSNTP v1.2.0
- SigV4 v1.2.0
- FreeRTOS Cellular Interface v1.3.0
+ Updated coreMQTT Agent library to v1.2.0 to be compatible with coreMQTT v2.X.X.
+ Demo Updates
- Added Visual Studio static library projects for FreeRTOS Kernel, FreeRTOS+TCP,
Logging, MbedTLS, coreHTTP, and corePKCS11 in FreeRTOS-Plus/VisualStudio_StaticProjects.
- All demos dependent on coreMQTT have been updated to be compatible with coreMQTT v2.X.X.
- All Windows Simulator projects have been updated to use new static Visual Studio projects.
+ Updated MbedTLS version to 3.2.1.
Changes between FreeRTOS 202111.00 and FreeRTOS 202112.00 released December 2021
+ Added Fleet Provisioning library and demo showcasing the use of Fleet Provisioning library.
+ Added Sigv4 library and updated HTTP S3 download demo to showcase its use.
+ Added CBMC proofs for all public and private functions in the OTA Update library
+ Updated mbed TLS version used by corePKCS11 to v2.28.0
Changes between FreeRTOS 202107.00 and FreeRTOS 202111.00 released November 2021
+ Add Cellular library and demo showcasing use of Cellular library.
+ Add demo project for [PolarFire SoC FPGA Icicle Kit](https://www.microsemi.com/existing-parts/parts/152514).
Changes between FreeRTOS 202104.00 and FreeRTOS 202107.00 released July 2021
+ Release coreSNTP v1.0.0, a client library for SNTP communication.
+ Add demo showcasing use of coreSNTP library to setup SNTP client for
synchronizing demo system time with time servers.
+ Demo Updates
- Update Device Shadow demo to use Named Shadow feature.
Changes between FreeRTOS 202012.00 and FreeRTOS 202104.00 released April 2021
+ Released LTS versions of AWS IoT Device Defender, AWS IoT Jobs and
AWS IoT Over-the-air-Updates (OTA) libraries
- AWS IoT Device Defender v1.1.0
- AWS IoT Jobs v1.1.0
- AWS IoT Over-the-air (OTA) Update v3.0.0
+ Added new coreMQTT Agent library.
+ Demo Updates
- Add basic publish-subscribe demo for coreMQTT Agent library.
- For examples of using coreMQTT Agent library to communicate with
multiple AWS IoT services from different tasks using a shared
MQTT connection, refer to https://github.com/FreeRTOS/coreMQTT-Agent-Demos
- OTA demo over MQTT
- OTA demo over HTTP
- Added custom metrics to AWS Device Defender demo.
Changes between FreeRTOS 202011.00 and FreeRTOS 202012.00 released December 2020
+ Includes libraries that are part of the FreeRTOS 202012.00 LTS release.
- Learn more at https:/freertos.org/lts-libraries.html
+ Networking support for QEMU MPS2
+ Demo Updates
- AWS IoT Jobs Library
- AWS Device Defender
- HTTP Mutual Auth
- HTTP Plaintext
- UDP for FreeRTOS+TCP
- S3 Upload & Download
Changes between FreeRTOS V10.4.1 and FreeRTOS 202011.00 released November 10 2020
+ Added new coreJSON Library. See https://www.freertos.org/json/
+ Added new coreMQTT Library. See https://www.freertos.org/mqtt/
+ Added new corePKCS11 Library. See https://www.freertos.org/pkcs11/
+ Added new AWS IoT Device Shadow Library. See
https://www.freertos.org/iot-device-shadow/
+ Updated to FreeRTOS Kernel v10.4.2. See
https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/master/History.txt
+ Updated to FreeRTOS+TCP v2.3.1. See
https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/master/History.txt
+ Update WolfSSL to 4.5.0 and add the WolfSSL FIPS ready demo.
+ Convert most dependent libraries to Git submodules.
+ Various general maintenance and improvements.
Changes between FreeRTOS V10.4.0 and FreeRTOS V10.4.1 released September 17 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
+ Fixed an incorrectly named parameter that prevented the
ulTaskNotifyTakeIndexed macro compiling, and the name space clash in the
test code that prevented this error causing test failures.
Changes between FreeRTOS V10.3.1 and FreeRTOS V10.4.0 released September 10 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
Major enhancements:
+ Task notifications: Prior to FreeRTOS V10.4.0 each created task had a
single direct to task notification. From FreeRTOS V10.4.0 each task has
an array of notifications. The direct to task notification API has been
extended with API functions postfixed with "Indexed" to enable the API to
operate on a task notification at any array index. See
https://www.freertos.org/RTOS-task-notifications.html for more information.
+ Kernel ports that support memory protection units (MPUs): The ARMv7-M and
ARMv8-M MPU ports now support a privilege access only heap. The ARMv7-M
MPU ports now support devices that have 16 MPU regions, have the ability
to override default memory attributes for privileged code and data
regions, and have the ability to place the FreeRTOS kernel code outside of
the Flash memory. The ARMv8-M MPU ports now support tickless idle mode.
See https://www.freertos.org/FreeRTOS-MPU-memory-protection-unit.html
for more information.
Additional noteworthy updates:
+ Code formatting is now automated to facilitate the increase in
collaborative development in Git. The auto-formated code is not identical
to the original formatting conventions. Most notably spaces are now used
in place of tabs.
+ The prototypes for callback functions (those that start with "Application",
such as vApplicationStackOverflowHook()) are now in the FreeRTOS header
files, removing the need for application writers to add prototypes into
the C files in which they define the functions.
+ New Renesas RXv3 port layer.
+ Updates to the Synopsys ARC code, including support for EM and HS cores,
and updated BSP.
+ Added new POSIX port layer that allows FreeRTOS to run on Linux hosts in
the same way the Windows port layer enables FreeRTOS to run on Windows
hosts.
+ Many other minor optimisations and enhancements. For full details
see https://github.com/FreeRTOS/FreeRTOS-Kernel/commits/master
Changes between FreeRTOS V10.3.0 and FreeRTOS V10.3.1 released February 18 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.3.x.html
+ ./FreeRTOS-Labs directory was removed from this file. The libraries it
contained are now available as a separate download.
Changes between FreeRTOS V10.2.1 and FreeRTOS V10.3.0 released February 7 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.3.x.html
New and updated kernel ports:
+ Added RISC-V port for the IAR compiler.
+ Update the Windows simulator port to use a synchronous object to prevent
a user reported error whereby a task continues to run for a short time
after being moved to the Blocked state. Note we were not able to
replicate the reported issue and it likely depends on your CPU model.
+ Correct alignment of stack top in RISC-V port when
configISR_STACK_SIZE_WORDS is defined to a non zero value, which causes
the interrupt stack to be statically allocated.
+ The RISC-V machine timer compare register can now be for any HART, whereas
previously it was always assumed FreeRTOS was running on HART 0.
+ Update the sequence used to update the 64-bit machine timer
compare register on 32-bit cores to match that suggested in RISC-V
documentation.
+ Added tickless low power modes into the ARM, IAR and GCC Cortex-M0 compiler
ports.
+ Updated the behaviour of the ARMv7-M MPU (Memory Protection Unit) ports to
match that of the ARMv8-M ports whereby privilege escalations can only
originate from within the kernel's own memory segment. Added
configENFORCE_SYSTEM_CALLS_FROM_KERNEL_ONLY configuration constant.
+ Update existing MPU ports to correctly disable the MPU before it is
updated.
+ Added contributed port and demo application for a T-Head (formally C-SKY)
microcontroller.
New API functions:
+ Added the vPortGetHeapStats() API function which returns information on
the heap_4 and heap_5 state.
+ Added xTaskCatchUpTicks(), which corrects the tick count value after the
application code has held interrupts disabled for an extended period.
+ Added xTaskNotifyValueClear() API function.
+ Added uxTimerGetReloadMode() API function.
Other miscellaneous changes:
+ Change type of uxPendedTicks from UBaseType_t to TickType_t to ensure it
has the same type as variables with which it is compared to, and therefore
also renamed the variable xPendingTicks.
+ Update Keil projects that use the MPU so memory regions come from linker
script (scatter file) variables instead of being hard coded.
+ Added LPC51U68 Cortex-M0+ demos for GCC (MCUXpresso), Keil and IAR
compilers.
+ Added CORTEX_MPU_STM32L4_Discovery_Keil_STM32Cube demo.
+ Added LPC54018 MPU demo.
+ Rename xTaskGetIdleRunTimeCounter() to ulTaskGetIdleRunTimeCounter().
Changes between FreeRTOS V10.2.1 and FreeRTOS V10.2.0 released May 13 2019:
+ Added ARM Cortex-M23 port layer to complement the pre-existing ARM
Cortex-M33 port layer.
+ The RISC-V port now automatically switches between 32-bit and 64-bit
cores.
+ Introduced the portMEMORY_BARRIER macro to prevent instruction re-ordering
when GCC link time optimisation is used.
+ Introduced the portDONT_DISCARD macro to the ARMv8-M ports to try and
prevent the secure side builds from removing symbols required by the
non secure side build.
+ Introduced the portARCH_NAME to provide additional data to select semi-
automated build environments.
+ Cortex-M33 and Cortex-M23 ports now correctly disable the MPU before
updating the MPU registers.
+ Added Nuvoton NuMaker-PFM-M2351 ARM Cortex-M23 demo.
+ Added LPC55S69 ARM Cortex-M33 demo.
+ Added an STM32 dual core AMP stress test demo.
Changes between FreeRTOS V10.1.1 and FreeRTOS V10.2.0 released February 25 2019:
+ Added GCC RISC-V MCU port with three separate demo applications.
+ Included pre-existing ARM Cortex-M33 (ARMv8-M) GCC/ARMclang and IAR ports
with Keil simulator demo.
+ Update the method used to detect if a timer is active. Previously the
timer was deemed to be inactive if it was not referenced from a list.
However, when a timer is updated it is temporarily removed from, then
re-added to a list, so now the timer's active status is stored separately.
+ Add vTimerSetReloadMode(), xTaskGetIdleRunTimeCounter(), and
xTaskGetApplicationTaskTagFromISR() API functions.
+ Updated third party Xtensa port so it is MIT licensed.
+ Added configINCLUDE_PLATFORM_H_INSTEAD_OF_IODEFINE_H to the Renesas
compiler RX600v2 port to enable switching between platform.h and
iodefine.h includes within that port's port.c file.
+ Removed the 'FromISR' functions from the MPU ports as ISRs run privileged
anyway.
+ Added uxTaskGetStackHighWaterMark2() function to enable the return type to
be changed without breaking backward compatibility.
uxTaskGetStackHighWaterMark() returns a UBaseType_t as always,
uxTaskGetStackHighWaterMark2() returns configSTACK_DEPTH_TYPE to allow the
user to determine the return type.
+ Fixed issues in memory protected ports related to different combinations
of static memory only and dynamic memory only builds. As a result the
definition of tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE became more
complex and was moved to FreeRTOS.h with a table explaining its definition.
+ Added a 'get task tag from ISR' function.
+ Change the method used to determine if a timer is active or not from just
seeing if it is referenced from the active timer list to storing its
active state explicitly. The change prevents the timer reporting that it
is inactive while it is being moved from one list to another.
+ The pcName parameter passed into the task create functions can be NULL,
previously a name had to be provided.
+ When using tickless idle, prvResetNextTaskUnblockTime() is now only called
in xTaskRemoveFromEventList() if the scheduler is not suspended.
+ Introduced portHAS_STACK_OVERFLOW_CHECKING, which should be set to 1 for
FreeRTOS ports that run on architectures that have stack limit registers.
Changes between FreeRTOS V10.1.0 and FreeRTOS V10.1.1 released 7 September 2018
+ Reverted a few structure name changes that broke several kernel aware
debugger plug-ins.
+ Updated to the latest trace recorder code.
+ Fixed some formatting in the FreeRTOS+TCP TCP/IP stack code.
+ Reverted moving some variables from file to function scope as doing so
broke debug scenarios that require the static qualifier to be removed.
Changes between FreeRTOS V10.0.1 and FreeRTOS V10.1.0 released 22 August 2018
FreeRTOS Kernel Changes:
+ Update lint checked MISRA compliance to use the latest MISRA standard, was
previously using the original MISRA standard.
+ Updated all object handles (TaskHandle_t, QueueHandle_t, etc.) to be
unique types instead of void pointers, improving type safety. (this was
attempted some years back but had to be backed out due to bugs in some
debuggers). Note this required the pvContainer member of a ListItem_t
struct to be renamed - set configENABLE_BACKWARD_COMPATIBILITY to 1 if
this causes an issue.
+ Added configUSE_POSIX_ERRNO to enable per task POSIX style errno
functionality in a more user friendly way - previously the generic thread
local storage feature was used for this purpose.
+ Added Xtensa port and demo application for the XCC compiler.
+ Changed the implementation of vPortEndScheduler() for the Win32 port to
simply call exit( 0 ).
+ Bug fix in vPortEnableInterrupt() for the GCC Microblaze port to protect
the read modify write access to an internal Microblaze register.
+ Fix minor niggles when the MPU is used with regards to prototype
differences, static struct size differences, etc.
+ The usStackHighWaterMark member of the TaskStatus_t structure now has type
configSTACK_DEPTH_TYPE in place of uint16_t - that change should have been
made when the configSTACK_DEPTH_TYPE type (which gets around the previous
16-bit limit on stack size specifications) was introduced.
+ Added the xMessageBufferNextLengthBytes() API function and likewise stream
buffer equivalent.
+ Introduce configMESSAGE_BUFFER_LENGTH_TYPE to allow the number of bytes
used to hold the length of a message in the message buffer to be reduced.
configMESSAGE_BUFFER_LENGTH_TYPE default to size_t, but if, for example,
messages can never be more than 255 bytes it could be set to uint8_t,
saving 3 bytes each time a message is written into the message buffer
(assuming sizeof( size_t ) is 4).
+ Updated the StaticTimer_t structure to ensure it matches the size of the
Timer_t structure when the size of TaskFunction_t does not equal the size
of void *.
+ Update various Xilinx demos to use 2018.1 version of the SDK tools.
+ Various updates to demo tasks to maintain test coverage.
+ FreeRTOS+UDP was removed in FreeRTOS V10.1.0 as it was replaced by
FreeRTOS+TCP, which was brought into the main download in FreeRTOS
V10.0.0. FreeRTOS+TCP can be configured as a UDP only stack, and
FreeRTOS+UDP does not contain the patches applied to FreeRTOS+TCP.
FreeRTOS+TCP Changes:
+ Multiple security improvements and fixes in packet parsing routines, DNS
caching, and TCP sequence number and ID generation.
+ Disable NBNS and LLMNR by default.
+ Add TCP hang protection by default.
We thank Ori Karliner of Zimperium zLabs Team for reporting these issues.
Changes between FreeRTOS V10.0.0 and FreeRTOS V10.0.1, released December 20 2017
+ Fix position of "#if defined( __cplusplus )" in stream_buffer.h.
+ Correct declarations of MPU_xQueuePeek() and MPU_xQueueSemaphoreTake() in
mpu_prototypes.h.
+ Correct formatting in vTaskList() helper function when it prints the state
of the currently executing task.
+ Introduce #error if stream_buffer.c is built without
configUSE_TASK_NOTIFICATIONS set to 1.
+ Update FreeRTOS+TCP to V2.0.0
- Improve the formatting of text that displays the available netword
interfaces when FreeRTOS+TCP is used on Windows with WinPCap.
- Introduce ipconfigSOCKET_HAS_USER_WAKE_CALLBACK option to enable a user
definable callback to execute when data arrives on a socket.
Changes between FreeRTOS V9.0.1 and FreeRTOS V10.0.0:
The FreeRTOS kernel is now MIT licensed: https://www.FreeRTOS.org/license
New Features and components:
+ Stream Buffers - see https://www.FreeRTOS.org/RTOS-stream-buffer-example.html
+ Message Buffers - see https://www.FreeRTOS.org//RTOS-message-buffer-example.html
+ Move FreeRTOS+TCP into the main repository, along with the basic Win32
TCP demo FreeRTOS_Plus_TCP_Minimal_Windows_Simulator.
New ports or demos:
+ Added demo for TI SimpleLink CC3220 MCU.
+ Added MPU and non MPU projects for Microchip CEC and MEC 17xx and 51xx
MCUs.
+ Added CORTEX_MPU_Static_Simulator_Keil_GCC demo to test static allocation
in the MPU port.
Fixes or enhancements:
+ Cortex-M ports push additional register prior to calling
vTaskSwitchContext to ensure 8-byte alignment is maintained. Only
important if a user defined tick hook function performs an operation that
requires 8-byte alignment.
+ Optimisations to the implementation of the standard tickless idle mode on
Cortex-M devices.
+ Improvements to the Win32 port including using higher priority threads.
+ Ensure interrupt stack alignment on PIC32 ports.
+ Updated GCC TriCore port to build with later compiler versions.
+ Update mpu_wrappers.c to support static allocation.
+ The uxNumberOfItems member of List_t is now volatile - solving an issue
when the IAR compiler was used with maximum optimization.
+ Introduced configRECORD_STACK_HIGH_ADDRESS. When set to 1 the stack start
address is saved into each task's TCB (assuming stack grows down).
+ Introduced configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H to allow user defined
functionality, and user defined initialisation, to be added to FreeRTOS's
tasks.c source file. When configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H is
set to 1 a user provided header file called freertos_task_c_additions.h
will be included at the bottom of tasks.c. Functions defined in that
header file can call freertos_tasks_c_additions_init(), which in turn
calls a macro called FREERTOS_TASKS_C_ADDITIONS_INIT(), if it is defined.
FREERTOS_TASKS_C_ADDITIONS_INIT() can be defined in FreeRTOSConfig.h.
+ Introduced configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING( x ) which can be
defined by a user in FreeRTOSConfig.h. The macro is called before
assessing whether to enter tickless idle mode or not. If the macro sets
x to zero then tickless idle mode will not be entered. This allows users
to abort tickless idle mode entry before the tickless idle function is
even called - previously it was only possible to abort from within the
tickless idle function itself.
+ Added configPRINTF(), which can be defined by users to allow all libraries
to use the same print formatter.
+ Introduced configMAX() and configMIN() macros which default to standard
max( x, y ) and min( x, y ) macro behaviour, but can be overridden if the
application writer defines the same macros in FreeRTOSConfig.h.
+ Corrected the definition of StaticTask_t in the case where
INCLUDE_xTaskAbortDelay is set to 1.
+ Introduced configTIMER_SERVICE_TASK_NAME and configIDLE_TASK_NAME, both of
which can be defined to strings in FreeRTOSConfig.h to change the default
names of the timer service and idle tasks respectively.
+ Only fill the stack of a newly created task with a known value if stack
checking, or high water mark checking/viewing, is in use - removing the
dependency on memset() in other cases.
+ Introduced xTaskCreateRestrictedStatic() so static allocation can be used
with the MPU.
+ Ensure suspended tasks cannot be unsuspended by a received task
notification.
+ Fix race condition in vTaskSetTimeOutState().
+ Updated trace recorder files to the latest version.
Changes since FreeRTOS V9.0.0:
+ Priority dis-inheritance behaviour has been enhanced in the case where a
task that attempted to take a mutex that was held by a lower priority task
timed out before it was able to obtain the mutex (causing the task that
holds the mutex to have its priority raised, then lowered again, in
accordance with the priority inheritance protocol).
+ Split the overloaded xQueueGenericReceive() function into three separate
dedicated functions.
+ Allow the default human readable text names given to the Idle and Timer
tasks to be overridden by defining the configIDLE_TASK_NAME and
configTIMER_SERVICE_TASK_NAME definitions respectively in FreeRTOSConfig.h.
+ Introduced configINITIAL_TICK_COUNT to allow the tick count to take a
value of than than 0 when the system boots. This can be useful for
testing purposes - although setting configUSE_16_BIT_TICKS to 1 can also
be used to test frequent tick overflows.
+ Ensure the Cortex-M SysTick count is cleared to zero before starting the
first task.
+ Add configASSERT() into ARM Cortex-M ports to check the number of priority
bit settings.
+ Clear the 'control' register before starting ARM Cortex-M4F ports in case
the FPU is used before the scheduler is started. This just saves a few
bytes on the main stack as it prevents space being left for a later save
of FPU registers.
+ Added xSemaphoreGetMutexHolderFromISR().
+ Corrected use of portNVIC_PENDSVSET to portNVIC_PENDSVSET_BIT in MPU ports.
+ Introduced configSTACK_DEPTH_TYPE to allow users to change the type used
to specify the stack size when using xTaskCreate(). For historic reasons,
when FreeRTOS was only used on small MCUs, the type was set to uint16_t,
but that can be too restrictive when FreeRTOS is used on larger
processors. configSTACK_DEPTH_TYPE defaults to uint16_t.
xTaskCreateStatic(), being a newer function, used a uint32_t.
+ Increase the priority of the Windows threads used by the Win32 port. As
all the threads run on the same core, and the threads run with very high
priority, there is a risk that the host will become unresponsive, so also
prevent the Windows port executing on single core hosts.
Changes between FreeRTOS V9.0.0 and FreeRTOS V9.0.0rc2 released May 25 2016:
See https://www.FreeRTOS.org/FreeRTOS-V9.html
RTOS kernel updates:
+ The prototype of the new xTaskCreateStatic() API function was modified to
remove a parameter and improve compatibility with other new
"CreateStatic()" API functions. The stack size parameter in
xTaskCreateStatic() is now uint32_t, which changes the prototype of the
callback functions. See the following URL:
https://www.FreeRTOS.org/xTaskCreateStatic.html
+ GCC ARM Cortex-A port: Introduced the configUSE_TASK_FPU_SUPPORT
constant. When configUSE_TASK_FPU_SUPPORT is set to 2 every task is
automatically given a floating point (FPU) context.
+ GCC ARM Cortex-A port: It is now possible to automatically save and
restore all floating point (FPU) registers on entry to each potentially
nested interrupt by defining vApplicationFPUSafeIRQHandler() instead of
vApplicationIRQHandler().
+ All ARM Cortex-M3/4F/7 ports: Clear the least significant bit of the task
entry address placed onto the stack of a task when the task is created for
strict compliance with the ARM Cortex-M3/4/7 architecture documentation
(no noticeable effect unless using the QMEU emulator).
+ Added GCC and Keil ARM Cortex-M4F MPU ports - previously the MPU was only
supported on ARM Cortex-M3.
+ ARM Cortex-M3/4F MPU ports: Update to fully support the FreeRTOS V9.0.0
API (other than static object creation) and added the
FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC demo application to
demonstrate how to use the updated MPU port.
+ All ARM Cortex-M3/4F/7 ports: Add additional barrier instructions to the
default low power tickless implementation.
+ All ARM Cortex-M0 ports: Prevent an item being left on the stack of the
first task that executes.
+ Win32 ports: Reduce the amount of stack used and change the way Windows
threads are deleted to increase the maximum execution time.
+ Add an ARM Cortex-M4F port for the MikroC compiler. Ensure to read the
documentation page for this port before use.
+ MPS430X IAR port: Update to be compatible with the latest EW430 tools
release.
+ IAR32 GCC port: Correct vPortExitCritical() when
configMAX_API_CALL_INTERRUPT_PRIORITY == portMAX_PRIORITY.
+ For consistency vTaskGetTaskInfo() now has the alias vTaskGetInfo(),
xTaskGetTaskHandle() now has the alias xTaskGetHandle() and
pcQueueGetQueueName() now has an alias pcQueueGetName().
+ Fix various errors in comments and compiler warnings.
Demo application updates:
+ Update Atmel Studio projects to use Atmel Studio 7.
+ Update Xilinx SDK projects to use the 2016.1 version of the SDK.
+ Remove dependency on legacy IO libraries from the PIC32 demos.
+ Move the Xilinx UltraScale Cortex-R5 demo into the main distribution.
+ Update the MSP432 libraries to the latest version.
+ Add Microchip CEC1302 (ARM Cortex-M4F) demos for GCC, Keil and MikroC
compilers.
+ Move the Atmel SAMA5D2 demo into the main distribution.
Changes between FreeRTOS V9.0.0rc1 and FreeRTOS V9.0.0rc2 (release candidate 2)
released March 30 2016:
NOTE - See https://www.FreeRTOS.org/FreeRTOS-V9.html for details
+ The functions that create RTOS objects using static memory allocation have
been simplified and will not revert to using dynamic allocation if a
buffer is passed into a function as NULL.
+ Introduced the configSUPPORT_DYNAMIC_ALLOCATION configuration constant to
allow a FreeRTOS application to be built without a heap even being being
defined. The Win32 example located in the
/FreeRTOS/demo/WIN32-MSVC-Static-Allocation-Only directory is provided as
a reference for projects that do not include a FreeRTOS heap.
+ Minor run-time optimisations.
+ Two new low power tickless implementations that target Silicon Labs EFM32
microcontrollers.
+ Addition of the xTimerGetPeriod() and xTimerGetExpireTime() API functions.
Changes between FreeRTOS V8.2.3 and FreeRTOS V9.0.0rc1 (release candidate 1)
released February 19 2016:
RTOS Kernel Updates:
+ Major new feature - tasks, semaphores, queues, timers and event groups can
now be created using statically allocated memory, so without any calls to
pvPortMalloc().
+ Major new features - Added the xTaskAbortDelay() API function which allows
one task to force another task to immediately leave the Blocked state,
even if the event the blocked task is waiting for has not occurred, or the
blocked task's timeout has not expired.
+ Updates necessary to allow FreeRTOS to run on 64-bit architectures.
+ Added vApplicationDaemonTaskStartupHook() which executes when the RTOS
daemon task (which used to be called the timer service task) starts
running. This is useful if the application includes initialisation code
that would benefit from executing after the scheduler has been started.
+ Added the xTaskGetTaskHandle() API function, which obtains a task handle
from the task's name. xTaskGetTaskHandle() uses multiple string compare
operations, so it is recommended that it is called only once per task.
The handle returned by xTaskGetTaskHandle() can then be stored locally for
later re-use.
+ Added the pcQueueGetQueueName() API function, which obtains the name of
a queue from the queue's handle.
+ Tickless idling (for low power applications) can now also be used when
configUSE_PREEMPTION is 0.
+ If one task deletes another task, then the stack and TCB of the deleted
task is now freed immediately. If a task deletes itself, then the stack
and TCB of the deleted task are freed by the Idle task as before.
+ If a task notification is used to unblock a task from an ISR, but the
xHigherPriorityTaskWoken parameter is not used, then pend a context switch
that will then occur during the next tick interrupt.
+ Heap_1.c and Heap_2.c now use the configAPPLICATION_ALLOCATED_HEAP
settings, which previously was only used by heap_4.c.
configAPPLICATION_ALLOCATED_HEAP allows the application writer to declare
the array that will be used as the FreeRTOS heap, and in-so-doing, place
the heap at a specific memory location.
+ TaskStatus_t structures are used to obtain details of a task.
TaskStatus_t now includes the bae address of the task's stack.
+ Added the vTaskGetTaskInfo() API function, which returns a TaskStatus_t
structure that contains information about a single task. Previously this
information could only be obtained for all the tasks at once, as an array
of TaskStatus_t structures.
+ Added the uxSemaphoreGetCount() API function.
+ Replicate previous Cortex-M4F and Cortex-M7 optimisations in some
Cortex-M3 port layers.
Demo Application Updates:
Further demo applications will be added prior to the final FreeRTOS V9
release.
+ Updated SAM4L Atmel Studio project to use Atmel Studio 7.
+ Added ARM Cortex-A53 64-bit port.
+ Added a port and demo for the ARM Cortex-A53 64-bit cores on the Xilinx
Ultrascale MPSoC.
+ Added Cortex-M7 SAME70 GCC demo.
+ Added EFM32 Giant and Wonder Gecko demos.
Changes between V8.2.2 and V8.2.3 released October 16, 2015
RTOS kernel updates:
+ Fix bug identified in a modification made in V8.2.2 to the software timer
code that allows tickless low power applications to sleep indefinitely
when software timers are used.
+ Simplify and improve efficiency of stack overflow checking.
+ Add xTaskNotifyStateClear() API function.
+ New IAR and GCC Cortex-R ports for microprocessors that do not use an ARM
generic interrupt controller (GIC).
+ New PIC32MEC14xx port.
+ Add support for PIC32MZ EF parts (with floating point) into the PIC32MZ
port.
+ Zynq7000 port layer now declares the functions that setup and clear the
tick interrupt as weak symbols so they can be overridden by the
application, and uses a global XScuGic object so the same object can be
used by the application code.
+ Introduced configUSE_TASK_FPU_SUPPORT, although the PIC32MZ EF port is
currently the only port that uses it.
+ Updates to RL78 and 78K0 IAR port layers to improve support for
combinations of memory models.
+ Minor updates to heap_5.c to remove compiler warnings generated by some
compilers.
+ License simplifications. See /FreeRTOS/License/license.txt in the
official distribution.
FreeRTOS+ updates:
+ Update directory names to use WolfSSL instead of CyaSSL, inline with
WolfSSL's re-branding.
+ Update to latest WolfSSL code.
+ Update to latest FreeRTOS+Trace recorder code.
+ Add in the FreeRTOS+Trace recorder library required for streaming trace.
Demo application changes:
+ Add demo applications for Renesas RZ/T (Cortex-R), PIC32MZ EF (PIC32 with
floating point hardware), PIC32MEC14xx, RX71M, RX113 and RX231.
+ General tidy up of spelling and compiler warnings.
Changes between V8.2.1 and V8.2.2 released August 12, 2015
RTOS kernel updates:
+ Added Intel IA32/x86 32-bit port.
+ General maintenance.
+ PRIVILEGED_FUNCTION and PRIVILEGED_DATA macros, which are used in memory
protected systems, have been added to the newer event group and software
timer functions.
+ Add the errno definitions used by FreeRTOS+ components into projdefs.h.
+ Remove the restriction that prevented tick-less idle implementations
waiting indefinitely when software timers were used in the same
application.
+ Introduce xTaskNotifyAndQueryFromISR() as the interrupt safe version of
xTaskNotifyAndQuery().
+ Add additional NOPs to the MSP430X port layers to ensure strict compliance
with the hardware documentation.
+ Microblaze port: Added option for port optimised task selection.
+ Microblaze port: Previously tasks inherited the exception enable state
at the time the task was created. Now all tasks are created with
exceptions enabled if the Microblaze design supports exceptions.
+ Windows port: Add additional safe guards to ensure the correct start up
sequence and thread switching timing.
+ Windows port: Improve the implementation of the port optimised task
selection assembly code.
+ Update heap_4 and heap_5 to allow use on 64-bit processors.
+ Simplify the code that creates a queue.
+ General improved tick-less idle behaviour.
+ Ensure none of the variables in the common kernel files are initialised to
anything other than zero.
+ Correct calculation of xHeapStructSize in heap_4 and heap_5.
Demo application updates:
+ Added demo project for the new IA32/x86 port that targets the Galileo
hardware.
+ Added MSP430FR5969 demos (previously provided as a separate download).
+ Added FreeRTOS BSP repository for automatic creation of FreeRTOS
applications in the Xilinx SDK.
+ Added Atmel Studio / GCC project for the SAMV71 (ARM Cortex-M7)
+ Update Xilinx SDK projects to use version 2015.2 of the SDK.
+ Remove Microblaze demos that were using obsolete tools.
+ Add MSP43FR5969 IAR and CCS demos.
FreeRTOS+ Updates:
+ Updated FreeRTOS+Trace recorder library, which requires an update to the
FreeRTOS+Trace application.
+ Added Reliance Edge source code and demo application. Reliance edge is
a fail safe transactional file system ideal for applications that require
file storage, and especially when high reliability is essential.
+ Introduce configAPPLICATION_PROVIDES_cOutputBuffer to allow FreeRTOS+CLI
users to place the output buffer at a fixed memory address.
+ Improve the NetworkInterface.c file provided for the Windows port of
FreeRTOS+UDP.
Changes between V8.2.0 and V8.2.1 released 24th March 2015.
RTOS kernel updates:
+ Added user definable and flexible thread local storage facility.
+ Added vTimerSetTimerID() API function to complement the pvTimerGetTimerID()
function to allow the timer's ID to be used as timer local storage.
+ Fixed a potential issue related to the use of queue sets from an ISR.
+ Some updates to the Xilinx Microblaze GCC port.
+ Added ARM Cortex-M4F port for Texas Instruments Code Composer Studio.
+ Added ARM Cortex-M7 r0p1 port layer for IAR, GCC and Keil which contains a
minor errata work around. All other ARM Cortex-M7 core revisions should
use the ARM Cortex-M4F port.
+ Exclude the whole of croutine.c if configUSE_CO_ROUTINES is set to 0.
+ Change some data types from uint32_t to size_t in preparation for 64-bit
Windows port.
+ Update the PIC32 port to remove deprecation warnings output by the latest
XC32 compilers.
+ Fix bug when xQueueOverwrite() and xQueueOverwrite() from ISR are used to
overwrite items in two queues that are part of the same set.
Demo application updates:
+ Added demo application for TI's ARM Cortex-M4F based MSP432
microcontroller using IAR, Keil and CCS compilers.
+ Added demo application for STM32F ARM Cortex-M7 based microcontroller
using IAR and Keil.
+ Added demo application for Atmel SAMV71 ARM Cortex-M7 based
microcontroller using IAR and Keil.
+ Added Microblaze demo that uses the 2014.4 version of the Xilinx SDK and
runs on the KC705 evaluation board (Kintex FPGA).
Changes between V8.1.2 and V8.2.0 released 16th January 2015
Changes between release candidate 1 and the official release are restricted
to maintenance only.
Significant RTOS kernel updates:
+ MAJOR NEW FEATURE! Task notifications. Please see the following URL for
details: https://www.FreeRTOS.org/RTOS-task-notifications.html
+ NEW HEADER FILE REQUIRED! Obsolete definitions have been separated into
a new header file called FreeRTOS/Source/include/deprecated_definitions.h.
This header file must be present to build. Note some of the obsolete
definitions are still used by very old demo application projects.
Other RTOS kernel updates:
+ Made xSemaphoreGiveFromISR() a function rather than a macro that calls
xQueueGenericSendFromISR(). This allows for major performance
enhancements at the expense of some additional code size if both functions
are used in the same application. NOTE: In most uses cases such use of
a semaphore can now be replaced with a task notification which is smaller
and faster still.
+ The TCB is now always allocated such that the task's stack grows away from
the TCB (improves debugging of stack overflows as the overflow will not
overwrite the task's name).
+ GCC, IAR and Keil Cortex-M4F ports now use more inlining (performance
enhancements at the cost of a little additional code space).
+ Queues are now allocated with a single call to pvPortMalloc() which
allocates both the queue structure and the queue storage area.
+ Introduced a new critical section macro for reading the tick count that
defines away to nothing in cases where the width of the tick allows the
tick count to be read atomically (performance benefits - especially when
optimisation is on).
+ Introduced configAPPLICATION_ALLOCATED_HEAP in heap_4.c to allow the
application writer to provide their own heap array - and in so doing
control the location of the heap.
+ Introduced configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES which, when set, will
include known values in both list and list item structures. The values
are intended to assist debugging. If the values get overwritten then it
is likely application code has written over RAM used by the kernel.
+ configASSERT()s in all Cortex-M ports used to test the lowest 5 bits of
the interrupt control register to detect taskENTER_CRITICAL() being called
from an interrupt. This has been changed to test all 8 bits.
+ Introduced uxTaskPriorityGetFromISR().
+ Microblze V8 port now tests XPAR_MICROBLAZE_0_USE_FPU for inequality to 0
rather than equality to 1, and 2 and 3 are also valid values.
+ Cortex-A5 GIC-less port no longer passes the address of the interrupting
peripheral into the interrupt handler.
+ Fix an issue in FreeRTOS-MPU where an attempt was made to free the stack
belonging to a task when the task was deleted, even when the stack was
allocated statically.
+ Utility (helper) functions that format task statistic information into
human readable tables now pad task names with spaces to ensure columns
line up correctly even where task name lengths vary greatly.
+ Update FreeRTOS+Trace recorder library to version 2.7.0.
Demo application updates:
+ Added two new standard demo task sets: IntSemTest and TaskNotify.
+ Added port and demo application for Atmel SAMA5D4 Cortex-A5 MPU.
+ Added demo application for Altera Cyclone V Cortex-A9 MPU.
+ Updated Zynq demo to use version 2014.4 of Xilinx's SDK and added in
demo tasks for new RTOS features.
+ Updated Atmel SAM4E and SAM4S demos to include a lot of additional test
and demo tasks.
+ Fixed a corner case issue in Atmel SAM4L low power tickless
implementation, and added button interrupt handling.
+ Make the interrupt queue tests more tolerant to heave CPU loads.
+ Updated MSVC FreeRTOS simulator demo to include the latest standard test
and demo tasks.
+ Updated MingW/Eclipse FreeRTOS simulator demo to match the FreeRTOS MSVC
simulator demo.
+ Updated all demos that use FreeRTOS+Trace to work with the latest trace
recorder code.
Changes between V8.1.1 and V8.1.2 released September 2nd 2014
Move the defaulting of configUSE_PORT_OPTIMISED_TASK_SELECTION into the
individual port layers where necessary so it does not affect ports that do
not support the definition.
Changes between V8.1.0 and V8.1.1 released August 29th 2014
By popular requests - a minor patch to V8.1.0 to re-instate the ability to
give a mutex type semaphore (with priority inheritance) from an interrupt
handler.
Changes between V8.0.1 and V8.1.0 released August 26th 2014
FreeRTOS scheduler, kernel, demo and test updates:
+ Improved the priority inheritance algorithms to assist integration with
off the shelf middleware that may hold multiple mutexes simultaneously.
+ Introduce heap_5.c, which is similar to heap_4.c but allows the heap to
span multiple non-contiguous memory regions.
+ Updated all Cortex-A9 ports to help trap a couple of common usage errors -
the first being when a task incorrectly attempts to exit its implementing
function and the second being when a non interrupt safe API function is
called from an interrupt.
+ Update all Cortex-A9 ports to remove obsolete mode switches prior to
restoring a task context.
+ configUSE_PORT_OPTIMISED_TASK_SELECTION now defaults to 1 instead of 0.
+ Update all Cortex-M3/4F ports to trap a non interrupt safe API function
being called from an interrupt handler.
+ Simplify the alignment checks in heap_4.c.
+ Update the MSVC Windows simulator demo to use heap_5.c in place of
heap_4.c to ensure end users have an example to refer to.
+ Updated standard demo test code to test the new priority inheritance
algorithms.
+ Updated the standard demo tasks to make use of stdint and the FreeRTOS
specific typedefs that were introduced in FreeRTOS V8.0.0.
+ Introduce the pdMS_TO_TICKS() macro as a more user friendly and intuitive
alternative to pdTICKS_PER_MS - both of which can be used to convert a
time specified in milliseconds to a time specified in RTOS ticks.
+ Fix a bug in the Tasking compiler's Cortex-M port that resulted in an
incorrect value being written to the basepri register. This only effects
users of the Tasking compiler.
+ Update the Zynq demo to use version 2014.2 of the SDK and add in an lwIP
example that demonstrates lwIP being used with both its raw and sockets
interfaces.
+ Updated the CCS Cortex-R4 port to enable it to be built with the latest
CCS compiler.
New ports and demo applications:
+ Two Renesas RX64M ports (RXv2 core) and demos introduced, one for the GCC
compiler and one for the Renesas compiler. Both demos use e2 studio.
+ Generic IAR Cortex-A5 port (without any reliance on a GIC) introduced.
The new port is demonstrated on an Atmel SAMA5D3 XPlained board.
FreeRTOS+ component updates:
+ Update CyaSSL to the latest version.
+ Updated the FreeRTOS+ components supplied directly by Real Time Engineers
Ltd. to make use of stdint and the FreeRTOS specific typedefs that were
introduced in FreeRTOS V8.0.0.
+ Rework and simplify the FreeRTOS+FAT SL RAM disk driver.
Miscellaneous updates and maintenance:
+ Update the IAR and DS-5/ARM RZ demos to target the official RZ RSK
hardware in place of the previously targeted Renesas internal (not
publicly available) hardware.
+ Various other maintenance tasks.
Changes between V8.0.0 and V8.0.1 released 2nd May 2014
+ Minor fixes to the event group functionality that was released in V8.0.0.
The 'clear bits from ISR' functionality is now implemented using a
deferred interrupt callback instead of a function, and the 'wait bits' and
'task sync' functions now correctly clear internal control bits before
returning a value in every possible path through the respective functions.
+ Ensure the updating of internal control data is protected by a critical
section after a task is deleted or suspended.
+ Minor fixes to FreeRTOS+FAT SL - namely seeking beyond the end of a file
when the offset was not a multiple of the sector size.
+ Ensure Cortex-A9 system registers are only ever accessed as 32-bit values,
even when only the lest significant byte of the register is implemented.
Other updates:
+ Updated the XMC4200 IAR project so it links with version 7.x of the IAR
tools.
+ Add RL78L1C demo.
+ Add pcTimerGetName() API function.
+ Call _reclaim_reent() when a task is deleted if configUSE_NEWLIB_REENTRANT
is defined.
Changes between V7.6.0 and V8.0.0 released 19th Feb 2014
https://www.FreeRTOS.org/upgrading-to-FreeRTOS-V8.html
FreeRTOS V8.x.x is a drop-in compatible replacement for FreeRTOS V7.x.x,
although a change to the type used to reference character strings may result
in application code generating a few (easily clearable) compiler warnings
after the upgrade, and an updated typedef naming convention means use of the
old typedef names is now discouraged.
See https://www.FreeRTOS.org/upgrading-to-FreeRTOS-V8.html for full
information.
New features and functionality:
+ Event groups - see https://www.FreeRTOS.org/FreeRTOS-Event-Groups.html
+ Centralised deferred interrupt processing - see
https://www.FreeRTOS.org/xTimerPendFunctionCallFromISR.html
Other updates:
+ Previously, when a task left the Blocked state, a context switch was
performed if the priority of the unblocked task was greater than or equal
to the priority of the Running task. Now a context switch is only
performed if the priority of the unblocked task is greater than the
priority of the Running task.
+ New low power tickless demonstration project that targets the ST STM32L
microcontroller - see
https://www.FreeRTOS.org/STM32L-discovery-low-power-tickless-RTOS-demo.html
+ Add xPortGetMinimumEverFreeHeapSize() to heap_4.c.
+ Small change to the tickless low power implementation on the SAM4L to
ensure the alarm value (compare match value) cannot be set to zero when a
tickless period is exited due to an interrupt originating from a source
other than the RTOS tick.
+ Update the GCC/Eclipse Win32 simulator demo to make better use of Eclipse
resource filters and match the functionality of the MSVC equivalent.
+ xTaskIsTaskSuspended() is no longer a public function. Use
eTaskGetState() in its place.
+ Improved trace macros, including tracing of heap usage.
+ Remove one level of indirection when accepting interrupts on the PIC32MZ.
+ Add Cortex-A9 GCC port layer.
+ Add Xilinx Zynq demo application.
Changes between V7.5.3 and V7.6.0 released 18th November 2013
V7.6.0 changes some behaviour when the co-operative scheduler is used (when
configUSE_PREEMPTION is set to 0). It is important to note that the
behaviour of the pre-emptive scheduler is unchanged - the following
description only applies when configUSE_PREEMPTION is set to 0:
WHEN configUSE_PREEMPTION IS SET TO 0 (which is in a small minority of
cases) a context switch will now only occur when a task places itself into
the Blocked state, or explicitly calls taskYIELD(). This differs from
previous versions, where a context switch would also occur when implicitly
moving a higher priority task out of the Blocked state. For example,
previously, WHEN PREEMPTION WAS TURNED OFF, if task A unblocks task B by
writing to a queue, then the scheduler would switch to the higher priority
task. Now, WHEN PREEMPTION IS TURNED OFF, if task A unblocks task B by
writing to a queue, task B will not start running until task A enters the
Blocked state or task A calls taskYIELD(). [If configUSE_PREEMPTION is not
set to 0, so the normal pre-emptive scheduler is being used, then task B
will start running immediately that it is moved out of the Blocked state].
Other changes:
+ Added a port layer and a demo project for the new PIC32MZ architecture.
+ Update the PIC32MX port layer to re-introduce some ehb instructions that
were previously removed, add the ability to catch interrupt stack
overflows (previously only task stack overflows were trapped), and also
add the ability to catch an application task incorrectly attempting to
return from its implementing function.
+ Make dramatic improvements to the performance of the Win32 simulator port
layer.
+ Ensure tasks that are blocked indefinitely report their state as Blocked
instead of Suspended.
+ Slight improvement to the Cortex-M4F port layers where previously one
register was inadvertently being saved twice.
+ Introduce the xSemaphoreCreateBinary() API function to ensure consistency
in the semantics of how each semaphore type is created. It is no longer
recommended to use vSemaphoreCreateBinary() (the version prefixed with a
'v'), although it will remain in the code for backward compatibility.
+ Update the Cortex-M0 port layers to allow the scheduler to be started
without using the SVC handler.
+ Added a build configuration to the PIC32MX MPLAB X demo project that
targets the PIC32 USB II starter kit. Previously all the build
configurations required the Explorer 16 hardware.
+ Some of the standard demo tasks have been updated to ensure they execute
correctly with the updated co-operative scheduling behaviour.
+ Added comprehensive demo for the Atmel SAM4E, including use of
FreeRTOS+UDP, FreeRTOS+FAT SL and FreeRTOS+CLI.
FreeRTOS+ Changes:
+ Minor maintenance on FreeRTOS+UDP.
Changes between V7.5.2 and V7.5.3 released October 14 2013
Kernel changes:
+ Prior to V7.5.x yields requested from the tick hook would occur in the
same tick interrupt - revert to that original behaviour.
+ New API function uxQueueSpacesAvailable().
+ Introduced the prvTaskExitError() function to Cortex-M0, Cortex-M3/4
and Cortex-M4F ports. prvTaskExitError() is used to trap tasks that
attempt to return from their implementing functions (tasks should call
vTaskDelete( NULL ); if they want to exit).
+ The Cortex-M0 version of portSET_INTERRUPT_MASK_FROM_ISR and
portCLEAR_INTERRUPT_MASK_FROM_ISR are now fully nestable.
+ Improved behaviour and robustness of the default Cortex-M tickless idle
behaviour.
+ Add workaround for silicon errata PMU_CM001 in Infineon XMC4000 devices to
all Cortex-M4F ports.
+ Add Cortex-M0 port for Keil.
+ Updated Cortus port.