summaryrefslogtreecommitdiffstats
path: root/src/doc/src/b2qt.qdoc
blob: 6f2d44c7312940cf08640ec1f905d5a6c3b6a360 (plain)
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
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc
** All rights reserved.
** For any questions to Digia, please use the contact form at
** http://qt.digia.com/
**
** This file is part of Qt Enterprise Embedded.
**
** Licensees holding valid Qt Enterprise licenses may use this file in
** accordance with the Qt Enterprise License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.
**
** If you have questions regarding the use of this file, please use
** the contact form at http://qt.digia.com/
**
****************************************************************************/

/*!
    \contentspage{index.html}{Qt Enterprise Embedded}
    \page index.html
    \nextpage qtee-overview.html
    \title Qt Enterprise Embedded

    \SDK provides a fully-integrated solution to get you started immediately
    with software development on your embedded device with a tailored user
    experience for embedded Linux and embedded Android. \SDK contains the tools
    you need for fast, easy, and fully-integrated embedded device application
    development. It comes with \B2Q, a light-weight UI stack for embedded
    systems, and the Qt Creator integrated development environment (IDE) with
    preconfigured build targets for hardware platforms, as well as an emulator
    for testing the applications.

    \e{\b{IMPORTANT:} Make sure to follow the \l{Installation Guide}
    closely!}

    \section1 Contents

    \list
        \li \l{About Qt Enterprise Embedded}
        \li \l{Installation Guide}
        \li \l{Supported Platforms}
        \li \l{Preparing Hardware}
        \list
            \li \l{Preparing Nexus 7}{Nexus 7 (2012) (embedded Android)}
            \li \l{Preparing Sabre Lite i.MX 6}{Sabre Lite i.MX 6 (embedded Android and Linux)}
            \li \l{Preparing BeagleBone Black}{BeagleBone Black (embedded Android and Linux)}
            \li \l{Preparing BeagleBoard-xM}{BeagleBoard-xM (embedded Linux)}
            \li \l{Preparing Raspberry Pi}{Raspberry Pi Model B (embedded Linux)}
        \endlist
        \li \l{Building and Running an Example}
        \li \l{Customization}
        \li \l{ChangeLog}
        \li \l{Troubleshooting}
        \li \l{License Information}
    \endlist
*/

/*!
    \contentspage{index.html}{Qt Enterprise Embedded}
    \page qtee-overview.html
    \previouspage index.html
    \nextpage qtee-installation-guide.html

    \title About Qt Enterprise Embedded

    \SDK has two main parts:

    \list
        \li Development environment that is installed on a Linux development
            desktop by using an online installer
        \li \B2Q
    \endlist

    \section1 About the Development Environment

    The development is done with the Qt Enterprise libraries and device
    deployment can be done with one click directly from Qt Creator to a device
    connected via USB. Alternatively, you can deploy the application locally
    directly to the \B2Q Emulator that is running the full target software stack
    as in the device.

    As with any Qt based application, the same application can be deployed to
    desktop and mobile OS targets as well.

    \section1 About \B2Q

    \e{\b{\B2Q}} is a light-weight, Qt-optimized, full software stack for
    embedded systems that is installed into the actual target device. This is
    done by flashing the device's memory card or internal memory directly with a
    pre-built image that comes with the development environment.

    \B2Q supports two different operating systems:

    \list
        \li \b{\B2QA} where the software stack is based on the Android Kernel
            (version 4.1 or higher) and selected  middleware. It includes a lean
            software stack where Qt/QML replaces the top Java graphical layer
            and removes the Zygote process layer as well the Android home screen
            enabling better and faster development where modern UIs are at the
            forefront.

        \li \b{\B2QL} where the software stack is using the traditional embedded
            Linux kernel built with the Yocto Poky reference system (Yocto 1.5
            \e Dora release). The Embedded Linux variant is designed for great
            customization possibilities. It contains only components required in
            the embedded device, resulting in smaller image sizes while keeping
            valuable development tools available.
    \endlist

    Both versions have been tested and verified on a number of different
    hardware configurations. \B2Q support is not limited to the devices used
    as reference platforms, it can be made to run on a variety of hardware.

    \section1 About Qt

    \l{http://qt.digia.com/}{Qt} is a full development framework with tools
    designed to streamline the creation of applications and user interfaces
    for desktop, embedded, and mobile platforms.

    \list
        \li \b{Qt Framework} - intuitive APIs for C++
            and CSS/JavaScript-like programming with
            \b{Qt Quick} for rapid UI
            creation
        \li \b{Qt Creator IDE} - powerful cross-platform integrated development
            environment, including UI designer tools and on-device debugging
        \li \b{Tools and toolchains} - internationalization support, embedded
            toolchains and more.
    \endlist

    With Qt, you can reuse code efficiently to target multiple platforms
    with one code base. The modular C++ class library and development tools
    enable developers to create applications for one platform and easily
    build and run to deploy also on other platforms.


    \section1 \B2Q vs Qt for Android

    \image b2qt-vs-qt-for-android.png

    \e{\b{Qt for Android}} is a port of the Qt Framework to be used for application
    development on the Android platform. Its purpose is to enable development
    of applications that can run on Android devices. For developers writing
    applications for the Android ecosystem, Qt for Android is the right choice.

    \b{\B2QA} tries to strip down the Android
    stack to the bare minimum, relying only on basic Linux
    features. The majority of the Android stack, such as
    \e{Dalvik virtual machine} is not running in \B2Q,
    resulting in faster startup times, lower memory consumption and
    overall better performance.
*/

