Friday, October 26, 2012

Unembedded Font Error in IEEE PDF eXpress Plus

Recently when I was going to submit a camera ready version of a paper to a conference I had to do it via IEEE PDF eXpress Plus. This website provides the verification facility for our papers to check whether they meet the correct formatting requirements defined in IEEE paper templates. What I had to do is submit a PDF version of my paper through my account and check whether my paper is OK according to the IEEE standards.

I was using Latex to prepare my paper with the help of IEEE conference paper templates. However, when I initially submitted the paper to the site it was rejected with an error report. The error report mentioned that some fonts in my paper are not embedded. These fonts are Times-Italic, Times-Roman, Times-BoldItalic, Times-Bold, Helvetica and Courier. I searched the web as usual to find a solution. According to some links I found in the web there are some commands to be issued when generating my PDF from the latex source files in addition to the other usual commands I use. 

So, I issued the commands as described in those web sites and then the resulting PDF was passed by IEEE PDF eXpress Plus without any error. Since there is a high probability for me to face this error in the future again, I thought to make it available here. The followings are the commands I issued to generate my PDF from latex source files.

    latex research_paper.tex

    bibtex
research_paper.aux

    latex
research_paper.tex

    latex
research_paper.tex

    dvips -Ppdf -G0 -tletter
research_paper.dvi

    ps2pdf -dCompatibilityLevel=1.4 -dEmbedAllFonts=true -dPDFSETTINGS=/prepress
research_paper.ps research_paper.pdf


Web Sources:

1. http://mohamednabeel.blogspot.com/2009/10/fixing-font-not-embedded-issue-to-pass.html

2. http://www.latex-community.org/forum/viewtopic.php?f=5&t=11296


Friday, October 19, 2012

Serial Line Internet Protocol (SLIP) implementation in Python

Sometime back I had a requirement to communicate with an external device which is connected to a USB port of my computer. The external device was a MSB430 sensor mote running contiki on it. My application running on the mote communicate with the computer using SLIP protocol. Therefore I needed to make my program on the PC to communicate using SLIP protocol over the USB port with the sensor mote.


Serial Line Internet Protocol (SLIP) is a very simple protocol which can be used to communicate between different devices over serial lines. It just encodes the users data byte streams before writing to the serial line and decode after reading from the serial line. I found a C language implementation of the SLIP protocol but I wanted a Python implementation. So first thing I did was searching through the Internet for a python based implementation of SLIP. But I couldn't find anything. Finally what I had to do is implement it on my own. Since there can be more people who need such a Python based implementation of SLIP protocol, I thought to put my code in the Internet.

My code consists of two source files. SLIP protocol encoding and decoding functions are defined in the ProtoSLIP.py file. Another file named as SerialComm.py wraps around those functions and provide some high-level functions which can be used by a user program to open a serial port, write data to it and read data from it using SLIP protocol. So, here we go.

Content of the ProtoSLIP.py file

1:  import termios  
2:  import serial  
3:  from collections import deque  
4:  SLIP_END = 0300          # declared in octal  
5:  SLIP_ESC = 0333    
6:  SLIP_ESC_END = 0334  
7:  SLIP_ESC_ESC = 0335  
8:  DEBUG_MAKER = 0015  
9:  MAX_MTU = 200  
10:  readBufferQueue = deque([])  
11:  #-------------------------------------------------------------------------------  
12:  # This function takes a byte list, encode it in SLIP protocol and return the encoded byte list  
13:  def encodeToSLIP(byteList):  
14:       tempSLIPBuffer = []  
15:       tempSLIPBuffer.append(SLIP_END)  
16:       for i in byteList:  
17:            if i == SLIP_END:  
18:                 tempSLIPBuffer.append(SLIP_ESC)  
19:                 tempSLIPBuffer.append(SLIP_ESC_END)  
20:            elif i == SLIP_ESC:  
21:                 tempSLIPBuffer.append(SLIP_ESC)  
22:                 tempSLIPBuffer.append(SLIP_ESC_ESC)  
23:            else:  
24:                 tempSLIPBuffer.append(i)  
25:       tempSLIPBuffer.append(SLIP_END)  
26:       return tempSLIPBuffer  
27:  #-------------------------------------------------------------------------------  
28:  #-------------------------------------------------------------------------------  
29:  # This function uses getSerialByte() function to get SLIP encoded bytes from the serial port and return a decoded byte list  
30:  def decodeFromSLIP(serialFD):  
31:       dataBuffer = []  
32:       while 1:  
33:            serialByte = getSerialByte(serialFD)  
34:            if serialByte is None:  
35:                 return -1  
36:            elif serialByte == SLIP_END:  
37:                 if len(dataBuffer) > 0:  
38:                      return dataBuffer  
39:            elif serialByte == SLIP_ESC:  
40:                 serialByte = getSerialByte(serialFD)  
41:                 if serialByte is None:  
42:                      return -1  
43:                 elif serialByte == SLIP_ESC_END:  
44:                      dataBuffer.append(SLIP_END)  
45:                 elif serialByte == SLIP_ESC_ESC:  
46:                      dataBuffer.append(SLIP_ESC)  
47:                 elif serialByte == DEBUG_MAKER:  
48:                      dataBuffer.append(DEBUG_MAKER)  
49:                 else:  
50:                      print("Protocol Error")  
51:            else:  
52:                 dataBuffer.append(serialByte)  
53:       return            
54:  #-------------------------------------------------------------------------------  
55:  #-------------------------------------------------------------------------------  
56:  # This function read byte chuncks from the serial port and return one byte at a time  
57:  def getSerialByte(serialFD):       
58:       if len(readBufferQueue) == 0:  
59:            #fetch a new data chunk from the serial port       
60:            i = 0  
61:            while len(readBufferQueue) < MAX_MTU:  
62:                 newByte = ord(serialFD.read())  
63:                 readBufferQueue.append(newByte)  
64:            newByte = readBufferQueue.popleft()  
65:            return newByte  
66:       else:  
67:            newByte = readBufferQueue.popleft()  
68:            return newByte  
69:  #-------------------------------------------------------------------------------  

