Converged IoT Developer Platform

I installed the most popular racing drone motor on the tail of a hobby helicopter for IOT/MQTT/COAP research to see what happened. It cruised for 35 minutes straight, breaking the world record of any commercial platform of 250 grams by 50+% extra mission time! The fuselage is Blade Fusion 180s body; the main motor size is 4004 for utility inspector drones. The main rotor is built from 180-250 sized helicopter parts. The flight computer and tail motor are taken from the famous racing quadcopter HGLRC Petrel 132. Is it nice if highways were patrolled by camera drones to broadcast the video of traffic accidents, and an AI server phones motorists to get out of the road at the immediate exit before lining up in a traffic jam?

The build procedures notes are 

https://nocomputerbutphone.blogspot.com/2018/09/converged-iot-platform-build-notes.html

https://nocomputerbutphone.blogspot.com/2020/04/iot-platform-endurance.html

https://nocomputerbutphone.blogspot.com/2018/08/converged-drone-at-edge-of-space.html

The part listing is in the following table. A shipping discount for multiple items from a vendor has been applied. No volume discounts are used.

The entire craft can be built without a machine shop and hence can be repaired by gig workers in a car.  Only light hand tools and light electric tools powered by car batteries are needed. This creates jobs.

And the working endurance video follows,

C Programming Raspberry Pi MQTT Drone PWM

Drones commonly require real time programming because a split second control delay of a tail rotor can mean 180 degrees difference of a helicopter's heading.  For this reason, flight controller programming is often done with C language on a micro controller, where control logic can be optimized on a per-CPU-instruction basis.

However, a new trend has emerged to use Raspberry Pi Zero as a robotic controller to take advantage of the ubiquitous Linux programming, which the OS hides the underlying custom circuitry of micro controllers and presents the abstract programming interface to the programmers so that a program can be portable between different hardware systems. Adafruit has many tutorials focus on the Python library for the I2C devices. But, again, few resources provide the comprehensive view of the requirement of real time C programming. So, as soon as I found a hint of a C library controlling I2C servos, I have to jump in and test drive its performance.

The solution is https://github.com/Reinbert/pca9685 . Steps I took:

1. "Burn" SD Card with 2017-06-21-raspbian-jessie-lite.img , which is public downloadable from raspberrypi official site. After first powering on with the "burned" SD, wait for the disk expansion to finish in a few minutes while green LED light busy flashes.
2. Wire up as the following diagram, 
   
3. The usual IP connectivity chores. First thing is to get UART access through USB-FTDI adapter. Raspberry Pi Kernel side needs "enable_uart=1" in /boot/config.txt . To do so, insert the SD in to my PC to mount it .  
4.  Then try to get IP access. Comment out the wlan entries in /etc/network/interfaces , and replaces it with my AP access credential,
   auto wlan0
   iface wlan0 inet static
   address 192.168.43.5
   netmask 255.255.255.0
   gateway 192.168.43.1
   wpa-ssid "pc36000"
   wpa-psk "A...."
   Then, systemctl enable ssh , and reboot. Once IP SSH access is successful, apt install vim , and comment out the "enable_uart=1" .
5. apt-get install git-core
   git clone git://git.drogon.net/wiringPi
   cd wiringPi/
   ./build
6. git clone https://github.com/Reinbert/pca9685.git
   cd pca9685/src/
   sudo make install
7. cd; mkdir mqtt-pizero
   cd mqtt-pizero
8. vim servo-check.c ; The content follows,
   
   #include <pca9685.h>

   #include <stdio.h>

   
   

   int calcTicks(float impulseMs, int hertz)

   {

   float cycleMs = 1000.0f / hertz;

   return (int)(4096 * impulseMs / cycleMs + 0.5f);

   }

   
   

   int main()

   {

   int fd = pca9685Setup(300, 0x40, 50);

   pca9685PWMReset(fd);

   
   

   float millis = 1.5;

   int tick = calcTicks(millis, 50);

   pwmWrite(300, tick);

   
   

   while (1)

   {

   delay(1000);

   millis = 1.8;

   tick = calcTicks(millis, 50);

   pwmWrite(300, tick);

   
   

   delay(1000);

   millis = 1.2;

   tick = calcTicks(millis, 50);

   pwmWrite(300, tick);

   }

   }
9. gcc servo-check.c -o servo-check -l wiringPiPca9685 -l wiringPi
10. apt install i2c-tools
11. sudo vim /boot/config.txt ;  uncomment the following line,
    dtparam=i2c_arm=on
    
12. sudo vim /etc/modules; content follows,
    i2c-dev
    i2c-bcm2708
    
13. sudo vim /etc/modules-load.d/modules.conf; content follows,
    i2c-dev
    i2c-bcm2708
    
14. sudo sync ; sudo reboot
15. Once rebooted, check i2c device is at 0x40 by gpio readall ; then cd mqtt-pizero/ ; ./servo-check

Inbound And Outbound Dialings Are "Institutional"

Why are there inbound and outbound boundaries with phones but not with Facebook/Google/Apple voice chats? Can we answer that question by looking at the smallest bits and pieces ourselves? I think so. But, what is the implication behind all these?

