LearnDelataX

Setup Secure and Non-Secure LDAP Server on Ubuntu

2018-11-20T00:50:00.003-08:00

OpenLDAP Server Setup on Ubuntu

This documentation helps a beginner to install and Configuring OpenLDAP server on Ubuntu and also helps in installing the phpLDAPadmin which is web-based management tool through which we can configure(add users/groups e.t.c) on our openldap server.

What is OpenLDAP

OpenLDAP is an open-source and fast directory server that provides network client with directory services. Client applications connect to OpenLDAP server using the Lightweight Directory Access Protocol (LDAP) to access organizational information stored on that server. Given the appropriate access, clients can search the directory, modify and manipulate records in the directory. OpenLDAP is efficient on both reading and modifying data in the directory. OpenLDAP servers are most commonly used to provide centralized management of user accounts.

Install Necessary packages :

Run the following command to install OpenLDAP server and the client command-line utilities from Ubuntu package repository. slapd stands for the Stand-Alone LDAP Daemon.

sudo apt install slapd ldap-utils

Once it’s done, slapd will be automatically started. You can check out its status with:

systemctl status slapd

Be default, it runs as the openldap user as is defined in /etc/default/slapd file.

Basic Post-Installation Configuration

The installation process installs the package without any configurations. To have our OpenLDAP server running properly, we need to do some basic post-installation configuration. Run the following command to start the configuration wizard.

sudo dpkg-reconfigure slapd

You will need to answer a series of questions. Answer these questions as follows:

1 . Omit LDAP server configuration: NO

2 . When asked for Domain Name :XXXX(This will be used as base DN of the LDAP directory)

Example : learndeltax.com

3 . Organization name: Enter your organization name Example : XXX

4 . Administrator password: Enter the same password set during installation.

5 . Database backend: MDB

6 . Do you want the database to be removed when slapd is purged? No

7 . Move old database? Yes

8 . Allow LDAPv2 protocol? No. The latest version of LDAP is LDAP v.3, developed in 1997. LDAPv2 is obsolete.

9 . Now the process will reconfigure the OpenLDAP service according to your answers. Your OpenLDAP server is now ready to use.

By using the above mentioned steps, we will have the non-secure openldap server working.

Install phpLDAPadmin to Manage LDAP with a Web Interface

Although it is very possible to administer LDAP through the command line, most users will find it easier to use a web interface. We're going to install phpLDAPadmin, which provides this functionality, to help remove some of the friction of learning the LDAP tools.
The Ubuntu repositories contain the phpLDAPadmin package. You can install it by typing:

sudo apt-get install phpldapadmin

This should install the administration interface, enable the necessary Apache virtual hosts files, and reload Apache.

Begin by opening the main configuration file with root privileges in your text editor:

sudo nano /etc/phpldapadmin/config.php

In this file, we need to add the configuration details that we set up for our LDAP server. Start by looking for the host parameter and setting it to your server's domain name or public IP address. This parameter should reflect the way you plan on accessing the web interface:

$servers->setValue('server','host','127.0.0.1');

Next up, you'll need to configure the domain name you selected for your LDAP server. Remember, in our example we selected learndeltax.com. We need to translate this into LDAP syntax by replacing each domain component (everything not a dot) into the value of a dc specification.
All this means is that instead of writing learndeltax.com, we will write something like dc=learndeltax,dc=com.or else we can leave it empty so that it can pick automatically as shown below:

$servers->setValue('server','base',array());

We need to adjust this same thing in our login bind_id parameter. The cn parameter is already set as "admin". This is correct. We just need to adjust the dc portions again, just as we did above:

$servers->setValue('login','bind_id','cn=admin,dc=learndeltax,dc=com');

The last thing that we need to adjust is a setting that control the visibility of warning messages. By default phpLDAPadmin will throw quite a few annoying warning messages in its web interface about the template files that have no impact on the functionality.
We can hide these by searching for the hide_template_warning parameter, uncommenting the line that contains it, and setting it to "true":

$config->custom->appearance['hide_template_warning'] = true;

This is the last thing that we need to adjust. You can save and close the file when you are finished.

Now if we open http://localhost/phpldapadmin , the user should see the ldap server admin console as displayed first.

Enabling Secure LDAP on port 636 on the same setup :

There are two ways to encrypt LDAP connections with SSL/TLS.
Traditionally, LDAP connections that needed to be encrypted were handled on a separate port, typically 636. The entire connection would be wrapped with SSL/TLS. This process, called LDAP over SSL, uses the ldaps:// protocol. This method of encryption is now deprecated.
STARTTLS is an alternative approach that is now the preferred method of encrypting an LDAP connection. STARTTLS "upgrades" a non-encrypted connection by wrapping it with SSL/TLS after/during the connection process. This allows unencrypted and encrypted connections to be handled by the same port. This guide will utilize STARTTLS to encrypt connections.

Install the SSL Components

Once your OpenLDAP server is configured, we can go ahead and install the packages we'll use to encrypt our connection. The Ubuntu OpenLDAP package is compiled against the GnuTLS SSL libraries, so we will use GnuTLS to generate our SSL credentials:

sudo apt-get install gnutls-bin ssl-cert

With all of our tools installed, we can begin creating the certificates and keys needed to encrypt our connections.

The default slapd package in debian stretch uses gnutls to perform it’s crypto operations by default and NOT openssl. So while generating certificates keep that in mind (some options are meant for slapd built against Mozilla’s NSS and some are for OpenSSL).

Create the Certificate Templates

To encrypt our connections, we'll need to configure a certificate authority and use it to sign the keys for the LDAP server(s) in our infrastructure. So for our single server setup, we will need two sets of key/certificate pairs: one for the certificate authority itself and one that is associated with the LDAP service.
To create the certificates needed to represent these entities, we'll create some template files. These will contain the information that the certtool utility needs in order to create certificates with the appropriate properties.
Start by making a directory to store the template files:

sudo mkdir /etc/ssl/templates

Create the CA Template file

Create the template for the certificate authority first. We'll call the file ca_server.conf. Create and open the file in your text editor:

sudo nano /etc/ssl/templates/ca_server.conf

We only need to provide a few pieces of information in order to successfully create a certificate authority. We need to specify that the certificate will be for a CA (certificate authority) by adding the ca option. We also need the cert_signing_key option to give the generated certificate the ability to sign additional certificates. We can set the cn to whatever descriptive name we'd like for our certificate authority:

File : caserver.conf

cn = LDAP Server

CA

cacert_signing_key

Save and close the file.

Create the LDAP Service Template

Next, we can create a template for our LDAP server certificate called ldap_server.conf. Create and open the file in your text editor with sudo privileges:

sudo nano /etc/ssl/templates/ldap_server.conf

Here, we'll provide a few different pieces of information. We'll provide the name of our organization and set the tls_www_server, encryption_key, and signing_key options so that our cert has the basic functionality it needs.

The cn in this template must match the FQDN of the LDAP server. If this value does not match, the client will reject the server's certificate. We will also set the expiration date for the certificate. We'll create a 10 year certificate to avoid having to manage frequent renewals:

File : ldapserver.conf

organization = "IBM"

cn = learndeltax.com

tls_www_server

encryption_key

signing_key

expiration_days = 3652

Save and close the file when you're finished. Create CA Key and Certificate
Now that we have our templates, we can create our two key/certificate pairs. We need to create the certificate authority's set first.

Use the certtool utility to generate a private key. The /etc/ssl/private directory is protected from non-root users and is the appropriate location to place the private keys we will be generating. We can generate a private key and write it to a file called ca_server.key within this directory by typing:

sudo certtool -p --outfile /etc/ssl/private/ca_server.key

Now, we can use the private key that we just generated and the template file we created in the last section to create the certificate authority certificate. We will write this to a file in the /etc/ssl/certs directory called ca_server.pem:

sudo certtool -s --load-privkey /etc/ssl/private/ca_server.key --template /etc/ssl/templates/ca_server.conf --outfile /etc/ssl/certs/ca_server.pem

We now have the private key and certificate pair for our certificate authority. We can use this to sign the key that will be used to actually encrypt the LDAP session. Create LDAP Service Key and Certificate and Next, we need to generate a private key for our LDAP server. We will again put the generated key in the /etc/ssl/private directory for security purposes and will call the file ldap_server.key for clarity.

We can generate the appropriate key by typing:

sudo certtool -p --sec-param high --outfile /etc/ssl/private/ldap_server.key

Once we have the private key for the LDAP server, we have everything we need to generate a certificate for the server. We will need to pull in almost all of the components we've created thus far (the CA certificate and key, the LDAP server key, and the LDAP server template).
We will put the certificate in the /etc/ssl/certs directory and name it ldap_server.pem. The command we need is:

sudo certtool -c --load-privkey /etc/ssl/private/ldap_server.key --load-ca-certificate /etc/ssl/certs/ca_server.pem --load-ca-privkey /etc/ssl/private/ca_server.key --template /etc/ssl/templates/ldap_server.conf --outfile /etc/ssl/certs/ldap_server.pem

Give OpenLDAP Access to the LDAP Server Key

We now have all of the certificates and keys we need. However, currently, our OpenLDAP process will be unable to access its own key.

A group called ssl-cert already exists as the group-owner of the /etc/ssl/private directory. We can add the user our OpenLDAP process runs under (openldap) to this group:

sudo usermod -aG ssl-cert openldap

Now, our OpenLDAP user has access to the directory. We still need to give that group ownership of the ldap_server.key file though so that we can allow read access. Give the ssl-cert group ownership over that file by typing:

sudo chown :ssl-cert /etc/ssl/private/ldap_server.key

Now, give the ssl-cert group read access to the file:

sudo chmod 640 /etc/ssl/private/ldap_server.key

Our OpenSSL process can now access the key file properly.

Configure OpenLDAP to Use the Certificate and Keys

We have our files and have configured access to the components correctly. Now, we need to modify our OpenLDAP configuration to use the files we've made. We will do this by creating an LDIF file with our configuration changes and loading it into our LDAP instance.
Move to your home directory and open a file called addcerts.ldif. We will put our configuration changes in this file:

cd ~nano addcerts.ldif

To make configuration changes, we need to target the cn=config entry of the configuration DIT. We need to specify that we are wanting to modify the attributes of the entry. Afterwards we need to add the olcTLSCACertificateFile, olcCertificateFile, and olcCertificateKeyFile attributes and set them to the correct file locations.
The end result will look like this: addcerts.ldif

dn: cn=config
changetype: modify
add: olcTLSCACertificateFile
olcTLSCACertificateFile: /etc/ssl/certs/ca_server.pem
-
add: olcTLSCertificateFile
olcTLSCertificateFile: /etc/ssl/certs/ldap_server.pem
-
add: olcTLSCertificateKeyFile

olcTLSCertificateKeyFile: /etc/ssl/private/ldap_server.key

Save and close the file when you are finished. Apply the changes to your OpenLDAP system using the ldapmodify command:

sudo ldapmodify -H ldapi:// -Y EXTERNAL -f addcerts.ldif

We can reload OpenLDAP to apply the changes:

sudo service slapd force-reload

Our clients can now encrypt their connections to the server over the conventional ldap:// port by using STARTTLS.

Configure OpenLDAP to listen over SSL

Edit the /etc/default/slapd file and configure OpenLDAP to listen over SSL.

vi /etc/sysconfig/slapd

Update the below line to enable ldaps:/// as shown below

SLAPD_URLS="ldapi:/// ldap:/// ldaps:///"

