forked from apache/nuttx
-
Notifications
You must be signed in to change notification settings - Fork 0
/
README.txt
2539 lines (2041 loc) · 93.7 KB
/
README.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
APACHE NUTTX (INCUBATING)
^^^^^^^^^^^^^^^^^^^^^^^^^
o Introduction
- Incubation Status
o Community
- Getting Help
- Mailing Lists
- Issue Tracker
- Source Code
- Website Source Code
o Environments
- Installing Cygwin
- Ubuntu Bash under Windows 10
- Using macOS
o Installation
- Download and Unpack
- Semi-Optional apps/ Package
- Installation Directories with Spaces in the Path
- Downloading from Repositories
- Related Repositories
- Notes about Header Files
o Configuring NuttX
- Instantiating "Canned" Configurations
- Refreshing Configurations
- NuttX Configuration Tool
- Finding Selections in the Configuration Menus
- Reveal Hidden Configuration Options
- Make Sure that You are on the Right Platform
- Comparing Two Configurations
- Making defconfig Files
- Incompatibilities with Older Configurations
- NuttX Configuration Tool under DOS
o Toolchains
- Cross-Development Toolchains
- NuttX Buildroot Toolchain
o Shells
o Building NuttX
- Building
- Re-building
- Build Targets and Options
- Native Windows Build
- Installing GNUWin32
o Cygwin Build Problems
- Strange Path Problems
- Window Native Toolchain Issues
o Documentation
INTRODUCTION
^^^^^^^^^^^^
Apache NuttX (Incubating) is a real-time operating system (RTOS) with an
emphasis on standards compliance and small footprint. Scalable from 8-bit
to 32-bit microcontroller environments, the primary governing standards in
NuttX are POSIX and ANSI standards. Additional standard APIs from Unix and
other common RTOSs (such as VxWorks) are adopted for functionality not
available under these standards, or for functionality that is not
appropriate for deeply-embedded environments (such as fork()).
Extensive documentation can be found on the project wiki:
https://cwiki.apache.org/NUTTX/Nuttx
Incubation Status
-----------------
Apache NuttX (Incubating) is an effort undergoing Incubation at The Apache
Software Foundation (ASF), sponsored by the Incubator. For more on our
incubation effort, please see the file DISCLAIMER-WIP, in the same
directory as this README.
For brevity, the rest of this file will refer to it as Apache NuttX or
simply NuttX.
COMMUNITY
^^^^^^^^^
Every volunteer project obtains its strength from the people involved in
it. We invite you to participate as much or as little as you choose.
We encourage you to:
- Use our project and provide feedback.
- Provide us with use-cases.
- Report bugs and submit patches.
- Contribute code or documentation.
Getting Help
------------
The best place to get help is the developer's mailing list. Please see
the following section:
Mailing Lists
-------------
Get help using NuttX or contribute to the project on our mailing lists:
dev@nuttx.apache.org is for people who want to contribute code to NuttX.
- To subscribe, send an email to dev-subscribe@nuttx.apache.org.
- To unsubscribe, send an email to dev-unsubscribe@nuttx.apache.org.
- View the archives at:
https://www.mail-archive.com/dev@nuttx.apache.org/
commits@nuttx.apache.org is a read-only list that notifies subscribers
about commit messages and patches to NuttX.
- To subscribe, send an email to commits-subscribe@nuttx.apache.org.
- To unsubscribe, send an email to commits-unsubscribe@nuttx.apache.org.
- View the archives at:
https://www.mail-archive.com/commits@nuttx.apache.org/
Issue Tracker
-------------
Bug Reports:
Found bug? Send an email to the dev list dev@nuttx.apache.org.
Before submitting an issue, please:
- Verify that the bug does in fact exist.
- Search the mailing list archives to verify there is no existing issue
reporting the bug you've found.
- Consider tracking down the bug yourself in the NuttX source code and
submitting a patch along with your bug report. This is a great time
saver for the NuttX developers and helps ensure the bug will be fixed
quickly.
Feature Requests:
Enhancement requests for new features are also welcome. The more concrete
and rational the request is, the greater the chance it will incorporated
into future releases.
Source Code
-----------
The project sources are in two Git repositories. The core OS is in
incubator-nuttx and the apps repository is in incubator-nuttx-apps. These
are housed in GitBox on ASF servers and also mirrored at GitHub. These
are kept in sync, so you can use whichever option you prefer.
- NuttX core OS repository:
Primary:
https://gitbox.apache.org/repos/asf?p=incubator-nuttx.git
GitHub Mirror:
https://github.com/apache/incubator-nuttx
- Apps repository:
Primary:
https://gitbox.apache.org/repos/asf?p=incubator-nuttx-apps.git
GitHub Mirror:
https://github.com/apache/incubator-nuttx-apps
Website Source Code
-------------------
The project website sources are accessible via the website source code
repository which is also mirrored in GitHub:
Primary:
https://gitbox.apache.org/repos/asf?p=incubator-nuttx-website.git
GitHub Mirror:
https://github.com/apache/incubator-nuttx-website
ENVIRONMENTS
^^^^^^^^^^^^
NuttX requires a POSIX development environment such as you would find under
Linux or macOS. NuttX may also be installed and built on Windows system
if you also provide such a POSIX development environment. Options for a
POSIX development environment under Windows include:
- An installation of Linux on a virtual machine (VM) in Windows. I have
not been happy using a VM myself. I have had stability problems with
open source VMs and commercial VMs cost more than I want to spend.
Sharing files with Linux running in a VM is awkward; sharing devices
connected to the Windows box with Linux in a VM is, at the very least,
confusing; Using Windows tools (such as Segger J-Link) with files
built under the Linux VM is not a possibility.
- The Cygwin environment. Instructions for installation of Cygwin on a
Windows system are provided in the following paragraph, "Installing
Cygwin". Cygwin is a mature, well-tested, and very convenient
environment. It is especially convenient if you need to
integrate with Windows tools and files. Downsides are that the
installation time is very long and the compile times are slow.
- Ubuntu/Bash shell under Windows 10. This is a new option under
Windows 10. See the section "Ubuntu Bash under Windows 10" below.
This is an improvement over Cygwin if your concern is compile time;
its build performance is comparable to native Linux, certainly better
than the Cygwin build time. It also installs in a tiny fraction of
the time as Cygwin, perhaps 20 minutes for the basic Ubuntu install
(vs. more than a day for the complete Cygwin install).
There have been even more recent ports of Linux environment to
Windows. I need to update this section to include some mention of
these alternatives.
- The MSYS environment. MSYS derives from an older version of Cygwin
simplified and adapted to work more naturally in the Windows
environment. See http://www.mingw.org/wiki/MSYS if you are
interested in using MSYS. The advantages of the MSYS environment is
that it is better integrted with the native Windows environment and
lighter weight; it uses only a minimal number of add-on POSIX-land
tools.
The download link in that Wiki takes you to the SourceForge download
site. The SourceForge MSYS project has been stagnant for some time.
The MSYS project has more recently moved to
http://odsn.net/projects/sfnet_mingwbundle. Downloads of current .zip
files are available there but no instructions for the installation.
- MSYS2 appears to be a re-write of MSYS based on a newer version of
Cygwin. Is it available at https://www.msys2.org. A windows
installer is available at that site along with very good installation
instructions. The download is relatively quick (at least compared to
Cygwin) and the 'pacman' package management tool supports supports
simple system updates. For example, 'pacman -S git' will install the
GIT command line utilities.
- Other POSIX environments. Check out:
UnxUtils: https://sourceforge.net/projects/unxutils/,
https://en.wikipedia.org/wiki/UnxUtils
MobaXterm: https://mobaxterm.mobatek.net/
Gow: https://github.com/bmatzelle/gow/wiki
Disclaimer: In principle, these should work. However, I have never
used any of these environments and cannot guarantee that there is
not some less-than-obvious issues.
NuttX can also be installed and built on a native Windows system, but with
some potential tool-related issues (see the discussion "Native Windows
Build" under "Building NuttX" below). GNUWin32 is used to provide
compatible native windows tools.
Installing Cygwin
-----------------
Installing Cygwin on your Windows PC is simple, but time consuming. See
http://www.cygwin.com/ for installation instructions. Basically you just
need to download a tiny setup.exe program and it does the real, network
installation for you.
Some Cygwin installation tips:
1. Install at C:\cygwin
2. Install EVERYTHING: "Only the minimal base packages from the
Cygwin distribution are installed by default. Clicking on categories
and packages in the setup.exe package installation screen will
provide you with the ability to control what is installed or updated.
Clicking on the "Default" field next to the "All" category will
provide you with the opportunity to install every Cygwin package.
Be advised that this will download and install hundreds of megabytes
to your computer."
If you use the "default" installation, you will be missing many
of the Cygwin utilities that you will need to build NuttX. The
build will fail in numerous places because of missing packages.
NOTE: The last time I installed EVERYTHING, the download was
about 5GiB. The server I selected was also very slow so it took
over a day to do the whole install!
NOTE: You don't really have to install EVERYTHING but I cannot
answer the question "Then what should I install?" I don't know
the answer to that and so will continue to recommend installing
EVERYTHING.
You should certainly be able to omit "Science", "Math", and
"Publishing". You can try omitting KDE, Gnome, GTK, and other
graphics packages if you don't plan to use them.
Perhaps a minimum set would be those packages listed below for the
"Ubuntu Bash under Windows 10" installation?
UPDATE: Sergey Frolov had success with the following minimal
Cygwin configuration:
1. After starting the Cygwin installer, keep the recommended
packages that are pre-selected in the default configuration.
2. Using the installation tools, add the following packages:
make (GNU make) bison libgmp3-dev
gcc-core byacc libmpfr-dev
gcc-g++ gperf libmpc-dev
flex gdb automake-1.15
libncurses-dev libgmp-dev
After installing Cygwin, you will get lots of links for installed
tools and shells. I use the RXVT native shell. It is fast and reliable
and does not require you to run the Cygwin X server (which is neither
fast nor reliable). Unless otherwise noted, the rest of these
instructions assume that you are at a bash command line prompt in
either Linux or in Cygwin shell.
Using MSYS
----------
MSYS is an environment the derives from Cygwin. Thus, most things said
about Cygwin apply equally to MSYS. This section will, then, focus on
the differences when using MSYS, specifically MSYS2.
Here is it assumed that you have already downloaded and installed MSYS2
from https://www.msys2.org using the windows installer available at that
location. It is also assumed that you have brought in the necessary
tools using the 'pacman' package management tool Tools needed including:
pacman -S git
pacman -S make
pacman -S gcc
pacman -S gdb
And possibly others depending upon your usage. Then you will need to
build and install kconfig-frontends per the instructions of the top-level
README.txt file in the tools repository. This requires the following
additional tools:
pacman -S bison
pacman -S gperf
pacman -S ncurses-devel
pacman -S automake-wrapper
pacman -S autoconf
pacman -S pkg-config
Because of some versioning issues, I had to run 'aclocal' prior to
running the kconfig-frontends configure script. See "Configuring NuttX"
below for further information.
Unlike Cygwin, MSYS does not support symbolic links. The 'ln -s' command
will, in fact, copy a directory! This means that you Make.defs file will
have to include definitions like:
ifeq ($(CONFIG_WINDOWS_MSYS),y)
DIRLINK = $(TOPDIR)/tools/copydir.sh
DIRUNLINK = $(TOPDIR)/tools/unlink.sh
endif
This will force the directory copies to work in a way that can be handled
by the NuttX build system. NOTE: The default link.sh script has been
updated so that is should now be MSYS2 compatible. The above is preferred
but no longer necessary in the Make.defs file.
To build the simulator under MSYS, you also need:
pacman -S zlib-devel
It appears that you cannot use directory names with spaces in them like
"/c/Program\ Files \(86\)" in the MSYS path variable. I worked around this
by create Windows junctions like this::
1. Open the a windows command terminal,
2. CD to c:\msys64, then
3. mklink /j programfiles "C:/Program\ Files" and
4. mklink /j programfiles86 "C:/Program\ Files\ \(x86\)"
They then show up as /programfiles and /programfiles86 with the MSYS2
sandbox. Those paths can then be used with the PATH variable. I had
to do something similar for the path to the GNU Tools "ARM Embedded
Toolchain" which also has spaces in the path name.
Ubuntu Bash under Windows 10
----------------------------
A better version of a command-line only Ubuntu under Windows 10 (beta)
has recently been made available from Microsoft.
Installation
------------
Installation instructions abound on the Internet complete with screen
shots. I will attempt to duplicate those instructions in full here.
Here are the simplified installation steps:
- Open "Settings".
- Click on "Update & security".
- Click on "For Developers".
- Under "Use developer features", select the "Developer mode" option to
setup the environment to install Bash.
- A message box should pop up. Click "Yes" to turn on developer mode.
- After the necessary components install, you'll need to restart your
computer.
Once your computer reboots:
- Open "Control Panel".
- Click on "Programs".
- Click on "Turn Windows features on or off".
- A list of features will pop up, check the "Windows Subsystem for Linux
(beta)" option.
- Click OK.
- Once the components installed on your computer, click the "Restart
now" button to complete the task.
After your computer restarts, you will notice that Bash will not appear in
the "Recently added" list of apps, this is because Bash isn't actually
installed yet. Now that you have setup the necessary components, use the
following steps to complete the installation of Bash:
- Open "Start", do a search for bash.exe, and press "Enter".
- On the command prompt, type y and press Enter to download and install
Bash from the Windows Store. This will take awhile.
- Then you'll need to create a default UNIX user account. This account
doesn't have to be the same as your Windows account. Enter the
username in the required field and press Enter (you can't use the
username "admin").
- Close the "bash.exe" command prompt.
Now that you completed the installation and setup, you can open the Bash
tool from the Start menu like you would with any other app.
Accessing Windows Files from Ubuntu
-----------------------------------
File systems will be mounted under "/mnt" so for example "C:\Program Files"
appears at "/mnt/c/Program Files". This is as opposed to Cygwin where
the same directory would appear at "/cygdrive/c/Program Files".
With these differences (perhaps a few other Windows quirks) the Ubuntu
install works just like Ubuntu running natively on your PC.
A good tip for file sharing is to use symbolic links within your Ubuntu
home directory. For example, suppose you have your "projects" directory
at C:\Documents\projects. Then you can set up a link to the projects/
directory in your Ubuntu directory like:
ln -s /mnt/c/Documents/projects projects
Accessing Ubuntu Files From Windows
-----------------------------------
In Ubuntu Userspace for Windows, the Ubuntu file system root directory is
at:
%localappdata%\lxss\rootfs
Or
C:\Users\Username\AppData\Local\lxss\rootfs
However, I am unable to see my files under the rootfs\home directory.
After some looking around, I find the home directory
%localappdata%\lxss\home.
With that trick access to the /home directory, you should actually be
able to use Windows tools outside of the Ubuntu sandbox with versions of
NuttX built within the sandbox using that path.
Executing Windows Tools from Ubuntu
-----------------------------------
You can also execute Windows tools from within the Ubuntu sandbox:
/mnt/c/Program\ Files\ \(x86\)/Microchip/xc32/v1.43/bin/xc32-gcc.exe --version
Unable to translate current working directory. Using C:\WINDOWS\System32
xc32-gcc.exe (Microchip Technology) 4.8.3 MPLAB XC32 Compiler v1.43 Build date: Mar 1 2017
...
The error message indicates that there are more issues: You cannot mix
Windows tools that use Windows style paths in an environment that uses
POSIX paths. I think you would have to use Linux tools only from within
the Ubuntu sandbox.
Install Ubuntu Software
-----------------------
Use "sudo apt-get install <package name>". As examples, this is how
you would get GIT:
sudo apt-get install git
This will get you a compiler for your host PC:
sudo apt-get install gcc
This will get you an ARM compiler for your target:
sudo apt-get install gcc-arm-none-eabi
NOTE: That is just an example. I am not sure if apt-get will give you a
current or usable compiler. You should carefully select your toolchain
for the needs of your project.
You will also need to get the kconfig-frontends configuration as
described below under "NuttX Configuration Tool". In order to build the
kconfig-frontends configuration tool you will also need: make, gperf,
flex, bison, and libncurses-dev.
That is enough to do a basic NuttX build.
Integrating with Windows Tools
------------------------------
If you want to integrate with Windows native tools, then you would need
deal with the same kind of craziness as with integrating Cygwin with
native toolchains, see the section "Cygwin Build Problems" below.
However, there is currently no build support for using Windows native
tools with Ubuntu under Windows. This tool combination is made to work
with Cygwin through the use of the 'cygpath -w' tool that converts paths
from say '/cydrive/c/Program Files' to 'C:\Program Files'. There is,
however, no corresponding tool to convert '/mnt/c/Program Files' in the
Ubuntu environment.
Graphics Support
----------------
The Ubuntu version support by Microsoft is a command-line only version.
There is no support for Linux graphics utilities.
This limitation is not a limitation of Ubuntu, however, only in what
Microsoft is willing to support. If you install a X-Server, then you
can also use basic graphics utilities. See for example:
http://www.howtogeek.com/261575/how-to-run-graphical-linux-desktop-applications-from-windows-10s-bash-shell/
Many Linux graphics programs would, however, also require a graphics
framework like GTK or Qt. So this might be a trip down the rabbit hole.
Using macOS
-----------
You need to install at least the following tools specific to macOS.
* flock (used by APPDIR build logic)
A macOS port is available at: https://github.com/discoteq/flock
brew tap discoteq/discoteq
brew install flock
If you want to build the sim:
* Xcode (the native compiler and the rest of the toolchain)
* ELF toolchain (if you want to build modules for CONFIG_LIBC_MODLIB)
brew install x86_64-elf-gc
INSTALLATION
^^^^^^^^^^^^
There are two ways to get NuttX: You may download released, stable
tarballs from either the project website. Or you may get NuttX by
cloning the GIT repositories. Let's consider the released tarballs
first:
Download and Unpack
-------------------
Download and unpack the NuttX tarball. If you are reading this, then
you have probably already done that. After unpacking, you will end
up with a directory called nuttx-version (where version is the NuttX
version number). You might want to rename that directory nuttx to
match the various instructions in the documentation and some scripts
in the source tree.
Download location:
https://nuttx.apache.org/download/
Legacy download locations:
https://bitbucket.org/nuttx/nuttx/downloads
https://sourceforge.net/projects/nuttx/files/nuttx/
Semi-Optional apps/ Package
---------------------------
All NuttX libraries and example code used to be in included within
the NuttX source tree. As of NuttX-6.0, this application code was
moved into a separate tarball, the apps tarball. If you are just
beginning with NuttX, then you will want to download the versioned
apps tarball along with the NuttX tarball. If you already have your
own product application directory, then you may not need the apps
tarball.
It is called "Semi-optional" because if you don't have some apps/
directory, NuttX will *fail* to build! You do not necessarily need
to use the NuttX apps tarball but may, instead, provide your own
custom application directory. Such a custom directory would need
to include a valid Makefile to support the build and a valid Kconfig
file to support the configuration. More about these files later.
Download then unpack the apps tarball in the same directory where you
unpacked the NuttX tarball. After you unpack the apps tarball, you
will have a new directory called apps-version (where the version
should exactly match the version of the NuttX tarball). Again, you
might want to rename the directory to simply apps/ to match what
you read in the documentation
After unpacking (and renaming) the apps tarball, you will have two
directories side by side like this:
|
+----+----+
| |
nuttx/ apps/
This is important because the NuttX build will expect to find the
apps directory in that (default) location. That default location
can be changed by modifying your NuttX configuration file, but that
is another story.
Installation Directories with Spaces in the Path
------------------------------------------------
The nuttx build directory should reside in a path that contains no
spaces in any higher level directory name. For example, under
Cygwin, your home directory might be formed from your first and last
names like: "/home/First Last". That will cause strange errors when
the make system tries to build.
[Actually, that problem is probably not too difficult to fix. Some
Makefiles probably just need some paths within double quotes]
I work around spaces in the home directory name, by creating a
new directory that does not contain any spaces, such as /home/nuttx.
Then I install NuttX in /home/nuttx and always build from
/home/nuttx/nuttx-code.
Downloading from Repositories
-----------------------------
Cloning the Repository
BEFORE cloning repositories on any Windows platform do the following GIT
command:
git config --global core.autocrlf false
That will avoid conversions of linefeeds (newlines, \n) to carriage
return plus linefeed sequences (\r\n)
The current NuttX du jour is available in from a GIT repository. Here are
instructions for cloning the core NuttX RTOS (corresponding to the nuttx
tarball discussed above):
git clone https://gitbox.apache.org/repos/asf/incubator-nuttx.git nuttx
-or-
git clone https://github.com/apache/incubator-nuttx.git nuttx
And the semi-optional apps/ application directory and be cloned like:
git clone https://gitbox.apache.org/repos/asf/incubator-nuttx-apps.git apps
-or-
git clone https://github.com/apache/incubator-nuttx-apps.git apps
That will give you the same directory structure like this:
|
+----+----+
| |
nuttx/ apps/
Configuring the Clones
The following steps need to be performed for each of the repositories.
After changing to the clone directory:
Set your identity:
git config --global user.name "My Name"
git config --global user.email my.name@example.com
Colorized diffs are much easier to read:
git config --global color.branch auto
git config --global color.diff auto
git config --global color.interactive auto
git config --global color.status auto
Checkout other settings
git config --list
Cloning NuttX Inside Cygwin
If you are cloning the NuttX repository, it is recommended to avoid
automatic end of lines conversions by git. These conversions may break
some scripts like configure.sh. Before cloning, do the following:
git config --global core.autocrlf false
Related Repositories
--------------------
These are standalone repositories:
* https://gitbox.apache.org/repos/asf/incubator-nuttx-apps
or
https://github.com/apache/incubator-nuttx-apps.git
This directory holds an optional package of applications and libraries
can be used with the NuttX RTOS. There is a README.txt file there that
will provide more information about that package.
* https://bitbucket.org/nuttx/nxwidgets
This is the NuttX C++ graphics support. This includes NxWM, the tiny
NuttX Window Manager.
* https://bitbucket.org/nuttx/uclibc
This repository contains a version of the uClibc++ C++ library. This code
originates from http://cxx.uclibc.org/ and has been adapted for NuttX by the
RGMP team (http://rgmp.sourceforge.net/wiki/index.php/Main_Page).
* https://bitbucket.org/nuttx/buildroot
A environment that you can to use to build a custom, NuttX GNU toolchain.
* https://bitbucket.org/nuttx/tools
There are snapshots of some tools here that you will need to work with
NuttX: kconfig-frontends, genromfs, and others.
Notes about Header Files
------------------------
Other C-Library Header Files.
When a GCC toolchain is built, it must be built against a C library.
The compiler together with the contents of the C library completes the
C language definition and provides the complete C development
environment. NuttX provides its own, built-in C library. So the
complete, consistent C language definition for use with NuttX comes from
the combination of the compiler and the header files provided by the
NuttX C library.
When a GCC toolchain is built, it incorporates the C library header
files into the compiler internal directories and, in this way, the C
library really becomes a part of the toolchain. If you use the NuttX
buildroot toolchain as described below under "NuttX Buildroot
Toolchain", your GCC toolchain will build against the NuttX C library
and will incorporate the NuttX C library header files as part of the
toolchain.
If you use some other, third-party tool chain, this will not be the
case, however. Those toolchains were probably built against some
other, incompatible C library distribution (such as newlib). Those
tools will have incorporated the incompatible C library header files
as part of the toolchain. These incompatible header files must *not*
be used with NuttX because they will conflict with definitions in the
NuttX built-in C-Library. For such toolchains that include header
files from a foreign C-Library, NuttX must be compiled without using
the standard header files that are distributed with your toolchain.
This prevents including conflicting, incompatible header files such
as stdio.h.
The math.h and stdarg.h are probably the two most trouble some header
files to deal with. These troublesome header files are discussed in
more detail below.
Header Files Provided by Your Toolchain.
Certain header files, such as setjmp.h, stdarg.h, and math.h, may still
be needed from your toolchain and your compiler may not, however, be able
to find these if you compile NuttX without using standard header files
(i.e., with -nostdinc). If that is the case, one solution is to copy
those header file from your toolchain into the NuttX include directory.
Duplicated Header Files.
There are also a few header files that can be found in the nuttx/include
directory which are duplicated by the header files from your toolchain.
stdint.h and stdbool.h are examples. If you prefer to use the stdint.h
and stdbool.h header files from your toolchain, those could be copied
into the nuttx/include/ directory. Using most other header files from
your toolchain would probably cause errors.
math.h
Even though you should not use a foreign C-Library, you may still need
to use other, external libraries with NuttX. In particular, you may
need to use the math library, libm.a. NuttX supports a generic, built-in
math library that can be enabled using CONFIG_LIBM=y. However, you may
still want to use a higher performance external math library that has
been tuned for your CPU. Sometimes such tuned math libraries are
bundled with your toolchain.
The math library header file, math.h, is a then special case. If you do
nothing, the standard math.h header file that is provided with your
toolchain will be used.
If you have a custom, architecture specific math.h header file, then
that header file should be placed at arch/<cpu>/include/math.h. There
is a stub math.h header file located at include/nuttx/lib/math.h. This stub
header file can be used to "redirect" the inclusion to an architecture-
specific math.h header file. If you add an architecture specific math.h
header file then you should also define CONFIG_ARCH_MATH_H=y in your
NuttX Configuration file. If CONFIG_ARCH_MATH_H is selected, then the
top-level Makefile will copy the stub math.h header file from
include/nuttx/lib/math.h to include/math.h where it will become the system
math.h header file. The stub math.h header file does nothing other
than to include that architecture-specific math.h header file as the
system math.h header file.
float.h
If you enable the generic, built-in math library, then that math library
will expect your toolchain to provide the standard float.h header file.
The float.h header file defines the properties of your floating point
implementation. It would always be best to use your toolchain's float.h
header file but if none is available, a default float.h header file will
be provided if this option is selected. However, there is no assurance
that the settings in this float.h are actually correct for your platform!
stdarg.h
In most cases, the correct version of stdarg.h is the version provided
with your toolchain. However, sometimes there are issues with
using your toolchains stdarg.h. For example, it may attempt to draw in
header files that do not exist in NuttX or perhaps the header files that
it uses are not compatible with the NuttX header files. In those cases,
you can use an architecture-specific stdarg.h header file by defining
CONFIG_ARCH_STDARG_H=y.
See the discussion above for the math.h header. This setting works
exactly the same for the stdarg.h header file.
CONFIGURING NUTTX
^^^^^^^^^^^^^^^^^
Instantiating "Canned" Configurations
-------------------------------------
configure.sh and configure.bat:
"Canned" NuttX configuration files are retained in:
boards/<arch-name>/<chip-name>/<board-name>/configs/<config-dir>
Where <board-name> is the name of your development board and <config-dir>
is the name of the sub-directory containing a specific configuration for
that board. <arch-name> and <chip-name> refer to characteristics of the
MCU used on the board: <arch-name> is the CPU architecture implemented
by the MCU; <chip-name> identifies the MCU chip family. Only a few
steps are required to instantiate a NuttX configuration, but to make the
configuration even easier there are scripts available in the tools/
sub-directory combines those simple steps into one command.
There is one tool for use with any Bash-like shell that does configuration
steps. It is used as follows:
tools/configure.sh <board-name>:<config-dir>
There is an alternative Windows batch file that can be used in the windows
native environment like:
tools\configure.bat <board-name>:<config-dir>
And, to make sure that other platforms are supported, there is also a
C program at tools/configure.c that can be compiled to establish the
board configuration.
See tools/README.txt for more information about these scripts.
General information about configuring NuttX can be found in:
{TOPDIR}/boards/README.txt
{TOPDIR}/boards/<arch-name>/<chip-name>/<board-name>/README.txt
The Hidden Configuration Scripts:
As mentioned above, there are only a few simple steps to instantiating a
NuttX configuration. Those steps are hidden by the configuration scripts
but are summarized below:
1. Copy Files
Configuring NuttX requires only copying two files from the
<config-dir> to the directory where you installed NuttX (TOPDIR):
Copy boards/<arch-name>/<chip-name>/<board-name>/configs/<config-dir>/Make.def
to {TOPDIR}/Make.defs
OR
Copy boards/<arch-name>/<chip-name>/<board-name>/scripts/Make.def
to {TOPDIR}/Make.defs
Make.defs describes the rules needed by your tool chain to compile
and link code. You may need to modify this file to match the
specific needs of your toolchain. NOTE that a configuration may
have its own unique Make.defs file in its configuration directory or
it may use a common Make.defs file for the board in the scripts/
directory. The first takes precedence.
Copy boards/<arch-name>/<chip-name>/<board-name>/configs/<config-dir>/defconfig
to{TOPDIR}/.config
The defconfig file holds the actual build configuration. This
file is included by all other make files to determine what is
included in the build and what is not. This file is also used
to generate a C configuration header at include/nuttx/config.h.
Copy other, environment-specific files to{TOPDIR}
This might include files like .gdbinit or IDE configuration files
like .project or .cproject.
2. Refresh the Configuration
New configuration setting may be added or removed. Existing settings
may also change there values or options. This must be handled by
refreshing the configuration as described below.
NOTE: NuttX uses only compressed defconfig files. For the NuttX
defconfig files, this refreshing step is *NOT* optional; it is also
necessary to uncompress and regenerate the full making file. This is
discussed further below.
Refreshing Configurations
-------------------------
Configurations can get out of date. As new configuration settings are
added or removed or as dependencies between configuration settings
change, the contents of a default configuration can become out of synch
with the build systems. Hence, it is a good practice to "refresh" each
configuration after configuring and before making. To refresh the
configuration, use the NuttX Configuration Tool like this:
make oldconfig
AFTER you have instantiated the NuttX configuration as described above.
The configuration step copied the .config file into place in the top-level
NuttX directory; 'make oldconfig' step will then operate on that .config
file to bring it up-to-date.
If your configuration is out of date, you will be prompted by 'make oldconfig'
to resolve the issues detected by the configuration tool, that is, to
provide values for the new configuration options in the build system. Doing
this can save you a lot of problems down the road due to obsolete settings in
the default board configuration file. The NuttX configuration tool is
discussed in more detail in the following paragraph.
Confused about what the correct value for a new configuration item should
be? Enter ? in response to the 'make oldconfig' prompt and it will show
you the help text that goes with the option.
If you don't want to make any decisions are willing to just accept the
recommended default value for each new configuration item, an even easier
way is:
make olddefconfig
The olddefconfig target will simply bring your configuration up to date with
the current Kconfig files, setting any new options to the default value.
No questions asked.
NuttX Configuration Tool
------------------------
An automated tool has been incorporated to support re-configuration
of NuttX. This tool is based on the kconfig-frontends application available
at https://bitbucket.org/nuttx/tools/src/master/kconfig-frontends/. (This
is a snapshot of the old http://ymorin.is-a-geek.org/projects/kconfig-frontends
which is no longer available.) This application provides a tool called
'kconfig-mconf' that is used by the NuttX top-level Makefile. The following
make target is provided:
make menuconfig
This make target will bring up NuttX configuration menus.
WARNING: Never do 'make menuconfig' on a configuration that has
not been converted to use the kconfig-frontends tools! This will
damage your configuration (see
http://www.nuttx.org/doku.php?id=wiki:howtos:convertconfig).
How do we tell a new configuration from an old one? See "Incompatibilities
with Older Configurations" below.
The 'menuconfig' make target depends on two things:
1. The Kconfig configuration data files that appear in almost all
NuttX directories. These data files are the part that is still
under development (patches are welcome!). The Kconfig files
contain configuration information for the configuration settings
relevant to the directory in which the Kconfig file resides.
NOTE: For a description of the syntax of this configuration file,
see kconfig-language.txt in the tools repository at
https://bitbucket.org/nuttx/tools
2. The 'kconfig-mconf' tool. 'kconfig-mconf' is part of the
kconfig-frontends package. You can download that package from the
snapshot in the tools repository at https://bitbucket.org/nuttx/tools.
Building kconfig-frontends under Linux may be as simple as
'configure; make; make install' but there may be some build
complexities, especially if you are building under Cygwin. See
the more detailed build instructions in the top-level README.txt
file of the tools repository at https://bitbucket.org/nuttx/tools.