OK. In my diagram above, when lines, connections touch, it means they are associated. The purple inbound dialings do not touch any trunk lines, which means the inbound dialings are not associated with any particular trunk line. The orange PBX outbound dialing does not touch any phone line and is not associated with any phone protocol. The PBX outbound dialing, however, does touch SIP trunk line, which means it only goes out on the SIP trunk and not H323 protocol. So, all that means is that an inbound dialing does not care what the outbound trunk or protocol will be; an outbound dialing does not care what the inbound phone or protocol is. This is the essence of the PSTN call leg and the essence of VOIP.
For the green VOIP signal dash lines, the corresponding configs are in pjsip.aor.conf ,

[101] type=aor [102] type=aor

[SIP-to-CUCM] type=aor contact=sip:10.1.10.76:5060

, and in ooh323.conf ,

[10.1.10.76] type=friend context=from-trunk host=10.1.10.76 port=1720

[ekiga223] IP=10.1.10.223 port = 1720 type=peer context=from-external

. The purple inbound dialings are in extensions_additional.conf ,
[ext-did-0002]
exten => 18001231101,1,Set(__DIRECTION=INBOUND)
exten => 18001231101,n(dest-ext),Goto(from-did-direct,101,1)

exten => 18001231102,1,Set(__DIRECTION=INBOUND)
exten => 18001231102,n(dest-ext),Goto(from-did-direct,102,1)

exten => 18004561203,1,Set(__DIRECTION=INBOUND)

exten => 18004561203,n(dest-ext),Goto(from-did-direct,203,1)

, and outbound dialings are also in extensions_additional.conf , 

[outrt-1] ; siptrunk

exten => _1800321XXXX,1,Macro(user-callerid,LIMIT,EXTERNAL,)

exten => _1800321XXXX,n,Macro(dialout-trunk,2,${EXTEN:7},,off)

[outrt-2] ; h323trunk

exten => _1800654XXXX,1,Macro(user-callerid,LIMIT,EXTERNAL,)

exten => _1800654XXXX,n,Macro(dialout-trunk,1,${EXTEN:7},,off)

. The FreePBX GUI generates the entire extensions_additional.conf and pjsip_aor.conf . ooh323.conf is entirely manually created. All configurations are downloadable here, https://drive.google.com/file/d/0B2NfHoyfFf1aTWR6QUxQQVhkQWc .
The GUI dialogs are

The voice-vlan enabled router configuration is as  https://drive.google.com/file/d/0B2NfHoyfFf1aNXRhMnJyU01Zb0E .
The CUCM GUI screenshots are 

So, a call leg becomes a proxy in the TCP/IP/HTTP world so that the destination and source phones do not know the IP address of each other. The very definition of protocol proxy. It provides some isolation("does not care") of parts of the network while requiring the border routers to have the insights into the protocol. Speaking of proxy, do you know that this very page you are viewing is a proxy'ed page when you are at blog.mpls-phone.com, which is 34.225.89.249 . The true IP address of the web server is google's blogger web server IP address. That will be yet another posting about the Apache configuration that made the proxy.

Watching The Branch Office Traffic

The branch office is on the far side of the WAN, and predictably the SCCP phones are on the branch router's EtherSwitch ports. So, how to find the actual voice packets that we want to know how much network bandwidth is utilized?

1. Easy, just browse the flow exports pcap. But the number of voice flows is actually a very small fraction of the number of signaling flows. Just look at this screenshot of pcap search, 
   , the first actual voice flow is at packet 280. The IP source/destination is indistinguishable between small, frequent signaling flows and actual voice flow. It turns out, among the thousands of packets, only 3 are actual voice traffic flow exports. Browsing is out of the question. The real C1900's flow pcap is at https://drive.google.com/file/d/0B2NfHoyfFf1aMzlNbnM0SkhpQTg/view?usp=sharing . You can try it yourself. 
2. Easy, just search the TOS on the flow exports pcap, right? The problem is that the hardware phone is subject to change without notice, so the TOS number is unknow. 
3. Why not search for flow packet size? The size is actually unknown as well. In above screenshot, there is a roughly 36MB sized packet every half an hour of 1800 seconds. The string "Octets: 360" seems very unique. However,  how do you get this number? Intranet voice runs at the common 64kbps for u/alaw 8kps sample,  8 bits quantization. (64+16overhead)kbps * 1800 seconds / 8bit/Byte . It should be 18MB. It turns out, the counting is done twice for each packet while ingress to the router and at the egress interface. There is no certain way to foresee the search string "Octets: 360".

It turns out, ELK search is necessary to figure out what search strings we want! And that search is performed by ranking all flow size(bytes), and the 36MB stands out in the crowd of 1KB short signaling flows.

The ELK graphing is as below picture after taking out all signaling flows,

. Notice, that straight ELK can't handle niche fields like VLAN ID. When VLAN ID is present, ELK may simply discard the whole flow. That is why we need to alter the flow content in an editor in the terminal.

Now, after going through so much, are we sure that modern phone voice indeed is with 8kps sampling rate? According to Math, 8 kHz sampling rate can only transmit 4kHz sound, and that seems too low for high human hearing. The answer is that modern SD phone speech is defined as from 300 to 3400 Hz. We can hear a lot wider range of sounds than we can make. And the speech encoding is not meant to transmit Hi-Fi music, waves, etc.

Mind In The Data Center Zone

Zoning out on a compact setup that has everything.

The MQTT logs come from the Internet, sourced from a ARM mosquitto program. And the Kibana display of the MQTT traffic flow is this,

, notice TOS is marked down to precedence 1 (TOS 32 decimal), by T-Mobile. And a hundred of these IoT sensors looks like the picture at the top.