/*!
    \page qtee-installation-guide.html
    \title Installation Guide
    \previouspage qtee-overview.html
    \nextpage qtee-supported-platforms.html

    To successfully set up \SDK, you must closely follow the instructions in
    this section and perform all the described tasks.

    In case of problems, see the \l{Troubleshooting} information and the
    \l {Known Issues} in \SDK \l {product page}.

    \target Requirements for Development Host
    \section1 Requirements for Development Host

    A 64-bit Linux system is required to install and use \SDK. Instructions
    in this documentation assume Ubuntu Linux 64-bit 12.04 LTS or later.
    Other Linux distributions may work, but have not been tested. C/C++ build
    essentials must be installed.

    \target Installing 32-bit Support Libraries
    \section1 1. Installing 32-bit Support Libraries

    Some of the build tools in \SDK are 32-bit programs, and on 64-bit
    systems they require support libraries for running 32-bit code. To
    install the required packages in recent versions of Ubuntu, use
    the following command in a terminal:

    \code
        sudo apt-get install g++-multilib zlib1g:i386
    \endcode

    For older Ubuntu versions such as 12.04, instead do:

    \code
        sudo apt-get install g++-multilib ia32-libs
    \endcode

    \target Installing VirtualBox
    \section1 2. Installing VirtualBox

    The \B2Q emulator in \SDK relies on VirtualBox virtualization software. You can
    download it from \l{https://www.virtualbox.org/wiki/Linux_Downloads} or
    install it via distribution tools.

    If you have older Ubuntu versions such as 12.04 you have to install a newer
    version of VirtualBox than your distribution does provide.
    You have to add a foreign package source:

    \code
        wget -q http://download.virtualbox.org/virtualbox/debian/oracle_vbox.asc -O- | sudo apt-key add -
        echo "deb http://download.virtualbox.org/virtualbox/debian $(lsb_release -sc) contrib" | sudo tee /etc/apt/sources.list.d/virtualbox.list
        sudo apt-get update
    \endcode

    Now install VirtualBox on your computer
    \code
        sudo apt-get install virtualbox-4.3
    \endcode

    To configure VirtualBox:

    \list 1
        \li Start the VirtualBox user interface.
        \li Select \b{File > Preferences} > \b{Network} to open VirtualBox
            network settings.
        \li Create a new network named \e{vboxnet0} and edit its properties:

        \list 1
            \li Change the IPv4 address to \c{192.168.56.1} and the IPv4 network
                 mask to \c{255.255.255.0}.
            \li In the \b{DCHP Server} tab, select the \b{Enable Server} check
                box.
            \li Change the server address to \c{192.168.56.1}.
            \li Change both the lower and upper address bounds to
                \c{192.168.56.101}.
        \endlist
    \endlist

    If a firewall is enabled on the development host, it needs to
    allow TCP and UDP packets between your host and the virtual
    machine.

    \section1 3. Installing \SDK

    \list 1

        \li Download the binary \SDK installer, and make sure it is executable
            by using one of the following methods:

    \list
        \li Enter the \c{chmod +x <filename>} command.
        \li Right-click the file, and select \b{Properties} >
            \b{Permissions} > \b{Allow executing file as program}.
    \endlist

        \li Run the installer and follow its instructions.

    \endlist

    The installer will let you select a directory where \SDK will be
    installed. In this documentation, the installation directory is referred
    to as \b{\c{<INSTALL_DIR>}}. The default installation directory is
    \tt{~/Qt}.

    \target Installing Boot to Qt on Target Devices
    \section1 4. Install \B2Q on Target Devices

    \e{If you target only the emulator, you can skip this step.}

    Before you can deploy and test your Qt application on hardware, you must
    flash the target device with an image that contains the
    \B2Q stack. The steps vary from device to device. Follow the instructions
    specific to your device in \l {Preparing Hardware}.

    \section1 5. Setting up USB Access to Embedded Devices

    \e{If you target only the emulator, you can skip this step.}

    \include b2qt-post-install-setup.qdocinc setting up usb access

    \section1 6. Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring device kit

    You are now ready to start developing for your device.
    For more information, see \l{Building and Running an Example}.
*/

/*!
    \page qtee-preparing-hardware.html
    \title Preparing Hardware
    \previouspage qtee-supported-platforms.html
    \nextpage qtee-building-and-running.html

    Before you can deploy and test your Qt application on hardware, you must
    flash the target device with an image that contains the
    \B2Q stack. These steps vary from device to device:

    \list
        \li \l{Nexus 7 (2012) (embedded Android)}
        \li \l{Sabre Lite i.MX 6 (embedded Android and Linux)}
        \li \l{BeagleBone Black (embedded Android and Linux)}
        \li \l{BeagleBoard-xM (embedded Linux)}
        \li \l{Raspberry Pi Model B (embedded Linux)}
    \endlist

    If you use only the emulator, you can skip this step
    and continue straight to \l {Building and Running an Example}.
*/

