Wadix Group

Controller Area Network - Development Process

2011-11-20T00:52:00.000-08:00

DEVELOPMENT PROCESS

As the application is designed to be as simple as possible, the first thing to start with is a simple code which uses buttons for connecting to the board (“Connect”) and disconnecting from it (“Disconnect”).

For displaying the information received from the board, a RichEdit is placed into the application. The source code should have functions for opening ports, closing them, reading from and writing to the buffer as well as error handling.

Code Snippet

//-----Code Snippet from the TCommPort Constructor-----//
TCommPort::TCommPort()
: m_CommOpen(false),
m_CommPort(“COM5”),
m_hCom(0)
{
 m_dcb.DCBlength = sizeof(DCB);
 m_dcb.BaudRate  =1382400;
 m_dcb.ByteSize  =8;
 m_dcb.Parity    =NOPARITY;    //NOPARITY and friends are #defined in windows.h
 m_dcb.StopBits  =ONESTOPBIT;  //ONESTOPBIT is also from windows.h
}
//----end of TCommPort constructor-----//

The first step of implementing the communication library into the application is to assign the “OpenCommPort()” function to the “Connect” Button.

// Open the COM PORT

com->OpenCommPort();

“com” is the name of the class used to call functions from the library. This is enabled by the following code snippet at the top of the file:

TCommPort *com = new TCommPort;

The “OpenCommPort()” function first checks if the port is already open and if so throws an exception and then proceeds to handle the COM port treating it to be a file. It then writes the relevant configurations to the port like BaudRate, ByteSize and Parity. Besides the port open function, the Connect button also disables all other buttons while enebling the Disconnect Button. A safety feature to cut down on the amount of error messages the user may face.

The final application consists of seven buttons namely: Start, Stop, Exit, Connect, Disconnect, Run, Save along with two RichEdit Boxes namely: Display and Message.

A screenshot of the running application

At the start of the application, all the buttons, timers and flags are initialized to a default status.

The code snippet below provides the information:

__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
// Intializing the Buttons
Start->Enabled = true;
Stop->Enabled = false;
Exit->Enabled = true;
Connect->Enabled = false;
Disconnect->Enabled = false;
Run->Enabled = false;
Save->Enabled = false;
// Initializing the flags
open_port = false;
filesaved = false;
// Initializing the Timer
Timer1->Enabled = false;
}

Main features of the Buttons:

Start: Initially only the Start and the Exit buttons are enabled. With the click of the Start button the system becomes active enabling the Connect, Stop and Exit buttons and displaying an information regarding the status of the system through the RichEdit Box named “Message”.

Connect: The Connect button press triggers the application to display a helpful message to the user through RichEdit Box “Message” letting them know that the port has been opened. It disables the Start button while enabling the Run, Disconnect, Stop, Exit buttons also updating various flag status mainly the open_port flag.

Run: The Run button press updates various button status. The major feature being triggering the Timer added to the application from the C++ Builder. This is done using the following code snippet:

Timer1->Enabled = true;

The enabled timer updates the RichEdit Box “Display” with the data from the CAN-Bus every millisecond, clears the buffer and then repeats itself until an external agent deactivates (Disconnect/Stop buttons) the process.

Disconnect: The Disconnect button press enables the Save, Connect, Stop and Exit buttons while keeping Run, Start and Disconnect buttons deactivated. This also disables the Timer and other flags and double checks with the open_port status and another Boolean function from the COM Library “ifConnected()”. When satisfied a helpful message is displayed through the RichEdit Box “Message” to inform the user about the connection status.

Save: The Save button opens the screen which allows options to save the information in the RichEdit Boxes to be written into .txt or .doc files for further analysis. The following code snippet is used to bring screen:

Form2->ShowModal();

Screenshot (a) from the running application showing the options to save to files

Screenshot (b) from the running application showing the menu to save to a logfile

The Exit button shown on screenshot (a) closes the screen and goes back to the main screen.

Stop: The Stop button press triggers an application which deals with bringing the system to its default state, i.e., in a disconnected state and all buttons in disabled mode except the Start and Exit buttons.

The button press initially checks if the network is still live. If no, then it shuts down any action going on and brings the system to default state. If yes, pops up a warning message informing the user about the situation and providing options to override the system to disconnect from the network and sit at the default state or cancel the current operation and manually disconnect from the network, clear both the RichEdit boxes and passes appropriate status information for the user through RichEdit Box “Message” that the system is at halt.

The code snippet below shows the generation of the warning pop up:

// Message Box for options
int response = Application->MessageBoxA("The PORT is still connected. Are you sure you wish to STOP\n","Warning", MB_YESNOCANCEL|MB_ICONQUESTION);

Screenshot from a running application showing warning pop up.

Exit: The Exit button press, as the name indicates terminates the application.
The two RichEdit Boxes “Message” and “Display” have the same major functionality but varies in their usage. The Message Box is used to display system update information messages for the user while the Display Box displays the data streamed from the network.

Controller Area Network(CAN ) Hardware

2011-11-08T10:03:00.000-08:00

The Development Board:

The analyzer itself is a LPC-E2294-RB development board from Olimex. This development board uniquely features four CAN controllers and a UART to USB conversion chip capable of RS-232 with speeds exceeding 1Mbits/s.

Picture courtesy of www.olimex.com

The key features of the board:

MCU: LPC2294 16/32 bit ARM7TDMI-S™t with 256K Bytes Program Flash, 16K Bytes RAM, EXTERNAL MEMORY BUS, RTC,4x 10 bit ADC 2.44 uS, 2x UARTs, 4x CAN, I2C, SPI, 2x 32bit TIMERS, 7x CCR, 6x PWM, WDT, 5V tolerant I/O, up to 60MHz operation
Standard JTAG connector with ARM 2x10 pin layout for programming/debugging with ARM-JTAG
1MB (256Kx32bit) 12 ns 71V416 SRAM
4MB (512Kx16bit) 70ns TE28F320C3BD70 C3 INTEL FLASH
USB to RS232 convertor, board can take power only from USB port
4 CAN drivers and connectors
RESET circuit with exterman control of Philips ISP utility via USB-RS232 virtual port
Jumpers for boot select from external memory
Jumpers for ISP/RUN mode
Ethernet controller with CS8900A and RJ45 connector
LCD 16x2 DISPLAY with BACKLIGHT
2 BUTTONS
POTENTIOMETER connected to AIN0
SPI connector
RS232 driver and connector
DALLAS i-BUTTON interface and connector
I2C 24LC515 EEPROM on board
Two on board voltage regulators 1.8V and 3.3V with up to 800mA current .

The Communication Cable :

A serial communication cable.

Picture courtesy of www.ebay.co.uk

The main features of the cable:

USB Specification 1.1 and 2.0 compliant
Supports RS-232 interface
Supports over 1Mbits/s data transfer rate
Buffer: 96 bytes for both upstream and downstream data flow
Supports remote wake up and power management
Support automatic handshake protocol
Supports Windows(98/Se/Me/2000/Xp/Vista)
Supports Mac OS9.0/OSX/Linux
Creates a perfect solution for laptops that does not have serial port and establishes a bridge between the serial devices to the computer USB port. The cost for the cable was just £4.99 and well within the budget provided.

CAN-Controller Area Network -A Graphical User Interface

2011-11-08T09:53:00.000-08:00

Introducing CAN

Controller Area Network (CAN) is the de-facto protocol for communication between embedded devices. It was developed by Bosch in 1983 and was designed originally to be used in automotive industry where many systems within a car need to be communicated with a central ECU.

CAN or CAN-bus is a vehicle bus standard design to allow microcontrollers and devices to communicate within a vehicle without a host computer.

CAN is a high integrity serial data communications bus for real time control applications. Operates at data rates up to 1Mbits/s over links up to approximately 40m.