Restart the slapd service.

systemctl restart slapd

Verify the LDAP service. LDAP service should now be listening on TCP port 636 as well.

netstat -antup | grep -i 636

Output:tcp 0 0 0.0.0.0:636 0.0.0.0:* LISTEN 11720/slapdtcp6 0 0 :::636 :::* LISTEN 11720/slapd

Firewall

Add the LDAPS service to the firewall (TCP 686).

firewall-cmd --permanent --add-service=ldapsfirewall-cmd --reload

Setting up the Client Machines

In order to connect to the LDAP server and initiate a STARTTLS upgrade, the clients must have access to the certificate authority certificate and must request the upgrade. On the OpenLDAP Server
If you are interacting with the OpenLDAP server from the server itself, you can set up the client utilities by copying the CA certificate and adjusting the client configuration file.
First, copy the CA certificate from the /etc/ssl/certs directory to a file within the /etc/ldap directory. We will call this file ca_certs.pem. This file can be used to store all of the CA certificates that clients on this machine may wish to access. For our purposes, this will only contain a single certificate:

sudo cp /etc/ssl/certs/ca_server.pem /etc/ldap/ca_certs.pem

Now, we can adjust the system-wide configuration file for the OpenLDAP utilities. Open up the configuration file in your text editor with sudo privileges:

sudo nano /etc/ldap/ldap.conf

Adjust the value of the TLS_CACERT option to point to the file we just created:/etc/ldap/ldap.conf

. . .TLS_CACERT /etc/ldap/ca_certs.pem. . .

Save and close the file.

Configuring Remote Clients

If you are connecting to your OpenLDAP server from remote servers, you will need to complete a similar process. First, you must copy the CA certificate to the client machine. You can do this easily with the scp utility.

Copying the CA Certificate

Once you are connected to the OpenLDAP client, you can copy the CA certificate by typing:

scp user@learndeltax.com:/etc/ssl/certs/ca_server.pem ~/

Now, append the copied certificate to the list of CA certificates that the client knows about. This will append the certificate to the file if it already exists and will create the file if it doesn't:

cat ~/ca_server.pem | sudo tee -a /etc/ldap/ca_certs.pem

Adjust the Client Configuration

Next, we can adjust the global configuration file for the LDAP utilities to point to our ca_certs.pem file. Open the file with sudo privileges:

sudo nano /etc/ldap/ldap.conf

Find the TLS_CACERT option and set it to the ca_certs.pem file:/etc/ldap/ldap.conf

. . .TLS_CACERT /etc/ldap/ca_certs.pem. . .

Save and close the file when you are finished.

References :

1/.https://www.itzgeek.com/how-tos/linux/centos-how-tos/configure-openldap-with-ssl-on-centos-7-rhel-7.html
2/.https://www.digitalocean.com/community/tutorials/how-to-encrypt-openldap-connections-using-starttls
3/.https://www.linuxbabe.com/ubuntu/install-configure-openldap-server-ubuntu-16-04

Fibonacci series using Cortex M4 Assembly

2016-10-19T06:46:00.000-07:00

Fibonacci Series:

1 ,1 ,2, 3, 5, 8, 13....

Series can be checked element by element in R4 or in the memory location mentioned.

Code:

   PRESERVE8
    THUMB
    AREA    |.text|,CODE,READONLY
    EXPORT __main
    ENTRY
__main    FUNCTION
    MOV R0,#0;Initial number 0
    MOV R1,#1;Initial number 1
    MOV R3,#255;Upto What Number you want the series(req)
    MOV R4,#0;every element in series will be stored in r4
    MOV R5,#0x20000000;The entire series is written from this memory location
    ADD R4,R0,R1;val = t0+t1
loop1 CMP R4,R3;if(val > req)
    BLE LOOP;if less goto loop
    B stop;Else goto end
LOOP STR R4,[R5],#1;Storing the series into memory
    MOV R0,R1;t1=t0;
    MOV R1,R4;t0=val
    ADD R4,R0,R1;val = t0 + t1
    B loop1;Loop untill val >= req
stop    B stop
        ENDFUNC
        END

Exponential Series in ARM Cortex M4 Assembly

2016-10-19T06:38:00.001-07:00

e^x = 1 + (x/1!)+((x^2)/2!)+((x^3)/3!)+......

The below ARM assembly code will be used to find the value of e^x based on the above definition for any value of x using the Floating point unit of ARM Cortex-M4 Processor.

Code:

PRESERVE8
        THUMB
        AREA    |.text|,CODE,READONLY
        EXPORT __main
        ENTRY
__main    FUNCTION
        MOV R0,#10;Holding the Number of Terms in Series 'n'
        MOV R1,#1;Counting Variable 'i'
        VLDR.F32 S0,=1;Holding the sum of series elements 's'
        VLDR.F32 S1,=1;Temp Variable to hold the intermediate series elements 't'
        VLDR.F32 S2,=3;Holding 'x' Value
LOOP1    CMP R1,R0;Compare 'i' and 'n'
        BLE LOOP;if i < n goto LOOP
        B stop;else goto stop
LOOP      VMUL.F32 S1,S1,S2; t = t*x
        VMOV.F32 S5,R1;Moving the bit stream in R1('i') to S5(floating point register)
        VCVT.F32.U32 S5, S5;Converting the bitstream into unsigned fp Number 32 bit
        VDIV.F32 S1,S1,S5;Divide t by 'i' and store it back in 't'
        VADD.F32 S0,S0,S1;Finally add 's' to 't' and store it in 's'
        ADD R1,R1,#1;Increment the counter variable 'i'
        B LOOP1;Again goto comparision
stop    B stop
        ENDFUNC
        END

Five Stage Pipeline

2016-10-19T06:22:00.001-07:00

In simple terms, pipelining enables instruction level parallelism. From fetching an instruction to its actual execution, one can divide this whole process into well-defined stages. So, in a five stage pipeline, we can effectively execute five different instructions in one clock cycle.

However, each stage can be stalled due to complexity of operations like division, branching takes more time than addition or unavailability of data, or dependency between successive instructions.

Implementing a pipeline stage adds cost and delay to architecture, but overall CPI (clocks per instruction) decreases, which makes pipelining viable for computer architecture.

As the pipeline is as stronger as its weakest link, it should be taken care that every stage should be load balanced while designing a pipeline i.e. time required to process should remain almost equal.

Reading and writing the memory and register file and using the ALU typically constitute the biggest delays in the processor. So we try to choose five pipeline stages so that each stage involves exactly one of these slow steps. The five stages, one step per stage are:

Fetch

In the Fetch stage, the processor reads the instruction from instruction memory.

Decode

In the Decode stage, the processor reads the source operands from the register file and decodes the instruction to produce the control signals.

Execute

In the Execute stage, the processor performs a computation with the ALU.

Memory

In the Memory stage, the processor reads or writes data memory.

Writeback

Writeback stage, the processor writes the result to the register file, when applicable.

In the pipelined processor given in the above figure, the length of a pipeline stage is set at 250 ps by the slowest stage, the memory access (in the Fetch or Memory stage). At time 0, the first instruction is fetched from memory. At 250 ps, the first instruction enters the Decode stage, and a second instruction is fetched. At 500 ps, the first instruction executes, the second instruction enters the Decode stage, and a third instruction is fetched. And so forth, until all the instructions complete. The instruction latency is 5 * 250 = 1250 ps. The throughput is 1 instruction per 250 ps (4 billion instructions per second). Because the stages are not perfectly balanced with equal amounts of logic, the latency is slightly longer for the pipelined than for the single-cycle processor. Similarly, the throughput is not quite five times as great for a five-stage pipeline as for the single-cycle processor. Nevertheless, the throughput advantage is substantial.

Advantages of Five Stage Pipeline:

Will help in executing multiple instructions in parallel.All the stages i.e. all the units in the pipeline will be busy all the time.

Because each stage has only one-fifth of the entire logic, the clock frequency is almost five times faster.

Hence, the latency of each instruction is ideally unchanged, but the throughput is ideally five times better.

Microprocessors execute millions or billions of instructions per second, so throughput is more important than latency.

But the Pipelining process will introduce some overhead, so the throughput will not be quite as high as we might ideally desire, but pipelining nevertheless gives such great advantage for so little cost that all modern high-performance microprocessors are pipelined.

How Hazards Come into picture in a Five Stage Pipeline:
A central challenge in pipelined systems is handling hazards that occur when the results of one instruction are
needed by a subsequent instruction before the former instruction has completed.

Types of Hazards:

Structure Hazards: (because of one memory)
This type of Hazard occurs when there is a conflict for use of a common resource. Because somewhere in the
pipeline there can be a situation where instruction fetch and the data fetch can happen at the same time. So
in that case instruction fetch would have to stall for that cycle, which would cause a pipeline bubble. Hence
the pipelined data paths require separate instruction/data memories.

Data Hazards:
This type of Hazard occurs when an instruction depends on the result of a previous instruction which is still in the pipeline.

Possible Solutions for Data Hazards:

Solving Data Hazards with Forwarding:

Some data hazards can be solved by forwarding (also called bypassing) a result from the memory or write back stage to a dependent instruction in the Execute stage.

Solving Data Hazards with Stalls:

The alternative solution is to stall the pipeline, holding up operation until the data is available.

Control Hazards:
Control hazards occur when the decision of what instruction to fetch has not been made by the time the next instruction must be fetched. Control hazards are solved by predicting which instruction should be fetched and flushing the pipeline if the prediction is later determined to be wrong. Moving the decision as early as possible minimizes the number of instructions that are flushed on a mis-prediction.

Building Modules For Raspberry Pi using Cross Compilation

2016-09-15T00:41:00.002-07:00

For the task to complete it requires a deep understanding on the below mentioned terms that we encounter will building a module.

There are two types of Compilation:
1.Native Compilation
2.Cross Compilation

Native Compilation:

What this means is that you are trying to build an object file or a module for the same underlying hardware that you are using on your host.By default Linux builds for the same architecture the host system is running. This is called “native compiling”. An x86 system building an x86 kernel, x86-64 building x86-64,or PowerPC building PowerPC are all examples of native compiling.

ex:

Assuming you are trying to run a C-Code(test.c) in Ubuntu(linux) on Intel Hardware machine.

gcc -o test test.c

The result of this compilation will generate an executable file which will work on the x86 processor but will not work on ARM.

Cross Compilation:

It is the process in which user will try to generate the binaries or the executable files for other architectures.You use a cross compiler to produce executable (or objects) for a platform other than the local host.Cross compiling is hard. The build system for the Linux kernel supports cross compiling via a two step process:

1) Specify a different architecture (ARCH) during the configure, make, and install stages.

2) Supply a cross compiler (CROSS_COMPILE) which can output the correct kind of binary code.

An example cross compile command line (building the “arm” architecture) looks like:

make ARCH=arm menuconfig

make ARCH=arm CROSS_COMPILE=armv5l-

Don't bother about the above two statements,you will get to know about that later.

Steps to Make your Setup ready:

Things you require:

1.PC with Ubuntu in it.

2.A Raspberry pi with Raspbian OS(Jessie) in it.

Connect your raspberry pi to the PC and try to remotely login into it using ssh.

This step can be done by following the video below:

The next step is to download the required source code files and the build tool chain for arm.

Step 1:

create a directory named devicedriver inside a directory named Work in your home directory.

cd ~;mkdir Work;cd Work;mkdir devicedriver;cd devicedriver

Step 2:get the source files into the devicedriver directory

