Source

LO52 / zigbee_c3 / presentation.tex

  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
\documentclass[trans]{beamer}
%%\documentclass{beamer}

\usepackage{natim-beamer}
\usepackage{multirow}
\usepackage{listings}

\usetheme[shownavigation={true},  % true | false
          logo={images/ionyse.png},
          titlepageimage={images/titleimage.png},
          header=utbm,          % fullnav | shortnav | utbm
          dept={Logiciels Embarqués et Informatique Mobile}
        ]{UTBM}
\usecolortheme{UTBMOfficial}
\usepackage{upgreek}

\title[API de Zigbee]{L'API de Zigbee}
\subtitle{LO52 - Automne \the\year}
\author{Rémy HUBSCHER}
\institute{remy.hubscher@utbm.fr}
\date{\today}


\hypersetup{
      pdfpagemode = FullScreen,% afficher le pdf en plein écran
      pdfauthor   = {Rémy HUBSCHER},%
      pdftitle    = {LO52 : L'API de Zigbee},%
      pdfsubject  = {UTBM - LO52},%
      pdfkeywords = {utbm, leim, lo52, api, zigbee},%
      pdfcreator  = {PDFLaTeX},%
      pdfproducer = {PDFLaTeX}%
}

\begin{document}
\lstset{language=C,breaklines=true,xleftmargin=7mm,basicstyle=\scriptsize,frame=single,framexleftmargin=7mm,captionpos=b,tabsize=2,numbers=left,numberstyle=\scriptsize,escapechar={\%}{\_}}

\selectlanguage{french}

\begin{frame}[plain]
  \titlepage
\end{frame}

\AtBeginSection[]{
   \begin{frame}
     \frametitle{Sommaire}
     %%% affiche en début de chaque section, les noms de sections et
     %%% noms de sous-sections de la section en cours.
     \tableofcontents[currentsection,hideothersubsections]
   \end{frame} 
}

\begin{frame}
  \frametitle{Sommaire}
  \tableofcontents[pausesections,hideothersubsections]
\end{frame}

\section{Introduction}

\begin{frame}
  \frametitle{Introduction}
  \begin{enumerate}
    \item Conversation entre deux humains
    \pause \item Conversation entre deux ordinateurs
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Conversation entre deux humains}
  \begin{enumerate}
    \item Jane et Mike doivent discuter
    \pause \item Les deux se mettent d'accord sur une même langue
    \pause \item Jane commence et Mike attends qu'elle termine pour répondre
    \pause \item Si un camion passe Jane va demander à Mike de repéter ...
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Conversation entre deux ordinateurs}
  \begin{enumerate}
    \item Les règles de validations doivent être définies
    \pause \item Si l'un parle tout le temps et l'autre écoute pas de problème
    \pause \item Prenons un exemple : \textbf{La base météorologique}
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{La base météorologique}
  \begin{enumerate}
    \item Au départ, la base capte uniquement la luminosité et envoie cette valeur sur 1 octet\\
      \pause \texttt{135...136...137...138...137...136...139...135...128...110...125...130}
    \pause \item Ensuite on ajoute un capteur de température qui envoie la valeur sur 1 octet\\
      \pause {\footnotesize \texttt{138...135...138...135...137...136...139...128...140...115...128...130}}
    \pause \item Quelle est la valeur correspondante à l'un ou l'autre ?
    \pause \item On introduit le \textbf{Start byte}\\
      \pause {\footnotesize \texttt{255...135...138...255...137...136...255...128...140...255...128...130}}
    \pause \item Si on ajoute maintenant un capteur d'humidité qui a besoin de plus de temps pour récupèrer la valeur ?
    \pause \item On introduit le \textbf{Length byte}\\
      \pause {\footnotesize \texttt{255...2...135...138...255...3...137...136...110...255...2...128...130}}

    \pause \item En parlant de cette structure, on parle de frame
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{La base météorologique}
  \begin{enumerate}
    \item Notre base se complexifie et nous avons maintenant une dizaine de capteurs
    \pause \item On introduit le \textbf{Contents ID}
    \pause \item C'est un identifiant du capteur. (10: temperature, 11: luminosité, 12: humidité, 13: vitesse du vent, 14: hydrométrie, ...)
      \pause {\footnotesize \texttt{255...2...11...135...10...138...255...3...12...139...13...140...00...128}}
    \pause \item Ainsi on peut aussi ajouter un identifiant de la base, l'état de charge de la batterie du capteur ...
    \pause \item Que ce passe-t-il lors d'une erreur de transmission ?
    \pause \item Analogie : Jane et Mike en soirée \pause | \textbf{Le checksum}
  \end{enumerate}