Principle

A typical CAN message contains an ID (11 or 29 bits long) in the header and is followed by 8 bytes of data. There are other pieces of information in the message such as SOF (Start of Frame) and a 15 bit CRC.

Data messages transmitted from any node of a CAN bus does not contain addresses of either of the transmitting node or any of the intended receiving mode. Instead, the content of the message (e.g. Revolutions per minute, etc.) is labeled by an identifier that is unique throughout the network. All other nodes on the network receive the message and each performs an acceptance test on the identifier to determine if the message, and thus its content, is relevant to that particular node.

If the message is relevant, it will be processed; otherwise it is ignored. The unique identifier also determines the priority of the message. The lower the numerical value of the identifier, the higher the priority.

In situations where two or more nodes attempt to transmit at the same time, a non-destructive arbitration technique guarantees that messages are sent in order of priority and no messages are lost.
CAN will operate in extremely harsh environments and the extensive error checking mechanisms ensure that any transmission errors are detected.

CAN Analyzer

A CAN Analyzer is an efficient and versatile tool for analysis of CAN-based networks. This development and service tool aids an engineer to observe record and analyze communication protocols on CAN bus at a logical level. The analyzer distinguishes itself by its programmability and ability to work with different hardware interfaces.

A CAN tool specification
• Multi channel functionality
• Inter-window, time synchronous analysis of received data
• Graphic highlighting of altered data contents
• Communication with the CAN driver and the hardware is carried out centrally via a communication server
• Analysis of functions are provided by separate function modules; customer-specific functions can be integrated using individual modules
• Safe reception of CAN messages and time oriented buffering, even with high bus loads and baud rates.

Google's Android tops as others including BlackBerry and Nokia sink

2011-06-02T08:56:00.001-07:00

Google's Android devices have become most popular smart phones in the US, said a Nielsen survey Tuesday, a day when Nokia shares tanked more than 15 percent on weaker quarterly outlook.

The April survey of 65,000 users showed that 36 percent mobile consumers now use an Android device, compared to 26 percent who use Apple iPhones and 23 percent who use Blackberry.

If current mobile data usage is also any indicator, Google Android smart phones are set to leave Apple iPhones way behind. Android smartphone owners use an average of 582 MB of data each month, compared to 492 MB for iPhone owners, said the survey. Google's Android operating system (OS) is also proving to be the most popular, according to the survey.

The Neilsen survey came yet another bad news for BlackBerry maker Research In Motion (RIM) which was dragged down more than four percent as Nokia shares tanked more than 15 percent in New York after the global handset leader warned of lower sales in the second quarter.

Jittery investors also abandoned RIM stock which closed at $41.35 - the lowest levels not seen since 2006 - on the Toronto Stock Exchange.

While RIM has lost more than 60 percent of its value since 2008, Nokia's value has shrunk 43 percent since the last year. At $7.02 Tuesday, Nokia stock is at its 13-year low.

'Nokia's warning this morning is probably just the prelude to another RIM warning that investors have learned to get used to,'' analyst Jon Ogg told the Globe and Mail.
He said merger was the only solution for RIM and Nokia.

'We do not like mergers but this may be the only shot for these companies to stop the bleeding. Admittedly, this is a long-shot deal. A RIM-Nokia merger might encounter too many problems before getting off the ground. Still, what choices to these two companies have today?' the analysts said.
RIM, whose current stock is a pale shadow of $150 seen in June 2008, is currently valued at about $23 billion.

The presence of Microsoft CEO Steve Ballmer at RIM's BlackBerry World annual conference of customers, developers and partners in Florida last month fuelled speculation that the cash-rich software giant could soon buy the BlackBerry company to make a mark in the smart phone market. Microsoft, which is sitting on a $48-billion cash pile, has already partnered RIM to adopt its Bing as the default search engine on BlackBerry smart phones.

Code for Linked Lists

2011-04-28T03:09:00.000-07:00

This is a C code for inserting elements in a linked list at its end, deleting elements from the end.

This code is for the Linux environment written in the vi editor.