Content of the SerialComm.py file

1:  import ProtoSLIP  
2:  import termios  
3:  import serial  
4:  #-------------------------------------------------------------------------------  
5:  # This function connect and configure the serial port. Then returns the file discripter  
6:  def connectToSerialPort():  
7:       serialFD = serial.Serial(port='/dev/ttyUSB0', baudrate=115200, bytesize=8, parity='N', stopbits=1, xonxoff=False, rtscts=False)  
8:       # port='/dev/ttyUSB0'- port to open  
9:       # baudrate=115200  - baud rate to communicate with the port  
10:       # bytesize=8           - size of a byte  
11:       # parity='N'           - no parity  
12:       # stopbits=1           - 1 stop bit  
13:       # xonxoff=False           - no software handshakes  
14:       # rtscts=False           - no hardware handshakes  
15:       if serialFD < 0:  
16:            print("Couldn't open serial port")  
17:            return -1  
18:       else:  
19:            print("Opened serial port")  
20:            return serialFD  
21:  #-------------------------------------------------------------------------------  
22:  #-------------------------------------------------------------------------------  
23:  # This function accept a byte array and write it to the serial port  
24:  def writeToSerialPort(serialFD, byteArray):  
25:       encodedSLIPBytes = ProtoSLIP.encodeToSLIP(byteArray)  
26:       byteString = ''.join(chr(b) for b in encodedSLIPBytes) #convert byte list to a string  
27:       serialFD.write(byteString)  
28:       return  
29:  #-------------------------------------------------------------------------------  
30:  #-------------------------------------------------------------------------------  
31:  # This function reads from the serial port and return a byte array  
32:  def readFromSerialPort(serialFD):  
33:       i = 1  
34:       byteArray = None  
35:       byteArray = ProtoSLIP.decodeFromSLIP(serialFD)  
36:       if byteArray is None:  
37:            print "readFromSerialPort(serialFD): Error"  
38:            return -1  
39:       else:  
40:            return byteArray  
41:  #-------------------------------------------------------------------------------  
42:  #-------------------------------------------------------------------------------  
43:  # This function reads from the serial port and return a byte array  
44:  def disconnectFromSerialPort(serialFD):  
45:       serialFD.close()  
46:       return  
47:  #-------------------------------------------------------------------------------  

SerialComm.py file should be imported from a user program and call the functions appropriately. I hope comments I have put in the code will make understanding of functionality of the program clear enough. Some information like the exact serial port we are opening, baud rate, parity, etc has to be edited in the code according to the requirement.

I hope my code will help someone. Cheers!



Multitasking in life: A good idea ?

From the beginning of my research life, I have been working on multiple tasks at the same time. At the same time means I had to interchangeably do several tasks in a day without completely focusing on a specific one for a long time. However sometimes I had to involve in a single work since there were no any other task to be done. The stressful workload I'm handling these days made my mind to review my way of working and reorganise it if necessary.

    I have been thoroughly reviewing research papers and different documents for research purposes. Now I have an important requirement to review my life and my working pattern in a similar way to find any defects of it. The experiences of last few weeks showed me some important issue in multitasking. I have so many important works to be done and unfortunately almost all of them seems need high priority. Moreover each of those tasks takes a significant amount of time and effort. I did up to now and I will do my best in the future to make all those works done simultaneously but I have a bad feeling that doing things in this way does not result in a good quality work.

    When comparing to the days where I did one important task a day, doing things interchangeably seems a very bad idea. Unlike computers, my mind is not very good at multitasking. When I switch between multiple tasks it seems I'm not making any good progress in each of the tasks. I have a feeling that if I do all these works in a sequential manner I could complete all the works before completing things by doing parallel even with a much more good quality. This is because when I involve in a single work for a longer time I get very good amount of time to think about it. Fresh ideas and innovation fills my mind making the work really successful. However when doing things parallel, before my mind settle down on one work I have to switch the task. Therefore it's hard to keep the focus on what I'm doing right now resulting in less quality work.

    OK, having the understanding about single tasking is better for me than multitasking, why do I still keep doing multiple tasks interchangeably everyday? This is the most important question. I don't have the control of my life completely. There are things I have the control and there are a lot more things which are out of my reach. Sometimes it seems I'm not very good at identifying things which I have my control. For example I usually hesitate to say 'No' to people and because of that I trap in works which I really don't have to do. However there are some works which are actually out of my control and therefore I have to do such works somehow. For example main research project works in our lab, my final year research project works and also other academic works like assignments, etc are out of my control. Therefore those works come into my 'To Do' list with higher priorities and I have to find some time slot for all those works in my busy schedule.

    This is really a problematic situation. Last few days I was so much stressed. Specially yesterday evening I could not figure out how I'm going to make any progress in my life in this way. Therefore yesterday when I went back to my boarding place I directly went to sleep without doing anything else. This morning I thought I should write down my situation because it helps when bringing the thoughts out from my mind and into some different form. So, that's what I did right now. I will find better ways to organise my works in particular and organise my life in general in the future from now on.