\end{frame}

\section{Zigbee API Protocol}
\subsection{Configurer le Xbee en mode API}
\begin{frame}
  \frametitle{Configurer le Xbee en mode API}
  \begin{enumerate}
    \item L'API de Zigbee fonctionne de manière similaire
    \pause \item Le microcontrolleur des puces Xbee ne permet pas de
    contenir les deux firmwares AT mode et API mode, il faudra donc
    flasher le composant avec X-CTU en fonction du mode souhaité.
  \end{enumerate}
  \pause \image{xbee-api-firmware}{0.5}
\end{frame}

\subsection{Description d'une frame}
\begin{frame}
  \frametitle{Description d'une frame}

  \begin{tabular}{|l|l|l|l|l|}
    \hline
    \textbf{Start} & \multicolumn{2}{|l|}{\textbf{Lenght}} & \textbf{Frame data}         & \textbf{Checksum}\\
    \hline
    \textit{Byte 1}          & \textit{Byte 2}  & \textit{Byte 3}     & \textit{Byte 4 ... Byte n} & \textit{Byte n+1}\\
    \hline
    \texttt{0x7E}            & MSB              & LSB                 & API specific structure     & Single byte\\
    \hline
  \end{tabular}

  \pause
  \begin{enumerate}
    \item \textbf{Au départ}, on recherche le premier 0x7E \pause (126 en décimal)
    \pause \item \textbf{La longueur} totale de la frame est donc $(MSB \times 0xFF) + LSB$
    \pause \item Généralement MSB est égal à zéro sauf si la longueur de la frame est supérieure à 255 et nécessite donc plus d'un octet.
    \pause \item \textbf{Frame data bytes :} Analogie avec un livre
    \pause \item \textbf{Checksum :} 
    \begin{itemize}
      \pause \item \textbf{Création :} Additionner tous les octets de la \textit{frame data} garder le plus petit octet et le soustraire à \texttt{0xFF}
      \pause \item \textbf{Vérification :} Additionner tous les octets de la \textit{frame data} et le checksum, vous devez trouver \texttt{0xFF}
      \pause \item \textbf{Byte mask :} \texttt{\& 0xFF} | \texttt{0x5215 \& 0xFF => 0x15}
    \end{itemize}
  \end{enumerate}

\end{frame}


\subsection{API Frame Types}
\begin{frame}
  \frametitle{API Frame Types}
  \begin{enumerate}
    \item Différence entre un livre de cuisine et un rapport de stage
    \pause \item Il existe 12 types de frames différentes pour Xbee ZB
  \end{enumerate}

  \begin{center}
  \begin{tabular}{|l|l|}
    \hline
    \textbf{Type}       & \textbf{Data}\\
    \hline
    \textit{Byte 4}     & \textit{Byte 5 ... Byte n}\\
    \hline
    \texttt{0x08}       & AT command (immediate)\\
    \hline
    \texttt{0x09}       & AT command (queued)\\
    \hline
    \texttt{0x95}       & Node Identification Indicator\\
    \hline
    \texttt{0x88}       & AT command response\\
    \hline
    \texttt{0x8A}       & Modem Status\\
    \hline
    \texttt{0x10}       & TX request\\
    \hline
    \texttt{0x8B}       & TX response\\
    \hline
    \texttt{0x90}       & RX received\\
    \hline
    \texttt{0x92}       & RX I/O data received\\
    \hline
    \texttt{0x17}       & Remote Command Request \\
    \hline
    \texttt{0x97}       & Remote Command Response\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}


\subsection{AT commands}
\begin{frame}
  \frametitle{API Frame Types : AT command}
  \begin{enumerate}
    \item Ce sont les mêmes qu'en AT command mode
  \end{enumerate}

  \pause
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}        & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}        & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x04}        & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x08}        & AT command immediate\\
    Frame ID                    & 4                      & \textit{0x52}        & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK}\\
    AT command                  & 5                      & \textit{0x4E} (N)    & Nom de la commande sur \\
                                & 6                      & \textit{0x4A} (J)    & 2 caractères ASCII\\
    Parameter                   &                        &                      & Valeur a entrer, ou demande\\
    \hline
    Checksum                    & 7                      & \textit{0x0D}        & $0xFF - ((0x08+0x52+0x4E$\\
                                &                        &                      & $    +0x4A)  \&  0xFF)$ \\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{AT response}