git clone --depth=1 https://github.com/raspberrypi/linux

After the execution of above command you will find a directory named linux inside the devicedriver directory.

Step 3:get the build tool chain in the devicedriver directory

git clone https://github.com/raspberrypi/tools

After the execution of above command you will find a directory named tools inside the devicedriver directory.

Step 4:Look into the tools directory

In the arm-bcm2708 folder in the tools directory ,you'll see four other folders, each containing a separate tool chain:

arm-bcm2708-linux-gnueabi
arm-bcm2708hardfp-linux-gnueabi
gcc-linaro-arm-linux-gnueabihf-raspbian
gcc-linaro-arm-linux-gnueabihf-raspbian-x64

So what this folders Mean?

arm--Architecture of the target(Raspberry pi have arm)

linux--os used host(Laptop)

gnuabihf--application binary interface(Don't bother about it at this point)

raspbian--OS of the target(Raspberry pi)

x64--Architecture of the host(Laptop-64 bit host)

So in this experiment i am using the gcc-linaro-arm-linux-gnueabihf-raspbian-x64 as my tool chain.You can use different tool chain as well but for time being i used the one mentioned above.

Step 5 :Adding the tool chain to your system PATH

export PATH=$PATH:$HOME/Work/devicedriver/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin

While this step is not strictly necessary, it does make it easier for later command lines!

Type the below command to execute the bashrc file with the PATH variable updated

source .bashrc

After this command you can even check whether your tool chain path is added to your system path or not just by typing $PATH

Step 6: Generate the .config File

In most of the cases we will generate the .config file with the default configuration.

So first we have to navigate to linux directory in the devicedriver directory and then

For Pi 1 or Compute Module:type

KERNEL=kernel
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- bcmrpi_defconfig

For Pi 2/3:Type

KERNEL=kernel7
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- bcm2709_defconfig

Then for both type the below :

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- zImage modules dtbs

Note: To speed up compilation on multiprocessor systems, and get some improvement on single processor ones, use -j n where n is number of processors * 1.5. Alternatively, feel free to experiment and see what works!

After this step is done ,just check the linux directory ,you will be able to find the file named Module.symvars and some other files,and in the arch/arm/boot/ folder you will find an uncompressed image file named Image and a compressed image named zImage.

But for cross compilation there is no need of Image file or even the zImage file,what you need are the intermediate files in the build process of the kernel that will be generated after the successful kernel build.

What you are going to read in the next paragraph is the most important step that needs to be grasped,because i found that many resources in the Internet are quite confusing mixing the kernel source compilation and the cross compilation.

Cross Compilation means, building your kernel and modules on a different platform rather than on the Raspberry Pi hardware directly. I did NOT have any luck compiling my kernel module directly on Raspberry Pi hardware.

In detail, first you'll want to cross-compile the Raspberry Pi Linux kernel(which you did in this step) so it builds Module.symvars and other intermediates. You won't actually use the kernel image that is being cross-compiled, just the intermediates to compile your module. Next, you'll cross-compile your module using those intermediates. Once your module is cross-compiled, copy the .ko module to your running Raspberry Pi and you should be able to load it along with the stock kernel.

But just for being safe side,do the following steps also,or else you may land in having a module which works for one version of kernel and your raspberry pi might me having a different kernel version.

Remove the SD card from the raspberry pi and insert into your computer using a card reader,ensure that the hardware write lock is removed,then type the below commands:

Check for the mount point of your SDcard using sudo fdisk -l command.In my case the boot partition is mounted to /dev/sdb1 and my root partition is mounted to /dev/sdb2..But in your case it might be different.

mkdir /mnt/fat32
mkdir /mnt/ext4
sudo mount /dev/sdb1 mnt/fat32
sudo mount /dev/sdb2 mnt/ext4

Next, install the modules into the SD card:

sudo make ARCH=arm CROSS_COMPILE=$(HOME)/Work/devicedriver/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf- INSTALL_MOD_PATH=mnt/ext4 modules_install

Finally, copy the kernel and Device Tree blobs onto the SD card, making sure to back up your old kernel:

Before executing the below commands ensure that KERNEL variable is set to kernel7 by using $KERNEL command,if the output is kernel7,then it is fine,otherwise type KERNEL=kernel7 and press enter.

sudo cp /mnt/fat32/$KERNEL.img mnt/fat32/$KERNEL-backup.img

sudo scripts/mkknlimg arch/arm/boot/zImage /mnt/fat32/$KERNEL.img

sudo cp arch/arm/boot/dts/*.dtb /mnt/fat32/

sudo cp arch/arm/boot/dts/overlays/*.dtb* /mnt/fat32/overlays/

sudo cp arch/arm/boot/dts/overlays/README /mnt/fat32/overlays/

sudo umount /mnt/fat32

sudo umount /mnt/ext4

Finally, plug the card into the Pi and boot it!

So if the build is successful then our cross compilation is done.

Step 7: Time to Test

Now make a directory named code in the devicedriver directory. In that create two files named test.c and Makefile.

Content of test.c:

#include <linux/module.h>

static int __init simple_init(void)

{

pr_info("Hi ManojKiran %s ..\n", __FUNCTION__);

return 0;

}

static void __exit simple_exit(void)

{

pr_info("Bye ManojKiran %s ...\n", __FUNCTION__);

}

module_init(simple_init);

module_exit(simple_exit);

MODULE_LICENSE("GPL");

Contents of MakeFile:

COMPILER:=$(HOME)/Work/devicedriver/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-

SOURCE:=$(HOME)/Work/devicedriver/linux/

PWD:= $(shell pwd)

obj-m := test.o

default:

make ARCH=arm CROSS_COMPILE=${COMPILER} -C $(SOURCE) M=$(PWD) modules

rm *.mod.c *.o

clean:

-rm *.mod.c *.o *.ko modules.order Module.symvers 2>/dev/null

Then type make in the code directory.If every thing works fine ,then you should see test.ko file being generated in the test directory.

Step 8:

Test it by insmod command

In Laptop it should generate an error because that module is built for arm architecture.

Type below command in laptop(Ubuntu) in code directory ,and you should get an error like this

Command:

sudo insmod test.ko

Output:

insmod: ERROR: could not insert module dr2016f1.ko: Invalid module format

Step 9:

Now time to test the test.ko module in the raspberry pi and it should work.

Use scp to send the test.ko module to raspberry pi using the below command in the code directory.

sudo scp test.ko pi@IPADDRESS:/home/pi

Then you can find the test.ko file lying in the home directory of raspberry pi.Then type this command in the home directory of raspberry pi.

sudo insmod test.ko

if the above command is successful then nothing will be visible.To see if it actually worked type the following command

dmesg

The last line of the output of the dmesg will be Hi ManojKiran

*****************************************************************

Thanks For reading my post.Hope you guys enjoyed it and learnt deltax amount today.Fell free to comment my efforts.

Python Language Translator

2016-06-17T11:21:00.000-07:00

Synopsis:

The Python Language Translator is a python script which takes the input from the user and converts it to any language that user want and read the converted text in that particular language

Execution:

Command : python PyLanguage_Translator.py

Script Link:

Ubuntu News Application

2016-06-17T11:16:00.000-07:00

Synopsis:

The Ubuntu News Application is a python script which takes the input i.e the category of input that user wants the news to be and from that category the script will try to fetch the latest news from the CNN news Website and push the titles of the news as a notification in Ubuntu.

Execution:

Command : python Ubuntu_News_App.py

Script Link :

3D - OBJECT DETECTION USING OPENCV-PYTHON

2016-05-15T23:07:00.000-07:00

The following Code will detect the object present in the image ,whether it is a Cube or a Cylinder or Sphere based on Contour Approximation.The below Code is written Using the Python API for OpenCV Library.

Script:

import cv2
# Importing the Opencv Library
import numpy as np
# Importing NumPy,which is the fundamental package for scientific computing with #Python

# Reading Image
img = cv2.imread("/home/whoami/Pictures/cylinder1.jpg")
cv2.namedWindow("Original Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Original Image",img)
# Display image

# RGB to Gray scale conversion
img_gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
cv2.namedWindow("Gray Converted Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Gray Converted Image",img_gray)
# Display Image

# Noise removal with iterative bilateral filter(removes noise while preserving edges)
noise_removal = cv2.bilateralFilter(img_gray,9,75,75)
cv2.namedWindow("Noise Removed Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Noise Removed Image",noise_removal)
# Display Image
# Thresholding the image
ret,thresh_image = cv2.threshold(noise_removal,0,255,cv2.THRESH_OTSU)
cv2.namedWindow("Image after Thresholding",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Image after Thresholding",thresh_image)
# Display Image

# Applying Canny Edge detection
canny_image = cv2.Canny(thresh_image,250,255)
cv2.namedWindow("Image after applying Canny",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Image after applying Canny",canny_image)
# Display Image
canny_image = cv2.convertScaleAbs(canny_image)

# dilation to strengthen the edges
kernel = np.ones((3,3), np.uint8)
# Creating the kernel for dilation
dilated_image = cv2.dilate(canny_image,kernel,iterations=1)
cv2.namedWindow("Dilation", cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Dilation", dilated_image)
# Displaying Image
contours, h = cv2.findContours(dilated_image, 1, 2)
contours= sorted(contours, key = cv2.contourArea, reverse = True)[:1]
pt = (180, 3 * img.shape[0] // 4)
for cnt in contours:
    approx = cv2.approxPolyDP(cnt,0.01*cv2.arcLength(cnt,True),True)
    # print len(cnt)
    print len(approx)
    if len(approx) ==6 :
        print "Cube"
        cv2.drawContours(img,[cnt],-1,(255,0,0),3)
        cv2.putText(img,'Cube', pt ,cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, 2, [0,255, 255], 2)
    elif len(approx) == 7:
        print "Cube"
        cv2.drawContours(img,[cnt],-1,(255,0,0),3)
        cv2.putText(img,'Cube', pt ,cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, 2, [0, 255, 255], 2)
    elif len(approx) == 8:
        print "Cylinder"
        cv2.drawContours(img,[cnt],-1,(255,0,0),3)
        cv2.putText(img,'Cylinder', pt ,cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, 2, [0, 255, 255], 2)
    elif len(approx) > 10:
        print "Sphere"
        cv2.drawContours(img,[cnt],-1,(255,0,0),3)
        cv2.putText(img,'Sphere', pt ,cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, 2, [255, 0, 0], 2)

cv2.namedWindow("Shape", cv2.WINDOW_NORMAL)
cv2.imshow('Shape',img)

corners    = cv2.goodFeaturesToTrack(thresh_image,6,0.06,25)
corners    = np.float32(corners)
for    item in    corners:
    x,y    = item[0]
    cv2.circle(img,(x,y),10,255,-1)
cv2.namedWindow("Corners", cv2.WINDOW_NORMAL)
cv2.imshow("Corners",img)

cv2.waitKey()

Transparent Wood Could Potentially Help Light Up Homes

2016-04-03T12:02:00.000-07:00

Scientists from the KTH, School of Chemical Science and engineering have recently published a paper which is capable of featuring the perfect blend between interior decoration and bio composites. The team has designed a material that can come forward as the next generation home décor, namely transparent wood. People invest a huge amount of money in artificial lights to create a suitable presence inside the room. However with this new material, an automatic transparent ambience can be created and it also has great use as a potential material for solar cell windows.
Lars Berglund and his subordinates have taken the initiative to gift design enthusiasts an artificial wood which is transparent, reflective and refractive in nature. Contemporary work regarding extracting transparent paper from transparent wood guided the team to frame an abstract related to a similar, but stronger material.

The method of preparation includes several steps, among which the first step made the team remove lignin from samples of commercial balsa wood. The polymer is held responsible for absorbing 80 to 95 percent light and preventing it from passing through. Although the team successfully removed the polymer, they were still unable to produce a complete see-through material due to scattering. To overcome the glitch, scientists added acrylic, colloquially known as Plexiglass. Finally a customized, optically transparent wood was developed, having transmittance of 85% and haze of 71%. Additionally, the hazing property could even boost the manufacturing of solar cells.

The research was supported by the Knut and Alice Wallenberg Foundation, and was published in the Biomacromolecules journal of the American Chemical Society.

Source: Biomacromolecules

IMAGE CLASSIFICATION USING SIFT+KMEANS+KNN PYTHON

2016-04-03T11:54:00.000-07:00

Implement Bike vs. Horse Classification

(Use Bag-of-visual words approach (SIFT/SURF + KMEANS + KNN))

In this post i am trying to classify the test image into either Bike class or the Horse Class.

Procedure (KNN):
1. Get the path of images in the training set.
2. Extract SIFT features from each and every image in the set.
3. Compute K-Means over the entire set of SIFT features, extracted from the
training set.
4. Compute the histogram of features.
5. Train the KNearest classifier with the features (samples) and their
corresponding class names (responses).
6. Get the path of image in the test set.
7. Implement step 2 to step 6 for the image in the test set.
8. Now give the Test feature vector and the K value (Number of neighbors.
to be considered for classification) to the trained classifier (KNearest).
9. Get the prediction.
10. Print the prediction on to the image in the test data set.

Approach (KNN):
The code was written in two parts both for KNN :

Finding Features(Features.py)

Classifier(class.py)---Training & Testing

Both the files were attached to this link.

Steps followed in finding the features are :--( Features.py)

1.Importing the necessary libraries.

2.Fetching path of training dataset.

3.Get the training classes names and store them in a list.

4.Get all the path to the images and save them in a list (image_paths) and
the corresponding label in another list (image_classes).
5. Create feature extraction and key point detector objects.
6. Stack all the descriptors vertically in a numpy array i.e. convert a list into
a vertical numpy array.
7. Perform the K-means clustering over the descriptors.
8. Calculate the histogram of features.
9. Now give more weightage to the clusters which occur more frequently in
the data set and scale the visual words (This is used to increase the
efficiency of classifier).
10. Now save the entire copy of visual vocabulary, feature (samples),
Image_classes (responses) on to the disk. (This will reduce the complexity
and confusion).

Features.py:

#!/usr/bin/env python

import argparse as ap
# Importing library that supports user friendly commandline interfaces
import cv2
# Importing the opencv library
import imutils
# Importing the library that supports basic image processing functions
import numpy as np
# Importing the array operations library for python
import os
# Importing the library which supports standard systems commands
from scipy.cluster.vq import *
# Importing the library which classifies set of observations into clusters
from sklearn.preprocessing import StandardScaler
# Importing the library that supports centering and scaling vectors

# Get the path of the training set
parser = ap.ArgumentParser()
parser.add_argument("-t", "--trainingSet", help="Path to Training Set", required="True")
args = vars(parser.parse_args())

# Get the training classes names and store them in a list
train_path = args["trainingSet"]
training_names = os.listdir(train_path) # Listing the train_path directory

# Get all the path to the images and save them in a list
# image_paths and the corresponding label in image_paths
image_paths = [] # Inilialising the list
image_classes = [] # Inilialising the list
class_id = 0
for training_name in training_names: # Iterate over the training_names list
    dir = os.path.join(train_path, training_name)
    class_path = imutils.imlist(dir)
    image_paths+=class_path
    image_classes+=[class_id]*len(class_path)
    class_id+=1

# Create feature extraction and keypoint detector objects
fea_det = cv2.FeatureDetector_create("SIFT")
des_ext = cv2.DescriptorExtractor_create("SIFT")

# List where all the descriptors are stored
des_list = []
# Reading the image and calculating the features and corresponding descriptors
for image_path in image_paths:
    im = cv2.imread(image_path)
    kpts = fea_det.detect(im) # Computing the keypoints
    kpts, des = des_ext.compute(im, kpts) # Computing the key points and the descriptors
    des_list.append((image_path, des)) # Appending all the descriptors into the single list

# Stack all the descriptors vertically in a numpy array
descriptors = des_list[0][1]
for image_path, descriptor in des_list[1:]:
    descriptors = np.vstack((descriptors, descriptor)) # Stacking the descriptors

# Perform k-means clustering
k = 500 # Number of clusters
voc, variance = kmeans(descriptors, k, 1) # Perform Kmeans with default values

# Calculate the histogram of features
im_features = np.zeros((len(image_paths), k), "float32")
for i in xrange(len(image_paths)):
    words, distance = vq(des_list[i][1],voc)
    for w in words:
        im_features[i][w] += 1

# Perform Tf-Idf vectorization
nbr_occurences = np.sum( (im_features > 0) * 1, axis = 0)
# Calculating the number of occurrences
idf = np.array(np.log((1.0*len(image_paths)+1) / (1.0*nbr_occurences + 1)), 'float32')
# Giving weight to one that occurs more frequently

# Scaling the words
stdSlr = StandardScaler().fit(im_features)
im_features = stdSlr.transform(im_features) # Scaling the visual words for better Prediction

# Saving the contents into a file
np.savetxt("samples.data",im_features)
np.savetxt("responses.data",np.array(image_classes))
np.save("training_names.data",training_names)
np.save("stdSlr.data",stdSlr)
np.save("voc.data",voc)

class.py:

#!/usr/local/bin/python2.7

import argparse as ap
# Importing library that supports user friendly commandline interfaces
import cv2
# Importing the opencv library
import imutils
# Importing the library that supports basic image processing functions
import numpy as np
# Importing the array operations library for python
import os
# Importing the library which supports standard systems commands
from scipy.cluster.vq import *
# Importing the library which classifies set of observations into clusters

# Load the classifier, class names, scaler, number of clusters and vocabulary
samples = np.loadtxt('samples.data',np.float32)
responses = np.loadtxt('responses.data',np.float32)
classes_names = np.load('training_names.data.npy')
voc = np.load('voc.data.npy')
k = 500 # Loading the number of cluster

# Training the Knearest classifier with the test descriptors
clf = cv2.KNearest()
clf.train(samples,responses) # Train model using the training samples and corresponding responses

# Get the path of the testing set
parser = ap.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-t", "--testingSet", help="Path to testing Set")
group.add_argument("-i", "--image", help="Path to image")
parser.add_argument('-v',"--visualize", action='store_true')
args = vars(parser.parse_args())

# Get the path of the testing image(s) and store them in a list
image_paths = []
if args["testingSet"]:
    test_path = args["testingSet"]
    try:
        testing_names = os.listdir(test_path)
    except OSError:
        print "No such directory {}\nCheck if the file exists".format(test_path)
        exit()
    for testing_name in testing_names:
        dir = os.path.join(test_path, testing_name)
        class_path = imutils.imlist(dir)
        image_paths+=class_path
else:
    image_paths = [args["image"]]

# Create feature extraction and keypoint detector objects
fea_det = cv2.FeatureDetector_create("SIFT")
des_ext = cv2.DescriptorExtractor_create("SIFT")

# List where all the descriptors are stored
des_list = []
for image_path in image_paths:
    im = cv2.imread(image_path)
    if im == None:
        print "No such file {}\nCheck if the file exists".format(image_path)
        exit()
    kpts = fea_det.detect(im) # Computing the key points of test image
    kpts, des = des_ext.compute(im, kpts) # Computing the descriptors of the test image
    des_list.append((image_path, des))   # Appending the descriptors to a single list

# Stack all the descriptors vertically in a numpy array
descriptors = des_list[0][1]
for image_path, descriptor in des_list[0:]:
    descriptors = np.vstack((descriptors, descriptor))   # Stacking the descriptors in to a numpy array

# Computing the histogram of features
test_features = np.zeros((len(image_paths), k), "float32")
for i in xrange(len(image_paths)):
    words, distance = vq(des_list[i][1],voc)
    for w in words:
        test_features[i][w] += 1 # Calculating the histogram of features

# Perform Tf-Idf vectorization
nbr_occurences = np.sum( (test_features > 0) * 1, axis = 0) # Getting the number of occurrences of each word
idf = np.array(np.log((1.0*len(image_paths)+1) / (1.0*nbr_occurences + 1)), 'float32')
# Assigning weight to one that is occurring more frequently

# Perform the predictions
retval, results, neigh_resp, dists = clf.find_nearest(test_features,k=17)
# Finding the 17 nearest neighbours of the test image descriptor

if results[0][0] == 0: # results[0][0] will have the predicted class
    prediction = "Horse"
else:
    prediction = "Bike"

# Visualize the results, if "visualize" flag set to true by the user
if args["visualize"]:
    image = cv2.imread(image_path)
    cv2.namedWindow("Image",cv2.WINDOW_AUTOSIZE) # Creating a named window
    pt = (180,3*image.shape[0]//4) # Framing the size of font on the image
    cv2.putText(image, prediction, pt ,cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,2, [0, 0, 255],2) # Placing text on the image
    cv2.imshow("Image",image) # Displaying the image
    cv2.waitKey() # Wait for the keystroke of the user

I have attached the link to the code(in github):Feel free to use it for your purpose.
https://github.com/manojkiraneda/Machine-Perception/tree/master/Image%20Classification(ML)

Segmentation Using Canny+Watershed in Opencv-python

2016-02-26T03:17:00.000-08:00

Python Script is given below:

import cv2

# Importing opencv library
import numpy as np
# Importing NumPy,which is the fundamental package for scientific computing with Python
img = cv2.imread('C:\\Users\Ram\Pictures\\humans\\368078.jpg')
# Read the image from disk
cv2.imshow("Original image", img) # Display image
img_float = np.float32(img) # Convert image from unsigned 8 bit to 32 bit float
criteria = (cv2.TERM_CRITERIA_EPS+cv2.TERM_CRITERIA_MAX_ITER, 10, 1)
# Defining the criteria ( type, max_iter, epsilon )
# cv2.TERM_CRITERIA_EPS - stop the algorithm iteration if specified accuracy, epsilon, is reached.
# cv2.TERM_CRITERIA_MAX_ITER - stop the algorithm after the specified number of iterations, max_iter.
# cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER - stop the iteration when any of the above condition is met.
# max_iter - An integer specifying maximum number of iterations.In this case it is 10
# epsilon - Required accuracy.In this case it is 1
k = 50 # Number of clusters
ret, label, centers = cv2.kmeans(img_float, k, None, criteria, 50, cv2.KMEANS_RANDOM_CENTERS)
# apply kmeans algorithm with random centers approach
center = np.uint8(centers)
# Convert the image from float to unsigned integer
res = center[label.flatten()]
# This will flatten the label
res2 = res.reshape(img.shape)
# Reshape the image
cv2.imshow("K Means", res2) # Display image
cv2.imwrite("1.jpg", res2) # Write image onto disk
meanshift = cv2.pyrMeanShiftFiltering(img, sp=8, sr=16, maxLevel=1, termcrit=(cv2.TERM_CRITERIA_EPS+cv2.TERM_CRITERIA_MAX_ITER, 5, 1))
# Apply meanshift algorithm on to image
cv2.imshow("Output of meanshift", meanshift)
# Display image
cv2.imwrite("2.jpg", meanshift)
# Write image onto disk
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Convert image from RGB to GRAY
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# apply thresholding to convert the image to binary
fg = cv2.erode(thresh, None, iterations=1)
# erode the image
bgt = cv2.dilate(thresh, None, iterations=1)
# Dilate the image
ret, bg = cv2.threshold(bgt, 1, 128, 1)
# Apply thresholding
marker = cv2.add(fg, bg)
# Add foreground and background
canny = cv2.Canny(marker, 110, 150)
# Apply canny edge detector
new, contours, hierarchy = cv2.findContours(canny, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# Finding the contors in the image using chain approximation
marker32 = np.int32(marker)
# converting the marker to float 32 bit
cv2.watershed(img,marker32)
# Apply watershed algorithm
m = cv2.convertScaleAbs(marker32)
ret, thresh = cv2.threshold(m, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# Apply thresholding on the image to convert to binary image
thresh_inv = cv2.bitwise_not(thresh)
# Invert the thresh
res = cv2.bitwise_and(img, img, mask=thresh)
# Bitwise and with the image mask thresh
res3 = cv2.bitwise_and(img, img, mask=thresh_inv)
# Bitwise and the image with mask as threshold invert
res4 = cv2.addWeighted(res, 1, res3, 1, 0)
# Take the weighted average
final = cv2.drawContours(res4, contours, -1, (0, 255, 0), 1)
# Draw the contours on the image with green color and pixel width is 1
cv2.imshow("Watershed", final) # Display the image
cv2.imwrite("3.jpg", final) # Write the image
cv2.waitKey() # Wait for key stroke

The result of the above script is given in the pdf below (2nd Answer):

Number Plate Detection in OpenCV - Python

2016-02-14T19:35:00.000-08:00

Script:

import cv2
# Importing the Opencv Library
import numpy as np
# Importing NumPy,which is the fundamental package for scientific computing with Python

# Reading Image
img = cv2.imread("/home/whoami/Pictures/number1.jpg")
cv2.namedWindow("Original Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Original Image",img)
# Display image

# RGB to Gray scale conversion
img_gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
cv2.namedWindow("Gray Converted Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Gray Converted Image",img_gray)
# Display Image

# Noise removal with iterative bilateral filter(removes noise while preserving edges)
noise_removal = cv2.bilateralFilter(img_gray,9,75,75)
cv2.namedWindow("Noise Removed Image",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Noise Removed Image",noise_removal)
# Display Image

# Histogram equalisation for better results
equal_histogram = cv2.equalizeHist(noise_removal)
cv2.namedWindow("After Histogram equalisation",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("After Histogram equalisation",equal_histogram)
# Display Image

# Morphological opening with a rectangular structure element
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
morph_image = cv2.morphologyEx(equal_histogram,cv2.MORPH_OPEN,kernel,iterations=15)
cv2.namedWindow("Morphological opening",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Morphological opening",morph_image)
# Display Image

# Image subtraction(Subtracting the Morphed image from the histogram equalised Image)
sub_morp_image = cv2.subtract(equal_histogram,morph_image)
cv2.namedWindow("Subtraction image", cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Subtraction image", sub_morp_image)
# Display Image

# Thresholding the image
ret,thresh_image = cv2.threshold(sub_morp_image,0,255,cv2.THRESH_OTSU)
cv2.namedWindow("Image after Thresholding",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Image after Thresholding",thresh_image)
# Display Image

# Applying Canny Edge detection
canny_image = cv2.Canny(thresh_image,250,255)
cv2.namedWindow("Image after applying Canny",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Image after applying Canny",canny_image)
# Display Image
canny_image = cv2.convertScaleAbs(canny_image)

# dilation to strengthen the edges
kernel = np.ones((3,3), np.uint8)
# Creating the kernel for dilation
dilated_image = cv2.dilate(canny_image,kernel,iterations=1)
cv2.namedWindow("Dilation", cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Dilation", dilated_image)
# Displaying Image

# Finding Contours in the image based on edges
new,contours, hierarchy = cv2.findContours(dilated_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contours= sorted(contours, key = cv2.contourArea, reverse = True)[:10]
# Sort the contours based on area ,so that the number plate will be in top 10 contours
screenCnt = None
# loop over our contours
for c in contours:
# approximate the contour
peri = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.06 * peri, True) # Approximating with 6% error
# if our approximated contour has four points, then
# we can assume that we have found our screen
if len(approx) == 4: # Select the contour with 4 corners
screenCnt = approx
break
final = cv2.drawContours(img, [screenCnt], -1, (0, 255, 0), 3)
# Drawing the selected contour on the original image
cv2.namedWindow("Image with Selected Contour",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Image with Selected Contour",final)

# Masking the part other than the number plate
mask = np.zeros(img_gray.shape,np.uint8)
new_image = cv2.drawContours(mask,[screenCnt],0,255,-1,)
new_image = cv2.bitwise_and(img,img,mask=mask)
cv2.namedWindow("Final_image",cv2.WINDOW_NORMAL)
cv2.imshow("Final_image",new_image)

# Histogram equal for enhancing the number plate for further processing
y,cr,cb = cv2.split(cv2.cvtColor(new_image,cv2.COLOR_RGB2YCrCb))
# Converting the image to YCrCb model and splitting the 3 channels
y = cv2.equalizeHist(y)
# Applying histogram equalisation
final_image = cv2.cvtColor(cv2.merge([y,cr,cb]),cv2.COLOR_YCrCb2RGB)
# Merging the 3 channels
cv2.namedWindow("Enhanced Number Plate",cv2.WINDOW_NORMAL)
# Creating a Named window to display image
cv2.imshow("Enhanced Number Plate",final_image)
# Display image
cv2.waitKey() # Wait for a keystroke from the user

The test cases and the result obtained from the above script are uploaded in the below pdf file

The code which is written above is also uploaded in my github account here.

How to Install open CV 3.0.0 in UBUNTU 15.04

2015-12-18T00:58:00.000-08:00

Step 1:Download open CV

open the link to download open CV 3.0:

Step 2:Extraction

Extract the downloaded archive to any arbitrary folder.

Step 3:Installing the Dependencies:

open terminal and follow the below steps or you can download the script file and run it (with sudo privileges):

sudo apt-get -y install libopencv-dev build-essential cmake git libgtk2.0-dev pkg-config python-dev python-numpy libdc1394-22 libdc1394-22-dev libjpeg-dev libpng12-dev libjasper-dev libavcodec-dev libavformat-dev libswscale-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev libtbb-dev libqt4-dev libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev x264 v4l-utils unzip

Go to the extracted folder named opencv-3.0.0 and then start typing the following commands:

mkdir build

cd build

cmake -D WITH_CUDA=OFF -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D WITH_V4L=ON -D WITH_OPENGL=ON ..

sudo make -j4

sudo make install

Step 4: Finishing installation

sudo /bin/bash -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'

sudo ldconfig

Step 6:Testing(Download this file and extract it and go to that directory and then type these commands)

sudo cmake .

sudo make

./DisplayImage lena.jpg

If the image of lenna appears then evry thing is perfect.Press Enter to close the image viewer window

C Code to Perform Sampling Rate Convertion

2015-12-17T21:12:00.000-08:00

Sampling Rate Conversion in Real Time(Using a C language)

Upsampling and DownSampling using Reconstruction

(Using sinc Function):

Code:

#include<stdio.h>
#include<math.h>
#define PI 3.14
void main()
{
int m,n,samplingrate,chunksize,subchunk2size,newchunksize,newsamplingrate,newsubchunk2size;
float i;
//int noofsamples;
int factor;
unsigned char a,b,c,d,e;
FILE *fp,*fp2;
void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,FILE *fp2);
void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,float i,int subchunk2size,FILE *fp2);
printf("Original Song is in : song1.wav\nResult is stored in : Createdsong.wav\n");
fp=fopen("song1.wav","r");
fp2=fopen("Createdsong.wav","w+");
fseek(fp,24,SEEK_SET);
fread(&samplingrate,4,1,fp);
printf("Sampling Rate is : %d\n",samplingrate);
fseek(fp,4,SEEK_SET);
fread(&chunksize,4,1,fp);
printf("chunksize is : %d\n",chunksize);
fseek(fp,40,SEEK_SET);
fread(&subchunk2size,4,1,fp);
printf("subchunk2size is : %d\n",subchunk2size);
printf("Enter the New Sampling Rate : ");scanf("%d",&newsamplingrate);
i=(float)samplingrate/newsamplingrate;
//printf("I value is : %f\n",i);
//noofsamples=readnoofsamples(fp);
printf("No of Samples in Given File : %d\n",subchunk2size/4);
newsubchunk2size=subchunk2size/i;
newchunksize=newsubchunk2size+36;
//noofsamples=newsubchunk2size/4;
writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size,fp2);
//fclose(fp2);
// fp2=fopen("Createdsong.wav","w+");
writedatafile(fp,newsamplingrate,newchunksize,newsubchunk2size,i,subchunk2size,fp2);
}
/*int readnoofsamples(FILE *fp)
{
int count=1;
unsigned char c;
fp=fopen("song1.wav","r");
fseek(fp,44,SEEK_SET);
while(1)
{
if(feof(fp)) break;
fscanf(fp,"%c",&c);
count++;
//printf("%d\n",count);

}
//count=count/4;
return count;
}*/
void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,float i,int subchunk2size,FILE *fp2)
{
//FILE *fp2;
int count=0,samco=1,center,samp=0,previous=0,x,temp;
short int e,r;
long int m,n,sumfr,sumfl;
float suml=0,sumr=0;
unsigned char z,s,v,w,c;
float sinc(int m,float i,int n);
printf("Writing the Samples in File....Please Wait....\n");
//fp=fopen("song1.wav","r");
fseek(fp,40,SEEK_SET);
fread(&subchunk2size,4,1,fp);
//printf("subchunk2size is : %d\n",subchunk2size);
//fclose(fp);
//fp=fopen("song1.wav","r");
//fp2=fopen("Createdsong.wav","a");
fseek(fp,44,SEEK_SET);
fseek(fp2,44,SEEK_SET);
//printf("%d\n",subchunk2size);
for(m=0;m<=subchunk2size;m++)
{
//if(feof(fp)) break;

sumfl=0;
sumr=0;
suml=0;
sumfr=0;
center=rint(m*i);
if(previous==center)
{

}
else
{
for(temp=0;temp<(center-previous);temp++)
{
count++;
}
}
previous=center;
fseek(fp,44+(4*count),SEEK_SET);
for(n=count-10;n<count+10;n++)
{
//printf("m value : %d\n",m);
if(n<0)
{
e=0;
r=0;
}
else
{

fread(&e,2,1,fp);
fread(&r,2,1,fp);
}
sumr=sumr+(e*sinc(m,i,n));
suml=suml+(r*sinc(m,i,n));
sumfl=suml;
sumfr=sumr;
//if(sumfl==0) printf("m=%d\t n=%d\n",m,n);
//printf("m*I=%d\t n=%d\t e=%d\n",m*i,n,e);
//printf("suml=%lf\t sumr=%lf\t n=%d\t count=%d\t e=%d\t r=%d\n",suml,sumr,n,count,e,r);

}
fwrite(&sumfr,2,1,fp2);
fwrite(&sumfl,2,1,fp2);
/*fscanf(fp,"%c",&t);
fscanf(fp,"%c",&s);
fscanf(fp,"%c",&v);
fscanf(fp,"%c",&w);
printf("%d %d %d %d\n",t,s,v,w);*/
//if(sumfr==0) printf("m=%d\t and n=%d\n",m,n);
//printf("m=%d\t and sumfl=%d\t sumfr=%d\n",m,sumfl,sumfr);
//getchar();
}
printf("Process Completed...Result is in Createdsong.wav\n");

fclose(fp);
fclose(fp2);
}
float sinc(int m,float i,int n)
{
float temp;
if(rint(m*i)==n)
{
//printf("sinc value is : %f\n",1.00);
return 1.00;
}
else
{
temp=PI*(m*i-n);
//printf("sinc value is : %f\n",(sin(temp)/temp));
return (sin(temp)/temp);
}
}

