electrofriends.com

Handheld Vehicle Lock Control System Using Wireless Communication (IR / RF)

venugopal — Mon, 20 Feb 2012 11:18:46 +0000

ABSTRACT:

In this project we are using IR communication to implement the handheld vehicle lock control system. Infrared (IR) radiation is electromagnetic radiation whose wavelength is longer than that of visible light (400-700 nm), but shorter than that of terahertz radiation (1 µm – 1mm) and microwaves (~30,000 µm). Infrared radiation spans roughly three orders of magnitude (750 nm and 100 µm).

A remote control locks operation system for a vehicle capable of unlocking a mechanical locking mechanism for mechanically disabling traveling of the vehicle by an infrared signal, without using the key. Components of the system include a handheld remote control transmitter, a receiver, a mechanical locking mechanism, a lock actuator and control unit, and wiring sections for connecting the lock actuator and the receiver to the control unit mounted in a common module housing contained on the vehicle body. The main components of the system, including the wiring section leading to the lock actuator, are unitized and integrate into the common module housing in order to prevent unauthorized unlocking of the lock.

To implement this application required components are one microcontroller, TV remote, IR receiver (TSOP1738), LCD, l293D and DC motor. Whenever user want to open the door, he has to press one remote switch which is related to ON. For that user has to develop one application program in EMBEDDED-C. At the same time for close the door separate key is assigned.

BLOCK DIAGRAM:

HARDWARE REQUIREMENTS

AT89S52
LCD DISPLAY
TV REMOTE
IR RECEIVER (TSOP1738)
L293D
DOOR (DC MOTOR)
BUZZER

SOFTWARE REQUIREMENTS

KEIL C Compiler
PROGRAMMING IN EMBEDDED C
ISP PROGRAMMER

SCHEMATIC DIAGRAM:

What is a global variable?

chitra — Tue, 14 Feb 2012 17:59:36 +0000

variables that are known throughout the program and may be used by any piece of code is called a global variable. Also, they will hold their value throughout the program’s execution. Global variables can be created by declaring them outside of any function.

Global variables are helpful when many functions in the program use the same data. Storage for global variables is in a fixed region of memory set aside for this purpose by the compiler.

In the following program, the variable count has been declared outside of all functions.

Example:

#include "stdio.h"
int count;  /* count is global  */
void func1(void);
int main(void)
{
  count = 100;
  func1();
  return 0;
}
void func1(void)
{
  printf("count is %
d", count); /* will print 100 */
}

What is a local variable?

chitra — Tue, 14 Feb 2012 09:47:40 +0000

Variables that are declared inside a function are called local variables. Local variables can be used only by statements that are inside the block in which the variables are declared. In other words, local variables are not known outside their own code block. A block of code begins with an opening curly brace and terminates with a closing curly brace.

Local variables exist only while the block of code in which they are declared is executing. That is, a local variable is created upon entry into its block and destroyed upon exit. Furthermore, a variable declared within one code block has no bearing on or relationship to another variable with the same name declared within a different code block.

Example:

void func1(void) 
{ 
  int y; 
  y = 10;
}
void func2(void)
{ 
  int y;
  y = -199;
}

The integer variable y is declared twice, once in func1( ) and once in func2( ). The y in func1( ) has no relationship to the y in func2( ). This is because each y is known only to the code within the block in which it is declared.

The C language contains the keyword auto, which can be used to declare local variables. However, since all variables are, by default, assumed to be auto, this keyword is virtually never used.

What is the use of sizeof() operator in C?

chitra — Tue, 07 Feb 2012 08:41:28 +0000

The sizeof operator returns the size in bytes of its operand. Operand may be a variable or data type.

Here are few examples,

Example 1:

main()
 {
  char c;
 
  printf("%d,%d\n", sizeof c, sizeof(int)); /* returns 1, 4*/
 }

Example 2:

(main)
 {
	 struct 
	 {
	   int a;
	   int b;
	 }s;
 
	printf ("% d \ n", sizeof (s)); /* returns 8*/
	}

Example 3:

main()
 {
  short array [] = {1, 2, 3, 4, 5};
 
  short la = sizeof (array) / * returns 10 * /
 }

Remote System Monitoring and Controlling via Web based Mobile or Desktop Application

Ranjan — Sun, 29 Jan 2012 09:41:22 +0000

Introduction

The idea of remote system monitoring and controlling application is to do some of the actions like ex: Shutdown, Reboot, Hibernate of the users systems remotely. The user can also make use of this application to query additional details of the systems.

Consider a scenario where you have a set of systems (Computers) and you want to control them from your mobile or any other desktop anywhere from the world. So this started as initial requirement of how we can implement the same to control numerous systems remotely.

Consider another scenario of how you can retrieve the information of a particular system remotely from your handheld devices or through desktops. By retrieving information, one may be interested in knowing the following

Machine Name
CPU information
Username
Domain Name
OS Version

Software Requirements Specification

Aim: The aim of this project is to provide a facility for the end user to remotely control their systems through desktop or mobile based web application.
Purpose: The purpose of this project is to implement a proof or concept of the same. And to show how easily it can be done with .NET technology
Scope: The scope of this project is very limited to controlling the system with few actions like Shutdown, Reboot, Hibernate, Logoff, Force close all applications etc. The user registration is done only at the client application and the it should be always running in-order to control the system remotely.
User Characteristics: The Following things are taken into consideration with this software development
1. Users can have multiple systems for controlling. There is absolutely no limit in the number of systems being controlled by the users.
2. The user can either control her/his systems through mobile or desktop based web application.
3. Each user can control his/her system only and don’t have access to control others systems.
4. Right now there is only one type of user of this system i.e. the System Administrators who will be using this system to control or fetch additional information of the system on their own interest.

Software and Hardware Requirement

Software Requirements:

Operating system: Microsoft Windows XP / Win 7 / Vista
.NET framework 4.0
SQL Server 2008

Hardware Requirements:

Processor Pentium 4
RAM- 256Mb
HDD-10GB

Technologies Used

Visual Studio.NET

The Client Application is developed with .NET C# Winform technology
The Server side web application is developed with ASP.NET MVC3 technology.

Internet based / Cloud based Microsoft SQL Server 2008

This software is designed with Software as a Service model with a common single cloud database which stores all the users and their system information.

How does the software functions?

Client Application:

When you run the client application for the first time, you will have to register yourself with the username and password. The same has to be provided as log on information which will authenticate the user in client and server applications.

Once authenticated, the user has to click on the Start button for continuous monitoring of the system behind the scene. The system registers by itself by putting an entry in database (this happens only for the first usage of the client app) so that the user can control that particular machine. When the user closes the client application, the entry in the database for that system will be deactivated. For subsequent usable of the client application, the system will be activated for monitoring and controlling.

Server Application:

It is a web based application, on requesting the user will be authenticated. The use has to provide the same username and password he/she has provided at the time of user registration in client app.

On successful authentication, the list of active systems will be displayed in a screen. The user can select one and perform the actions like Shutdown, Reboot etc.

Database Entity Relationship Design Diagram

Dependency Injection in C# .NET

Ranjan — Fri, 20 Jan 2012 01:56:01 +0000

Dependency injection basically allows us to create loosely coupled, reusable, and testable objects in your software designs by removing dependencies.

We will take a look into the Object dependencies before digging in more.
Consider a scenario of fetching an employee details and show display in UI. Let us say create a Business logic layer class named EmployeeBAL and a data access layer class named EmployeeDAO

public class EmployeeDao
{
//Some code
}

public class EmployeeBAL
{
var employeeDAO = new EmployeeDao();
//Some code
}

From the above code you will notice one thing that we are creating EmployeeDAO instance inside the Business logic layer class. So here comes the dependency

What is wrong if we have a dependency?

Think about whether your code is unit testable. We cannot fully unit test the EmployeeBAL as it has a dependency on Employee DAO. So we can say as long as the composition of the DAO exists within the BAL we cannot unit test the EmployeeBAL.

You will also notice one more thing here; with this type of implementation you will see a high coupling of BAL and DAL.

How to make it loose coupling?

The basic idea behind Dependency Injection is that you should isolate the implementation of an object from the construction of objects on which it depends.

Coming to the example, we should be isolating the implementation of EmployeeBAL object and the construction of the dependent EmployeeDAO object.

We will see how we can make loosely coupled objects in detail

Constructor based dependency injection

We will have to modify the EmployeeBAL to accept an EmployeeDAO instance within its constructor.

public class EmployeeDao
{
//Some code
}

public class EmployeeBAL
{
EmployeeDao employeeDAO;

public EmployeeBAL(EmployeeDAO employeeDao){
this.employeeDAO = employeeDao;
}
//Some code
}

Property based dependency injection

With property based injection we will have a public getter and setter Property of type EmployeeDao so that the dependency can be externally set.

public class EmployeeBAL
{
Public EmployeeDao EmployeeDataAccess{ get; set; }
}

var employeeBAL = new EmployeeBAL();
EmployeeBAL.EmployeeDataAccess = new EmployeeDao();

Wait!!!

The above ones are just some techniques of injecting the dependency. We are still yet to discuss one more interesting thing Unit Testing.

Are you agreeing that we have removed the DAO creation from the Business Logic EmployeeBAL? Yes it is good but it still depends on the actual instance of EmployeeDao.

Consider the below mentioned implementation of the same sample senarios

interface IDataAccess
{
//Some code
}

class EmployeeDao : IDataAccess
{
//Some code
}

public class EmployeeBAL
{
private IDataAccess dataAccess;
public BusinessFacade(IDataAccess dao)
{
dataAccess = dao;
}
}

You can notice we are doing a constructor dependency injection but most important thing here
is we are using Interface type than creating a strongly typed object.

The advantage that we are getting here is we can have an in memory data access object of
IDataAccess interface type and we can easily inject the dependency to the EmployeeBAL.
By this way we no need to have the actual database dependency.

Are you happy that we can unit test the BAL without the data access dependency?

Advantages of Dependency Injection

The primary advantages of dependency injection are:
Loose coupling
Centralized configuration
Easily testable

what is Void Pointer?

chitra — Thu, 19 Jan 2012 07:18:21 +0000

Void pointer or generic pointer is a special type of pointer that can be pointed at objects of any data type. A void pointer is declared like a normal pointer, using the void keyword as the pointer’s type.

Pointers defined using specific data type cannot hold the address of the some other type of variable i.e., it is incorrect in C++ to assign the address of an integer variable to a pointer of type float.

Example:

float *f; //pointer of type float
int i;  //integer variable
f = &i; //compilation error

The above problem can be solved by general purpose pointer called void pointer.

Void pointer can be declared as follows:

void *v // defines a pointer of type void

The pointer defined in this manner do not have any type associated with them and can hold the address of any type of variable.

Example:

void *v; 
int *i;
int ivar;
char chvar;
float fvar;
v = &ivar; // valid
v = &chvar; //valid
v = &fvar; // valid
i = &ivar; //valid
i = &chvar; //invalid
i = &fvar; //invalid

What is dangling pointer?

chitra — Tue, 17 Jan 2012 10:43:23 +0000

Dangling pointers and wild pointers in computer programming are pointers that do not point to a valid object of the appropriate type.

In many applications memory is allocated for holding data objects. After using these objects, tha aplication will de-allocate this memory so that the memory can be re-used. In some cases the alications may use a pointer to an object whose memory is already de-allocated. This may lead to application crash or an unpredictable behavior.

scenarios which leads to dangling pointer

Application makes use of a object after it has been released, and there by access to an invalid memory location.
A function returns a pointer to one of its local variables, and since this local variable is defined only fro the function, the pointer becomes invalid once the function ends.

The most common result of this bug is the crash of the application or its running thread.

Examle 1:

#include "stdlib.h"
 
void func()
{
    char *dp = malloc(A_CONST);
    /* ... */
    free(dp);         /* dp now becomes a dangling pointer */
    /* ... */
}

Example 2:

{
   char *dp = NULL;
   /* ... */
   {
       char c;
       dp = &c;
   } /* c falls out of scope */
     /* dp is now a dangling pointer */
}

Example 3:

#include "stdio.h"
 
int *call();
void main(){
 
int *ptr;
ptr=call();
 
fflush(stdin);
printf("%d",*ptr);
}
 
int * call(){
 
int x=25;
++x;
 
return &x;
}

Delegate and Events in C# .NET

Ranjan — Sun, 15 Jan 2012 16:54:06 +0000

Delegates

A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.

The signature of a single cast delegate is shown below:

delegate result-type identifier ([parameters]);

where:

result-type: The result type, which matches the return type of the function.
identifier: The delegate name.
parameters: The Parameters that the function takes.

Delegates allow a clearer separation of specification and implementation. A delegate specifies the signature of a method, and authors can write methods that are compatible with the delegate specification.

Multicast delegates

With multicast delegate, it is just like a normal delegate but it can point to multiple functions so on invocation of such delegate it will invoke all the methods and functions associated with the same one after another sequentially.

Events:

Events are wrapper around the delegate. It sits on top of the delegate and provides only the necessary encapsulation so that the destination objects can subscribe to the Event and not have full control on the delegate object.

Events are declared using delegates. The delegate object encapsulates a method so that it can be called anonymously. An event is a way for a class to allow clients to give it delegates to methods that should be called when the event occurs. When the event occurs, the delegate(s) given to it by its clients are invoked.
We will consider an example implementation of Logger application, which can be used to log messages in Console, File or Database etc.

Logger Application ClassDiagram

We will declare a delegate named LogWriteDelegate which accepts one parameter named message.

public delegate void LogWriteDelegate(string message);

Next we will declare an Event of type LogWriteDelegate

public event LogWriteDelegate LogWriteEvent;

In our sample Logger the FileLogger and ConsoleLogger will subscribe or register to the above mentioned event so that when the Write method of logger is called the respective logic within the Write method of FileLogger and ConsolLogger will also gets invoked.

using (var logger = new Logger("testing", EntryType.Debug)) { logger.LogWriteEvent += new Logger.LogWriteDelegate(consoleLogger.Write); logger.LogWriteEvent += new Logger.LogWriteDelegate(fileLogger.Write); logger.Write(); }

You can notice here a multicast delegate; the LogWriteEvent is being registered with Console and File log write methods.

While firing an Event within the Logger object, it is always a good practice to check whether the event is registered or not.

public void Write() { if (LogWriteEvent != null) LogWriteEvent(ToString()); }

Here the LogWriteEvent holds the address of the methods console.Write and fileLogger.Write. When firing an event it will sequentially call the respective methods which are pre-registered to this Event.

Note: The Logger application is designed in such a way that in future you can have multiple implementations of Loggers. Right now we have Console and File Logger; if you are interested in implementing a Database logger we can create a new Class named DatabaseLogger which will implement ILogger interface. Provide necessary Write method logic so that it will log messages to database.

Ones you have done with the DatabaseLogger implementation, you just have to create an instance and register the event as we have done for Console and File Loggers.

Download Sample Logger Application

Mobile Information Device Profile (MIDP 2.0) in J2ME

Ranjan — Sat, 14 Jan 2012 11:25:42 +0000

MIDP in general is one of the J2ME profile, a profile consists of Java classes. MIDP provides high-level API’s using which J2ME developer can easily develop applications, which is easy to use, highly graphical, with optimized for small computing devices such as Mobile phone. Also provides low-level user interface API’s giving the developers a control over the graphics and input. Thus reduces the development effort.

MIDP is targeted at a class of devices known as mobile information devices (MIDs). These are devices that have the following minimal characteristics:

1) Enough memory to run MIDP applications

