HTTP

HTTP is the protocol that allows for sending documents back and forth on the web. A protocol is a set of rules that determines which messages can be exchanged, and which messages are appropriate replies to others.

HTTP Proxies

An HTTP proxy is a program that acts as an intermediary between a client and a server. It receives requests from clients, and forwards those requests to the intended servers. When a client uses a proxy, it typically sends all requests to that proxy, instead of to the servers in the URLs. Requests to a proxy differ from normal requests in one way: in the first line, they use the complete URL of the resource being requested, instead of just the path. For example,

GET http://www.somehost.com/path/file.html HTTP/1.0

 That way, the proxy knows which server to forward the request to.

HTTP Verbs

HTTP verbs tell the server what to do with the data identified by the URL. The request can optionally contain additional information in its body, which might be required to perform the operation for instance, data you want to store with the resource.

GET / HTTP/1.1

means the GET method is being used, while


DELETE /clients/anne HTTP/1.1
means the DELETE method is being used.


Other HTTP verbs are PUT,DELETE,OPTIONS,HEAD.

HTTP Status codes

The status code is meant to be computer-readable;

• The status code is a three-digit integer, and the first digit identifies the general category of response:
  

• 1xx indicates an informational message only
• 2xx indicates success of some kind
• 3xx redirects the client to another URL
• 4xx indicates an error on the client's part
• 5xx indicates an error on the server's part
  

Basic REST principels

REST is a simple way to organize interactions between independent systems. REST is a set of principles that define how Web standards, such as HTTP and URIs, are supposed to be used. The five key principles are:

• Give every “thing” an ID
• Link things together
• Use standard methods
• Resources with multiple representations
• Communicate statelessly
  

Give every “thing” an ID

Everything that should be identifiable should obviously get an ID on the Web, there is a unified concept for IDs: The URI. URIs make up a global namespace, and using URIs to identify your key resources means they get a unique, global ID. The main benefit of a consistent naming scheme for things is that you don’t have to come up with your own scheme you can rely on one that has already been defined, works pretty well on global scale and is understood by practically anybody.  

Link things together

<order self='http://example.com/customers/1234' > 
   <amount>23</amount> 
   <product ref='http://example.com/products/4554' /> 
   <customer ref='http://example.com/customers/1234' /> 
</order>

we can easily imagine how an application that has retrieved it can “follow” the links to retrieve more information. This would be the case if there were a simple “id” attribute adhering to some application-specific naming scheme, too — but only within the application’s context. The beauty of the link approach using URIs is that the links can point to resources that are provided by a different application.

links are useful way to make an application dynamic.

Use standard methods

Set of standard methods includes GET,POST,PUT, DELETE, HEAD and OPTIONS.

GET supports very efficient and sophisticated caching, so in many cases, you don’t even have to send a request to the server. You can also be sure that a GET is idempotent — if you issue a GET request and don’t get a result, you might not know whether your request never reached its destination or the response got lost on its way back to you. The idempotence guarantee means you can simply issue the request again. Idempotence is also guaranteed for PUT (which basically means “update this resource with this data, or create it at this URI if it’s not there already”) and for DELETE (which you can simply try again and again until you get a result — deleting something that’s not there is not a problem). POST, which usually means “create a new resource”, can also be used to invoke arbitrary processing and thus is neither safe nor idempotent.

Resources with multiple representations

Provide multiple representations of resources for different needs. For example, Using HTTP content negotiation, a client can ask for a representation in a particular format:

GET /customers/1234 HTTP/1.1
Host: example.com 
Accept: application/vnd.mycompany.customer+xml  

The result might be some company-specific XML format that represents customer information. If the client sends a different request, e.g. one like this:

GET /customers/1234 HTTP/1.1
Host: example.com 
Accept: text/x-vcard 

The result could be the customer address in VCard format.

Communicate statelessly

In REST, stateless means that there is no client session data stored on the server. The server only records and manages the state of the resources it exposes. If there needs to be session-specific data, it should be held and maintained by the client and transferred to the server with each request as needed. A service layer that does not have to maintain client sessions is a lot easier to scale, as it has to do a lot fewer expensive replications in a clustered environment.

Run Python script in the background as a service in raspberry pi on boot

This is a simple service in Python and need it to start running in the background when the Raspberry Pi boots. Here Python script receive udp data in real time. The following init script makes getting a Python script (or e.g. a Perl script) to run when the Raspberry Pi boots fairly painless. Services are supposed to run as "daemons" which is quite complicated in Python. We use start-stop-daemon command to run our script in the background and basically deals with everything we need.

This is init file save it as myservice.sh at

 /etc/init.d   

 #!/bin/sh 
 ### BEGIN INIT INFO 
 # Provides:     myservice 
 # Required-Start:  $remote_fs $syslog 
 # Required-Stop:   $remote_fs $syslog 
 # Default-Start:   2 3 4 5 
 # Default-Stop:   0 1 6 
 # Short-Description: Put a short description of the service here 
 # Description:    Put a long description of the service here 
 ### END INIT INFO 
 # Change the next 3 lines to suit where you install your script and what you want to call it 
 DIR=/usr/local/bin/myservice 
 DAEMON=$DIR/myservice.py 
 DAEMON_NAME=myservice 
 # Add any command line options for your daemon here 
 DAEMON_OPTS="" 
 # This next line determines what user the script runs as. 
 # Root generally not recommended but necessary if you are using the Raspberry Pi GPIO from Python. 
 DAEMON_USER=root 
 # The process ID of the script when it runs is stored here: 
 PIDFILE=/var/run/$DAEMON_NAME.pid 
 . /lib/lsb/init-functions 
 do_start () { 
   log_daemon_msg "Starting system $DAEMON_NAME daemon" 
   start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --user $DAEMON_USER --chuid $DAEMON_USER --startas $DAEMON -- $DAEMON_OPTS 
   log_end_msg $? 
 } 
 do_stop () { 
   log_daemon_msg "Stopping system $DAEMON_NAME daemon" 
   start-stop-daemon --stop --pidfile $PIDFILE --retry 10 
   log_end_msg $? 
 } 
 case "$1" in 
   start|stop) 
     do_${1} 
     ;; 
   restart|reload|force-reload) 
     do_stop 
     do_start 
     ;; 
   status) 
     status_of_proc "$DAEMON_NAME" "$DAEMON" && exit 0 || exit $? 
     ;; 
   *) 
     echo "Usage: /etc/init.d/$DAEMON_NAME {start|stop|restart|status}" 
     exit 1 
     ;; 
 esac 
 exit 0 

Then create myservice.py file at /usr/local/bin/myservice . and also create output.txt file in the same directory. change permission by chmod 777 myservice.py

 import sys, struct  
 from socket import *  
 SIZE = 1024   # packet size  
 hostName = gethostbyname('0.0.0.0')  
 mySocket = socket( AF_INET, SOCK_DGRAM )  
 mySocket.bind((hostName,18736))  
 repeat = True  
 while repeat:  
   (data,addr) = mySocket.recvfrom(SIZE)  
   data = struct.unpack('d',data)  
   data=int(data[0])  
   file = open("output.txt", "w")  
   file.write(str(data))  
   file.close()  

To run this when raspberry pi boot

 sudo nano /etc/rc.local  

:

then add bellow line before exit line in rc.local 

 sudo /etc/init.d/myservice.sh start  

you can also manually start your Python script using the command

 sudo /etc/init.d/myservice.sh start  

check its status with the

 sudo /etc/init.d/myservice.sh status  

stop it with

 sudo /etc/init.d/myservice.sh stop   

Run script at boot as service

This is achieved using the init run-level based rc scripts. Basically the command "service" used to start and stop system services. for example "service <your script> start".

  # update boot / reboot files   
  sudo cp <your script> /etc/init.d/ # <your script> your script file with the path   
  # do it as soon as the device is going down,   
  # both for shutdown and reboot   
  sudo chmod u+x <your script>   
  sudo update-rc.d /etc/init.d/<your script> defaults   