void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,FILE *fp2)
{long int count=1;
unsigned char header;
//FILE *fp2;
//fp=fopen("song1.wav","r");
//fp2=fopen("Createdsong.wav","w+");
fseek(fp,0,SEEK_SET);
while(1)
{
fread(&header,4,1,fp);
fwrite(&header,4,1,fp2);
if(ftell(fp)==44) break;
}
fseek(fp2,4,SEEK_SET);
fwrite(&newchunksize,4,1,fp2);
fseek(fp2,24,SEEK_SET);
fwrite(&newsamplingrate,4,1,fp2);
fseek(fp2,40,SEEK_SET);
fwrite(&newsubchunk2size,4,1,fp2);
//fclose(fp2);
//fclose(fp);
//printf("Suc\n");
}

Down Sampling using Decimation(Without Using Sinc Function):

Code:

#include<stdio.h>
void main()
{
FILE *fp,*fp2;
unsigned char down;
int samplingrate,ratio,i=4,chunksize,subchunk2size,newchunksize,newsubchunk2size;
int newsamplingrate;
long int count=1;

//Getting the Sampling Rate from the File
// while(1)
// {
fp=fopen("mono.wav","r");
fseek(fp,24,SEEK_SET);
fread(&samplingrate,4,1,fp);
rewind;
fseek(fp,4,SEEK_SET);
fread(&chunksize,4,1,fp);
rewind;
fseek(fp,40,SEEK_SET);
fread(&subchunk2size,4,1,fp);

//fscanf(fp,"%d",&sample);
//**fprintf(stdout,"samplingrate is %u\n chunksize is : %u\nsubchunk2size is : %u\n",samplingrate,chunksize,subchunk2size);
//count++;
//if(count>44) break;
//}
//printf("The count value is : %ld\n",count-1);

fclose(fp);
//printf("Enter the New Sampling Rate : ");scanf("%d",&newsamplingrate);
newsamplingrate=5000;
if(newsamplingrate<samplingrate)
{
ratio=samplingrate/newsamplingrate;
fp=fopen("song1.wav","r");
fseek(fp,44,SEEK_SET);
while(1)
{
fscanf(fp,"%c",&down);
//fprintf(stdout,"%d\t",down);
count++;
i--;
if(feof(fp)) break;
if(i<1)
{
i=4;
fseek(fp,SEEK_CUR+4*(ratio-1)-1,SEEK_CUR);
}
}

fclose(fp);

count=count/4;
// printf("Count is : %ld\n",count);
newsubchunk2size=chunksize/3;
newchunksize=newsubchunk2size+36;
writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size);
writedatafile(fp,newsamplingrate,newchunksize,newsubchunk2size,ratio);

}
/*if(newsamplingrate>samplingrate)
{
ratio=newsamplingrate/samplingrate;
fp=fopen("song1.wav","r");
fseek(fp,44,SEEK_SET);
newsubchunk2size=chunksize*3;
newchunksize=newsubchunk2size+36;
writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size);
writedataupfile(fp,newsamplingrate,newchunksize,newsubchunk2size,ratio);
}*/
}
//Writing the Header Section
void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size)
{long int count=1;
unsigned char header;
FILE *fp2;
fp=fopen("mono.wav","r");
fp2=fopen("song2.wav","w+");
//rewind;
while(1)
{
fread(&header,4,1,fp);
//if(ftell(fp)==5) fprintf(fp2,"%c",newchunksize);
//else if(ftell(fp)==17) fprintf(fp2,"%c",newsubchunk2size);
//else if(ftell(fp)==25) fprintf(fp2,"%c",newsamplingrate);
//else fprintf(fp2,"%c",header);
fwrite(&header,4,1,fp2);
if(ftell(fp)==44) {fclose(fp);break;}
}
//fp=fopen("song1.wav","r");
//fp2=fopen("song2.wav","w+");
//rewind(fp2);
fseek(fp2,4,SEEK_SET);
fwrite(&newchunksize,4,1,fp2);//fprintf(fp2,"%c",&newchunksize);
//rewind(fp2);
fseek(fp2,40,SEEK_SET);
fwrite(&newsubchunk2size,4,1,fp2);
//rewind(fp2);
fseek(fp2,24,SEEK_SET);
fwrite(&newsamplingrate,4,1,fp2);
//fclose(fp);
fclose(fp2);


}
//Write data to file
void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,int ratio)
{unsigned char down;
long int count=1;
int i=4;
FILE *fp2;
fp=fopen("mono.wav","r");
fp2=fopen("song2.wav","a+");
fseek(fp,44,SEEK_SET);
while(1)
{
fscanf(fp,"%c",&down);
fprintf(fp2,"%c",down);
count++;
i--;
if(feof(fp)) break;
if(i<1)
{
i=4;
fseek(fp,SEEK_CUR+4*(ratio-1)-1,SEEK_CUR);
}
}

fclose(fp);
fclose(fp2);
}