Program :

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
struct node{
int data;
struct node *link;
}*start=NULL,*temp,*ptr;void display(){
ptr=start;
printf("Data in the list:\t");
if(start==NULL)
{
printf("List empty");
while(ptr!=NULL)
{
printf("%d\t",ptr->data);
ptr=ptr->link;
}
}void insert_end(){
temp=malloc(sizeof(struct node));
printf("\nEnter data for node \n");
scanf("%d",&temp->data);
if(start==NULL)
{
temp->link=NULL;
start=temp;
}
else
{
ptr=start;
while(ptr->link!=NULL)
{
ptr=ptr->link;
}
ptr->link=temp;
temp->link=NULL;
}
display();
}
void delete_end(){
if(start==NULL)
{
printf("No more nodes in the list");
return;
}
if(start->link==NULL)
{
free(start);
start=NULL;
return;
}
ptr=start;
while(ptr->link!=NULL)
{
temp=ptr;
ptr=ptr->link;
}
temp->link=NULL;
free(ptr);
display();
}
int main(){
int ch;
while(1)
{
system("clear");
printf("\n------Menu --------\n");
printf("\n1.Insert at the end\n");
printf("\n2.Delete from end\n");
printf("\n3.Exit\n");
printf("\nEnter choice\n");
scanf("%d",&ch);
switch(ch)
{
case 1:
{
insert_end();
break;
}
case 2:
{
delete_end();
break;
}
case 3:
{
exit(0);
}
}
}
return 0;
}

Linked Lists:

2011-04-12T11:17:00.000-07:00

A linked list is a linear collection of data elements called nodes. The linear order is given by means of pointers. Each node is divided into two parts: the data part and the link part.

The data part contains the data that is to be stored and the link part contains the address of the next node in the list.

A linked list with four nodes.

The linked list also contains a list pointer variable called the Start pointer that contains the address of the first node in the list. We need this pointer in order to get the address of the linked list and to go through the list whenever required.

The end of the list is marked by a special pointer known as the NULL pointer.

The Start and the Null pointer are very necessary in order to perform operations on the linked lists.

Representation of linked lists in memory:

Start = 20 , Info[20] = W (The first character of the list)

Link[20]= 29 , Info[29]= E

Link[29]= 31 , Info[31]= L

Link [31]= 35, Info[35]= C

Link[35]= 39 , Info[39]= O

Link[39]= 45, Info[45]= M

Link[45]= 50 , Info[50]= E (The last character of the list)

Memory representation of linked lists

Need for use of linked lists:

1. The successive elements of linked lists do not need to occupy the adjacent memory space in the memory unlike arrays as is shown in the figure above.

2. Dynamic allocation of memory leaves us with an ease of including more data into the list.

3. . Linked lists allow insertion and removal of nodes at any point in the list, and can do so with a constant number of operations if the link previous to the link being added or removed is maintained during list traversal.

Disadvantages of Linked lists:

1. Linked lists do not allow random access to the data other than the first node's data, or any form of efficient indexing. Many basic operations like obtaining the last node of the list or finding a node that contains a given datum, or locating the place where a new node should be inserted may require scanning most or all of the list elements.

Nokia facing software problems!!!

2011-04-12T06:15:00.001-07:00

A critical issue has been noticed recently with Nokia handsets including its latest N8. The problem leads to text message delivery failure and software slow down. This is not only the case that Nokia is facing with its current market share dropped to 30% its getting difficult for Nokia to survive. I am personally a Nokia lover every cell phone that I have till date is Nokia, now it’s getting me to think over it.

The problem that N8 faces is with the text message delivery. N8 fails to deliver text message. The problem can be solved by flashing or formatting. I formatted my Nokia N8 twice still after a day or two it gets into the same problem. According to Nokia Care the problem is with the software. Nokia should get a quick remedy for this.

The problem not only persists for N8 other handsets like N79 N73 E63 are too into it. I would suggest you to quickly upgrade the software. You can do that with Nokia Software Updater online.

Google Makes April FOOL!!!

2011-04-01T03:26:00.001-07:00

Google Motion BETA

A new way to communicate

The mouse and keyboard were invented before the Internet even existed. Since then, countless technological advancements have allowed for much more efficient human computer interaction. Why then do we continue to use outdated technology? Introducing Gmail Motion -- now you can control Gmail with your body.

Click on Try Gmail Motion

It shows loading... you wait and then...

That's right....APRIL FOOL!!!

Reading Images Using C++

2011-03-31T03:23:00.001-07:00

This had been a long way to perform Image processing using C++. In C++, it is not possible to even read an image without some libraries. The library for this is OpenCv.OpenCV (Open Source Computer Vision) is a library of programming functions for real time computer vision. In your C++ code , you need to include cv.h and highgui.h libraries. Here is the code for reading an image. Once reading is accomplished you can modify the code to do other image manipulations to your image. This is just the basic code:


#include<iostream>

#include<cv.h>

#include<highgui.h>

using namespace std;

int main(int argc,char **argv)

{

    IplImage *img = 0;

    unsigned char *data;

    int i,j,k;

    img=cvLoadImage(argv[1],-1);

    if(!img)

    {

        cout<<"Cannot Open File"<<endl;

    }

    /* Extracting the data members */

    int height    = img->height;

    int width     = img->width;

    int channels  = img->nChannels;

    int  step      = img->widthStep;

    int depth     = img->depth;

    data      = (unsigned char *)img->imageData;

    // creating the image pixels

    for(i=0;i<height;i++) for(j=0;j<width;j++) for(k=0;k<channels;k++)

            data[i*step+j*channels+k]=data[i*step+j*channels+k];

    // defining the new image structure

    IplImage * new_img=cvCreateImage(cvSize(width,height),depth,channels);

    new_img->imageData=(char*)data;

    cvNamedWindow("Original Image", CV_WINDOW_AUTOSIZE);

    cvMoveWindow("Original Image", 100, 100);

    cvShowImage("Original Image", img);

    cvNamedWindow("Image Read", CV_WINDOW_AUTOSIZE);

    cvMoveWindow("Image Read", 550, 100);

    cvShowImage("Image Read", new_img);

    cvWaitKey(0);  

    cvDestroyWindow("Image Read");

    cvDestroyWindow("Original Image");

    return 0;

}

IplImage is a structure in OpenCv with the following data members :

|-- int  nChannels;     // Number of color channels (1,2,3,4)
|-- int  depth;         // Pixel depth in bits:
|                       //   IPL_DEPTH_8U, IPL_DEPTH_8S,
|                       //   IPL_DEPTH_16U,IPL_DEPTH_16S,
|                       //   IPL_DEPTH_32S,IPL_DEPTH_32F,
|                       //   IPL_DEPTH_64F
|-- int  width;         // image width in pixels
|-- int  height;        // image height in pixels
|-- char* imageData;    // pointer to aligned image data
|                       // Note that color images are stored in BGR order
|-- int  dataOrder;     // 0 - interleaved color channels,
PL image:
|                       // 1 - separate color channels
|                       // cvCreateImage can only create interleaved images
|-- int  origin;        // 0 - top-left origin,
|                       // 1 - bottom-left origin (Windows bitmaps style)
|-- int  widthStep;     // size of aligned image row in bytes
|-- int  imageSize;     // image data size in bytes = height*widthStep
|-- struct _IplROI *roi;// image ROI. when not NULL specifies image
|                       // region  to be processed.
|-- char *imageDataOrigin; // pointer to the unaligned origin of image data
|                          // (needed for correct image deallocation)
|
|-- int  align;         // Alignment of image rows: 4 or 8 byte alignment
|                       // OpenCV ignores this and uses widthStep instead
|-- char colorModel[4]; // Color model - ignored by OpenCV

cvCreateImage creates an image of width/height , using bit depth to represent the colour values, and with colour channels.
The depth is represented as
IPL_DEPTH_{U|S|F} where U, S and F stand for unsigned,signed and floating point. i.e.

IPL_DEPTH_8U
IPL_DEPTH_8S
IPL_DEPTH_16U
IPL_DEPTH_16S
IPL_DEPTH_32S
IPL_DEPTH_32F
IPL_DEPTH_64F


To compile this program ,you need to include some libraries as shown:


Opencv flags

The output of the above program is here :


Reading image in C++

Add multiple logos in LaTex

2011-03-31T02:15:00.000-07:00

Now we can easily add multiple logos in any Tex file. The following code is to be included before your document block, if you want to include the logos throughout your document.

\logo{\includegraphics[height=1cm]{i2.png}
\hspace{4.2 in}
\includegraphics[height=1cm]{i3.png}}

If not, then you can write this code with logos of your choice wherever you want to include them or from where you want the particular logos to be!

For this you need to add the graphicx package by means of putting the command \usepackage{graphicx} near the top of the LaTeX file, just after the documentclass command.

The \hspace command adds horizontal space.

\hspace[*]{length}

The length of the space can be expressed in any terms that LaTeX understands, i.e., points, inches, etc. You can add negative as well as positive space with an \hspace command. Adding negative space is like backspacing.

LaTeX removes horizontal space that comes at the end of a line. If you don't want LaTeX to remove this space, include the optional * argument. Then the space is never removed.

The output pdf file looks like this :

Add Logos in Latex.

Get FREE Live Cricket Match Scores

2011-03-29T08:59:00.002-07:00

Get FREE!!! Live cricket match scores in mobile phone.

No premium charges!

No dataplan!

No internet!

Just nominal rate for messages charged by your mobile service provider.

How it works:

1. SMS: @cricbuzz to 92433-42000

2. Receive live cricket scores

Code in 26 Different Languages

2011-03-29T01:16:00.002-07:00

Coding in 26 Different languages!!!

C++

[code]
#include <iostream>

int main(void) {
char c, d=10;
while(std::cin.get(c) && (c!='2' || d!='4') && std::cout.put(d))
d=c;
}
[/code]

C

[code]

#include <stdio.h>

int main(void) {
int x;
for(; scanf("%d",&x) > 0 && x != 42; printf("%d\n", x));
return 0;
}
[/code]

Pascal

[code]

program test;
var x: integer;
begin
repeat
readln(x);
if x<>42 then writeln(x);
until x=42
end.
[/code]

Java

[code]

public class Main
{
public static void main (String[] args) throws java.lang.Exception
{
java.io.BufferedReader r = new java.io.BufferedReader (new java.io.InputStreamReader (System.in));
String s;
while (!(s=r.readLine()).startsWith("42")) System.out.println(s);
}
}
[/code]

Nice

[code]

void main (String[] args)
{
java.io.BufferedReader r = new java.io.BufferedReader (new java.io.InputStreamReader (System.in));
String s;
while (!(s=notNull(r.readLine())).startsWith("42")) System.out.println(s);
}
[/code]

Python

[code]

k=raw_input()
while int(k)!=42:
print k
k=raw_input()
[/code]

Lisp

[code]

(loop for l = (read-line)
for n = (parse-integer l)
until (= n 42) do (format t "~D~%" n))
[/code]

Scheme

[code]

(do ((i (read) (read)))
((eq? i 42) '())
(begin
(display i)
(newline)))
[/code]

OCaml

[code]

while true do
let n = read_int () in
if n=42 then exit 0 else print_int n; print_newline ()
done
[/code]

Haskell

[code]

main = interact f
where f = unlines . takeWhile (/="42") . words
[/code]

Clips

[code]

(defrule readin
?f<-(initial-fact)
=>
(retract ?f)
(assert (number (read)))
)

(defrule writeout
?f<-(number ?n)(test (<> ?n 42))
=>
(retract ?f)
(printout t ?n crlf)
(assert (initial-fact))
)
[/code]

Prolog

[code]

program :- get_char(X),get_char(Y),check(X,Y).
check('4','2'):-!.
check(X,Y):-write(X),get_char(Z),check(Y,Z).
[/code]

C#

[code]

using System;
public class Test
{
public static void Main()
{
int n;
while ((n = int.Parse(Console.ReadLine()))!=42)
Console.WriteLine(n);
}
}
[/code]

Brainf*ck

[code]

+[>>----------
[++++++++++<,----------]
>--------------------------------------------------
>----------------------------------------------------
>

[
<+++++++++++++++++++++++++++++++++++++++++++++++ ++ +++
<+++++++++++++++++++++++++++++++++++++++++++++++ ++ +
[>]<
[.<]++++++++++.---------->
[>]>>
]<

[++++++++++++++++++++++++++++++++++++++++++++++++++ ++
<+++++++++++++++++++++++++++++++++++++++++++++++ ++ +
[>]<
[.<]++++++++++.---------->
[>]>
]<

[>+++++++++++++++++++++++++++++++++++++++++++++++ ++ +++
<+++++++++++++++++++++++++++++++++++++++++++++++ ++ +
[>]<
[.<]++++++++++.---------->
[>]
]<

]

[/code]

Perl

[code]
print while($_=<>)!=42
[/code]

Ruby

[code]

print while gets != "42\n"
[/code]

Pike

[code]

int main() {
while (sscanf(Stdio.stdin->gets(), "%d", int n), n!=42 && write(n+"\n"));
return 0;
}
[/code]

PHP

[code]

<?php
while (true) {
$input = fgets(STDIN, 3);
if ($input == 42) {
break;
} else {
echo $input;
}
}
?>
[/code]

Intercal

[code]

PLEASE DO ,1 <- #1
PLEASE DO .4 <- #0
PLEASE DO .5 <- #0
PLEASE DO .99 <- #0
DO COME FROM (30)
DO COME FROM (31)
DO WRITE IN ,1
DO .1 <- ,1SUB#1
DO .2 <- .4
DO (1000) NEXT
DO .4 <- .3~#255
DO (10) NEXT
(42) DO .1 <- .1
(20) DO .42 <- "&'&.4~#26'$#1"
PLEASE RESUME "?.42$#1"~#3
(10) DO (20) NEXT
DO FORGET #1
PLEASE COME FROM (42)
PLEASE STASH .1+.2+.3
DO .1 <- .4
DO .2 <- #50
DO (1010) NEXT
DO (100) NEXT
PLEASE STASH .1+.2+.3
DO .1 <- .99
DO .2 <- #52
DO (1010) NEXT
DO (101) NEXT
PLEASE GIVE UP
(201) DO .3 <- '.3~.3'~#1
PLEASE RESUME "?.3$#2"~#3
(101) DO (201) NEXT
DO FORGET #1
(32) PLEASE RETRIEVE .1+.2+.3
(200) DO .3 <- '.3~.3'~#1
PLEASE RESUME "?.3$#2"~#3
(100) DO (200) NEXT
DO FORGET #1
DO COME FROM (32)
PLEASE RETRIEVE .1+.2+.3
DO (102) NEXT
(31) DO .99 <- .4
(202) DO .98 <- '.99~.99'~#1
PLEASE RESUME "?.98$#2"~#3
(102) DO (202) NEXT
DO FORGET #1
DO .3 <- !99~#15'$!99~#240'
DO .3 <- !3~#15'$!3~#240'
DO .2 <- !3~#15'$!3~#240'
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .2
DO ,1SUB#1 <- .3
PLEASE READ OUT ,1
(30) DO .99 <- .4
[/code]

NASM

[code]

global _start
section .data
buffer dw 0h
section .text
_start:
mov ecx, buffer
mov edx, 02h
call read
mov cx, word [buffer]
cmp cx, 3234h
je exit
cmp ch, 0ah
je one_dig
jmp two_dig
one_dig:
mov ecx, buffer
mov edx, 02h
call write
jmp _start
two_dig:
mov ecx, buffer
mov edx, 02h
call write
mov edx, 01h
mov ecx, buffer
call read ; read the 0ah
mov ecx, buffer
call write ; write the 0ah
jmp _start
exit:
mov eax, 01h ; exit()
xor ebx, ebx ; errno
int 80h
read:
mov eax, 03h ; read()
mov ebx, 00h ; stdin
int 80h
ret
write:
mov eax, 04h ; write()
mov ebx, 01h ; stdout
int 80h
ret
[/code]

Ada95

[code]

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure test is
x : integer;
begin
loop
get(x);
if x/=42
then
put(x);
new_line(1);
else
exit;
end if;
end loop;
end test;
[/code]

Bash

[code]

while read a; do
if [ $a -eq 42 ]; then
exit
else
echo $a
fi
done
[/code]

Smalltalk

[code]
|c number|
[
number:=0.
[ (c := stdin next) asciiValue ~= 10 ]
whileTrue:
[number := (number * 10) + (c asciiValue) - 48.].
number ~= 42
]
whileTrue:
[Transcript show: number printString; cr.]
!
[/code]

Fortran

[code]

program TEST
integer ans
do
read (*,*) ans
if (ans.eq.42) stop
write (*,*) ans
enddo
stop
end
[/code]

Icon

[code]

procedure main ()
while (l := read()) ~= 42 do
write(l);
end
[/code]

Erlang

[code]
-module(tested).
-export([main/0]).

main() ->
loop().
loop() ->
case io:fread( "","~d" ) of
eof ->
true;
{ok, X} ->
[Y] = X,
if
Y == 42 ->
true;
true ->
io:fwrite( "~B\n",X ),
loop()
end
end.
[/code]

Image Processing using GNURadio

2011-03-28T23:20:00.000-07:00

Image processing is any form of signal processing for which the input is an image, such as a photograph; the output of image processing may be either an image or, a set of characteristics or parameters related to the image. Most image-processing techniques involve treating the image as a two-dimensional signal and applying standard signal-processing techniques to it. To equip GNURadio with Image Processing capability OpenCV is used.

OpenCV (Open Source Computer Vision Library) is a library of programming functions mainly aimed at real time computer vision, developed by Intel and now supported by Willow Garage. It is free for use under the open source BSD license. OpenCV includes both its traditional C interface as well as a new C++ interface which makes it possible to integrate with GNURadio.

Introduction to OpenCV

OpenCV is an Open source computer vision library in C/C++ which is optimised and intended for real-time applications and is OS/hardware/window-manager independent. It can perform generic image/video loading, saving, and acquisition in both low and high level API. Supported image formats: BMP, DIB, JPEG, JPG, JPE, PNG, PBM, PGM, PPM,SR, RAS, TIFF, TIF.

OpenCV modules include:

cv - Main OpenCV functions.
cvaux - Auxiliary (experimental) OpenCV functions.
cxcore - Data structures and linear algebra support.
highgui - GUI functions.

OpenCV can be downloaded from here.

For installation guide through the synaptic manager click here.

For installation guide through the terminal click here.

Compilation instructions:

 $ g++ -I/usr/include/opencv -lcxcore -lcv -lhighgui -lcvaux -lml hello.cpp

OpenCV requires the following library for compilation.

Integarting OpenCV with GNURadio

To integrate OpenCV with GNURadio include the OpenCV library's in the top directory file, makefile.common specified by two flags AM_CXXFLAGS and AM_CPPFLAGS as;

AM_CXXFLAGS = @autoconf_default_CXXFLAGS@ \    
                          -I/usr/include/opencv \ 
                          -lcxcore -lcv -lhighgui -lcvaux -lml

AM_CPPFLAGS = -I/usr/include/opencv \ 
               $(STD_DEFINES_AND_INCLUDES) \ 
               $(PYTHON_CPPFLAGS) \ 
               $(CPPUNIT_INCLUDES) \ 
               $(GNURADIO_CORE_CPPFLAGS)

Once this is set OpenCV header files and functions can be used in GNURadio.
2RHGDSDQ67N2

Download Source Code

2011-03-24T11:35:00.002-07:00

Download source codes and projects in different language which includes C, C++, Socket Programming in C Linux, PHP, Java, J2EE, ALP 8086, Programming Contest and many more.

C
C programs written in TurboC and Linux. Includes programs from OS Scheduling and Compiler design

C++
C++ programs include Linklist, Operator overloading and templates

ALP 8086
Assembly Language Program in 8086 covers basic directory/file operations and others

Socket Programming in Linux using C
Socket Programming includes program in the Server Client architecture using UDP and TCP connection

Java
Java programs include basic exception handling concept, threads and JDBC

J2EE
J2EE programs include MVC architecture, Ajax, Cookies, Hibernate, EJB, JavaBeans and Struts

PHP
PHP programs include basic web application using MySql database

Programming Contest
Programming Contest covers various programs along with question, which are part of some programming contest or the other

The Ahoms Of Assam

2011-03-22T04:32:00.000-07:00

The Ahom King - Chao Lung Siuka-pha

The Ahoms, the dominant Tai group of Assam belong to the great Tai ethnic and linguistic family of South-East Asia. The original homeland of the Ahoms was Yunum of Southern China . They came to Assam and established a tiny kingdom in 1228 A.D in the easternmost part of India with Charaideo as its capital in the district of Sivasagar under the leadership of Siuka-pha, a Tai prince from Southern China .
Before the advent of the Ahoms, Assam was known variously as Pragjyotisha and Kamarupa in different period of time . In the epic period, the country was divided into Sonitpur, Kundil Rajya and Pragjyotisha . In addition there were the kingdoms of Hidimba, Davaka, Manipur and Tripura. Later the kingdom of Kamarupa arose in early Christian era, but this kingdom disappeared by the middle of the twelfth century A.D. Another kingdom known as Kamata also appeared in this region by this time . Taking advantage of this weakness of the Kamarupa , Kamata kingdom, the chiefs of the Koch and the Mech tribes organized several independent principalities on the western part of the kingdom of Kamarupa . Thus prior to the advent of the Ahoms, this land of the Brahmaputra was divided politically , socially and racially .

The Ahom Monuments

The Ahoms under Siuka-pha came and founded the first Tai kingdom in 1228 A.D . The tiny kingdom thus formed , was gradually extended by them eastward and westward in stages and thus they became the undisputed lord of the entire Brahmaputra Valley from Sadiya on the east to the river Manaha on the west . The Ahoms created history by ruling gloriously this land for six hundred years .Thirty eight rulers belongs to Ahom royal dynasty ruled Assam from 1228 A.D to 1826 A.D . It was during their long protracted reign that the land and the people came to be designated as “Assam” and “Assamese” Still today they are known by such names . It may be considered as their the greatest contribution to the land of their adoption i.e, Assam .

Original composition and written by : Dr. Khagen Chandra Phukan.

My sincere thanks to him.

Writing a Block in GNURadio

2011-03-22T02:44:00.000-07:00

GNU Radio provides a data flow abstraction.This abstraction is implemented by the Python gr.flow_graph class.Each block has a set of input ports and output ports.When we write the block, we need to construct them as shared libraries that may be dynamically loaded into Python using the `import' mechanism. SWIG, the Simplified Wrapper and Interface Generator, is used to generate the glue that allows our code to be used from Python. Writing a new signal processing block involves creating 3 files: The .h and .cc files that define the new block class and the .i file that tells SWIG how to generate the glue that binds the class into Python. The new class must derive from gr_block or one of it's subclasses. The C++ class gr_block is the base of all signal processing blocks in GNU Radio.

d_name is a string saving the block's name. d_unique_id is a long integer, defined as the `ID' of the block. The class gr_io_signature is defined in /src/lib/runtime/gr_io_signature.h.The definition of gr_io_signature.h.

For a block's input (output), the class gr_io_signature defines the minimal (d_min_streams) and maximal (d_max_streams) number of streams as the lower and upper bound. The `size' (number of bytes occupied) of an item in the stream is given by d_sizeof_stream_item, a member variable with the type of size_t.

gr_runtime.h is included in gr_block.h. In gr_runtime.h, gr_io_signature_sptr is a type defined as:

Further, gr_runtime.h includes gr_type.h first. In gr_type.h, an interesting header file is included.

GNU Radio takes the advantage of Boost smart pointers. Boost is a collection of C++ libraries, a pre-required package for the installation of GNU Radio. Boost provides powerful extensions to C++ from many aspects, such as algorithm implementation, math/numerics, input/output, iterators, etc. Interested programmers can refer to for more information. GNU Radio borrows one cool feature from Boost: the smart_ptr library, so called . Smart pointers are objects which store pointers to dynamically allocated objects. They behave much like built-in C++ pointers except that they automatically delete the object pointed to at the appropriate time. Smart pointers are particularly useful in the face of exceptions as they ensure proper destruction of dynamically allocated objects.the smart pointers are defined as class templates. The library smart_ptr provides five smart pointer class templates, but in GNU Radio, we only use one of them: shared_ptr, defined in <boost/shared_ptr.hpp>. shared_ptr is used for the case when the pointed object ownership is shared by multiple pointers. Using Smart pointers in GNURadio: boost::shared_ptr<T> pointer_name These smart pointer class templates have a template parameter, T, which specifies the type of the object pointed to by the smart pointer. For example, boost::shared_ptr<gr_io_signature> declares a smart pointer pointing to an object with the class type of gr_io_signature.

Datatypes in GNURadio:

The core of a block: the method general_work() The method general_work() is pure virtual, we definitely need to override that. general_work is the method that does the actual signal processing, which is the CPU of the block.

The method general_work() compute the output streams from the input streamsA block may have x input streams and y output streams. ninput_items is an integer `vector' of length x, the i^th element of which gives the number of available items on the i^th input stream.However noutput_items (output flow) is simply an integer and not a vector.This is because GNU Radio of the current version only supports a block having the same data rates for all output streams, i.e. the number of output items to write on each output stream is the same for all output streams. The data rates for input streams could be different. . input_items is a vector of pointers to the input items, one entry per input stream. output_items is a vector of pointers to the output items, one entry per output stream. We actually use these pointers to get the input data and write the computed output data to appropriate streams. The returned value of general_work() is the number of items actually written to each output stream, or -1 on EOF. It is OK to return a value less than noutput_items. Finally and significantly, when we override general_work() for our own block, we MUST call consume() or consume_each() methods to indicate how many items have been consumed on each input stream.

The method consume() tells the scheduler how many items (given by how_many_items') of the i^th input stream (given by `which_input') have been consumed. If each input stream has consumed the same number of items, we can use consume_each() instead. It tells the scheduler each input stream has consumed `how_many_items' items. The reason why we have to call the consume() or consume_each() method is we have to tell the scheduler how many items of the input streams have been consumed, so that the scheduler can arrange the upstream buffer and associated pointers accordingly.

The method forecast(): The method forecast() is used to estimate the input requirements given an output request. The first parameter noutput_items has been introduced in general_work(), which is the number of output items to produce for each output stream. The second parameter ninput_items_required is an integer vector, saving the number of input items required on each input stream. When we override the forecast() method, we need to estimate the number of data items required on each input stream, given the request to produce `noutput_items' items for each output stream. The estimate doesn't have to be exact, but should be close. The argument ninput_items_required is passed by reference, so that the calculated estimates can be saved into it directly. Naming Conventions: In GNU Radio, with the exception of macros and other constant values, all identifiers shall be in lower case with `words_separated_like_this'. Macros and constant values shall be in UPPER_CASE. Package prefix: All globally visible names (types, functions, variables, constants, etc.) shall begin with a package prefix', followed by an underscore. The bulk of the code in GNU Radio belongs to the `gr' package, hence names look like gr_open_file (...).

Class data members (instance variables): All class data members shall begin with the prefix `d_'.

File names

Each significant class shall be contained in its own files. For example, the declaration of the class gr_foo shall be in gr_foo.h and the definition in gr_foo.cc.

Suffixes

By convention, we encode the input and output types of signal processing blocks in their name using suffixes. The suffix is typically one or two characters long. Sources and sinks have single character suffixes. Regular blocks that have both inputs and outputs have two character suffixes. The first character indicates the type of the input streams, while the second indicates the type of the output streams.

The SWIG file: how.i

SWIG, the Simplified Wrapper and Interface Generator, is used to generate the glue that allows our code to be used from Python.The SWIG .i file tells SWIG the gluing guidelines.

A .i file can been treated as a pared-down version of the .h file, plus a bit of magic that has Python work with the boost::shared_ptr. To reduce the code bloat,declare methods that are required to access from Python.

GR_SWIG_BLOCK_MAGIC does some `magics' so that we can access howto_square_ff from Python as howto.square_ff(). From Python's point of view, howto is a package, and square_ff() becomes a function defined in howto. Calling this function will return a smart pointer howto_square_ff_sptr pointing to a new instance of howto_square_ff.

Installtion guide for Opencv in Linux using the Synaptic Manager

2011-03-21T04:06:00.000-07:00

This article is basically for installing Opencv 2.1 in Ubuntu 10.10. Opencv basically helps in image processing using c++ . For reading or writing images in c++ , we require Opencv. The steps below are the ways Opencv can be installed.

1. Go to Synaptic Package Manager (System> Administration> Synaptic Package Manager).

2. Search for “opencv” and install the main “opencv” package and the following lib files:

libcv

libcv-dev

libcvaux

libcvaux-dev

libhighgui

libhighgui-dev

opencv-doc

(‘python-opencv’ not required).
(you can also install opencv directly from the terminal by “sudo apt-get install” the above lib files

3. After installing all the packages, type this code:

$ export LD_LIBRARY_PATH=/home/opencv/lib

$ export PKG_CONFIG_PATH=/home/opencv/lib/pkgconfig

The above ones are default paths for the opencv libraries.

4. To check the path where opencv & other lib files are stored, do:

$ pkg-config --cflags opencv

This output shows the path of the header file as:

-I/usr/include/opencv

$ pkg-config --libs opencv

This output shows the libraries required to be included.

-lcxcore -lcv -lhighgui -lcvaux -lml

An Example code:

This code reads an image an displays it.It is named as img.cc

#include <stdlib.h>

#include <iostream>

#include <math.h>

#include </usr/include/opencv/cv.h>

#include </usr/include/opencv/highgui.h>

using namespace std;

int main(int argc, char *argv[])

{

IplImage* img = 0;

IplImage* img1=cvCreateImage(cvSize(256,256),IPL_DEPTH_8U,1);

int height,width,step,channels;

unsigned char *data;

int i,j,k;

if(argc<2){

cout<<"Usage: main <image-file-name>";

exit(0);

}

// load an image

img=cvLoadImage(argv[1],-1); //-1 is a flag (flag<0 the loaded image is loaded as is (with number of channels in the file)

if(!img){

cout<<"Could not load image file:"<<argv[1]<<endl;

exit(0);

}

// get the image data

height = img->height;

width = img->width;

step = img->widthStep;

channels = img->nChannels;

data = (unsigned char *)img->imageData;

cout<<"Height - "<<height<<endl;

cout<<"Width - "<<width<<endl;

cout<<"WidthStep - "<<step<<endl;

cout<<"Channels - "<<channels<<endl;

cout<<endl;

cvNamedWindow("Read Image", CV_WINDOW_AUTOSIZE);

// creating the image

for(i=0;i<height;i++) for(j=0;j<width;j++) for(k=0;k<channels;k++)

data[i*step+j*channels+k]=data[i*step+j*channels+k];

img1->imageData=(char*)data;

// show the image

cvShowImage("Read Image", img1 );

// wait for a key

cvWaitKey(0);

// release the image

cvReleaseImage(&img );

return 0;

}

These paths are needed to compile your opencv programs as shown below:

5. To compile & run:

$ g++ -I/usr/include/opencv -lcxcore -lhighgui -lm img.cc

where img.cc is c++ code for reading an image and displaying it.

$ ./a.out lena.bmp

6. For simplyfying the above command create an alias of the command in the home directory as

$ alias ocv="g++ -I/usr/include/opencv -lcv -lcxcore -lcvaux -lhighgui -lm"

$ ocv img.cc

$./a.out lena.bmp

Following steps 5 and 6 we get the output as shown below.

Reading an image in C++ using Opencv

Installtion guide for Opencv in Linux using the Terminal

2011-03-21T03:42:00.000-07:00

This article is basically for installing Opencv 2.1 in Ubuntu 10.10. Opencv basically helps in image processing using c++ . For reading or writing images in c++ , we require Opencv. The steps below are the commands to be given in the terminal.

1.This installation needs a C++ compiler like “g++”. So install g++ by typing the following command at the terminal–

$ sudo apt-get install g++

2. OpenCV requires GTK+ 2.0 or higher for displaying images. GTK is graphical user interface library. Type out the following code to know the version of GTK+ installed on ur pc.

$ dpkg -l | grep libgtk

This command should give o/p something like this if its installed on your system:

ii libgtk-vnc-1.0-0 0.4.1-3ubuntu2 A VNC viewer widget for GTK+ (runtime libraries)
ii libgtk2-perl 2:1.222-1 Perl interface to the 2.x series of the Gimp Toolkit library
ii libgtk2.0-0 2.22.0-0ubuntu1 The GTK+ graphical user interface library
ii libgtk2.0-bin 2.22.0-0ubuntu1 The programs for the GTK+ graphical user interface library
ii libgtk2.0-cil 2.12.10-1 CLI binding for the GTK+ toolkit 2.12
ii libgtk2.0-common 2.22.0-0ubuntu1 Common files for the GTK+ graphical user interface library
ii libgtk2.0-dev 2.22.0-0ubuntu1 Development files for the GTK+ library
ii libgtkhtml-editor-common 1:3.30.3-1ubuntu1 HTML rendering/editing library - editor widget data
ii libgtkhtml-editor0 1:3.30.3-1ubuntu1 HTML rendering/editing library - editor widget
ii libgtkhtml3.14-19 1:3.30.3-1ubuntu1 HTML rendering/editing library - runtime files
ii libgtkmm-2.4-1c2a 1:2.20.3-1 C++ wrappers for GTK+ (shared libraries)
ii libgtksourceview2.0-0 2.10.5-0ubuntu1 shared libraries for the GTK+ syntax highlighting widget
ii libgtksourceview2.0-common 2.10.5-0ubuntu1 common files for the GTK+ syntax highlighting widget
ii libgtkspell0 2.0.16-1 a spell-checking addon for GTK's TextView widget

If not, then you need to install the libraries for GTK+ 2.0 first, then start with this opencv installation.
To install GTK+ 2.0 libraries, type the following:

$ sudo apt-get install libgtk2.0-dev

3. After installing all the packages, type this code:

$ export LD_LIBRARY_PATH=/home/opencv/lib

$ export PKG_CONFIG_PATH=/home/opencv/lib/pkgconfig

The above ones are default paths for the opencv libraries.
4. To check the path where opencv & other lib files are stored, do:

$ pkg-config --cflags opencv

This output shows the path of the header file as:
-I/usr/include/opencv

$ pkg-config --libs opencv

This output shows the libraries required to be included.
-lcxcore -lcv -lhighgui -lcvaux -lml

An Example code:

This code reads an image an displays it.It is named as img.cc

#include <stdlib.h>
#include <iostream>
#include <math.h>
#include </usr/include/opencv/cv.h>
#include </usr/include/opencv/highgui.h>
using namespace std;

int main(int argc, char *argv[])
{
IplImage* img = 0;
IplImage* img1=cvCreateImage(cvSize(256,256),IPL_DEPTH_8U,1);
int height,width,step,channels;
unsigned char *data;
int i,j,k;

if(argc<2){
    cout<<"Usage: main <image-file-name>";
    exit(0);
}

// load an image
img=cvLoadImage(argv[1],-1);    //-1 is a flag (flag<0 the loaded image is loaded as is (with number of channels in the file)
if(!img){
    cout<<"Could not load image file:"<<argv[1]<<endl;
    exit(0);
}

// get the image data
height    = img->height;
width     = img->width;
step      = img->widthStep;
channels = img->nChannels;
data      = (unsigned char *)img->imageData;

cout<<"Height - "<<height<<endl;
cout<<"Width - "<<width<<endl;
cout<<"WidthStep - "<<step<<endl;
cout<<"Channels - "<<channels<<endl;
cout<<endl;

cvNamedWindow("Read Image", CV_WINDOW_AUTOSIZE);

// creating the image
for(i=0;i<height;i++) for(j=0;j<width;j++) for(k=0;k<channels;k++)
    data[i*step+j*channels+k]=data[i*step+j*channels+k];

img1->imageData=(char*)data;

// show the image
cvShowImage("Read Image", img1 );

// wait for a key
cvWaitKey(0);

// release the image
cvReleaseImage(&img );
return 0;
}

These paths are needed to compile your opencv programs as shown below:
5. To compile & run:

$ g++ -I/usr/include/opencv -lcxcore -lhighgui -lm img.cc

where img.cc is c++ code for reading an image and displaying it.

$ ./a.out lena.bmp

6. For simplyfying the above command create an alias of the command in the home directory as

$ alias ocv="g++ -I/usr/include/opencv -lcv -lcxcore -lcvaux -lhighgui -lm"

$ ocv img.cc

$./a.out lena.bmp

Following steps 5 and 6 we get the output as shown below.

Reading an image in C++ using OpenCv

CPU inside Keyboard

2011-03-18T01:01:00.000-07:00

The ZPC-9000 is a complete PC with a Pentium 4 CPU, LAN, and other PC parts inside a normal-size keyboard. While some of the benefits of this layout are obvious, such as the saving of space, a cleaner desktop and a significantly reduced number of cables, there are some additional clever features which make additional sense of the design. The ZPC-9000 uses just 120 Watt power supply compared with the usual 250-300 Watt power supplies used with a traditional PC.

Features include the latest Intel Pentium 4 HT processors up to 3.2GHz, up to 2GB of DDR-400MHz Memory, 1GB Ethernet LAN, 7-in-1 Card Reader, 2-Button touchpad, CD-RW/DVD and Fourth Generation Intel Extreme graphics controller. The ZPC-9000 also has a removable hard drive option and locking mechanism.

A complete keyboard layout

LEDs

USB, LAN Port, Printer Port, Mouse Port

Removable Harddisk

Tiny speakers

A complete CPU layout inside a keyboard

Working with GNURadio

2011-03-17T01:08:00.000-07:00

GNURadio is very easy to work with. It has blocks made for easy use. It consists of about 17 blocks which can be dragged and dropped for making a flowgraph. The flowgraph is the pictorial representation of the work that the user wants to do. Blocks present in GNURadio are shown below in the figure.

GNURadio Environment and its blocks

Now for more understanding of the GNURadio environment, a simple task of adding noise to a streaming signal is described below.This section illustrates the basic manipulations on streaming signals, in either discrete or continuous time, to perform useful operations on those signals in GNURadio.

Addition of noise:

1. To start with open a new flow graph in GRC.
2. Now create a flow graph as shown below. For ease of use the categories to which othe blocks used in the flow graph belong are also specified.

Flowgraph for Adding Noise

3. The signal sources and the noise blocks are in the category Sources, Add is in the category Operator and the Scope sink is in the category Graphical sinks .
4. The properties of the blocks can be changed by double clicking on the blocks for modification as shown below. As is seen, here the output type of both the signals is complex and the waveform type for one signal is Square while the other is a Sine waveform.The other properties like frequency and amplitude can also be changed as required. Similarly the noise type can also be changed from Gaussian to Uniform, Impulse or Laplacian.Here the noise type is Gaussian .

Properties setting for addition of noise

5. Execute the flowgraph from the Build option or by pressing F6. The Scope sink should open. It displays an output as shown below.

Output when noise type is Gaussian.

6. Modify the flow graph and change the properties of all the blocks to float and also at the same time change the waveform types of the signal sources and execute the flow graph again. For two Constant waveform and for the noise type Uniform , the following output is produced (keeping all other properties the same).

Output when noise type is Uniform.

Next is a flowgragh where correlation of streaming signals using multiplication is described.Correlation or disambiguation refers to any departure of two or more random variables from independence, but most commonly refers to a more specialized type of relationship between mean values.

Correlation using multiplication:

1. Open a new flow graph in GRC.
2. Now create a flow graph as shown below. For ease of use the categories to which the blocks used in the flow graph belong are also specified.

Flowgraph for correlation using multiplication.

3.The signal sources blocks are in the category Sources, Multiply is in the category Operator , the Scope sink and the Number Sink are in the category Graphical Sinks,Interpolating FIR filter is in the category Filters and Throttle is in the category Misc.
4.The properties of the blocks can be changed by double clicking on the blocks for modification as shown below. As is seen, here the output type of both the signals is float and the waveform type for one signal is Cosine while the other is a Sine waveform.The other properties like frequency and amplitude can also be changed as required.Here the frequencies of the signals are 5 Hz and amplitude being 1. Throttle is basically used as a rate limiting block.The FIR filter is used to integrate the region of interest of the signal (basically a window of size N filled with 1's as the tap of the FIR filter).

Properties setting for correlation using multiplication.

5.Execute the flowgraph from the Build option or by pressing F6. The Scope sink should open. It displays an output as shown below.

Output when waveform types are Sine and Cosine.

6.Modify the flow graph and change the properties of all the blocks to complex and also at the same time change the waveform types of the signal sources and execute the flow graph again. For a Triangular and a Square waveform , the following output is produced (keeping all other properties the same).

Output when waveform types are Triangular and Sqaure.

An Introduction to GNURadio

2011-03-16T23:17:00.000-07:00

GNURadio is a Software Defined Radio project that was designed to convert all hardware problems into software problems.GNURadio package is provided with a complete HDTV transmitter and receiver, a spectrum analyzer, an oscilloscope, a multichannel receiver and a wide collection of modulators and demodulators.Its applications are primarily written using the Python programming language, while the supplied, performance-criticGNURadio is a Software Defined Radio project that was designed to convert all hardware problems into software problems.

GNURadio package is provided with a complete HDTV transmitter and receiver, a spectrum analyzer, an oscilloscope, a multichannel receiver and a wide collection of modulators and demodulators.Its applications are primarily written using the Python programming language, while the supplied, performance-critical signal processing path is implemented in C++ using processor floating point extensions where available. The GNU Radio project created the Universal Software Radio Peripheral (USRP) which is a digital acquisition (DAQ) system. It’s a general purpose motherboard which can host a wide selection of daughter boards, each of which implements a signal processing block found in the GNURadio software package.

GNU Radio is licensed under the GNU General Public License (GPL) version 3. All of the code is copyright of the Free Software Foundation.

Strengths of GNURadio:

It can be reconfigured easily.
It can be easily and rapidly upgraded with newer versions.
It’s possible to talk and listen to multiple channels at the same time.
GNURadio package is provided with a complete HDTV transmitter and receiver, a spectrum analyzer, an oscilloscope, a multichannel receiver and a wide collection of modulators and demodulators.

Weakness of GNURadio:

GNURadio emphasizes only on the use of USRP hardware.
In order to interface a new hardware, we need to create hardware dependent GNURadio specific blocks.

Brainfuck Programming language.

2011-03-16T13:13:00.002-07:00

The brainfuck programming language is an esoteric programming language noted for its extreme minimalism. It is a Turing tarpit, designed to challenge and amuse programmers, and is not suitable for practical use. Its name has been variously bowdlerized, sometimes appearing as brainf***, brainf*ck, brainfsck, b****fuck or BF. The name of the language is generally not capitalized except at the start of a sentence, although it is a proper noun.

Brainfuck is created by Urban Muller, whose goal was apparently to create a Turing-complete language for which he could write the smallest compiler ever, for the Amiga OS 2.0. His compiler was 240 bytes in size.

A Brainfuck program has an implicit byte pointer, called "the pointer", which is free to move around within an array of 30000 bytes, initially all set to zero. The pointer itself is initialized to point to the beginning of this array. The Brainfuck programming language consists of eight commands, each of which is represented as a single character.

>   Increment the pointer.
<   Decrement the pointer.
+   Increment the byte at the pointer.
-    Decrement the byte at the pointer.
.    Output the byte at the pointer.
,    Input a byte and store it in the byte at the pointer.
[    Jump forward past the matching ] if the byte at the pointer is zero.
]    Jump backward to the matching [ unless the byte at the pointer is zero.

The semantics of the Brainfuck commands can also be succinctly expressed in terms of C, as follows (assuming that p has been previously defined as a char*):

>   becomes ++p;
<   becomes --p;
+   becomes ++*p;
-    becomes --*p;
.    becomes putchar(*p);
,    becomes *p = getchar();
[    becomes while (*p) {
]    becomes }

The following program prints "Hello World!" and a newline to the screen:

+++++ +++++ initialize counter (cell #0) to 10
[       use loop to set the next four cells to 70/100/30/10
> +++++ ++      add 7 to cell #1
> +++++ +++++     add 10 to cell #2
> +++   add 3 to cell #3
> +   add 1 to cell #4
<<<< -   decrement counter (cell #0)
]

> ++ . print 'H'
> + . print 'e'
+++++ ++ . print 'l'
. print 'l'
+++ . print 'o'
> ++ . print ' '
<< +++++ +++++ +++++ . print 'W'
> . print 'o'
+++ . print 'r'
----- - . print 'l'
----- --- . print 'd'
> + . print '!'
> . print '\n'

For readability, this code has been spread across many lines and blanks and comments have been added. Brainfuck ignores all characters except the eight commands +-<>[],. so no special syntax for comments is needed (as long as the comments don't contain the command characters).

The code could just as well have been written as:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

Extend your laptop display to a monitor.

2011-03-16T13:06:00.002-07:00

If you use your laptop as your main computer and if you have a spare monitor, then you can put your monitor to good use by making it your Laptop’s secondary monitor. It doesn’t really matter if the second monitor is a CRT or TFT, both work fine. First, let’s see why you would want to add a secondary monitor to your laptop.

Now lets see how to set up the secondary monitor. Make sure that both yourLaptop and the monitor are switched off. Connect the monitor to your Laptop by connecting it to the VGA or DVI connector, typically found on the rear of your laptop computer. Now switch on your laptop and the monitor. You will notice that initially, only one of the two monitors is activated. You can usually switch between the monitors by pressing the hotkeys in yourlaptop. Normally, it is a combination of the Fn key with another key with an image of a monitor on it (normally found on one of the function keys).

To bring on the display on both the monitors you’ll need to adjust your display settings by following these steps:

1. Right-Click on an empty area on your desktop. On the context menu that pops-up click on Properties and on the resulting ‘Display Properties‘ window, go to the Settings tab.

2. Click the monitor icon labeled 2, and then select the Extend my Windows desktop onto this monitor checkbox.
3. If necessary, drag the monitor icons so that they are arranged in the same way as the monitors on your desk. Clicking on the Identify button will help you know which monitor is 1 and which monitor is 2.

4. If need be, change the resolution of your secondary monitor to the most appropriate settings. You can change the resolution of the monitors independently.
5. Click Apply. Windows XP will activate your new monitor.
6. Finaly, click OK.

Once your monitor is set up, you can use your mouse to grab the title bar of a window and drag it to your new display. Make sure that the window you are trying to drag is not maximised, in which case you will not be able to drag it. To be able to drag it, first double-click on the title bar and then drag it. It may take you a while to get used to working on dual monitors, but once you do, it will forever change the way you work with your computer. Be creative and experiment with the sizing of application windows and what information you can keep in constant view while doing multiple tasks.

Protect your files

2011-03-16T12:58:00.002-07:00

Do you keep secrets?? Well, most of us do and for that they require a software that would protect the files, folders and drives. Most software’s encrypt the file for protecting it which creates problem as it requires a lot of time to encryption and decryption.
My search was still on when I came across FOLDER LOCK XP, which has the following features:

• Ability to hide files, folders, or drives from all other users (including the administrator).
• Password protection for files, folders, and drives.
• Unlimited number of objects to protect.
• Access restrictions on your data against local network users as well as Internet users.

• Ability to lock your Windows desktop so that users cannot delete, add, or modify the shortcuts and icons on your desktop.
• Password-protected start of Lock Folder XP.
• Ability to managing program from tray.
• Windows Explorer commands for instant folder hiding.
• Automatic protection activation after a set idle time.
• High-level protection.
• High performance rates.
• Multilingual interface.
• Support of FAT, FAT32, and NTFS systems.

Lock Folder XP does not change the file structure of the data, does not move the protected data, and does not change Windows system files. You cannot lose your files.

Download Folder Lock from the download section, search Folder Lock

Quine: Program that prints itself.

2011-03-16T12:52:00.002-07:00

A quine is a program which prints its own code. This means that when the program is run, it must print out precisely those instructions which the programmer wrote as part of the program.

The idea behind the code is simple, taking language C, we will initialize a char array with the code itself as per the code format. This array will be the format for the printf statement, as we know its syntax is;

int printf (const char *format [, argument, ...]);

The printf statement prints until it encounters a control string which is replaced by the value specified in the argument. printf(quine,10,10,34,quine,34,10,10,10,10,9,10,9,10);

Here the format is the array quine, 10,10,34,quine,34,10,10,10,10,9,10,9,10 are all arguments which are suitably replaced with new line(ASCII 10),double quotes (ASCII 34), the array quine itself and tab (ASCII 9).

Quine can be implemented in any language, the basic technique remains the same. Some may find this easier to do with a file but as far as Quine is considered, no file operations are used.

Sample Code in C:

#include <stdio.h>
char*quine="#include%c%cchar*quine=%c%s%c;%c%cint
main()%c{%c%cprintf(quine,10,10,34,quine,34,10,10,10,10,9,10,9,10);%c%creturn 0;%c}";

int main()
{
printf(quine,10,10,34,quine,34,10,10,10,10,9,10,9,10);
return 0;
}

Output: