Extended Kalman Filter (EKF) MATLAB Implimentation

Kalman Filter (KF) 

Linear dynamical system (Linear evolution functions)

Extended Kalman Filter (EKF) 

Non-linear dynamical system (Non-linear evolution functions)

Consider the following non-linear system:

Assume that we can somehow determine a reference trajectory 

Then:

where

For the measurement equation, we have:

We can then apply the standard Kalman filter to the linearized model

How to choose the reference trajectory?

Idea of the extended Kalman filter is to re-linearize the model around the most recent state estimate, i.e.

The Extended Kalman Filter (EKF) has become a standard    technique used in a number of 

# nonlinear estimation and 

# machine learning applications

#State estimation

#estimating the state of a nonlinear dynamic system

#Parameter estimation

#estimating parameters for nonlinear system identification

#e.g., learning the weights of a neural network

#dual estimation 

#both states and parameters are estimated simultaneously

#e.g., the Expectation Maximization (EM) algorithm

MATLAB CODE
########################################################################
function [x_next,P_next,x_dgr,P_dgr] = ekf(f,Q,h,y,R,del_f,del_h,x_hat,P_hat);
% Extended Kalman filter
%
% -------------------------------------------------------------------------
%
% State space model is
% X_k+1 = f_k(X_k) + V_k+1   -->  state update
% Y_k = h_k(X_k) + W_k       -->  measurement
%
% V_k+1 zero mean uncorrelated gaussian, cov(V_k) = Q_k
% W_k zero mean uncorrelated gaussian, cov(W_k) = R_k
% V_k & W_j are uncorrelated for every k,j
%
% -------------------------------------------------------------------------
%
% Inputs:
% f = f_k
% Q = Q_k+1
% h = h_k
% y = y_k
% R = R_k
% del_f = gradient of f_k
% del_h = gradient of h_k
% x_hat = current state prediction
% P_hat = current error covariance (predicted)
%
% -------------------------------------------------------------------------
%
% Outputs:
% x_next = next state prediction
% P_next = next error covariance (predicted)
% x_dgr = current state estimate
% P_dgr = current estimated error covariance
%
% -------------------------------------------------------------------------
%

if isa(f,'function_handle') & isa(h,'function_handle') & isa(del_f,'function_handle') & isa(del_h,'function_handle')
    y_hat = h(x_hat);
    y_tilde = y - y_hat;
    t = del_h(x_hat);
    tmp = P_hat*t;
    M = inv(t'*tmp+R+eps);
    K = tmp*M;
    p = del_f(x_hat);
    x_dgr = x_hat + K* y_tilde;
    x_next = f(x_dgr);
    P_dgr = P_hat - tmp*K';
    P_next = p* P_dgr* p' + Q;
else
    error('f, h, del_f, and del_h should be function handles')
    return
end

##############################################################################


For more

https://drive.google.com/folderview?id=0B2l8IvcdrC4oMzU3Z2NVXzQ0Y28&usp=sharing

Read more »

VibeApp Hack your email contacts , Grab everything you need to know about your email contacts

I was confused always when I get emails from unknowns , i stuck at finding the sender behind the craps , now I got a simple solution and that is vibeApp

And just in a simple hover the cursor over the email adress all about the email id is listed , everything the twitter handle , facebook  , linkedin  Google+, and even a web page they are most likely to be associated with


Hello Vibe is an application that more accurate and simple to use  know about the information about the email contacts , now its available for chrome and mac

Download it and know the people behind you
http://vibeapp.co/#/home

Read more »

Optimized Link State Routing Protocol (OLSR)

Optimized Link State Routing (OLSR) protocol for mobile ad hoc networks. The protocol is an optimization of the classical link state algorithm tailored to the requirements of a mobile wireless LAN. The key concept used in the protocol is that of multipoint relays (MPRs). MPRs are selected nodes which forward broadcast messages during the flooding process. This technique substantially reduces the message overhead as compared to a classical flooding mechanism, where every node retransmits each message when it receives the first copy of the message. In OLSR, link state information is generated only by nodes elected as MPRs. Thus, a second optimization is achieved by minimizing the number of control messages flooded in the network. As a third optimization, an MPR node may choose to report only links between itself and its MPR selectors. Hence, as contrary to the classic link state algorithm, partial link state information is distributed in the network. Thisinformation is then used for route calculation. OLSR provides optimal routes (in terms of number of hops). The protocol is particularly suitable for large and dense networks as the technique of MPRs works well in this contex

Download from this link 

Full paper Download 

SAMPLE PROGRAM 

# ======================================================================

# Define options

# ======================================================================

set opt(chan)           Channel/WirelessChannel  ;# channel type

#set opt(prop)           Propagation/TwoRayGround   ;# radio-propagation model

set opt(prop)           Propagation/Shadowing   ;# radio-propagation model

set opt(netif)          Phy/WirelessPhy          ;# network interface type

set opt(mac)            Mac/802_11               ;# MAC type

set opt(ifq)            Queue/DropTail/PriQueue  ;# interface queue type

set opt(ll)             LL                       ;# link layer type

set opt(ant)            Antenna/OmniAntenna      ;# antenna model

set opt(ifqlen)         50                       ;# max packet in ifq

set opt(nn)             11                       ;# number of mobilenodes

set opt(adhocRouting)   OLSR                 ;# routing protocol

set opt(cp)             ""                       ;# connection pattern file

set opt(sc)             ""                       ;# node movement file.

set opt(x)              1000                     ;# x coordinate of topology

set opt(y)              1000                     ;# y coordinate of topology

set opt(seed) X

set opt(stop)           50                       ;# time to stop simulation

set opt(cbr-start)      5.0

set opt(cbr-stop)       45.0

set opt(pa-start)       7.0

set opt(pa-stop)        37.0

set opt(pa1-start)      9.0

set opt(pa1-stop)       39.0

# ============================================================================

#

# check for random seed

#

if {$opt(seed) > 0} {

    puts "Seeding Random number generator with $opt(seed)\n"

    ns-random $opt(seed)

}

#Ganho das antenas

Antenna/OmniAntenna set Gt_ 18.0

Antenna/OmniAntenna set Gr_ 18.0

Phy/WirelessPhy set bandwidth_ 11Mb

# frequencia (2.4 GHz 802.11b) {Alcance = 276 metros}

Phy/WirelessPhy set freq_ 2.4e+9

Mac/802_11 set dataRate_ 11Mb

Mac/802_11 set basicRate_ 2Mb

Propagation/Shadowing set pathlossExp_ 2.7       ;#expoente de perdas

Propagation/Shadowing set std_db_ 4.0           ;#desvio padrao (dB)

#Propagation/TwoRayGround set L_ 1.0

#

# create simulator instance

#

set ns_ [new Simulator]

#

# control OLSR behaviour from this script -

# commented lines are not needed because

# those are default values

#

Agent/OLSR set use_mac_              true

Agent/OLSR set debug_                true

Agent/OLSR set willingness           3

Agent/OLSR set hello_ival_           2

Agent/OLSR set tc_ival_              5

Agent/OLSR set mpr_algorithm_        1

Agent/OLSR set routing_algorithm_    1

Agent/OLSR set link_quality_         1

Agent/OLSR set fish_eye_             false

Agent/OLSR set link_delay_           false

Agent/OLSR set tc_redundancy_        1

Agent/OLSR set c_alpha_              0.6

#

# open traces

#

$ns_ use-newtrace

set tracefd  [open wtrace.tr w]

set namtrace [open simulation.nam w]

$ns_ trace-all $tracefd

$ns_ namtrace-all-wireless $namtrace $opt(x) $opt(y)

#

# create topography object

#

set topo [new Topography]

#

# define topology

#

$topo load_flatgrid $opt(x) $opt(y)

#

# create God

#

create-god $opt(nn)

#

# configure mobile nodes

#

$ns_ node-config -adhocRouting $opt(adhocRouting) \

                 -llType $opt(ll) \

                 -macType $opt(mac) \

                 -ifqType $opt(ifq) \

                 -ifqLen $opt(ifqlen) \

                 -antType $opt(ant) \

                 -propType $opt(prop) \

                 -phyType $opt(netif) \

                 -channelType $opt(chan) \

                 -topoInstance $topo \

                 -wiredRouting OFF \

                 -agentTrace ON \

                 -routerTrace ON \

                 -macTrace OFF

for {set i 1} {$i < $opt(nn)} {incr i} {

    set node_($i) [$ns_ node]

}

#

# positions

$node_(1) set X_ 160.0  #CAPACIT

$node_(1) set Y_ 485.0

$node_(1) set Z_ 15.0

$node_(2) set X_ 305.0  #DI

$node_(2) set Y_ 277.0

$node_(2) set Z_ 15.0

$node_(3) set X_ 340.0   #SECOM

$node_(3) set Y_ 226.0

$node_(3) set Z_ 15.0

$node_(4) set X_ 270.0  #Grad Basico

$node_(4) set Y_ 32.0

$node_(4) set Z_ 15.0

$node_(5) set X_ 476.0  #Reitoria

$node_(5) set Y_ 200.0

$node_(5) set Z_ 15.0

$node_(6) set X_ 628.0  #Incubadora

$node_(6) set Y_ 320.0

$node_(6) set Z_ 15.0

$node_(7) set X_ 570.0  #Musica

$node_(7) set Y_ 440.0

$node_(7) set Z_ 15.0

$node_(8) set X_ 780.0  #LABS

$node_(8) set Y_ 480.0

$node_(8) set Z_ 15.0

$node_(9) set X_ 918.0  #CT

$node_(9) set Y_ 597.0

$node_(9) set Z_ 15.0

$node_(10) set X_ 968.0  #Grad Profissional

$node_(10) set Y_ 550.0

$node_(10) set Z_ 15.0

# cores

$ns_ color 1 red

$ns_ color 2 blue

$ns_ color 3 yellow

# setup UDP connection

# CAPACIT -> GRAD PROFISSIONAL

set udp [new Agent/UDP]

$udp set class_ 1

set null [new Agent/Null]

$ns_ attach-agent $node_(1) $udp

$ns_ attach-agent $node_(10) $null

$ns_ connect $udp $null

$udp set fid_ 1

set cbr [new Application/Traffic/CBR]

$cbr set packetSize_ 40     # RTP + UDP + Payload

$cbr set rate_ 8Kb

$cbr attach-agent $udp

$ns_ at 5.0 "$cbr start"

$ns_ at 45.0  "$cbr stop"

#GRAD PROFISSIONAL -> CAPACIT

set udp1 [new Agent/UDP]

$udp1 set class_ 2

set null1 [new Agent/Null]

$ns_ attach-agent $node_(10) $udp1

$ns_ attach-agent $node_(1) $null1

$ns_ connect $udp1 $null1

$udp1 set fid_ 2

set cbr1 [new Application/Traffic/CBR]

$cbr1 set packetSize_ 40     # RTP + UDP + Payload

$cbr1 set rate_ 8Kb

$cbr1 attach-agent $udp1

$ns_ at 5.0 "$cbr1 start"

$ns_ at 45.0  "$cbr1 stop"

#REITORIA -> CAPACIT

set udp2 [new Agent/UDP]

$udp2 set class_ 3

set null2 [new Agent/Null]

$ns_ attach-agent $node_(5) $udp2

$ns_ attach-agent $node_(1) $null2

$ns_ connect $udp2 $null2

$udp2 set fid_ 3

set cbr2 [new Application/Traffic/CBR]

$cbr2 set packetSize_ 40     # RTP + UDP + Payload

$cbr2 set rate_ 8Kb

$cbr2 attach-agent $udp2

$ns_ at 7.0 "$cbr2 start"

$ns_ at 45.0  "$cbr2 stop"

#CAPACIT -> REITORIA

set udp3 [new Agent/UDP]

$udp3 set class_ 4

set null3 [new Agent/Null]

$ns_ attach-agent $node_(1) $udp3

$ns_ attach-agent $node_(5) $null3

$ns_ connect $udp3 $null3

$udp3 set fid_ 4

set cbr3 [new Application/Traffic/CBR]

$cbr3 set packetSize_ 40     # RTP + UDP + Payload

$cbr3 set rate_ 8Kb

$cbr3 attach-agent $udp3

$ns_ at 7.0 "$cbr3 start"

$ns_ at 45.0  "$cbr3 stop"

#REITORIA -> CT

set udp4 [new Agent/UDP]

$udp4 set class_ 5

set null4 [new Agent/Null]

$ns_ attach-agent $node_(5) $udp4

$ns_ attach-agent $node_(9) $null4

$ns_ connect $udp4 $null4

$udp4 set fid_ 5

set cbr4 [new Application/Traffic/CBR]

$cbr4 set packetSize_ 40     # RTP + UDP + Payload

$cbr4 set rate_ 8Kb

$cbr4 attach-agent $udp4

$ns_ at 9.0 "$cbr4 start"

$ns_ at 45.0  "$cbr4 stop"

#CT -> REITORIA

set udp5 [new Agent/UDP]

$udp5 set class_ 6

set null5 [new Agent/Null]

$ns_ attach-agent $node_(9) $udp5

$ns_ attach-agent $node_(5) $null5

$ns_ connect $udp5 $null5

$udp5 set fid_ 6

set cbr5 [new Application/Traffic/CBR]

$cbr5 set packetSize_ 40     # RTP + UDP + Payload

$cbr5 set rate_ 8Kb

$cbr5 attach-agent $udp5

$ns_ at 9.0 "$cbr5 start"

$ns_ at 45.0  "$cbr5 stop"

#DI -> CT

set udp6 [new Agent/UDP]

$udp6 set class_ 7

set null6 [new Agent/Null]

$ns_ attach-agent $node_(2) $udp6

$ns_ attach-agent $node_(9) $null6

$ns_ connect $udp6 $null6

$udp6 set fid_ 7

set cbr6 [new Application/Traffic/CBR]

$cbr6 set packetSize_ 40     # RTP + UDP + Payload

$cbr6 set rate_ 8Kb

$cbr6 attach-agent $udp6

$ns_ at 11.0 "$cbr6 start"

$ns_ at 45.0  "$cbr6 stop"

#CT -> DI

set udp7 [new Agent/UDP]

$udp7 set class_ 8

set null7 [new Agent/Null]

$ns_ attach-agent $node_(9) $udp7

$ns_ attach-agent $node_(2) $null7

$ns_ connect $udp7 $null7

$udp7 set fid_ 8

set cbr7 [new Application/Traffic/CBR]

$cbr7 set packetSize_ 40     # RTP + UDP + Payload

$cbr7 set rate_ 8Kb

$cbr7 attach-agent $udp7

$ns_ at 11.0 "$cbr7 start"

$ns_ at 45.0  "$cbr7 stop"

#SECOM -> LABS

set udp8 [new Agent/UDP]

$udp8 set class_ 9

set null8 [new Agent/Null]

$ns_ attach-agent $node_(3) $udp8

$ns_ attach-agent $node_(8) $null8

$ns_ connect $udp8 $null8

$udp8 set fid_ 9

set cbr8 [new Application/Traffic/CBR]

$cbr8 set packetSize_ 40     # RTP + UDP + Payload

$cbr8 set rate_ 8Kb

$cbr8 attach-agent $udp8

$ns_ at 13.0 "$cbr8 start"

$ns_ at 45.0  "$cbr8 stop"

#LABS -> SECOM

set udp9 [new Agent/UDP]

$udp9 set class_ 10

set null9 [new Agent/Null]

$ns_ attach-agent $node_(8) $udp9

$ns_ attach-agent $node_(3) $null9

$ns_ connect $udp9 $null9

$udp9 set fid_ 10

set cbr9 [new Application/Traffic/CBR]

$cbr9 set packetSize_ 40     # RTP + UDP + Payload

$cbr9 set rate_ 8Kb

$cbr9 attach-agent $udp9

$ns_ at 13.0 "$cbr9 start"

$ns_ at 45.0  "$cbr9 stop"

#DI -> SECOM

set udp10 [new Agent/UDP]

$udp10 set class_ 11

set null10 [new Agent/Null]

$ns_ attach-agent $node_(2) $udp10

$ns_ attach-agent $node_(3) $null10

$ns_ connect $udp10 $null10

$udp10 set fid_ 11

set cbr10 [new Application/Traffic/CBR]

$cbr10 set packetSize_ 40     # RTP + UDP + Payload

$cbr10 set rate_ 8Kb

$cbr10 attach-agent $udp10

$ns_ at 15.0 "$cbr10 start"

$ns_ at 45.0  "$cbr10 stop"

#SECOM -> DI

set udp11 [new Agent/UDP]

$udp11 set class_ 12

set null11 [new Agent/Null]

$ns_ attach-agent $node_(3) $udp11

$ns_ attach-agent $node_(2) $null11

$ns_ connect $udp11 $null11

$udp11 set fid_ 12

set cbr11 [new Application/Traffic/CBR]

$cbr11 set packetSize_ 40     # RTP + UDP + Payload

$cbr11 set rate_ 8Kb

$cbr11 attach-agent $udp11

$ns_ at 15.0 "$cbr11 start"

$ns_ at 45.0  "$cbr11 stop"

#

# configurando trafego de background - pareto

#

# DI -> LABS

set tcp [new Agent/TCP]

$tcp set class_ 13

set sink [new Agent/TCPSink]

$ns_ attach-agent $node_(2) $tcp

$ns_ attach-agent $node_(8) $sink

$ns_ connect $tcp $sink

$tcp set fid_ 13

set p [new Application/Traffic/Pareto]

$p set packetSize_ 210

$p set burst_time_ 500ms

$p set idle_time_ 500ms

$p set rate_ 200k

$p set shape_ 1.5

$p attach-agent $tcp

$ns_ at 6.0 "$p start"

$ns_ at 35.0  "$p stop"

# GRAD BASICO -> CT

set tcp1 [new Agent/TCP]

$tcp1 set class_ 14

set sink1 [new Agent/TCPSink]

$ns_ attach-agent $node_(4) $tcp1

$ns_ attach-agent $node_(9) $sink1

$ns_ connect $tcp1 $sink1

$tcp1 set fid_ 14

set p1 [new Application/Traffic/Pareto]

$p1 set packetSize_ 210

$p1 set burst_time_ 500ms

$p1 set idle_time_ 500ms

$p1 set rate_ 200k

$p1 set shape_ 1.5

$p1 attach-agent $tcp1

$ns_ at 8.0 "$p1 start"

$ns_ at 35.0  "$p1 stop"

#SECOM -> GRAD PROFISSIONAL

set tcp2 [new Agent/TCP]

$tcp2 set class_ 15

set sink2 [new Agent/TCPSink]

$ns_ attach-agent $node_(3) $tcp2

$ns_ attach-agent $node_(10) $sink2

$ns_ connect $tcp2 $sink2

$tcp2 set fid_ 15

set p2 [new Application/Traffic/Pareto]

$p2 set packetSize_ 210

$p2 set burst_time_ 500ms

$p2 set idle_time_ 500ms

$p2 set rate_ 200k

$p2 set shape_ 1.5

$p2 attach-agent $tcp2

$ns_ at 10.0 "$p2 start"

$ns_ at 35.0  "$p2 stop"

## Label the Special Node in NAM

$ns_ at 0.0 "$node_(1) label CAPACIT"

$ns_ at 0.0 "$node_(2) label Dep_Informatica"

$ns_ at 0.0 "$node_(3) label SECOM"

$ns_ at 0.0 "$node_(4) label Grad_Basico"

$ns_ at 0.0 "$node_(5) label Reitoria"

$ns_ at 0.0 "$node_(6) label Incubadora"

$ns_ at 0.0 "$node_(7) label Musica"

$ns_ at 0.0 "$node_(8) label Laboratorios"

$ns_ at 0.0 "$node_(9) label Centro_Tec"

$ns_ at 0.0 "$node_(10) label Grad_Profissional"

#

# print (in the trace file) routing table and other

# internal data structures on a per-node basis

#

#$ns_ at 5.0 "[$node_(1) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(2) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(3) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(4) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(5) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(6) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(7) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(8) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(9) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(10) agent 255] print_rtable"

#$ns_ at 5.0 "[$node_(1) agent 255] print_linkset"

#$ns_ at 5.0 "[$node_(1) agent 255] print_nbset"

#$ns_ at 5.0 "[$node_(1) agent 255] print_nb2hopset"

#$ns_ at 5.0 "[$node_(1) agent 255] print_mprset"

#$ns_ at 5.0 "[$node_(1) agent 255] print_mprselset"

#$ns_ at 5.0 "[$node_(1) agent 255] print_topologyset"

#

# source connection-pattern and node-movement scripts

#

if { $opt(cp) == "" } {

    puts "*** NOTE: no connection pattern specified."

    set opt(cp) "none"

} else {

    puts "Loading connection pattern..."

    source $opt(cp)

}

if { $opt(sc) == "" } {

    puts "*** NOTE: no scenario file specified."

    set opt(sc) "none"

} else {

    puts "Loading scenario file..."

    source $opt(sc)

    puts "Load complete..."

}

#

# define initial node position in nam

#

for {set i 1} {$i < $opt(nn)} {incr i} {

    $ns_ initial_node_pos $node_($i) 20

}

#

# tell all nodes when the simulation ends

#

for {set i 1} {$i < $opt(nn) } {incr i} {

    $ns_ at $opt(stop).0 "$node_($i) reset";

}

$ns_ at $opt(stop).0002 "puts \"NS EXITING...\" ; $ns_ halt"

$ns_ at $opt(stop).0001 "stop"

proc stop {} {

    global ns_ tracefd namtrace

    $ns_ flush-trace

    close $tracefd

    close $namtrace

}

#

# begin simulation

#

puts "Starting Simulation..."

$ns_ run

Read more »

Encode your secret messages in Your Facebook Pics

Facebook is a place where you can share pictures of cute animals and fun activities. Now there’s a browser extension that lets you encode those images with secret, hard-to-detect messages.  With the extension, anyone — you, your sister, a terrorist — could share messages hidden in JPEG images uploaded to Facebook without the prying eyes of the company, the government or anyone else noticing or figuring out what the messages say. The only way to unlock them is through a password you create.

The goal of this research was to demonstrate that JPEG steganography can be performed on social media where it has previously been impossible,” Campbell-Moore tells Danger Room. He says he spent about two months spread out over the last year working on the extension as a research project for the university.

The extension is only available for the Google Chrome browser — Campbell-Moore cites its developer tools and popularity — and the messages are restricted to 140 characters. Less certain is what Facebook thinks; a spokesman declined to comment. But it’s still the first time anyone’s managed to figure out how to automate digital steganography — the practice of concealing messages inside computer files — through Facebook, the world’s biggest social media platform. Unlike cryptography, which uses ciphertext to encrypt messages, steganographic messages are simply hidden where no one would think to look.

How to do 
1.Go the link  secret book chrome store

2.Click add to chrome

Quickstart

Refresh Facebook. Press ctrl+alt+a while on Facebook to encode a message. Press ctrl+alt+a while looking at a photo to decode a message.

Creating a new secret message

If you've just installed Secretbook then please refresh Facebook before trying to use this extension.

1. Securely share a password with the friend you wish to communicate secretly with.
2. While on Facebook press ctrl+alt+a to activate the secret system.
3. Use the dialogue to create an image. Upload this new image to any album on Facebook or post it on your friend's wall.
   • Note that sending secret messages via messaging is not yet implemented
4. Attempt to receive the message from the image you just uploaded in case an error occurred!
5. Optional: Mention your friend in a comment or the description to ensure they know to check it for a message.

Your friend can now use the password you shared to decode the message.

Receiving a secret message

1. While looking at an image on Facebook press ctrl+alt+a to activate the secret system.
2. Enter your shared password to receive the secret message.

Secretbook has to be subtle. It uses Google Chrome’s web extension platform, since Facebook’s in-house apps publicly list their users — which would defeat the purpose of a secrecy tool. Since the extension runs through a web browser without a server connection, the users can’t be detected by network analysis. It’s also hard for Facebook to block or remove permissions, as the extension doesn’t rely on a Facebook API key.

Read more »

UNBRICK MICROMAX FUNBOOK P300

Description: 
Hello ! Guys , Today I'm Teaching You How To Un-Brick Micromax Funbook P-300 , Infinity , Alpha , Talk And Other.... As You Know Bricking Voids Warranty . If You Take a Bricked Device To Service Center They Won't Repair It or They May Need Some Green . So , This Tutorial Teaches You To Un-Brick Micromax Funbook , If You Have Bricked Any Other Tablet Or Phone "Click Here" . This Link May Help You , This Link Takes You To Facebook Timeline Of Ebin Ephrem , Make Him Friend And Chat With Him , He Will Shurely Help You.

Instructions:

Things Required : 1) PC.

                                 :  2) USB Data Cable. 

                                 :  3) Micromax Funbook.

Downloads            :  Unbrick.zip
  

Working Time

Step:1 Download unbrick.Zip , Extract It In a Convenient Place 

Step:2  You Will Find Livesuitpack_version_1.07 Inside The Folder Extracted Just Before .

Step:3 Open The Application , Give Yes To All.

Step:4 Choose The File Image From The Folder.

Step:5 Press And Hold Back Button , Connect Funbook To PC Via USB Data Cable.

Step:6 From Task Bar Something Will Popup , Just Ignore That.

Step:7 In Your PC's Keyboard press WIndows key+R You Will see Run Pop-up. 
            Type 'devmgmt.msc' and Press Enter . Device Manager Will Open.
             You can Notice That There Is a Device Named "Unknown Device".
             Right Click On it And Choose Update Driver software. 
             Now Choose "Browse My Compluer For Driver software".
             Browse To Folder Where You Have Extracted Livesuite Folder.

Step:8 Without Leaving Back Button , Press Power Button 10 Times As Quick As Possible.

Step:9  Now a Popup Will Appear In Live-Suite , Give Yes On Both Popup.

Step:10 Live Suite Started Flashing When It Becomes Full , Unplug Funbook From PC.

Step:11 Press Power Button , WoaaH! My Funbook Is Un-Bricked.

Read more »

KINECT : New Generation use It creative in new ways.

Microsoft built Kinect to revolutionize the way you play games and how you experience entertainment. Along the way, people started using Kinect in creative new ways. From helping children with autism, to helping doctors in the operating room, people are taking Kinect beyond games. And that’s what we call the Kinect Effect.

Tedesys is using Kinect technology in an operating room in Spain to help doctors navigate MRIs and CAT scans with a wave of their hand. It approved by national government agencies,

Therapists at Lakeside Center for Autism are integrating Kinect’s full body play technology into their therapy sessions.

 Rehabilitation therapists are making Kinect an important part of the rehabilitation process for stroke and other brain injury patients at Royal Berkshire Hospital.

The Kinect could recognize moods such as frustration, by looking at body posture and adjust games to be easier, suggested researcher Ulf Schwekendiek at NYU-Poly.

Kinect Fitnect – Interactive Dressing Room

The concept of a virtual fitting room has reached a new pinnacle of success! The Kinect Fitnect is an interactive dressing room which has bolstered the features of the idea and is surely nearing practical and commercial use. This video by Adam Horvath showcases this interactive dressing room at work and how through countless developments, the concept is becoming more viable. In the video, the user is seen interacting with a NUI while standing in front of the Kinect. The user then commences to try out different clothing by picking them through the control panel. The clothes then surround the user through the Kinect’s body tracking. The user exhibit shadow and physics effect, making this, the most convincing display of an interactive dressing room.

Kinect Kiwibank Interactive Wall

Play games, browse the internet and get necessary information through our wall! The Kinect Kiwibank Interactive Wall is a multi-feature interactive wall which allows top of the line computing to its users. This video by Lumen Digital displays the firm’s dedication in creating useful setups that make use of the Kinect. In the video, a user is seen interacting with the projected interface on the wall. Hand gestures help users play on-board games, browse through the internet and also research on compelling information. This handy setup is indeed the very foundations of cloud computing and we may soon see ourselves accessing the world wide web through various walls around the city!

Float Hybrid Entertainment with John Gaeta

Award winning visual effects designer, John Gaeta, is on-board the Kinect development train! The Float Hybrid Entertainment is a company formed by Matrix and Speed Racer visual designer, John Gaeta in an effort to push the world of interactive entertainment! This video by the company introduces us to their company and the various videos inside their Youtube Page are spectacular products! Various games are featured by the FLOAT Hybrid Entertainment company such as the World Builder, Infiltrator and Sound Flower. Each game utilizes the Kinect plus great gameplay and visuals in order to create a new gaming experience. Aside from these, the company has also made it possible to network multiple Kinects at one time!  With a gifted visual effects designer heading a team of dedicated Kinect minds,Float Hybrid Entertainment will surely be a major player in the Kinect industry!

Kinect JediBot

Want to train your lightsaber skills to be a Jedi? The Kinect JediBot gives users the feel of a great lightsaber fight by attacking and defending itself against users. This creation by Ken Oslund and Tim Jenkins gives the saber-wielding robot both offensive and defensive capabilities thanks to the Kinect’s sensor. In the video, the user is seen defending itself from the JediBot’s attack patterns. As the JediBot detects impact, the JediBot commences to renew another attack pattern, giving the user the feel of training defensively. Another mode that the JediBot can do is to defend itself against the user’s attack by detecting the light saber stance and trajectory through the Kinect. This results to a veryintuitive lightsaber duel between robot and man. May the force be with the Kinect!\

Kinect Augmented Urban Model

Urban development gets a Kinect kick and the results are just amazing! The Kinect Augmented Urban Model allows users to simulate urban time lines via a top mounted Kinect and an interactive table. This video by Katja Knecht displays this smart Kinect program and how engineers or urban developers can properly calculate some building dynamics (in this case, building shadow effects). In the video the user places blocks on top of the lighted table and the Kinect is able to detect these blocks and their depth. By putting an analog clock on the table and clocking it, the time frame of the urban setup changes and the blocks then conjure shadows based on on the time displayed. Developers then can calculate if their buildings will ruin the aesthetic value of other buildings. With these programs and Kinect hacks, urban development will surely reach a new phase of efficiency.

Kinect MultiTouch Surface with Grasshopper (for Architects)

Architects may soon find themselves buying their own Kinect devices for their professional work! The Kinect MultiTouch Surface with Grasshopper is a Kinect setup built to serve the purpose of communicating and collaborating architect designs and algorithms. This video by Dan Belcher and Viswa Kumaragurubaran displays how the Kinect’s depth detection can help create touch surface for short-day plan communication. In the video the user is seen preparing  and selecting various elements by touching a display surface. With the Kinect mounted at the top, the accuracy of the interaction between the user and the screen is impeccable. Various data then can be configured and edited through touch thanks to the Kinect and the Grasshopper software. The website explains the program/setup best and architects would greatly benefit from this program. Have a look and see how the Kinect has the potential to change the way we build our civilization

Kinect Real Hacking using Metasploit

This puts the art of computer hacking into a whole new interesting ground. The Kinect Real Hacking using Virtual Environment allows users to bypass systems and important firewalls by actually destroying them in an in-game environment. This video by jeffbryner displays this very intriguing program and how gestures may soon replace coding when hacking a computer. In the video, the user is plunged into a virtual reality scenario using the Kinect to navigate around and metasploit to be the chief foundation of the program. The environment is actually a visual representation of the framework of another computer/program. Then, with a first person shooter environment, users can “destroy” objects which represent the other computer’s security. Doing so will result into the user having full control or hack of that computer. It definitely sounds like the movie “The Matrix”! Gesture-based real hacking will have hackers giggling in delight and online security personnel cringing with fear!