Transient Analysis of CMOS NAND gate

2015-12-14T21:53:00.002-08:00

Transient analysis if a 2-input CMOS Nand gate is derived in the below pdf have a look at it .

Download Document

CMOS Buffer Using Two transistors

2015-12-14T20:24:00.000-08:00

How to Analyse the Cmos Buffer With Two transistors

This is one of the most prominent questions that is often asked in technical interviews of any electronics company.

This circuit seems like it is very simple,but it if you start solving it it will lead to hell.

In this post I will analyse this circuit and plot the VOUT vs VIN characteristics same as like the CMOS inverter.

I will give a few steps for users who are new.

step1:

Draw the Ids Vs vds Characteristics of PMOS.

Step2:

Draw the Ids Vs Vds charecteristics of NMOS.

Step3:

Overlap both the characteristics in a single plot.

Step4:

Find the Intersections Between the two plots for different values of Vgs.

These Values will give you the input and output values that are being satisfyied by the circuit.

As it is very tuff to say intutively that which transistor will On and which will off for which values of input because those conditions will include the output voltage,I use MATLAB to get these graphs and intersections.

The Matlab Code is given Below:

clc;
clear all;
close all; vdd=5; up=500; un=1500; cox=3.28e-6; wbyl=2; wbylp=6; vtn=0.5;
vtp=-0.5;
vin=0:0.1:5;
vout=0:0.01:5;
lengthofvin=length(vin);
lengthofvout=length(vout);
for j=1:lengthofvin
for i=1:lengthofvout
if (vin(j)-vout(i)) < vtn currentn(j,i)=0;
end
if (vdd-vout(i))>(vin(j)-vout(i)-vtn)&& (vin(j)-vout(i))>=vtn
currentn(j,i)=0.5*un*cox*wbyl*((vin(j)-vout(i)-vtn).^2);
end
if (vdd-vout(i))<=(vin(j)-vout(i)-vtn )&& (vin(j)-vout(i))>=vtn
currentn(j,i)=un*cox*wbyl*(vin(j)-vout(i)-vtn-(vdd-vout(i))./2).*(vdd-vout(i));
end
end
end
for j=1:lengthofvin
for i=1:lengthofvout
if (vout(i)-vin(j)) < abs(vtp)
currentp(j,i)=0;
end
if (vout(i))>(vout(i)-vin(j)-abs(vtp))&& (vout(i)-vin(j))>=abs(vtp)
currentp(j,i)=0.5*up*cox*wbylp*((vout(i)-vin(j)-abs(vtp)).^2);
end
if (vout(i))<=(vout(i)-vin(j)-abs(vtp)) && (vout(i)-vin(j))>=abs(vtp)
currentp(j,i)=up*cox*wbylp*(vout(i)-vin(j)-abs(vtp)-((vout(i))./2))*(vout(i));
end
end
end
hold on; plot(vout,currentp','b');
xlabel('--------->vds');
ylabel('--------->ids');
title('Ids Vs Vds'); plot(vout,currentn','r'); hold off;
for j=1:lengthofvin
count=0;
for i=1:lengthofvout
if currentn(j,i)==currentp(j,i)
newinput(1,j)=vin(j);
if(vout(i)<=abs(vtp))
newoutput(1,j)=abs(vtp);
else if(vout(i)>=vdd-vtn)
newoutput(1,j)=vdd-vtn;
end newoutput(1,j)=vout(i); count=count+1;
if count==1 break;
end
end
end
end
end
for j=1:lengthofvin count=0;
for i=lengthofvout:-1:1
if currentn(j,i)==currentp(j,i)
newoutput1(j,1)=vout(i);
if(vout(i)>=vdd-vtn)
newoutput1(j,1)=vdd-vtn;
end
count=count+1;
if count==1
break;
end
end
end
end
figure; hold on;
plot(newinput,newoutput,'b',newinput,newoutput1,'b');
axis([0 5 0 5]);
xlabel('--------------->vin');
ylabel('--------------->vout');
title('Transfer Characteristics');

The plot of the above MATLAB code will look something like give below:

So in the graph you can see that the intersection of the PMOS and NMOS curves for a particular value of VGS are the input and output voltages that will satisfy this circuit conditions.And from the above plot it is clear that we can see a lot of intersections between the PMOS and NMOS curves .So let us consider the average value of voltage between the first point of intersection and the last point of intersection between the two PMOS and NMOS curves for a particular value of VGS. Then we will get the input versus output characteristics as shown below.But still we have a confusion because we took an average intersection point .

If we take the first intersection point ,then we will get the characteristics like shown below:

WaterFlow Model of CommonSource Amplifier

2015-11-23T07:55:00.001-08:00

How Common Source Amplifier Works??

Have a look at the below video

Water Flow Model:
========================

1. Analogies used in the water flow model are as indicated

    Valve 1 as Vg1
    Valve 2 as Vg2
    Source Width as Width

2.For the existing waterflow system as shown the two valve's are used for controlling the water flow, similar to the biasing voltages of an Amplifier.

Valve 1 is used for setting up the maximum distance the water can travel,which is similar to biasing the P MOS using VG1 with which Upper limit in output voltage is set.

3.Valve 2 is used to apply pressure on the waterflow which increases the distance with which water can travel.
Here the maximum distance is analogous to Overdrive voltage which is biased by making use Vg2 of N MOS.

4.Valve 2 is used to release pressure on the waterflow which decreases the distance with which water can travel.
Here the minimum distance is analogous to Overdrive voltage which is biased by making use Vg2 of N MOS.

5.Based on Minimum/Maximum distance travelled we can decide the Distance swing which is similar to the voltage swing.

6. Based on the source width variation we will have the water flow variation , which is analogous to the variation in width ,which varies current ,which varies the Gm and inturn varies the gain of the amplifier.

    There at the Input pipe we can see the water flow with its pressure variation which is anologous to the applying a varying input voltage

    The output is interms of travel distance variation of water ,which is analogous to the output voltage variations.

INDIAN SPECIES & CONDIMENTS AS NATURAL HEALERS

2015-10-24T02:14:00.000-07:00

Species and condiments are one of the most important forms of natural food. This article describes the medicinal virtues of different species and condiments, and their usefulness in the treatment of various common ailments. This information can serve as a guide to the readers to solve their common health problems through the use of specific species and condiments. It would, however be advisable to consult a doctor or an expert in case of serious problems.

1. CARDAMOM (elaichi) - The queen of species

Medicinal virtues:

The aroma and therapeutic properties of cardamom are due to its volatile oil. Tinctures of cardamom are also made. They are used chiefly in medicines for windiness and for strengthening the stomach. It is used as an adjunct to carminative drugs.

Uses
In India it is used for flavouring curries cakes, gulab jamun, bread and for other culinary purposes.

2. ONION - Dynamite of Natural Foods

Medicinal virtues
Onion is one of civilizations oldest medicines. Onions should be taken with meals, preferably raw, as fried or cooked onions are comparatively difficult to digest. For therapeutic purposes, it is advisable to use onion juice instead of the whole onion as it is an all-round medicine.
An exceptionally strong antioxidant, onion is full of numerous anticancer compounds. It has been specifically linked to inhibit human stomach cancer. It thins the blood, lowers cholesterol, raises good-type HDL cholesterol, wards of blood clots, and fights asthma, chronic bronchitis, hay fever, diabetes, atherosclerosis and infections.

Uses
They are used in soups and sauces and for seasoning many foods. They may also be eaten fried. Onion oil, produced by steam distillation, is used to a limited extent for flavoring foods.

Precautions
Excessive use of onions should, however, be avoided as it may promote gas formation and aggravate heartburn. Recent experiments have also found that abundant use onions have a tendency to reduce the number of red cells and o lower the hemoglobin.

3.PEPPER

Pepper is one of the oldest and most popular species. It is known as 'king of species'. The pepper plant is a stout, evergreen creeper with smooth surface, much swollen at the nodes.

Medicinal virtues:
Black pepper is a stimulant, pungent, aromatic, digestive and nervine tonic. The pungency of pepper is due to the resin chavacine, which is most abundant in the mesocarp. Black pepper is useful in relieving flatulence.

Whatsapp-The worst Messaging app of all time

2015-06-03T08:13:00.000-07:00

Whatsapp-The worst Messaging app of all time

Sometimes it feels like WhatsApp was designed by a sadist: the amount of potential drama that a messaging app can produce is ridiculous. Has someone read my message? Can someone see if I've read theirs?

Of course, it's possible (and probable) that WhatsApp was designed with the best intentions, and that you're freaking out for no reason. Aside from the ability to now know when someone has read your messages, there are lots of potential mishaps and confusion that WhatsApp can produce.

Determined to clear up some of these mysteries, I've thoroughly investigated and compiled a list of the most frequent and distressing issues about WhatsApp to help keep your stress level at a minimum.

1. I don't want a contact to know I'm on WhatsApp. Can this be done?

No.

Even when you block a contact, they'll cotinue to have you in their contact list because they presumably still have your number in their phone book. The only way you won't show up is if the other person doesn't have your phone number saved in their phone.

WhatsApp's contact list reflects your phonebook

The fact that you can't see that person on the contact list doesn't mean they can't see you, and vice versa. Whether or not you can see the contact doesn't make a difference: If they have you on their list, they'll see you. And you can't clear their list remotely.

If you suspect that they don't have you, don't give them your number or send them a message. When you add someone to your contact list, you'll see them on WhatsApp, but if the other person doesn't have your number, they won't see you until you contact them.

2. Can I appear as invisible?

Yes.

On Android, you either need to activate airplane mode before you read a message, or turn WiFi and Data off. That will prevent the last seen message from being updated, and you won't show up as "Online".

It's known as the poorly named "invisible mode", which really just disconnects data and WiFi. To activate the "invisible mode" on WhatsApp for Android easily, you can use WhatShadow, an accessory that turns off WiFi and data.

On iPhone, the issue is much simpler: just go to chat options and in advanced options, disable "Last seen online." Note that the changes can take up to one day to apply, so don't start reading straight away.

3. If someone is given my old number, will they be able to download my messages and see my contacts?

No.

They won't see contacts or be able to access old chats - that data is saved on your phone - but they can receive messages sent to your old number (without knowing who sent them).

WhatsApp gets its contacts from your phonebook, so it's unlikely that the person taking your old number will have the same contact. On the other hand, if the other person has WhatsApp installed, your friends will see that this person isn't you.

To avoid any problems, WhatsApp recommends the following:

Post a status update with your new phone number

Inform everyone of the change of number with a broadcast message

Delete your account:

Android: Settings> Account Info > Delete my account

iPhone : Settings> Chat > Advanced> Delete my account

BlackBerry : Settings> Account Info > Delete my account

Nokia : Options> About > Account Info > Options> Delete Account

Windows Phone : Settings> Account> Delete Account

Deleting the account removes all chat history on your mobile, payment information and participation in WhatsApp groups. It will make your account disappear.

4. Is WhatsApp free or paid for?

WhatsApp is paid for.

It always has been and always will be a paid-for app. It's the only way the application can get away without having ads, something its developers have always fought for.

It's true that the length of the free trial period varies greatly between platforms, but either way, you end up paying very little to use the service.

5. Is there a way to delete contacts forever?

Yes.

To delete contacts, simply remove them from your phonebook. If you don't want that person to be able to message you either, you'll have to block them.

But remember, if they have you in their phonebook, then they'll still see you on their contact list, but won't know if you're online or not.

6. Is there any way to tell if someone has read my messages?

Yes.

Theoretically, there is no way to know for sure if someone's read your message, but the introduction of the double blue check mark indicates just that. Here's a quick summary of what WhatsApp's icons mean:

Clock: The message hasn't left your phone yet, meaning there's either a problem with data or Wi-Fi connection. You can delete the message before it's sent.

Single grey check mark: The message has been delivered to the WhatsApp server. It's left your phone, but hasn't yet been received by the other person.

Double grey check mark: The message has been delivered to the other person's phone, but they haven't necessarily read it yey.

Double blue check: A new icon that indicates that the message has been read (or at least opened in your conversation) by the recipient.

In addition, if you hold down on the message and tap Info, you'll be able to see what time the message was delivered, and what time it was read. Remember though, that just because the message is 'read', doesn't mean that the person has definitely read the message. Chances are they have, but they may also have left open your chat and gotten the message without actually reading it.

7. If I block a person, can they tell?

No.

A common symptom of blocking is that you can't see the "last seen" or "online" status. Be warned though, if the other person uses WhatsApp on an iPhone, they may have turned off this feature.

Another result of blocking is that messages are left with only one tick and never get a second, although this could also be due to other causes, like the phone being turned off or lost.

If you know it's neither of these reasons, the chances that you've been blocked are hight, but it's still not 100%. If you really wanna know, trying sending an SMS or calling the person.

8. Is there any way to silence a group and receive the messages after?

You don't need to.

When groups are muted, the messages keep coming, only you're not notified.

To silence a group, just tap the menu button (on Android) or info (on iPhone) and press "Mute" or "Mute Group". It's a useful feature to prevent your phone from vibrating incessantly.

9. When you invite someone to a group, will they be able to read previous messages?

No.

When entering a group, a person can only read messages sent from that time. They don't have access to the history.

10. If I delete a message or photo on my phone, is it deleted from the other person's phone too?

No.

If only it were that simple. As it turns out, a message, photo or sound sent through WhatsApp will be delivered as soon as the first green tick appears.

The only way to delete a message before it reaches the recipient is to delete it before it reaches the server. Turn off the data connection and delete the message while it still has the clock icon beside it.

Why then, does WhatsApp let you delete messages that have already been delivered? It's a mystery. Maybe it allows you to erase things that might hurt you to see over and over. If you really want to send private messages that self-destruct, give Snapchat a try.

What is Cloud Computing

2015-05-28T03:43:00.000-07:00

What is the cloud? Where is the cloud?

Are we in the cloud now?

One of the most important question that is often asked in an interview(IT company)

These are all questions you've probably heard or even asked yourself. The term "cloud computing" is everywhere.

In the simplest terms, cloud computing means storing and accessing data and programs over the Internet instead of your computer's hard drive. The cloud is just a metaphor for the Internet. It goes back to the days of flowcharts and presentations that would represent the gigantic server-farm infrastructure of the Internet as nothing but a puffy, white cumulonimbus cloud, accepting connections and doling out information as it floats.

What cloud computing is not about is your hard drive. When you store data on or run programs from the hard drive, that's called local storage and computing. Everything you need is physically close to you, which means accessing your data is fast and easy, for that one computer, or others on the local network. Working off your hard drive is how the computer industry functioned for decades; some would argue it's still superior to cloud computing, for reasons I'll explain shortly.

The cloud is also not about having a dedicated network attached storage (NAS) hardware or server in residence. Storing data on a home or office network does not count as utilizing the cloud. (However, some NAS will let you remotely access things over the Internet, and there's at least one NAS named "My Cloud," just to keep things confusing.)

For it to be considered "cloud computing," you need to access your data or your programs over the Internet, or at the very least, have that data synchronized with other information over the Web. In a big business, you may know all there is to know about what's on the other side of the connection; as an individual user, you may never have any idea what kind of massive data-processing is happening on the other end. The end result is the same: with an online connection, cloud computing can be done anywhere, anytime.

Microsoft Office Boy

2015-05-13T06:39:00.000-07:00

Microsoft Office Boy

A jobless man applied for the position of "office boy" at Microsoft.

The HR manager interviewed him then watched him cleaning the floor as a test.

"You are employed." He said." Give me your e-mail address and I'll send you the application to fill in, as well as date when you may start."

The man replied "But I don't have a computer, neither an email."

I'm sorry", said the HR manager, "If you don't have an email, that means you do not exist. And who doesn't exist, cannot have the job."

The man left with no hope at all. He didn't know what to do, with only $10 in his pocket. He then decided to go to the supermarket and buy a 10Kg tomato crate. He then sold the tomatoes in a door to door round. In less than two hours, he succeeded to double his capital. He repeated the Operation three times, and returned home with $60. The man realized that he can survive by this Way, and started to go everyday earlier, and return late Thus, his money doubled or tripled every day.

Shortly, he bought a cart, then a truck, then he had his own fleet of delivery vehicles. 5 years later , the man is one of the biggest food retailers in the US .

He started to plan his family's future, and decided to have a life insurance.

He called an insurance broker, and chose a protection plan. When the conversation was concluded, the broker asked him his email. The man replied, "I don't have an email". The broker answered curiously, "You don't have an email, and yet have succeeded to build an empire. Can you imagine what you could have been if you had an email?!!"

The man thought for a while and replied, "Yes, I'd be an office boy at Microsoft!"

Moral of the story:

M1 - Internet is not the solution to your life.

M2 - If you don't have internet, and work hard, you can be a millionaire.

M3 - If you received this message, you are closer to being an office boy, than a millionaire. .........

Have a great day!!!

Smiling after reading is not mandatory!!!!

Top 10 Robots of 2012

2015-05-01T21:10:00.000-07:00

Top 10 Robots of 2012

#10

Preparation for campus Selections

2015-04-11T21:55:00.000-07:00

HELLO GUYS!!................First thing I want to say for those who want to get job in campus selections is " BE POSITIVE AND CONFIDENT". Here I wanna share you the things which are required for the worst case preparation.If you prepare for all these then I'm 100% sure, you will be the one.

The rounds (maximum rounds will be covered in this article) that are to be cleared in campus selections are:-(Mainly most of the companies will have only these rounds)

1. Written test

2. Group discussion (sometimes 2 GD's will be there for more screening)

3. Technical interview 1 (most of the cases only one TR)

4. Technical interview 2

5. HR interview

But some companies may follow another recruitment pattern.But those recruitment procedure will definitely include above 5 rounds and sometimes you can have the 6th one mentioned below

6. JAM (Just A Minute)

For this you just need to take one good topic then prepare well.. and have a rehearsal.. try to make it for five minutes with good fluency without brakes. Here they will see your fluency, pronunciation, and sometimes body language. Be careful with your body language throughout the hiring process.

ok let me make things a bit more elaborate!!

1. Written test

How to prepare for written exam?

To clear written exam you need to prepare following..

1. General aptitude

2. Verbal

3. Reasoning

4. Logical

5. Computers

1.General aptitude (Quantitative Aptitude by R.S AGGARWAL is enough)

It includes mainly time and work, time and distance, problems on ages, profit & loss, problems on trains, average, numbers, percentage, ratio & proportion, chain rule, boats and streams, allegation and mixtures, simple interest, compound interest, races, clocks, calenders, probability, permutations and combinations, partnership, geometry (topics that are in red color are very important).

My suggestion for you to clear this round is to prepare as per the company pattern. First of all see the previous papers of the particular company and analyze in what topics they were covered then prepare in that mode. But you should have minimum knowledge about all topics then only it is easy to solve.

2. Verbal

For verbal you need to prepare synonyms, antonyms, tenses, voice, prepositions, speech, verbal analogies, idioms and phrases, spotting errors, one word substitute and somewhat general English based questions.You should have to be aware of all the topics so reading newspaper, reading books helps you a lot in this section. For synonyms and antonyms GRE Barrons is helpful.

3. Reasoning

This section consists of Blood relations, analogies, comprehension passage, statement and assumption, cause and effect, making judgment etc...To clear this section you should have just a presence of mind and a little bit of practice. My suggestion is to think only about whatever given in the passage or paragraph and ignore about the reality.

4. Logical

Logical section is covered with number series, pie diagrams, bar graphs, Logical problems (he will give two statements and two conclusions we have to identify which one is true),Logical deduction, filling the suitable number or alphabet or character or symbol in the given format.

5.Computers

Computers section tests the knowledge of Basic computers, C, C++, JAVA, SQL and operating systems.

Non-CSE people are better to concentrate on C and C++...they are enough but If possible learn databases also...its very useful. To clear this section most probably you should have basic knowledge of computer.

Finally to clear a written test is sometimes hard but not impossible...It needs continuous preparation because hard-work without will power is worthless and presence of mind at the time of examination ....and somewhat luck too...But " HARD WORK NEVER FAILS ".

The Followings links can help you a Lot:

1.INDIA BIX

2.FRESHERS WORLD

3.M4MATHS

4.CAMPUS GATE

2. Group Discussion

After getting shortlisted in the written test you may face group discussion. To clear the group discussion is really not a big task..For this you just need somewhat communication skills and Confidence. The next thing you should posses is to face the group i.e., not to feel afraid to speak in front of people.

The main thing you should keep in your mind is "If I want job I should speak" so mental preparation is very essential. To know about how the process is went.. see the videos of group discussion in you tube...Its very important before you face GD. It gives you many tips i.e., what to do and what not to do in GD.

The following are the video links:

7 Major tips for group Discussion:

1. Maintain eye contact.

2. Initiating the Discussion

3. Allow others to speak.

4. Talk to the point.

5. Be sensible.

6. Good listening.

7. Positive Attitude.

8. Body language.

If you are good aware of the topic given....then gear immediately to initiate the discussion..don't wait others to start because the panel members will only remember the starting and ending..meanwhile they don't remember..so always to start the discussion is the best choice only when if you are aware of the topic and to wind up the discussion is al impotant. These are the two major things you should try in GD.

If you don't know about the topic then

Go for the SPELT approach if you don't know about the topic given..

S- Social

P-Political

E-Economical

L-Legal

T-Technology

Otherwise wait for sometime until you get idea about the given topic. Then you start speaking..In GD, speaking is not important...Speaking relevant to the topic is important..Panel members will see How clear you are in your thoughts.... Also remember don't address the panel members while GD is going on.

Follow these rules definitely you will win in Group Discussion.

3,4. TECHNICAL INTERVIEWS

In these you need to have some technical knowledge and the most important thing to face interview is again CONFIDENCE.. Because sometimes they too don't know the answer so if you say wrong answer with more confidence then it works good. They will test whether you are trainable or not that's it. Whatever you know say it clearly with atmost confidence. If you don't know the answer then politely say 'sorry sir I don't know sir' or 'sorry sir I cannot recollect it now'. Answer every thing with a reason behind them...while preparing question yourself (why? and how? ).

Second thing is to have a complete preparation of your resume. Whatever you mention in your resume, you should have reasons behind them. If they ask about your hobbies...spontaneously you should able to frame a story about them which is positive and impressive.

Always try to impress the interviewer by saying only the facts. Never show your attitude infront of them. Show your enthusiasm towards the company and your willingness to learn new things.

In rare cases they will go in depth of your technical knowledge that time don't panic.. say whatever you know because you always keep one thing in your mind "Talented people can survive anywhere, can achieve any thing". For this what you should do is....practice practice practice....continuous preparation is very important guys..

Here the technical interview1 includes the testing of your problem solving ability by asking the questions in your written exam and they will ask how you have solved the particular question. You need to explain the solution clearly. Technical interview2 is somewhat difficult..they will ask questions in depth so prepare well if you two technical interviews.

5. HR INTERVIEW

After getting shortlisted in TR you have to face the HR interview.. In this most of the times he will ask about the family background and about your hobbies. Always be truthful to the interviewer about your personal information. Sometimes they will ask questions to test your patience, reaction and your emotion towards it. So better to "Be rational rather than emotional".

After that they will ask about your job location.. For that you need to say I can adjust myself to any environment. Anyway they will locate you nearby regions only but they want to test your acceptance.

Sometimes you may undergo stress with their questions that time you have to answer them carefully with your knowledge. Remember the answers should be positive and unique. Think out of the box.

Also they will ask puzzles to check your ability of logical thinking... First listen the question carefully because sometimes interviewer ask you to repeat the question to check your listening skill and then try to solve with your knowledge..even if you do not get the answer also they don't mind but whatever the answer you got explain it with suitable reason that's it.

As per my knowledge these are only the type of phases you face in any interview not only in campus but out of campus as well.

So i hope that i am clear.If you don't understand any of the things above.You can comment below the post and we would surely respond to it.Thanks for watching.

Antennas Small Enough To Fit On A Chip

2015-04-10T21:22:00.000-07:00

With the latest research work coming out of University of Cambridge, their engineers seem to have found a breakthrough in electromagnetism. In the words the Cambridge Professor, Gehan Amaratunga, who led this research work, their findings could be the last missing piece in the puzzle of electronmagnetic theory. Developing antennas this small has been called the last frontier to be explored in the world of semiconductor design. If brought into practical use, this research could be a giant leap ahead for wireless connectivity. The engineering researchers working on this subject, recently published their results in the journal 'Physical Review Letters'. According to their study, they have put forward a concept that says - Electromagnetic waves are generated not only from the acceleration of electrons, but also from a phenomenon known as "symmetry breaking".

Not just in the field of wireless communications, but this discovery can also find implications in identifying the link between Electromagnetism and Quantum Mechanics. More than a 100 years ago, it was found that the radiation generated from electron acceleration resulted in electrons jumping from higher energy state to lower. However, this theory had no counterpart in quantum mechanics. With the latest observations of Cambridge University engineers, some insight about the radiation outputted due to electric field's broken symmetry may come forward.

In the last decade, the modern electronics has only made smaller and smaller devices. The size of these devices is reducing very rapidly and it seems that the antenna has not been able to cope with it. They are still very big in size and incompatible with electronic circuits. If the antennas are reduced in size, after a certain extent, their losses are too big. Engineers find it difficult to compromise wavelength for the transmission frequency of the application for the sake of reducing the antenna's size.

The electromagnetism theory that we know depends on acceleration of electrons. However, when electromagnets have to deal with radio wave emission from a dielectric solid, an insulating material, which doesn't let electrons move around freely. Even though that's the case, these dielectric resonators are already used as antennas in our smartphones. To understand the mystery behind how a dielectric medium results in emission of electromagnetic waves, the Cambridge team exposed thin films of piezoelectric materials to an asymmetric excitation and found that in addition to being efficient resonators, they became efficient radiators too. Therefore, it was found that they can be used as antennas as well.

In physics, 'symmetry' is a word used to signify a constant feature of a particular aspect in a system. When electrons aren't in motion, symmetry of electric field is established. The Cambridge researchers have determined that due to symmetry breaking of the electric field associated with the electron acceleration, their phenomenon exists.

Lastly, the team has shared the thin films of piezoelectric materials can be created using materials like lithium niobate, gallium nitride and gallium arsenide. What are your thoughts on this research work? Share with us in comments below.

Source: Cambridge University

Technique To Improve Smartphone's Face Recognition

2015-04-02T07:39:00.001-07:00

Those of us who have used the face unlock system in smartphones have many times faced the problem where the system simply can't recognise the owner's photo. Though the face unlock system is present in Samsung Galaxy phones and it is really good at keeping most impostors at bay, when a team of researchers at University of York examined the performance of the feature, they found that it failed to recognise genuine owner of the phone. Dr. David Robertson of the Department of Psychology’s FaceVar lab from the University of York led a research team to find out a solution to this problem. They found that, instead of a single target image, if the system used a combination of different pictures of the user, the smartphone's face recognition is significantly improved.

The team published their research work in the journal PLOS ONE and described how the face recognition systems in our gadgets can be improved to a great extent if users stored an ‘average’ of their own photos – formed by morphing together several different photos. The concept behind this is that the automatic face recognition systems benefit from incorporating the advantages of familiarity. In their experiments, they found that users could unlock their phones more reliably when the device stored an average of the user’s face than when they stored a single image. Not only did this result in consistency across a wide variety of everyday viewing in various lighting conditions, but it also did not affect the rejection of imposter faces.

Smartphone-face-recognition-improved-university-york-research. Left: In a normal ‘face-unlock’ system, smartphone stores a single image of the owner. Right: Owner’s face ‘average’ – an image derived from many photos of a person – being encoded into the system. When it comes to recognising faces in a computational system, it remains a significant challenge for the cognitive sciences. Humans have been recognising faces using a variety of factors such as eye gaze, facial expression and attractiveness. Not many processes are available for processing the person’s identity. Depending upon the camera's specifications, lighting of the area, age, pose etc., a person's face varies considerably and therefore it is possible that two images of the same person could be less similar than two images of different people.

This where the proposition from York researchers comes into picture. They want to tackle this problem of varying face structure of the same person by storing many different images of the same person in memory and then using an 'average' of those photos to be used when recognisng it for letting access to a smartphone or tablet. What are your thoughts on the proposed system for improving face recognition? Have you tried our the face unlock feature available in Samsung Galaxy Android smartphones?

Share your thoughts with us in comments below.