2) A bit addressable display at least 96 pixels wide by 56 pixels high, either monochrome or color.

3) A keypad, keyboard, or touch screen.

4) Two-way wireless networking capability

Before we start up with MIDP 2.0 we will look over MIDP 1.0, which basically provides local storage, a user interface, networking capabilities and ability to operate in disconnected mode, ability to write applications in Java. But it was lacking end-to-end security and some other new features which is existing in MIDP 2.0

With MIDP 2.0, end-to-end security is now supported. MIDP 2.0 introduces the security concepts of application signing and privileged domains. With application signing applications can be trusted or not based on the ability to corroborate, via the use of a X.509 digital certificate, the application’s origin and integrity. These new features protect the device against unauthorized applications accessing data and functions. Also standard security protocols such as HTTPS, TLS/SSL and WTLS allows for secure transmission by encrypting the data. It is important to understand that MIDP in general is targeted at cell phones and low-end PDAs

The new MIDP 2.0 also includes support for an enhanced user interface API that allow developers create more functional and attractive business or consumer applications with less effort. It also includes new gaming and media APIs that can be used for business-applications.

MIDP 2.0 has expanded network connectivity support beyond HTTP, with support for UDP datagrams, TCP sockets, and serial port communication. Also a powerful feature called the push registry that activates dormant applications when new information is available. For example, with push support, server software can activate an application on the device to notify employees when a new calendar event has been scheduled or new sales lead generated, even if the application is not currently running.

The new Over-The-Air (OTA) application provisioning standardizes support for client-initiated download of applications over the wireless network. It allows users to find and install authorized applications wirelessly. It also allows application providers to track the installation and removal of applications for billing (or other) purposes.

MIDP also supports Short messaging service (SMS) and Cell Broadcast Service (CBS)

What does it MIDP provide?

The MIDP adds the following packages on top of the CLDC:

javax.microediton.lcdui	Provides classes for user interface.
javax.microedition.midlet	Defines MIDP applications and the interactions between the application and the environment in which the application runs.
javax.microedition.rms	Provides persistent storage (Record Management System).