Kinect Turntable Scanner

This cheap and affordable setup brings 3d scanning to all Kinect users! The Kinect Turntable 3D Scanner is an ingenious setup with the Microsoft device that rotates the item and allows a full 3d image to be captured. This video by A.J. Jeromin displays how the turntable works and the features that a Kinect user can make once he has a full 3d image scan of his desired object. In the video, the setup is introduced and the light that illuminates the object. A shoe was placed inside the turntable box and as the box begins to rotate, the Kinect is in charge of capturing the object detail. The result is a fully detailed 3d scan of the shoe for various uses. Innovations such as these bring much desired technology to everybody!

Kinect 3d Object and People Scan

For Second Life and archaeological digs, the Kinect can create 3d representations of scanned items and folks! TheKinect 3d Object and People Scan gives users the technology to scan their objects and people and create a virtual 3d representation of them. This video by Chris Palmer showcases this Kinect setup and how the future of gaming and inventory can radically be changed by the Kinect. In the video people and objects, through a guided Kinect is able to capture a robust 3d image. Not only that, but also the depth and texture of the object is captured, giving a more detailed scan. The 3d images can be handy and in this case, scanned images of people can properly be imported to the game, Second Life. Another use is predicted on the archaeological digs, scanning ancient items/relics to be studied in 3d by historians miles away!

 Kinect Head Tracking

The throne of our brain has entered the list of detectable body parts by the Kinect! The Kinect Head Tracking is proof that even the head of the user can now be used to provide interactive commands to the computers and machines! This video by Sezer Karaoglu displays the Kinect Head Tracking at work. In the video, a circular gauge at the screen is seen, showing the head alignment of the user. As the user tilts his head, the bar shows the movement of the user’s head and the direction. We can see from this hack that the Kinect is now able to read the user’s head movement. With this additional way to control Kinect, we can see virtual reality simulations change their POVs just by tilting the head!

Read more »