/*!
    \target Nexus 7 (2012) (embedded Android)
    \page qtee-preparing-hardware-nexus-7.html
    \title Preparing Nexus 7
    \previouspage qtee-installation-guide.html
    \nextpage qtee-building-and-running.html

    Take the following steps to prepare a
    \l{http://www.google.com/nexus/7/specs/}{Nexus 7 (2012)} for
    \B2Q.

    \section1 Unlocking Nexus 7 Bootloader

    You must unlock the Nexus 7 Bootloader to be able to install custom
    software. You need to do this only once.

    \list 1
        \li Power off the device.
        \li Connect the device to the development host with a USB cable.
        \li To start the Nexus up in \e{fastboot} mode, press the power button
            for a second, and then keep the \b {Volume Down} key pressed down,
            until you see a screen with a green robot with its front panel open.
            \note If the ordinary startup screen appears instead, power off the
            device and try again.
        \li On the development host, enter the following command:
        \code
            sudo <INSTALL_DIR>/Tools/b2qt/fastboot oem unlock
        \endcode
        \li Press the power button to confirm that you want to unlock the
            bootloader when the prompt appears on the Nexus screen.
        \li Wait a few seconds, and check that the text line stating the \c{LOCK STATE} now says \c{UNLOCKED}.
    \endlist

    \section1 Updating a Nexus 7 with \B2Q Images

    \note It is important that you repeat the steps in this section after you
    update \SDK.

    To update an unlocked Nexus 7 device with a \B2Q image:

    \list 1
    \li Make sure that the device is in \e{fastboot} mode and that it is
        connected to the development host via USB.

    \li Re-flash the \e{boot}, \e{system}, and \e{userdata} partitions on the
    device, by entering the following commands in the following order:

    \code
        cd <INSTALL_DIR>
        sudo ./Tools/b2qt/fastboot flash boot Boot2Qt-2.x/nexus7-eAndroid/images/boot.img
        sudo ./Tools/b2qt/fastboot flash system Boot2Qt-2.x/nexus7-eAndroid/images/system.img
        sudo ./Tools/b2qt/fastboot flash userdata Boot2Qt-2.x/nexus7-eAndroid/images/data.img
    \endcode

    \li Once the flashing is completed successfully, reboot the device:

    \code
        sudo ./Tools/b2qt/fastboot reboot
    \endcode

    \endlist

    \note You must install proprietary drivers for the Nexus 7 to boot
    correctly. Until then, the screen will only show the "Google" logo,
    instead of the \B2Q welcome screen or demo.

    \section1 Installing Proprietary Drivers

    Download the proprietary drivers for your Nexus 7. The following script downloads the third
    party drivers from \l{https://developers.google.com/android/nexus/drivers#grouperjdq39}
    {https://developers.google.com/android/nexus/drivers#grouperjdq39}
    \code
        cd <INSTALL_DIR>
        ./Boot2Qt-2.x/nexus7-eAndroid/images/download.sh
    \endcode

    \note Only the version "Android 4.2.2 (JDQ39 to JDQ39E)" works with the
    current \B2Q image.

    To install the drivers to Nexus 7:

    \list 1
        \li Power on the device and connect it to the development host via USB.
            Also check that the device is \e{not} in fastboot mode.
        \li Run the driver extractors:
        \code
            cd Boot2Qt-2.x/nexus7-eAndroid/images/drivers
            ./extract-nvidia-grouper.sh
            ./extract-asus-grouper.sh
            ./extract-invensense-grouper.sh
            cd -
        \endcode
            \note Carefully read the license terms enclosed in each individual
            extractor.
        \li Find out the serial number of the connected Nexus 7 device:
        \code
            ./Tools/b2qt/adb devices
        \endcode
        \li Deploy the drivers to your device:
        \code
            ./Boot2Qt-2.x/nexus7-eAndroid/images/deploy.sh <serial_number>
        \endcode
    \endlist

    After the installation is complete, power on the device and check that
    the \B2Q welcome screen and/or demo appear.

    \section1 Setting up USB Access

    \include b2qt-post-install-setup.qdocinc setting up usb access

    \section1 Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring device kit

    You are now ready to start developing for your device. For more information,
    see \l{Building and Running an Example}.
*/

/*!
    \target BeagleBoard-xM (embedded Linux)
    \page qtee-preparing-hardware-beagleboard.html
    \title Preparing BeagleBoard-xM
    \previouspage qtee-installation-guide.html
    \nextpage qtee-building-and-running.html

    Take the following steps to prepare a \l{http://beagleboard.org/hardware-xM}
    {BeagleBoard-xM} for
    \B2Q.

    \note It is important that you repeat the steps in this section after you
    update \SDK.

    The image containing \B2Q stack for BeagleBoard-xM are included in \SDK,
    ready to be copied to an SD card.

    \section1 Preparing an SD Card

    An SD card of at least 512 MB capacity is needed.

    \include detect-sd-card-device-name.qdocinc instructions

    \section1 Installing the \B2Q Image

    To write the image to the SD card:

    \code
        cd <INSTALL_DIR>
        sudo Boot2Qt-2.x/beagleboard-eLinux/images/deploy.sh /dev/<device_name>
    \endcode

    After the image has been deployed, power on the device and check that
    the \B2Q welcome screen and/or demo appear.

    \section1 Setting up USB Access

    \include b2qt-post-install-setup.qdocinc setting up usb access

    \section1 Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring device kit

    You are now ready to start developing for your device. For more information,
    see \l{Building and Running an Example}.
*/