\begin{frame}
  \frametitle{API Frame Types : AT response}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}        & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}        & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x05}        & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x88}        & AT command response\\
    Frame ID                    & 4                      & \textit{0x01}        & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK}\\
    AT command                  & 5                      & \textit{0x42} (B)    & Nom de la commande sur \\
                                & 6                      & \textit{0x44} (D)    & 2 caractères ASCII\\
    Status                      & 7                      & \textit{0x00}        & 0 = OK \\
                                &                        &                      & 1 = ERROR \\
                                &                        &                      & 2 = Invalid Command \\
                                &                        &                      & 3 = Invalid Parameter \\
                                &                        &                      & 4 = TX failure \\
    Data                        &                        &                      & La valeur lors d'une demande\\
    \hline
    Checksum                    & 8                      & \textit{0xF0}        & $0xFF - ((0x88+0x01+0x42$\\
                                &                        &                      & $    ++0x44+0x00)  \&  0xFF)$ \\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{Zigbee Transmit Request}
\begin{frame}
  \frametitle{Zigbee Transmit Request}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x16}   & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x10}   & TX request\\
    Frame ID                    & 4                      & \textit{0x01}   & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK}\\
    \hline
    64-bits                     & MSB 5                  & \textit{0x00}   & Si connue l'adresse exacte\\
    destination                 & 6                      & \textit{0x13}   & Sinon, 0x0 pour le coordinateur\\
    address                     & 7                      & \textit{0xA2}   & Ou encore 0xFFFF pour le \\
                                & 8                      & \textit{0x00}   & broadcast\\
                                & 9                      & \textit{0x40}   & \\
                                & 10                     & \textit{0x0A}   & \\
                                & 11                     & \textit{0x01}   & \\
                                & LSB 12                 & \textit{0x27}   & \\
    \hline
    16-bits                     & MSB 13                 & \textit{0xFF}   & Si connue, l'adresse locale\\
    destination                 & LSB 14                 & \textit{0xFE}   & Sinon \texttt{0xFFFE}\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}


\begin{frame}
  \frametitle{Zigbee Transmit Request}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Broadcast radius            & 15                     & \textit{0x00}   & {\footnotesize Nb de bonds - 0 pour la valeur de ATNH}\\
    \hline
    Options                     & 16                     & \textit{0x00}   & {\footnotesize 0x01 : Desactive ACK}\\
                                &                        &                 & {\footnotesize 0x20 : Active APS encryption (si EE 1) }\\
                                &                        &                 & {\footnotesize 0x40 : Timeout étendue}\\
    \hline
    RF Data                     & 17                     & \textit{0x54}   & Data that is send to\\
                                & 18                     & \textit{0x78}   & the destination device\\
                                & 19                     & \textit{0x44}   & ATNP pour connaitre la taille max \\
                                & 20                     & \textit{0x61}   & de RF Data\\
                                & 21                     & \textit{0x74}   & \\
                                & 22                     & \textit{0x61}   & Si APS est active, RF contient \\
                                & 23                     & \textit{0x30}   & 4 octets de moins\\
                                & 24                     & \textit{0x41}   & \\
    \hline
    Checksum                    & 25                     & \textit{0x13}   & 0xFF - 8-bits somme des bits\\
                                &                        &                 & entre offset 3 et cet octet (25)\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{Zigbee Transmit Status}
\begin{frame}
  \frametitle{Zigbee Transmit Status}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x07}   & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x8B}   & TX response\\
    Frame ID                    & 4                      & \textit{0x01}   & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK}\\
    \hline
    16-bits                     & 5                      & \textit{0x7D}   & L'adresse locale de reception\\
    destination                 & 6                      & \textit{0x84}   & du TX request\\
    \hline
    Retry count                 & 7                      & \textit{0x00}   & Nb d'essai de transmission\\
    \hline
    Delivery status             & 8                      & \textit{0x00}   & 0x00 = Success\\
                                &                        &                 & 0x01 = MAC ACK Failure\\
                                &                        &                 & 0x02 = CCA Failure\\
                                &                        &                 & 0x15 = Invalid destination\\
                                &                        &                 & 0x21 = Network ACK failure\\
                                &                        &                 & 0x22 = Not joined network\\
                                &                        &                 & 0x23 = Self addressed\\
  \end{tabular}
  \end{center}
\end{frame}

\begin{frame}
  \frametitle{Zigbee Transmit Status}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    Delivery status             & 8                      & \textit{0x00}   & 0x24 = Address not found\\
                                &                        &                 & 0x25 = Route not found\\
                                &                        &                 & 0x26 = Broadcast source failed\\
                                &                        &                 & 0x2B = Invalid binding table index\\
                                &                        &                 & 0x2C = {\footnotesize Resource error, lack of free buffers}\\
                                &                        &                 & 0x2D = {\footnotesize Attempted broadcast with APS}\\
                                &                        &                 & 0x2E = {\footnotesize \^ ~~~~ with APS but EE = 0}\\
                                &                        &                 & 0x32 = Resource error\\
                                &                        &                 & 0x74 = Data payload too large\\
                                &                        &                 & 0x75 = {\footnotesize Indirect messages unrequested}\\
    \hline
    Discovery status            & 9                      & \textit{0x01}   & 0x00 = No discovery overhead\\
                                &                        &                 & 0x01 = Address discovery\\
                                &                        &                 & 0x02 = Route discovery\\
                                &                        &                 & 0x03 = {\footnotesize Address and Route discovery}\\
                                &                        &                 & 0x40 = Extended timeout discovery\\
    \hline
    Checksum                    & 10                     & \textit{0x71}   & 0xFF - 8-bits somme des bits\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{Zigbee Receive Packet}
\begin{frame}
  \frametitle{Zigbee Receive Packet}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x11}   & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x90}   & RX received\\
    \hline
    64-bits                     & MSB 4                  & \textit{0x00}   & Si connue l'adresse exacte\\
    source                      & 5                      & \textit{0x13}   & Sinon, 0xFFFFFFFFFFFFFFFF\\
    address                     & 6                      & \textit{0xA2}   & si l'adresse 64-bits \\
                                & 7                      & \textit{0x00}   & de l'expéditeur\\
                                & 8                      & \textit{0x40}   & est inconnue\\
                                & 9                      & \textit{0x52}   & \\
                                & 10                     & \textit{0x2B}   & \\
                                & LSB 11                 & \textit{0xAA}   & \\
    \hline
    16-bits                     & MSB 12                 & \textit{0xFF}   & L'adresse locale\\
    source                      & LSB 13                 & \textit{0xFE}   & de l'expéditeur\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}


\begin{frame}
  \frametitle{Zigbee Receive Packet}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Options                     & 14                     & \textit{0x01}   & {\footnotesize 0x01 : Packet acknoledged}\\
                                &                        &                 & {\footnotesize 0x02 : Packet was a broadcast}\\
                                &                        &                 & {\footnotesize 0x20 : Packet encrypted with APS}\\
                                &                        &                 & {\footnotesize 0x40 : Packet send from an END-device}\\
    \hline
    RX Data                     & 15                     & \textit{0x52}   & Data that is received.\\
                                & 16                     & \textit{0x78}   & \\
                                & 17                     & \textit{0x44}   & \\
                                & 18                     & \textit{0x61}   & \\
                                & 19                     & \textit{0x74}   & \\
                                & 20                     & \textit{0x61}   & \\
    \hline
    Checksum                    & 25                     & \textit{0x0D}   & 0xFF - 8-bits somme des bits\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{Zigbee I/0 Sample Rx Indicator}

\begin{frame}
  \frametitle{Zigbee I/0 Sample Rx Indicator}
  Nous avons vu les types de frames basiques qui nous permettent :

  \begin{enumerate}
    \pause \item De configurer notre puce Xbee
    \pause \item D'envoyer des données
    \pause \item De recevoir des données
    \pause \item De vérifier le statut de nos commandes et transmissions
  \end{enumerate}

  Le Zigbee I/O Sample Rx Indicator est juste une extension du Zigbee Receive Packet.
\end{frame}

\begin{frame}
  \frametitle{Zigbee I/0 Sample Rx Indicator}

  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x14}   & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x92}   & RX I/O data received\\
    \hline
    64-bits                     & MSB 4                  & \textit{0x00}   & Si connue l'adresse exacte\\
    source                      & 5                      & \textit{0x13}   & de l'expéditeur\\
    address                     & 6                      & \textit{0xA2}   & \\
                                & 7                      & \textit{0x00}   & \\
                                & 8                      & \textit{0x40}   & \\
                                & 9                      & \textit{0x52}   & \\
                                & 10                     & \textit{0x2B}   & \\
                                & LSB 11                 & \textit{0xAA}   & \\
    \hline
    16-bits                     & MSB 12                 & \textit{0x7D}   & L'adresse locale\\
    source                      & LSB 13                 & \textit{0x84}   & de l'expéditeur\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}


\begin{frame}
  \frametitle{Zigbee I/0 Sample Rx Indicator}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Options                     & 14                     & \textit{0x01}   & {\footnotesize 0x01 : Packet acknoledged}\\
                                &                        &                 & {\footnotesize 0x02 : Packet was a broadcast}\\
    \hline
    Nb d'éléments               & 15                     & \textit{0x01}   & {\footnotesize Nombre d'éléments (Toujours 1)}\\
    \hline
    Masque du canal             & 16                     & \textit{0x00}   & {\footnotesize Détermine les PIN I/O actifs}\\
    Digital                     & 17                     & \textit{0x1C}   & \\
    \hline
    Masque du canal             & 18                     & \textit{0x02}   & \\
    Analogique                  &                        &                 & \\
    \hline    
    Elements digital            & 19                     & \textit{0x00}   & \\
                                & 20                     & \textit{0x14}   & \\
    \hline
    Elements Analog             & 21                     & \textit{0x02}   & \\
                                & 22                     & \textit{0x25}   & \\
    \hline
    Checksum                    & 23                     & \textit{0xF5}   & 0xFF - 8-bits somme des bits\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\subsection{Zigbee Remote Command Request}