The <your script> is : 

   #! /bin/sh   
   ### BEGIN INIT INFO   
   # Provides:   <your script name>   
   # Required-Start: $all   
   # Required-Stop:    
   # Default-Start:  2 3 4 5   
   # Default-Stop:  0 1 6   
   # Short-Description: Manage my cool stuff   
   ### END INIT INFO   
   PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/opt/bin   
   . /lib/init/vars.sh   
   . /lib/lsb/init-functions   
   # If you need to source some other scripts, do it here   
   case "$1" in   
   start)   
    log_begin_msg "Starting my super cool service"   
   # do something   
    log_end_msg $?   
    exit 0   
    ;;   
   stop)   
    log_begin_msg "Stopping the coolest service ever unfortunately"   
    # do something to kill the service or cleanup or nothing   
    log_end_msg $?   
    exit 0   
    ;;   
   *)   
    echo "Usage: /etc/init.d/<your script> {start|stop}"   
    exit 1   
    ;;   
   esac   

Then replace # do something with the content of your original script. for example : 
 

 sudo service hostapd stop  
 sudo service udhcpd stop  
 sudo service hostapd start  
 sudo service udhcpd start   

Simulink with Matlab

In the MATLAB command window enter the command               
                    

            >> simulink

The alternate method is to click the Simulink icon in the MATLAB toolbar

  A Simulink library window will pop up as shown below :

 

Introduction to Simulink in MATLAB

Simulink (Simulation and link) is developed by MathWorks as an add-on with MATLAB. It is a graphical programming language which offers modelling, simulation and analyzing of multi domain dynamic systems under Graphical User Interface (GUI) environment. The Simulink have tight integration with the MATLAB environment and have a comprehensive block libraries and toolboxes for linear and nonlinear analyses. The system models can be so easily constructed via just click and drag operations. The Simulink comes handy while dealing with control theory and model based design.

Receive data from a Simulink's built-in "UDP Send" block in python

 import sys, struct  
 import time  
 from socket import *  
 SIZE = 1024   # packet size  
 hostName = gethostbyname('0.0.0.0')  
 mySocket = socket(AF_INET,SOCK_DGRAM)  
 mySocket.bind((hostName,18726))  
 repeat = True  
 while repeat:  
   (data,addr) = mySocket.recvfrom(SIZE)  
   data = struct.unpack('d',data)  
   print int(data[0])  

List no of bluetooth devices that are connected to raspberry pi

 import bluetooth  
 print("performing inquiry...")  
 nearby_devices = bluetooth.discover_devices(lookup_names = True)  
 print("found %d devices" % len(nearby_devices))  
 for addr, name in nearby_devices:  
   print(" %s - %s" % (addr, name))  

Check availability of a device via bluetooth in raspberry pi

 #!/usr/bin/python  
 import bluetooth  
 import time  
 while True:  
   print "Checking " + time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime())  
   result = bluetooth.lookup_name('1C:66:AA:CF:DD:35', timeout=5)  
   if (result != None):  
     print "Available"  
   else:  
     print "Not Available"  
   time.sleep(60)  

Audio Slicing in python

Divide the audio file into no of sample by time interval and then play.

 import wave  
 import pygame  
 import time  
 import sys  
 def slice(infile, outfilename, start_ms, end_ms):  
   width = infile.getsampwidth() #Returns sample width in bytes  
   rate = infile.getframerate() #Returns sampling frequency  
   fpms = rate / 1000 # frames per ms  
   length = (end_ms - start_ms) * fpms  
   start_index = start_ms * fpms  
   out = wave.open(outfilename, "w")  
   out.setparams((infile.getnchannels(), width, rate, length, infile.getcomptype(), infile.getcompname()))  
   infile.rewind()       #Rewind the file pointer to the beginning of the audio stream  
   anchor = infile.tell()   #Return current file pointer position  
   infile.setpos(anchor + start_index) #Set the file pointer to the specified position  
   out.writeframes(infile.readframes(length)) #Write audio frames and make sure nframes is correct  
 if __name__ == "__main__":  
   slice(wave.open("song1.wav", "r"), "out.wav", int(sys.argv[1]), int(sys.argv[2]))  
   pygame.mixer.init()  
   pygame.mixer.music.load("out.wav")  
   pygame.mixer.music.play()  
   while pygame.mixer.music.get_busy() == True:  
     continue