/*!
    \target Sabre Lite i.MX 6 (embedded Android and Linux)
    \page qtee-preparing-hardware-imx6.html
    \title Preparing Sabre Lite i.MX 6
    \previouspage qtee-installation-guide.html

    Take the following steps to prepare a
    \l{http://boundarydevices.com/products/sabre-lite-imx6-sbc/}{Sabre
    Lite i.MX 6} for \B2Q.

    \note It is important that you repeat the steps in this section after you
    update \SDK.

    The images containing the \B2Q stack for Sabre Lite i.MX 6 are included
    in \SDK, ready to be copied to an SD card.

    \section1 Preparing an SD Card

    For \B2QA, an SD card of at least 4 GB capacity is needed. For \B2QL,
    a card of at least 512 MB capacity is sufficient.

    \include detect-sd-card-device-name.qdocinc instructions

    \section1 Installing the Android image

    \e{If installing} \B2QL, \e{you can skip this step and proceed to}
    \l{Installing the Boot to Qt Image}.

    Download the package \e{imx6-jb-20130628.tar.gz} from
    \l{http://boundarydevices.com/android-jellybean-on-i-mx6-with-no-disclaimers/}{Boundary
    Devices Android Jellybean i.MX6 images} (registration required).

    Use the following commands to create an SD card containing the
    downloaded image:

    \list 1
        \li Extract the downloaded package:
        \code
        ~/$ mkdir bd-android
        ~/$ cd bd-android
        ~/bd-android$ tar zxvf ~/Downloads/imx6-jb-20130628.tar.gz
        \endcode
        \li Run device/boundary/mksdcard.sh:
        \code
        ~/bd-android$ sudo device/boundary/mksdcard.sh /dev/<device_name>
        ~/bd-android$ sync
        \endcode
    \endlist

    \section1 Installing the \B2Q Image

    Make sure you have the required tools installed in your development machine:

    \code
        sudo apt-get install u-boot-tools
    \endcode

    Then, upgrade the SD card with \B2Q. Use one of the commands below,
    depending on whether you are developing for embedded Android or Linux:

    \list
        \li \b{\B2QA}
        \code
            cd <INSTALL_DIR>
            ./Boot2Qt-2.x/iMX6-eAndroid/images/deploy.sh /dev/<device_name>
        \endcode
        \li \b{\B2QL}
        \code
            cd <INSTALL_DIR>
            sudo ./Boot2Qt-2.x/iMX6-eLinux/images/deploy.sh /dev/<device_name>
        \endcode
    \endlist

    After the installation is complete, insert the SD card, power on the device and check that
    the \B2Q welcome screen and/or demo appear.

    \section1 Setting up USB Access

    \include b2qt-post-install-setup.qdocinc setting up usb access

    \section1 Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring device kit

    You are now ready to start developing for your device. For more information,
    see \l{Building and Running an Example}.
*/

/*!
    \target Raspberry Pi Model B (embedded Linux)
    \page qtee-preparing-hardware-rasberrypi.html
    \title Preparing Raspberry Pi
    \previouspage qtee-installation-guide.html
    \nextpage qtee-building-and-running.html

    Take the following steps to prepare a  \l{http://www.raspberrypi.org/}
    {Raspberry Pi} for
    \B2Q.

    \note Ethernet networking is required to connect the device to Qt Creator.
    This means that the support is currently limited to Raspberry Pi Model B, which
    includes an Ethernet port.

    \note It is important that you repeat the steps in this section after you
    update \SDK.

    The image containing \B2Q stack for Raspberry Pi is included in the SDK,
    ready to be copied to an SD card.

    \section1 Preparing an SD Card

    An SD card of at least 512 MB capacity is sufficient.

    \include detect-sd-card-device-name.qdocinc instructions

    \section1 Installing the \B2Q Image

    To write the image to the SD card:

    \code
        cd <INSTALL_DIR>
        sudo Boot2Qt-2.x/raspberrypi-eLinux/images/deploy.sh /dev/<device_name>
    \endcode

    After the image has been deployed, insert the SD card, power on the device and check that
    the \B2Q welcome screen and/or demo appear.

    \section1 Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring network device

    You are now ready to start developing for your device. For more information,
    see \l{Building and Running an Example}.
*/

/*!
    \target BeagleBone Black (embedded Android and Linux)
    \page qtee-preparing-hardware-beaglebone.html
    \title Preparing BeagleBone Black
    \previouspage qtee-installation-guide.html

    Take the following steps to prepare a
    \l{http://beagleboard.org/products/beaglebone%20black}{BeagleBone Black} for \B2Q.

    \note It is important that you repeat the steps in this section after you
    update \SDK.

    The images containing the \B2Q stack for BeagleBone Black are included
    in \SDK, ready to be copied to an SD card.

    \section1 Preparing an SD Card

    For \B2QA, an SD card of at least 2 GB capacity is needed. For \B2QL,
    a card of at least 512 MB capacity is sufficient.

    \include detect-sd-card-device-name.qdocinc instructions

    \section1 Installing the Android image

    \e{If installing} \B2QL, \e{you can skip this step and proceed to}
    \l{Installing the Boot to Qt Image}.

    Download the package \e{TI_Android_JB_4.2.2_DevKit_4.1.1_beagleboneblack.tar.gz} from
    \l{http://downloads.ti.com/sitara_android/esd/TI_Android_DevKit/TI_Android_JB_4_2_2_DevKit_4_1_1/index_FDS.html}
    {Texas Instruments} (search for \e {BeagleBone Black} in the list of download packages).

    Use the following commands to create an SD card containing the
    downloaded image:

    \list 1
        \li Extract the downloaded package:
        \code
        ~$ tar zxvf ~/Downloads/TI_Android_JB_4.2.2_DevKit_4.1.1_beagleboneblack.tar.gz
        \endcode
        \li Run beagleboneblack/mkmmc-android.sh:
        \code
        ~$ cd beagleboneblack
        ~/beagleboneblack$ sudo ./mkmmc-android.sh /dev/<device_name>
        \endcode
    \endlist

    \section1 Installing the \B2Q Image

    Then, upgrade the SD card with \B2Q. Use one of the commands below,
    depending on whether you are developing for embedded Android or Linux:

    \list
        \li \b{\B2QA}
        \code
            cd <INSTALL_DIR>
            ./Boot2Qt-2.x/beaglebone-eAndroid/images/deploy.sh /dev/<device_name>
        \endcode
        \li \b{\B2QL}
        \code
            cd <INSTALL_DIR>
            sudo ./Boot2Qt-2.x/beaglebone-eLinux/images/deploy.sh /dev/<device_name>
        \endcode
    \endlist

    After the installation is complete, insert the SD card, power on the device and check that
    the \B2Q welcome screen and/or demo appear.

    \section1 Setting up USB Access

    \include b2qt-post-install-setup.qdocinc setting up usb access

    \section1 Configuring a Device Kit in Qt Creator

    \include b2qt-post-install-setup.qdocinc configuring device kit

    You are now ready to start developing for your device. For more information,
    see \l{Building and Running an Example}.
*/