\begin{frame}
  \frametitle{Zigbee Remote Command Resquest}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x13}   & et checksum\\
    \hline
    Frame type                  & 3                      & \textit{0x17}   & Remote Command Request\\
    Frame ID                    & 4                      & \textit{0x01}   & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK}\\
    \hline
    64-bits                     & MSB 5                  & \textit{0x00}   & Adresse de la destination\\
    destination                 & 6                      & \textit{0x13}   & \\
    address                     & 7                      & \textit{0xA2}   & {\footnotesize 0x0000000000000000 pour le coordinator}\\
                                & 8                      & \textit{0x00}   & \\
                                & 9                      & \textit{0x40}   & {\footnotesize 0x000000000000FFFF pour le broadcast}\\
                                & 10                     & \textit{0x52}   & \\
                                & 11                     & \textit{0x2B}   & \\
                                & LSB 12                 & \textit{0xAA}   & \\
    \hline
    16-bits                     & MSB 13                 & \textit{0xFF}   & L'adresse locale\\
    destiantion                 & LSB 14                 & \textit{0xFE}   & 0xFFFE si inconnue\\
    \hline
  \end{tabular}
  \end{center}
\end{frame}


\begin{frame}
  \frametitle{Zigbee Remote Command Resquest}
  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Options                     & 15                     & \textit{0x02}   & {\footnotesize 0x01 : Disable ACK}\\
                                &                        &                 & {\footnotesize 0x02 : Apply change on remote}\\
                                &                        &                 & {\footnotesize 0x40 : Use extended transmission timeout}\\
    \hline
    AT                          & 16                     & \textit{0x42} (B)  & Name of the command\\
    Command                     & 17                     & \textit{0x48} (H)  & \\
    \hline
    Parameter                   & 18                     & \textit{0x01}   & Indicate the value to set\\    
    \hline
    Checksum                    & 19                     & \textit{0xF5}   & 0xFF - 8-bits somme des bits\\
    \hline
  \end{tabular}
  \end{center}

  \begin{enumerate}
    \item Il est possible d'envoyer plusieurs commande avec 15 set to \texttt{0x0}
    \pause \item Cela permet d'activer ensuite toutes les commandes en envoyant \texttt{AC}
    \pause \item On parle d'opération atomique ou de transaction.
  \end{enumerate}
\end{frame}

\subsection{Zigbee Remote Command Response}
\begin{frame}
  \frametitle{Zigbee Remote Command Response}
  Chaque Remote Command Request envoyé avec un Frame ID différent de 0 va recevoir une réponse.

  \vspace{-0.5cm}
  \pause
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    \textbf{Frame field}        & \textbf{Offset}        & \textbf{Ex}     & \textbf{Description}\\
    \hline
    Start delimiter             & 0                      & \textit{0x7E}   & \\
    \hline
    \multirow{2}{*}{Length}     & MSB 1                  & \textit{0x00}   & Nombre d'octet entre length \\
                                & LSB 2                  & \textit{0x13}   & et checksum \\
    \hline
    Frame type                  & 3                      & \textit{0x97}   & RX I/O data received \\
    Frame ID                    & 4                      & \textit{0x55}   & {\footnotesize ID pour le ACK, \texttt{0x00} pas de ACK} \\
    \hline
    64-bits                     & MSB 5                  & \textit{0x00}   & Si connue l'adresse exacte \\
    source                      & 6                      & \textit{0x13}   & de l'expéditeur \\
    address                     & 7                      & \textit{0xA2}   & \\
                                & 8                      & \textit{0x00}   & \\
                                & 9                      & \textit{0x40}   & \\
                                & 10                     & \textit{0x52}   & \\
                                & 11                     & \textit{0x2B}   & \\
                                & LSB 12                 & \textit{0xAA}   & \\
    \hline
  \end{tabular}
  \end{center}  
\end{frame}

\begin{frame}
  \frametitle{Zigbee Remote Command Response}

  \vspace{-0.7cm}
  \begin{center}
  \begin{tabular}{|l|l|l|l|}
    \hline
    16-bits                     & MSB 13                 & \textit{0x7D}   & L'adresse locale\\
    source                      & LSB 14                 & \textit{0x84}   & de l'expéditeur\\
    \hline
    AT                          & 15                     & \textit{0x53} (S)  & Name of the command\\
    Command                     & 16                     & \textit{0x4C} (L)  & \\
    \hline
    Command                     & 17                     & \textit{0x00}   & 0 = OK \\
    Status                      &                        &                 & 1 = ERROR \\
                                &                        &                 & 2 = Invalid Command \\
                                &                        &                 & 3 = Invalid Parameter \\
                                &                        &                 & 4 = TX failure \\
    \hline
    Command                     & 18                     & \textit{0x40}   & \\
    Data                        & 19                     & \textit{0x52}   & Données enregistrées au format\\
                                & 20                     & \textit{0x2B}   & binaire. Si c'est un set, ce\\
                                & 21                     & \textit{0xAA}   & champ n'est pas retourné.\\
    \hline
    Checksum                    & 22                     & \textit{0xF0}   & 0xFF - 8-bits somme des bits\\
    \hline
  \end{tabular}
  \end{center}
  
\end{frame}

\section{Utiliser ce dont vous avez besoin}

\begin{frame}
  \frametitle{Une stratégie minimaliste}
  
  \begin{enumerate}
    \item L'API est capable de gérer tous les cas de figures.
    \pause \item La plupart du temps, on en utilise qu'une infime partie et on ignore les autres.
    \pause \item Si vous n'utilisez pas le Digital PIN, ça ne servira à rien de vérifier le Digital Mask ou les Digital Samples.
    \pause \item On utilise donc une stratégie minimaliste | Uniquement ce qui nous est utile.
  \end{enumerate}
\end{frame}