/*!
    \page qtee-building-and-running.html
    \title Building and Running an Example
    \previouspage qtee-preparing-hardware.html
    \nextpage qtee-customization.html

    After you complete the installation and configuration steps for \SDK and the
    target devices, you can test the setup by creating a simple \l{Qt Quick}
    application and running it on the device:

    \list 1
        \li Make sure that your device is powered on and connected to the
            development host.
        \li In Qt Creator, select \b{File > New File or Project} >
            \b Applications > \b{Qt Quick Application} > \b{Choose}.
        \li Choose a location for your new project.
        \li In the \b{Qt Quick Component Set} dialog, select \b{Qt Quick 2.0}.
        \li In the \b{Kit Selection} dialog, select the kits for your
            devices. You can also select the emulator kit to test running the
            project in the emulator.
        \li Click \b{Next} and finish the wizard.
        \li In \b{Projects > Build & Run}, select the correct kit for your
            connected device.
        \li To build and run the project, click \inlineimage qtcreator-run.png
    \endlist

    \section1 Building and Running \B2Q Demos

    You can find the \B2Q demo applications in Qt Creator.

    \list 1
        \li Go to \b Welcome > \b Examples.
        \li Select a \e Boot2Qt Qt version from the drop-down list.
        \li Select a demo you want to build.
        \li In \b{Projects > Build & Run}, select the correct kit for your
            connected device or emulator.
        \li To build and run the project, click \inlineimage qtcreator-run.png
    \endlist

    \section1 Setting Up an Already Existing Project for Deployment

    New Qt Quick application projects generated by Qt Creator always have the correct
    settings for deployment on the device or emulator. However, other projects may
    need some changes.

    As a general rule, application binaries and resources (such as QML files and
    images) are deployed to the \c {/data/user/qt/<APPLICATION_NAME>} directory.
    Therefore, the \c path variable for the \c INSTALLS targets needs to be adjusted
    accordingly in .pro files.

    For example, change the following \c target.path value:

    \code
        target.path = ...
        INSTALLS += target
    \endcode

    to:

    \code
        target.path = /data/user/qt/<APPLICATION_NAME>
        INSTALLS += target
    \endcode
*/

/*!
    \page qtee-customization.html
    \title Customization
    \previouspage qtee-building-and-running.html
    \nextpage qtee-changelog.html

    \section1 Environment and Input

    By default, the basic environment variables and startup options of
    \B2Q applications are set in the file \c
    {/system/bin/appcontroller.conf} in embedded Android devices and
    in \c{/etc/appcontroller.conf} in embedded Linux devices.

    You can customize this file if you target a hardware device that
    has other input devices than the ones that the \B2Q stack is configured
    for by default.

    On some devices, the root file system (where this file
    resides) is mounted read-only at boot time. To allow modification,
    remount it read-write by entering the following command:
    \code
        <INSTALL_DIR>/Tools/b2qt/adb remount
    \endcode

    In the \c{appcontroller.conf} file, the input devices are
    specified by the lines similar to these:
    \code
        env=QT_QPA_GENERIC_PLUGINS=evdevtouch:/dev/input/event0
    \endcode

    Usually, you do not need to change this setting. USB input devices, such as
    keyboards and mice, are automatically recognized. The mouse pointer is shown
    automatically if a mouse is connected.

    However, hotplugging may not work, which means that the input
    devices, such as a keyboard and mouse, have to be connected at boot
    time.

    On some devices, for example the i.MX6 Sabre Lite, the touchscreen device is
    specified explicitly in \c QT_QPA_GENERIC_PLUGINS. This is necessary because
    the automatic device discovery would fail to find the touchscreen.

    \section1 Booting to a Custom Application

    After you have deployed your own application to the device, it will be
    launched on boot, instead of the \B2Q demo launcher. To prevent this
    behavior, remove the \b {Make this application the default one} step from
    the \b{Run Settings} for your project in the Qt Creator \b Projects mode.

    To remove your application from the default startup, use the following
    command:
    \code
        <INSTALL_DIR>/Tools/b2qt/adb shell appcontroller --remove-default
    \endcode

    \section1 Switching Between Portrait and Landscape Views

    Depending on device screen dimensions and application requirements, it might
    be desirable
    to change the default view orientation. The following example shows how to rotate your
    application in QML.

    \code
    import QtQuick 2.0

    Item {
        id: root
        width: 800
        height: 1280
        // Container element for rotating
        Rectangle {
            id: main
            // Swap the width and height of the root item
            width: root.height
            height: root.width
            anchors.centerIn: parent
            // Rotate 90 degrees clockwise around transformOrigin
            rotation: 90
            // The rotated content
            Text {
                text: qsTr("Hello World")
                anchors.centerIn: parent
            }
            MouseArea {
                anchors.fill: parent
                onClicked: {
                    Qt.quit();
                }
            }
        }
    }
    \endcode

    \section1 Disabling Screen Composer on Embedded Android

    By default, the \B2Q stack uses Android's screen composer, \e
    Surfaceflinger. It is required for Qt Multimedia functionality,
    i.e. video playback and camera. If that functionality is not
    required, Surfaceflinger may be disabled. This can in some
    situations improve performance.

    \list 1
      \li Edit \c {/system/bin/appcontroller.conf} to set the value of
      the environment variable \c QT_QPA_EGLFS_NO_SURFACEFLINGER to \c
      1 instead of \c 0.
      \li Disable the startup of \c surfaceflinger at boot-up. Either
      change \c /init.rc, or simply rename the \c
      {/system/bin/surfaceflinger} executable.
    \endlist

    \section1 Building Your Own Embedded Linux Image

    \B2QL is built using the tools and resources from the \l {Yocto Project},
    and is based on Yocto's reference distribution (\e Poky). You can
    use the same tools to build custom \B2Q images, and have control over
    which packages are included in the build and how the software stack
    is configured.

    \section2 Requirements

    You should be familiar with the Yocto tools and the concept of
    \e {recipes}. For more information, see Yocto Project
    \l{https://www.yoctoproject.org/documentation/current}{documentation}.

    To get started, you need the following:

    \list
        \li Install the \B2Q \e source packages. You can
            find these by running the \e MaintenanceTool application
            located in the \SDK installation directory and selecting
            \e {Package Manager}. The \e {Yocto meta layer} package
            contains the additional recipes required to make the image
            compatible with \B2Q.
        \li Install the dependencies for the Yocto tools. In Ubuntu,
            the following packages are required:
    \code
    sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath libsdl1.2-dev xterm
    \endcode
    \endlist

    \section2 Setting Up Yocto Build Environment

    Run the setup script that initializes the Yocto environment:

    \code
    cd <your/yocto/build/directory>
    <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-yocto-meta/b2qt-init-build-env .
    \endcode

    \section2 Building the Image and Toolchain

    After the Yocto environment is set up, you need to configure the
    build environment for your target device. Using Raspberry Pi as
    an example:

    \code
    export TEMPLATECONF=meta-b2qt/conf
    export MACHINE=raspberrypi
    source poky/oe-init-build-env build-raspberrypi
    \endcode

    Yocto recipes for \B2QL have two main targets to build: The target image,
    and the external toolchain that is used for building the Qt framework and
    applications.

    \code
    bitbake b2qt-embedded-image
    bitbake meta-toolchain-b2qt-embedded-sdk
    \endcode

    \note The generated target image does not yet include Qt libraries,
    you need to build Qt and add it into the image yourself.

    \section2 Building Qt and Addons

    \e {Build scripts} source package contains scripts that can be used to
    build Qt and all additional Qt addons that are part of \B2QL image.
    To setup build environment for your target hardware, create new build
    directory and run the initialization script. Using Raspberry Pi as
    an example:

    \code
    cd <your/qt/build/directory>
    <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-common/init_build_env.sh <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/config.raspberrypi
    \endcode

    You can use following scripts to build different parts of the \B2Q stack.

    \code
    <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/build_qt.sh <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/config.raspberrypi
    <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/build_extras.sh <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/config.raspberrypi
    <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/build_image.sh <INSTALL_DIR>/Boot2Qt-2.x/sources/b2qt-build-scripts/embedded-linux/config.raspberrypi
    \endcode

    After \e {embedded-linux/build_image.sh} has finished, you can flash the device with
    the updated image located in the build folder.

    \section2 Note About Support Services for Yocto Tools

    By default, Digia will only provide customer support for the Yocto
    recipes on the reference platforms, as delivered with \SDK, and
    setting up the development environment for them. Receiving support
    for any other configuration requires a separate service agreement
    between a customer and Digia.
*/

/*!
    \page qtee-supported-platforms.html
    \title Supported Platforms
    \previouspage qtee-installation-guide.html
    \nextpage qtee-changelog.html

    \section1 Supported Target Devices

    The \B2Q stack can be made to run on a variety of hardware. \B2QA
    requires hardware that has support for the Android operating system,
    version 4.0 or later.

    Approximate minimal hardware requirements for running \B2Q are:
    \list
        \li 256 MB of RAM
        \li 500 MHz CPU, 1 GHz preferred for 60-FPS velvet-smooth UI
        \li OpenGL ES 2.0 support
        \li Android 4.0+ compatible hardware
    \endlist

    \B2Q has been tested to work on the following reference devices:
    \list
        \li \l{http://www.google.com/nexus/7/specs/}{Google/Asus Nexus 7 (2012)}
        \li \l{http://beagleboard.org/hardware-xM}{BeagleBoard-xM}
        \li \l{http://beagleboard.org/products/beaglebone%20black}{BeagleBone Black}
        \li \l{http://boundarydevices.com/products/sabre-lite-imx6-sbc/}{Freescale i.MX6 Sabre Lite board (Boundary Devices)}
        \li \l{http://www.raspberrypi.org/faqs}{Raspberry Pi Model B}
    \endlist

    \section1 Supported Development Environment

    The development environment supported by \SDK is Ubuntu Linux 64-bit (12.04 LTS or 12.10).

    \sa {Requirements for Development Host}

*/