\subsection{Exemple avec Arduino - Lecture d'une API frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Lecture}
  
  \begin{lstlisting}
void loop() {
    // Make sure everything is in the buffer
    if (Serial.available() >= 21) {
      // look for the start byte
      if (Serial.read() == 0x7E) {
        // blink debug LED to indicate when data is received
        digitalWrite(debugLED, HIGH);
        delay(10);
        digitalWrite(debugLED, LOW);
        // Drop the variables that we are not using lenght, frame type, frame id ...
        for (int i = 0; i<18; i++) {
          byte discard = Serial.read();
        }
        int analogHigh = Serial.read();
        int analogLow = Serial.read();
        analogValue = analogLow + (analogHigh * 0xFF);
      }
    }
}
  \end{lstlisting}
\end{frame}

\subsection{Exemple avec Arduino - Écriture d'une API frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.3cm}
  
  \begin{lstlisting}
 // Pass value as 0x4 or 0x5 to turn the pin on or off
void setRemoteState(value) {
  Serial.print(0x7E, BYTE);  // Start Byte
  Serial.print(0x0, BYTE);   // High part of length
  Serial.print(0x10, BYTE);  // Low part of length
  Serial.print(0x17, BYTE);  // Remote AT Command
  Serial.print(0x0, BYTE);   // frame id set for no reply

  // ID of recipient set 0xFFFF to broadcast
  Serial.print(00, BYTE);
  Serial.print(00, BYTE);
  Serial.print(00, BYTE);
  Serial.print(00, BYTE);
  Serial.print(00, BYTE);
  Serial.print(00, BYTE);
  Serial.print(0xFF, BYTE);
  Serial.print(0xFF, BYTE);

  // Local ID set to 0xFFFE for unknown
  Serial.print(0xFF, BYTE);
  Serial.print(0xFE, BYTE);
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.3cm}
  
  \begin{lstlisting}
  // 0x02 to apply changes immediately
  Serial.print(0x02, BYTE);

  // ATD1 to set the first digital pin of Xbee
  Serial.print('D', BYTE);   // AT command first char
  Serial.print('1', BYTE);   // AT command second char

  Serial.print(value, BYTE); // Value given as parameter
  
  long sum = 0x17 + 0xFF + 0xFF + 0xFF + 0xFE;
  sum = sum + 0x02 + 'D' + '1' + value;

  // Set the proper checksum
  Serial.print(0xFF - (sum & 0xFF), BYTE);
}
  \end{lstlisting}
\end{frame}

\subsection{Utiliser une bibliothèque}

\begin{frame}
  \frametitle{Utiliser une bibliothèque}
  On va bien sur utiliser une bibliothèque pour gérer nos commandes à l'API :

  \begin{enumerate}
    \pause \item \textbf{Avantage} : tout est écrit pour vous et juste
    \pause \item \textbf{Désavantage} : Il va falloir lire pas mal de documentation \pause en anglais
    \pause \item \textbf{Arduino \& C/C++} : \url{http://code.google.com/p/xbee-arduino/}
    \pause \item \textbf{Python} : \url{http://code.google.com/p/python-xbee/}
    \pause \item \textbf{Processing \& Java} : \url{http://code.google.com/p/xbee-api/}
  \end{enumerate}

  Attention, il y a deux modes d'API, \texttt{ATAP 1} et \texttt{ATAP 2} avec des caractères échappés.
\end{frame}


\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.35cm}
  
  \begin{lstlisting}
// Copyright (c) 2009 Andrew Rapp. On GPL License
#include <XBee.h>
#include <NewSoftSerial.h>

XBee xbee = XBee();
uint8_t ssRX = 9;
uint8_t ssTX = 10;
NewSoftSerial nss(ssRX, ssTX); // USB Serial connected to (9, 10 pin)

uint8_t shCmd[] = {'S','H'};   // ATSH
uint8_t slCmd[] = {'S','L'};   // ATSL
uint8_t assocCmd[] = {'A','I'};// ATAI (Association status)

AtCommandRequest atRequest = AtCommandRequest(shCmd);
AtCommandResponse atResponse = AtCommandResponse();

void setup() { 
  xbee.begin(9600);
  Serial.begin(9600);
  
  delay(5000); // Wait for XBee radio to initialize.
}
  \end{lstlisting}
\end{frame}
\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.3cm}
  
  \begin{lstlisting}
void loop() {
  sendAtCommand(); // get SH
  atRequest.setCommand(slCmd); // set atRequest to SL
  sendAtCommand(); // get SL
  atRequest.setCommand(assocCmd); // set atRequest to AI
  sendAtCommand(); // get AI
  
  // we're done.  Hit the Arduino reset button to start the sketch over
  while (1) {};
}

void sendAtCommand() {
  nss.println("Sending command to the XBee");

  // send the command
  xbee.send(atRequest);

  // wait up to 5 seconds for the status response
  if (xbee.readPacket(5000)) {
    // got a response
  \end{lstlisting}
\end{frame}
\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.3cm}
  
  \begin{lstlisting}
  // should be an AT command response
  if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE) {
    xbee.getResponse().getAtCommandResponse(atResponse);
    if (atResponse.isOk()) {
      nss.print("Command [");
      nss.print(atResponse.getCommand()[0]);
      nss.print(atResponse.getCommand()[1]);
      nss.println("] was successful!");

      if (atResponse.getValueLength() > 0) {
        nss.print("Command value length is ");
        nss.println(atResponse.getValueLength(), DEC);

        nss.print("Command value: ");
        
        for (int i = 0; i < atResponse.getValueLength(); i++) {
          nss.print(atResponse.getValue()[i], HEX);
          nss.print(" ");
        }

        nss.println("");
      } 
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Exemple d'usage de l'API avec Arduino - Écriture}
  \vspace{-0.3cm}
  
  \begin{lstlisting}
    } else {
      nss.print("Command return error code: ");
      nss.println(atResponse.getStatus(), HEX);
    }
  } else {
    nss.print("Expected AT response but got ");
    nss.print(xbee.getResponse().getApiId(), HEX);
  }  
} else {
  // at command failed
  if (xbee.getResponse().isError()) {
    nss.print("Error reading packet.  Error code: ");  
    nss.println(xbee.getResponse().getErrorCode());
  } 
  else {
    nss.print("No response from radio");  
  }
}
  \end{lstlisting}
\end{frame}


\end{document}