/*!
    \page qtee-licenses.html
    \title License Information
    \previouspage qtee-troubleshooting.html

    \section1 Licensing

    \SDK is licensed under the Qt Enterprise commercial license. For more information,
    see \l {http://qt.digia.com/licensing}. Evaluation licenses are also available,
    see \l {product page}{\SDK} on qt.digia.com.

    \section1 3rd Party Software Licenses

    The third-party licenses used in \SDK are listed in the file
    \c {<INSTALL_DIR>/Licenses/ThirdPartySoftware_Listing.txt}.

    \section1 Embedded Android Images

    The embedded Android platform is built from the \e {Android Open Source Project},
    source code available at \l {http://android.googlesource.com/}. The open
    source licenses and notices are collected into the file
    \c {/etc/NOTICE.html.gz} in the target images.

    \section1 Android GNU C++ Run-time Licensing

    The Android platform does not provide a full implementation of the C++ run-time. Instead,
    apps that depend on features such as STL, exceptions, or RTTI, must include an additional
    native run-time library that provides the features they need.

    \B2QA uses the GNU libstdc++ library distributed as part of the \e {Android Open Source Project}.
    This library is included in the images for \B2QA, and will be loaded by the application
    on start-up to meet the run-time requirements of Qt.

    The GNU C++ run-time is licensed under the
    \l{http://gcc.gnu.org/onlinedocs/libstdc++/manual/appendix_gpl.html}{GNU General Public License version 3} with
    an exception which grants permission for run-time linking and usage of the library by an application which
    would otherwise violate the terms of the main license. For more information about this exception, see
    \l{http://gcc.gnu.org/onlinedocs/libstdc++/manual/license.html}{the official license page}.
*/

/*!
    \page qtee-changelog.html
    \title ChangeLog
    \previouspage qtee-customization.html
    \nextpage qtee-troubleshooting.html

    \section1 \B2Q 2.0.0

    \list
        \li Release date: Feb. 25, 2014
    \endlist

    \section2 Changes
    \b {New Features}:
    \list
        \li \B2Q stack was updated to use Qt 5.2.1 on embedded Android and Linux
        \li Building your own \B2Q embedded Linux stack was enabled
        \li Emulator graphics performance and quality was improved (GL-streaming)
        \li BeagleBone Black was added as a reference device
        \li \l {Qt Virtual Keyboard} was integrated into \B2Q
        \li \l {Qt Quick Enterprise Controls} was added to the \B2Q stack
        \li \l {Qt Charts} was added to the \B2Q stack
        \li \B2Q source code was made available via online installer
        \li WiFi networking support/configuration were implemented on embedded Android
        \li Ethernet connectivity was enabled on embedded Android
    \endlist

    \b {Improvements}:
    \list
        \li Updated GDB for embedded Android toolchain
        \li Enterprise demos (Charts, Enterprise Controls) were added
        \li Embedded Linux: Moved to use Yocto 1.5 (Dora)
        \li Demos available as examples in Qt Creator
        \li Embedded Android emulator updated to Android 4.2.2
    \endlist

    \b {Fixed Bugs}:
    \list
        \li Embedded Android emulator: Missing Mesa headers
        \li Embedded Linux emulator: Black screen in camera demo
        \li Emulator tries to load host plugins
        \li Sensors not working in emulators
        \li Empty \c HOME environment variable in processes launched by appcontroller
        \li Embedded Android emulator: C++ debugging fails
        \li Qt add-ons not installed to host
    \endlist

    \b {Fixed Known Issues}:
    \list
        \li Qt SQL: QML LocalStorage Fails to Connect to Database on Embedded Android
        \li Qt XML Patterns: Module not Available on embedded Android
        \li Qt Multimedia: Audio is Muted on Nexus 7
        \li Unnecessary Warnings Displayed by the Installer
        \li Virtual Keyboard: Backspace Removes Two Characters
    \endlist

    \section1 \B2Q 1.0.1

    \list
        \li Release date: Dec. 5, 2013
    \endlist

    \section2 Changes
    \list
        \li Emulator: Remote control widget version shown together with emulator version
        \li Emulator: Mouse events are sent instead of touch events
        \li Emulator: Raster window support added
        \li Emulator: emulatorproxyd shows its version on startup
        \li Emulator: Detect some network problems
        \li Emulator: Fixed issues related to startup
        \li Emulator: Updated source code license headers
        \li Emulator: Show all VirtualBox errors
        \li Emulator: Video playback support on embedded Linux
    \endlist
*/

/*!
    \page qtee-troubleshooting.html
    \title Troubleshooting
    \previouspage qtee-changelog.html
    \nextpage qtee-licenses.html

    \note An updated version of this information may be available in Digia customer portal,
    see \l {Known Issues} in \SDK \l {product page}.

    \section1 General Issues

    \section2 I have problems deploying/launching the application in Qt Creator

    Check that the device is properly connected to the development host via USB
    or Ethernet (depending on the device).
    See \l{Connectivity Issues}.

    If using the emulator, see \l{Installing VirtualBox}.

    \section2 I have problems deploying/launching a Qt or Qt Quick example application

    Because of a technical peculiarity in \c{qmake}, it is not
    possible to get correct deployment setup for any application that
    is placed inside a Qt source code tree.

    The workaround is to copy the example sources to a location
    outside the Qt source tree, and open this copy of the example
    application instead.

    \section2 I have problems launching or running applications on hardware after updating the SDK

    Remember to repeat the process of updating also your device with the latest
    version of \B2Q. See \l{Installing Boot to Qt on Target Devices}.

    \section2 Booting Sabre Lite i.MX 6 stops with \e {6x_bootscript not found} error

    Check the U-Boot version number. It should start with either \c{2012} or \c{2013}.
    If it is \c{2009.xx}, an upgrade of the bootloader is required. For more
    information, see:

    \list
        \li \l http://boundarydevices.com/6q_bootscript/
        \li \l http://boundarydevices.com/switching-u-boot-versions-on-i-mx6/
    \endlist

    \section2 How do I restore my Nexus 7 to factory settings?

    Go to \l{https://developers.google.com/android/nexus/images} and
    download the correct file for your device. Unpack it, and then enter the
    following commands:

    \code
        <INSTALL_DIR>/Tools/b2qt/adb reboot bootloader
        <INSTALL_DIR>/Tools/b2qt/fastboot -w update <image-file>.zip
    \endcode

    \section2 How do I shut down the Nexus 7?

    If the \B2Q demo launcher is running, start the \b {Launcher
    Settings} app, and select \b {Shut Down} to power off the device.

    Otherwise, make sure the Nexus 7 is connected to the development host, and run
    the following command in a terminal:
    \code
        <INSTALL_DIR>/Tools/b2qt/adb shell reboot -p
    \endcode

    If the device is in the fastboot mode, use the volume button to display the
    \b {Power off} option and press the power button to power off the device.

    Alternatively, press and hold the power button for 10
    seconds. This will force a reboot.

    \section2 How do I get HDMI output working properly on BeagleBone Black?

    Depending on the HDMI monitor, the cable, and the build variant of
    the BeagleBone Black device, it may not be able to drive an HDMI display in a
    stable way; the image may disappear or stutter. These issues are not caused by
    the \B2Q stack.

    More details and possible solutions can be found
    \l {http://www.elinux.org/Beagleboard:BeagleBoneBlack_HDMI}{here}.

    \section2 Trying to build for the emulator target fails with error message \e{make: i686-android-linux-g++: Command not found}

    You need to install support libraries in order to run 32-bit programs in a
    64-bit Linux operating system.

    See \l{Installing 32-bit Support Libraries}.

    \section2 Something crashed!

    The following command shows the system log:
    \code
        <INSTALL_DIR>/Tools/b2qt/adb logcat
    \endcode

    \section2 Mouse or touch input does not work

    See \l{Customization}.

    \note Hotplugging does not currently work, and therefore, any input device
    must be present at boot time to be recognized.

    \section2 Application stops with \e{EGLFS: OpenGL windows cannot be mixed with others.}

    OpenGL and Qt Quick 2 applications can only have one
    fullscreen window existing at a time. Trying to create another
    OpenGL window, or trying to mix an OpenGL window with a raster one
    will display the above message and abort the application.

    \note For raster windows (software rendered content based on QWidget or
    QPainter), there is no such limitation.

    \section2 I cannot edit the contents of appcontroller.conf on the device

    The file system where this file is located may be mounted as read-only.

    See \l{Customization}.

    \section1 Connectivity Issues
    \section2 I cannot connect to my hardware device via USB

    See \l{5. Setting up USB Access to Embedded Devices}.

    \section2 adb fails with "error: more than one device and emulator"

    You have to specify which Android device you want \c{adb} to talk
    to, using adb's \c{-s <serial-number>} option. Use the following
    command to find to see the serial number of the connected
    devices:

    \code
        <INSTALL_DIR>/Tools/b2qt/adb devices
    \endcode

    \section2 The emulator cannot connect to the Internet

    By default, the VirtualBox is configured to use a host-only network, so external
    connections do not work in the emulator.

    You may be able to enable Internet connectivity with another
    virtual network adapter in NAT mode by adapting
    \l{http://askubuntu.com/questions/293816/in-virtualbox-how-do-i-set-up-host-only-virtual-machines-that-can-access-the-in}{these}
    instructions.

    \section2 The emulator is stuck in \e{Waiting for display data} or fails to start properly

    Check the output of the following command:

    \code
        <INSTALL_DIR>/Tools/b2qt/adb devices
    \endcode

    If the emulator (192.168.56.101) is not listed there, try connecting to it:

    \code
        <INSTALL_DIR>/Tools/b2qt/adb connect 192.168.56.101
    \endcode

    If the emulator is already listed, try disconnecting it:
    \code
        <INSTALL_DIR>/Tools/b2qt/adb disconnect 192.168.56.101
    \endcode

    And then close the emulator and retry.

    \section2 What are the user and password to access my embedded Linux device?

    Embedded Linux devices can be accessed using user \c{root} and an empty password.


*/