atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

 <title type="text" xml:lang="">Electronics Club, IIT Bombay</title>
 <link type="application/atom+xml" href="https://elec-club-iitb.github.io/atom.xml" rel="self"/>
 <link type="text" href="https://elec-club-iitb.github.io/" rel="alternate"/>
 <updated>2017-05-09T19:11:28+00:00</updated>
 <id>https://elec-club-iitb.github.io/</id>
 <author>
   <name></name>
   <email>eciitb@gmail.com</email>
 </author>

 
 <entry>
   <title>Get Electrified 3</title>
   <link href="https://elec-club-iitb.github.io/blog/2017/04/get-electrified-3/"/>
   <updated>2017-04-24T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2017/04/get-electrified-3</id>
   <content type="html">&lt;p&gt;Electronics club conducted its last electrified session on 18th March, 2017. It was totally awesome as we got an opportunity to make a half adder, full adder, subtractor and priority encoder. Along with that we also learnt some cool stuff about digital circuits.&lt;/p&gt;

&lt;p&gt;##Where do we begin from to make anything as simple as an adder?&lt;/p&gt;

&lt;p&gt;We basically use a combinational circuit. Not only an adder but we can even make a subtractor, priority encoder, MUX and what not!&lt;/p&gt;

&lt;p&gt;Combinational circuit is basically used for making those circuits which depends on the current state.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_0.png&quot; alt=&quot;Combinational Logic Circuits&quot; /&gt;&lt;/p&gt;

&lt;p&gt;##So, let us now begin with how exactly do these combinational circuits function:&lt;/p&gt;

&lt;h2 id=&quot;adder&quot;&gt;Adder:&lt;/h2&gt;

&lt;p&gt;As you can guess an adder simply add two numbers. But why do we need a complicated circuit to just add numbers? Actually, adders are used in the arithmetic logic units in many computers and other kinds of processors.&lt;/p&gt;

&lt;p&gt;There are two kinds of adders:&lt;/p&gt;

&lt;h3 id=&quot;1-half-adder&quot;&gt;1) Half adder&lt;/h3&gt;

&lt;h3 id=&quot;2-full-adder&quot;&gt;2) Full adder&lt;/h3&gt;

&lt;p&gt;The major difference between a half adder and a full adder is that a full-adder has three inputs and two outputs where as a half adder has only two inputs and two outputs. In a full adder, the first two inputs are A and B and the third input is an input carry.&lt;/p&gt;

&lt;p&gt;The circuit diagram and truth table of a half adder and full adder is shown below:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_1.png&quot; alt=&quot;Half Adder&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_2.png&quot; alt=&quot;Full Adder&quot; /&gt;&lt;/p&gt;

&lt;h2 id=&quot;subtractor&quot;&gt;Subtractor:&lt;/h2&gt;

&lt;p&gt;Similarly, a subtractor subtracts two numbers. They are also of two types and as you can guess the two types are:&lt;/p&gt;

&lt;h3 id=&quot;1-half-subtractor&quot;&gt;1) Half subtractor&lt;/h3&gt;

&lt;h3 id=&quot;2-full-subtractor&quot;&gt;2) Full subtractor&lt;/h3&gt;

&lt;p&gt;Just like in an adder, the subtractor has similar inputs just the difference is that instead of a carry we have a “borrow”.&lt;/p&gt;

&lt;p&gt;The circuit diagram and truth table of a half subtractor and full subtractor is shown below:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_3.png&quot; alt=&quot;Half Subtractor&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_4.png&quot; alt=&quot;Full Subtractor&quot; /&gt;&lt;/p&gt;

&lt;h2 id=&quot;priority-encoder&quot;&gt;Priority Encoder:&lt;/h2&gt;

&lt;p&gt;So basically, what a priority encoder do is that it gives the highest priority of the current input as an output. So, when an input with a higher priority is present, all other inputs with a lower priority will be ignored. The priority encoder comes in many different forms with an example of an 8-input priority encoder along with its truth table shown below.&lt;/p&gt;

&lt;h2 id=&quot;8-to-3-bit-priority-encoder&quot;&gt;8-to-3 Bit Priority Encoder:&lt;/h2&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_5.png&quot; alt=&quot;8 to 3 bit Priority Encoder&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Where X equals “don’t care”, that is it can be either logic “0” or logic “1”.&lt;/p&gt;

&lt;h2 id=&quot;multiplexer-mux-and-demultiplexer&quot;&gt;Multiplexer (MUX) and Demultiplexer:&lt;/h2&gt;

&lt;h2 id=&quot;how-are-multiple-signals-combined&quot;&gt;How are multiple signals combined?&lt;/h2&gt;

&lt;p&gt;MUX is used for this purpose. It has N Select lines, 2N input lines, and it routes one of the input lines to the output. Conceptually, a MUX may be thought of as 2N switches. For a given combination of the select inputs, only one of the switches closes (makes contact), and the others are open.&lt;/p&gt;

&lt;p&gt;It is obvious from the name that a demultiplexer do the reverse of what a multiplexer do. It takes a single input (I) and routes it to one of the output lines. For N Select inputs, the number of output lines is 2^N.&lt;/p&gt;

&lt;p&gt;Circuit diagram and truth table of a multiplexer is shown below:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_6.png&quot; alt=&quot;4:1 Multiplexer&quot; /&gt;  &lt;img src=&quot;/assets/get-electrified-3/image_7.png&quot; alt=&quot;Truth Table&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Circuit diagram and truth table of a demultiplexer is shown below:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_8.png&quot; alt=&quot;1:4 Demultiplexer&quot; /&gt;  &lt;img src=&quot;/assets/get-electrified-3/image_9.png&quot; alt=&quot;Truth Table&quot; /&gt;&lt;/p&gt;

&lt;h2 id=&quot;encoders-and-decoders&quot;&gt;Encoders and Decoders:&lt;/h2&gt;

&lt;p&gt;You might be wondering what is the need of an encoder?&lt;/p&gt;

&lt;p&gt;It is actually used to convert information from one format to another for the purpose of standardization, speed and compressions.&lt;/p&gt;

&lt;p&gt;In encoders, only one input line is assumed to be active. The binary number corresponding to the active input line appears at the output pins. The N output lines can represent 2N binary numbers, each corresponding to one of the M input lines, i.e., we can have M = 2N. Some encoders have M &amp;lt; 2 N.&lt;/p&gt;

&lt;p&gt;Similarly, you can guess the functioning of a decoder. For each input combination, only one output line is active (which means 0 or 1, depending on whether the outputs are active low or active high). Since there are 2N input combinations, there could be 2N output lines, i.e., M = 2N. However, there are decoders with M &amp;lt; 2 N as well.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_10.png&quot; alt=&quot;Encoder&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-3/image_11.png&quot; alt=&quot;Decoder&quot; /&gt;&lt;/p&gt;

</content>
 </entry>
 
 <entry>
   <title>Improving ADCs by intentionally adding noise</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/10/improving-adcs-with-noise/"/>
   <updated>2016-10-29T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/10/improving-adcs-with-noise</id>
   <content type="html">&lt;p&gt;Everybody has this presumed notion that noise in an electronic system is bad.
We all learn about ways to reduce noise in the circuits we implement to get
better results. In this post we will see a case where intentionally &lt;em&gt;adding&lt;/em&gt;
noise to a system will give better results.&lt;/p&gt;

&lt;h2 id=&quot;what-is-wrong-with-a-normal-adc&quot;&gt;What is wrong with a normal ADC?&lt;/h2&gt;

&lt;p&gt;The purpose of an Analog to Digital converter is to obtain a digital value of
an analog signal. Lets say we want to convert a signal which is between -1 to 1V.
The analog version of this signal will be a real number and so can take one
of infinitely many real values between -1 and 1. But the digital representation
will only be able to take finite number of values because we only have a finite
number of bits to encode the real number.&lt;/p&gt;

&lt;p&gt;We will have to &lt;em&gt;quantize&lt;/em&gt; the signal i.e. pick the closest possible
approximation of it from the set of possible values. For the sake of simplicity,
lets assume we have just 1 bit to encode the signal. So the set of values our 
digital signal can take is &lt;script type=&quot;math/tex&quot;&gt;\{0, 1\}&lt;/script&gt;. Now it is clear that depending on the
analog value we will have to &lt;em&gt;pick&lt;/em&gt; one of 0 or 1 to represent this value as
our digital signal. The analog signal will almost never equal to -1 or 1
(try calculating the probability) so we will always get an error when we
try to &lt;em&gt;quantize&lt;/em&gt; our signal. This error is called &lt;strong&gt;Quantization Error&lt;/strong&gt;.&lt;/p&gt;

&lt;h2 id=&quot;there-is-already-an-error-and-you-want-to-add-more-noise&quot;&gt;There is already an error and you want to add more noise?!&lt;/h2&gt;

&lt;p&gt;We will eventually see that intentionally adding noise will help &lt;em&gt;reduce&lt;/em&gt;
quantization error. This kind of intentionally added noise is so commonly used
that it has its own name: Dither. Dither, apart from being used in ADCs is
very widely used in image processing to display better quality images.
See an example from &lt;a href=&quot;https://en.wikipedia.org/wiki/Dither&quot;&gt;the wikipedia page&lt;/a&gt;:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;//upload.wikimedia.org/wikipedia/commons/5/57/1_bit.png&quot; alt=&quot;dithered leaf&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The image of this leaf has been represented using just the colour white(1) and
black(0)! And yet it looks like it has various shades of grey! Lets see how
this happens.&lt;/p&gt;

&lt;h2 id=&quot;dither-in-adcs&quot;&gt;Dither in ADCs&lt;/h2&gt;

&lt;p&gt;Continuing with the quantization example above, lets say we have a 1-bit ADC
which gives output 0 if the input signal is negative and 1 if positive.
If &lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; is the digital output and &lt;script type=&quot;math/tex&quot;&gt;c&lt;/script&gt; is the analog input (assumed constant),&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;% &lt;![CDATA[
X = 
\begin{cases} 
\hfill 0 \hfill &amp; \text{ if $c \leq 0$} \\
\hfill 1 \hfill &amp; \text{ if $c &gt; 0$} \\
\end{cases}
, c \in [-1,1] %]]&gt;&lt;/script&gt;

&lt;p&gt;If we add a dither &lt;script type=&quot;math/tex&quot;&gt;d(t)&lt;/script&gt; to the analog input, the value of &lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; will be
decided by &lt;script type=&quot;math/tex&quot;&gt;c+d(t)&lt;/script&gt;. Lets say we add a dither which is characterised by a 
&lt;a href=&quot;https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)&quot;&gt;uniform random variable&lt;/a&gt;, so&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;d \sim \text{U}(-\frac{1}{2},\frac{1}{2})&lt;/script&gt;

&lt;p&gt;we will later see the significance of the range &lt;script type=&quot;math/tex&quot;&gt;-\frac{1}{2},\frac{1}{2}&lt;/script&gt;.
Cumulative density function of &lt;script type=&quot;math/tex&quot;&gt;d&lt;/script&gt; will be&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;F_d(x) = x + \frac{1}{2}, x \in [-\frac{1}{2},\frac{1}{2}]&lt;/script&gt;

&lt;p&gt;&lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; is dependent on a random variable, hence &lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; will also become a random
variable. And because &lt;script type=&quot;math/tex&quot;&gt;X \in \{0,1\}&lt;/script&gt; it will be a &lt;a href=&quot;https://en.wikipedia.org/wiki/Bernoulli_distribution&quot;&gt;Bernoulli random variable&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Hence,&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;X \sim \text{Ber}(p)&lt;/script&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;% &lt;![CDATA[
\begin{split}
P(X = 1) &amp; = P(c+d(t) &gt; 0) = p \\
 &amp; = P(d(t) &gt; -c) \\
 &amp; = 1 - P(d(t) \leq -c) \\
 &amp; = 1 - F_d(-c) \\
 &amp; = F_d(c) \\
 &amp; = c + \frac{1}{2}
\end{split} %]]&gt;&lt;/script&gt;

&lt;p&gt;We get &lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; to be a be a bernoulli variable with parameter dependent on our analog
value!&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;X \sim \text{Ber}(c+\frac{1}{2})&lt;/script&gt;

&lt;p&gt;We can see that expected value of &lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; is equal to &lt;script type=&quot;math/tex&quot;&gt;c + \frac{1}{2}&lt;/script&gt; (because X is bernoulli).
By the law of large numbers, we can say that if we take large number of samples of
&lt;script type=&quot;math/tex&quot;&gt;X&lt;/script&gt; (keeping &lt;script type=&quot;math/tex&quot;&gt;c&lt;/script&gt; constant), the average value of these samples will converge
to the expected value &lt;script type=&quot;math/tex&quot;&gt;c + \frac{1}{2}&lt;/script&gt;&lt;/p&gt;

&lt;h2 id=&quot;block-diagram-for-adding-dither&quot;&gt;Block diagram for adding dither&lt;/h2&gt;

&lt;p&gt;&lt;img src=&quot;/assets/improving-adcs-with-noise/block_diag.png&quot; alt=&quot;block diagram&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The Sampler just reads the value of its input at &lt;script type=&quot;math/tex&quot;&gt;t = nT&lt;/script&gt;, hence it gives
a sample at every &lt;script type=&quot;math/tex&quot;&gt;T&lt;/script&gt; seconds. From our previous derivation we can say that&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;\lim_{n\to\infty} \frac{1}{n}\sum_{n=0}^1 X[n] = c + \frac{1}{2}&lt;/script&gt;

&lt;p&gt;The problem here is that taking an infinite number of samples will take infinite
time which is impractical. But we can say that the larger number of samples we
the better accuracy in value of &lt;script type=&quot;math/tex&quot;&gt;c&lt;/script&gt; we will get. 
If we take &lt;script type=&quot;math/tex&quot;&gt;n&lt;/script&gt; samples, we can see that the average of &lt;script type=&quot;math/tex&quot;&gt;X[n]&lt;/script&gt; will take one
of &lt;script type=&quot;math/tex&quot;&gt;n&lt;/script&gt; values from the set &lt;script type=&quot;math/tex&quot;&gt;\{0,\frac{1}{n},\frac{2}{n},...,\frac{n}{n}\}&lt;/script&gt;.&lt;/p&gt;

&lt;p&gt;We thus have quantized &lt;script type=&quot;math/tex&quot;&gt;c&lt;/script&gt; to &lt;script type=&quot;math/tex&quot;&gt;n&lt;/script&gt; distinct values or &lt;script type=&quot;math/tex&quot;&gt;\text{log}_2(n)&lt;/script&gt; bits
using a 1-bit ADC!&lt;/p&gt;

&lt;h2 id=&quot;dither-in-images&quot;&gt;Dither in images&lt;/h2&gt;

&lt;p&gt;Lets take a look at the leaf image once again. Observe that a greyscale image has
been approximated here using two distinct values (black and white) i.e. a 1-bit value.
Such an image is called a binary image.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;//upload.wikimedia.org/wikipedia/commons/5/57/1_bit.png&quot; alt=&quot;dithered leaf&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Lets say the greyscale had values for every pixel as a real number
between 0 and 1, 0 corresponding to full black and 1 corresponding to full white.
There would be regions in this image with similar values of grey. For e.g.
take the section of the top of the leaf. It is a region of light grey (value&lt;script type=&quot;math/tex&quot;&gt;=c&gt;\frac{1}{2}&lt;/script&gt;).
If we convert this region directly to binary, the whole region will become white.
Similarly we would get a large patches of black and white all over the image 
which would be a pretty inaccurate depiction of the greyscale image.&lt;/p&gt;

&lt;p&gt;Now if we add dither to that small region of similar greyscale value 
and then convert to binary image, the probability of getting a white pixel
will be proportional to the value of that region (&lt;script type=&quot;math/tex&quot;&gt;=c&lt;/script&gt;). If the region has 100
pixels, instead of all 100 being converted to white pixels, &lt;script type=&quot;math/tex&quot;&gt;100c&lt;/script&gt; pixels will be
white and &lt;script type=&quot;math/tex&quot;&gt;100(1-c)&lt;/script&gt; will be black. On average that will look like the region is
grey with value &lt;script type=&quot;math/tex&quot;&gt;c&lt;/script&gt;.&lt;/p&gt;

&lt;p&gt;We can say that the average value of a small region in the binary image will be 
close to the greyscale value of that small region in the real image.
Hence we can see that dither gives us a better approximation after quantization.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: The leaf image is using a slightly better algorithm than just adding dither
and converting to binary (Random dithering). Such an image would look much worse, so for representative
purposes I have used this image. You can read more about better algorithms on the
wikipedia page of Dither&lt;/em&gt;&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Get Electrified 2</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/09/get-electrified-2/"/>
   <updated>2016-09-29T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/09/get-electrified-2</id>
   <content type="html">&lt;p&gt;Greetings from Electronics Club IIT Bombay&lt;/p&gt;

&lt;p&gt;We conduct Electrified sessions regularly wherein some basic electronics
concepts are discussed and some cool DIY projects based on the concepts
discussed are made.&lt;/p&gt;

&lt;p&gt;On 23rd september, 2016 we conducted Electrified 2 where we discussed
Operational amplifiers, transistors, sensors, and some awesome circuits
using these devices.&lt;/p&gt;

&lt;p&gt;An overview of the content we covered.&lt;/p&gt;

&lt;h3 id=&quot;operational-amplifiers&quot;&gt;Operational Amplifiers&lt;/h3&gt;

&lt;p&gt;Op-amp, as often called, is an extremely versatile devices which is fundamentally a
voltage amplifying device. Using opamps we can amplify, filter and do a
lot more with signals. Also in addition to that we can perform
mathematical operations such as addition, subtraction , integration and
differentiation etc.&lt;/p&gt;

&lt;p&gt;For more details of Opamps you can refer our
&lt;a href=&quot;/tutorials/basic_electronics/&quot;&gt;&lt;em&gt;tutorial&lt;/em&gt;&lt;/a&gt;
on basic electronics.&lt;/p&gt;

&lt;h3 id=&quot;bipolar-junction-transistors&quot;&gt;Bipolar Junction Transistors&lt;/h3&gt;

&lt;p&gt;Transistors are three terminal active devices made from different
semiconductor materials that can act as either an insulator or a
conductor by the application of a small signal voltage. The transistor’s
ability to change between these two states enables it to have two basic
functions: “switching” (digital electronics) or “amplification” (analog
electronics).&lt;/p&gt;

&lt;p&gt;Enough of boring theory I guess, let’s get started with the circuits.&lt;/p&gt;

&lt;h2 id=&quot;projects&quot;&gt;Projects&lt;/h2&gt;

&lt;h3 id=&quot;xyloband&quot;&gt;Xyloband&lt;/h3&gt;

&lt;p&gt;Have you ever seen the xylobands which we wear in concerts and they
flash light according to the music being played. You can make it on your
own with just basic knowledge of opamps !&lt;/p&gt;

&lt;p&gt;Formally the problem statement would be make an LED blink on the beats
of music.&lt;/p&gt;

&lt;p&gt;Now the beats of music are essentially the drum sounds which are of the
lowest frequency. So essentially we need to isolate the sound signals
produced made by a drum, amplify them and then make LED toggle on that
frequency.&lt;/p&gt;

&lt;p&gt;Here is the circuit of xyloband:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-2/xylo_band_circuit.jpg&quot; alt=&quot;xyloband_circuit&quot; /&gt;&lt;/p&gt;

&lt;p&gt;We start by taking the input of music via a microphone. We can model the
microphone as unipolar resistor. Therefore we have made a voltage
divider circuit in which one resistor is the microphone itself. When the
sound waves hit the microphone, the resistance of the microphone changes
according to the music.&lt;/p&gt;

&lt;p&gt;So theoretically we have a voltage output of music but you can’t
directly apply this output to the LED. The reasons being :&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;The voltage output is in order of about 10-20 millivolts.&lt;/li&gt;
  &lt;li&gt;The output contains all the frequencies.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;To amplify the signal we are using opamps.The next part of the circuit
you can see is an inverting voltage amplifier made by using an Opamp.
The gain factor of this amplifier is simply the ratio of resistances
connected which is 100/1.5 = 66.67.&lt;/p&gt;

&lt;p&gt;Now we need only the signals corresponding to the drum frequencies. But
we have all frequencies corresponding to all the instruments. We need to
“filter” out these frequencies. Since the frequency we want is the
lowest of all we need to design a low pass filter.&lt;/p&gt;

&lt;p&gt;Here too opamp comes to help. As you can see in the circuit we have
designed a low pass filter using opamp. The values of resistor and
capacitor is chosen such that the cutoff frequency of the filter is just
above the maximum frequency of drum beats.&lt;/p&gt;

&lt;p&gt;Now after filtering the signal this is what we have in our hands : An
amplified output corresponding the the beats of the music. Note that
after filtering the higher frequencies have been attenuated.&lt;/p&gt;

&lt;p&gt;Now what I want is that if I get the amplified output of drumbeats the
my LED should turn ON and if get the attenuated voltage of higher
frequencies then my LED should be OFF.&lt;/p&gt;

&lt;p&gt;So basically we need to “compare” the signals with respect to a particular value.
So that’s what our next part of the circuit is; a comparator. The
reference voltage of comparator has been set by using a simple voltage
divider.&lt;/p&gt;

&lt;p&gt;And we are done with our circuit and you are ready to make the LED dance
on your music beats.&lt;/p&gt;

&lt;h3 id=&quot;audio-amplifier&quot;&gt;Audio Amplifier&lt;/h3&gt;

&lt;p&gt;In this circuit we play music through our cell phones via an external
speaker.&lt;/p&gt;

&lt;p&gt;Here is the circuit diagram of the Audio Amplifier:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/get-electrified-2/audio_amplifier_circuit.jpg&quot; alt=&quot;audio_amplifier_circuit&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Can you see an AC source in the left part of circuit ? That’s where we
connect the audio jack output from our cell phones.&lt;/p&gt;

&lt;p&gt;Now to drive a speaker we need sufficient voltage and current. The
current and voltage that we receive from the audio jack is not
sufficient to drive the speaker. Therefore in the above circuit we are
amplifying the signal in two stages; one is voltage amplifier and the
another one is current amplifier.&lt;/p&gt;

&lt;p&gt;The voltage amplification is done by opamp. The current is amplified
using a differential amplifier made by an npn and a pnp transistor. The
final output is then connected to the speaker and you have the speaker
playing the music.&lt;/p&gt;

&lt;p&gt;Let’s have a look at how the things turned out to be :)&lt;/p&gt;

&lt;iframe width=&quot;1280&quot; height=&quot;720&quot; src=&quot;https://www.youtube.com/embed/So6K92vzHUw&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;&quot;&gt;&lt;/iframe&gt;
</content>
 </entry>
 
 <entry>
   <title>The Tech Behind Games</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/08/the-tech-behind-games/"/>
   <updated>2016-08-31T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/08/the-tech-behind-games</id>
   <content type="html">&lt;p&gt;Gaming is one of the most popular form of entertainment (and probably will hold this position forever).
Also, mobile gaming is on a boom now a days. Almost every good game needs its controls to be intuitive and flexible. 
There has been a lot of research and upgradations in the field of motion sensing.
Some of the major breakthroughs are Gyroscope, Accelerometer, Magnetometer, etc. Let’s know about these in detail.&lt;/p&gt;

&lt;h3 id=&quot;motion-sensing&quot;&gt;Motion Sensing&lt;/h3&gt;

&lt;p&gt;One key element of interaction is local motion of the phone, such as linear acceleration, rotational velocity, etc.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/the-tech-behind-games/accel_gyro.jpg&quot; alt=&quot;accel_gyro&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;Accelerometer&lt;/strong&gt;&lt;/p&gt;

    &lt;p&gt;Have you ever wondered how your phone manages to know what direction you are holding it?
It uses a device called accelerometer. An accelerometer is a device that measures linear acceleration.
As it has to measure acceleration, force should come in picture somewhere.
It measures force using a loaded capacitor with one plate attached to a spring.
A simplistic model is where one plate is fixed, and the other has the mass of the load attached to a spring.
This spring will change its amount of compression (and hence distance between plates) based on the force
applied to the capacitor. This change in distance leads to a change in capacitance
, which is measured and used to determine the acceleration of the device. Interesting isn’t it!
One capacitor is used for each axis X, Y, Z and hence we can get the acceleration
vector in 3D.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;img src=&quot;/assets/the-tech-behind-games/capacitor_diagram.jpg&quot; alt=&quot;capacitor&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;Gyroscope&lt;/strong&gt;&lt;/p&gt;

    &lt;p&gt;It is a device used to measure the angular velocity.
It basically consists a wheel or disc mounted so that it can spin rapidly
about an axis which itself is free to alter in any direction.
Also it is connected to different capacitors at its edges such that when the
device rotates and the disc moves there is a subtle change in the capacitance
(similar model like the accelerometer) which helps us to determine the
magnitude of the angular acceleration of the device.
Also, more than one capacitors are used so that we get an idea of the
direction in which the device is rotated.
One important observation here is that setup based on torsion strain cannot
be used as we have to measure angular velocity and not the angular acceleration.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;Magnetometer&lt;/strong&gt;&lt;/p&gt;

    &lt;p&gt;In the very basic sense a magnetormeter is a compass. 
It provides mobile phones with a orientation in relation to the Earth’s magnetic field.
There are two types of magnetometers, which use Hall-effect and others which
use Magneto-resistive effects, the former are used on a large scale.
In these kinds of magnetometers, a conductive plate is connected to a
complete circuit so that electrons flow through it is continuous.
When the device comes in the influence of a magnetic field, there is a deflection
in the path of the electrons due to which a potential difference is created
across the edges of the plate perpendicular to the flow of current.
By measuring this potential difference the magnetic field vector around is determined.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;gps-global-positioning-system&quot;&gt;GPS (Global Positioning System)&lt;/h3&gt;

&lt;p&gt;The United States began the GPS project in 1973 to overcome the limitations of
previous navigation systems. Later they thought that everyone should use this technology.
The purpose was providing geographical position in all weather conditions anywhere on or near Earth.&lt;/p&gt;

&lt;h4 id=&quot;working&quot;&gt;Working&lt;/h4&gt;

&lt;p&gt;This comprises of a network of 27 satellites (of which 3 are for backup)
which have a transmitter attached (they do not have a receiver).
They basically transmit data in the form of electromagnetic waves.
The transmitted data consists of three chunks:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A pre-determined random string&lt;/li&gt;
  &lt;li&gt;The satellite’s current orbital position and time of transmission&lt;/li&gt;
  &lt;li&gt;health data for monitoring&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The receiver also records when it recieved this transmission.
Thus we know the time of transmitting and using this info we can calculate the
distance between us and the satellite as we also know the time we received the wave,
and hence time it took to travel the distance. The speed of the wave is equal
to the speed of light because it is an electromagnetic wave.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/the-tech-behind-games/gps.jpg&quot; alt=&quot;gps&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Using this distance measurement from 3 different satellites and their orbital position
we get three spheres as loci of our position. The earth is the fourth sphere. Using coordinate geometry
we can find the intersection of these spheres to give one single point in 3D space
which will be our location.&lt;/p&gt;

&lt;p&gt;So 3 satellites are enough to pinpoint our location, but to increase the accuracy 4-5 satellites are generally used.&lt;/p&gt;

&lt;h3 id=&quot;augmented-reality&quot;&gt;Augmented Reality&lt;/h3&gt;

&lt;p&gt;As the name suggests it basically enhances the real world by adding the digital
graphics to real world. This is done by displaying the real world and additional
“augmented” data together on one screen.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/the-tech-behind-games/ar.jpg&quot; alt=&quot;AR&quot; /&gt;&lt;/p&gt;

&lt;p&gt;This has varied applications like visual art, greeting cards, video games
(any fans of Pokemon Go or Ingress here!)&lt;/p&gt;

&lt;p&gt;In this, we basically take an image, detect a pattern and attach an object to it.
Let me explain by giving an example, while playing pokemon go suppose a wild magikarp appears,
the camera will take input of the image in front of it and detect any water body
(the shades of colour which represent water are detected) present.
It will then deploy the water type pokemon over that water body.
There other components like angle, height, width, etc. are also considered to give 3D effects.&lt;/p&gt;

&lt;p&gt;Any game like Pokemon Go or Ingress will interface these sensors and use this
data to enhance your experience of interactivity with the game. They use AR
to give an immersive feel to the game, much like you are in the game’s world
and playing it in real life!&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Functioning of L293D motor driver</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/08/l293d/"/>
   <updated>2016-08-14T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/08/l293d</id>
   <content type="html">&lt;p&gt;Last year I entered IIT Bombay and had my first face off with the modern
tech then. We had a bot racing competition called XLR8 in which we have
to prepare a bot on our own and race it with others so as to win. Seems
easy? Not as much as it seems to be .&lt;/p&gt;

&lt;p&gt;It’s not just about making and winning, it’s about learning too . All
the components we are getting and assembling we should have knowledge
about them. How, when ,where they work and are used should be thing we
should really be taking care of .
So while we were making the bot we came across this most intriguing
small chip, &lt;strong&gt;L293D&lt;/strong&gt;. This is basically a motor driver, something which
helps in controlling motors (in our case, the wheels of the bot). A
first look at the connections and we feel it’s all too mixed up! Wires
entangled into one another and what goes where, NO IDEA!&lt;/p&gt;

&lt;p&gt;But actually it’s working is pretty easy. Here, I will try to explain it
in a simple way.&lt;/p&gt;

&lt;p&gt;So let’s explore this motor driver and see what we can do to learn it
(at least with a data sheet :P )&lt;/p&gt;

&lt;p&gt;Presuming we have this driver , its datasheet and zeal to learn.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/l293d/image00.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;It looks like this from outside and the connections inside are :&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/l293d/image01.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Working Of L293D&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;L293D is a motor driver 16 pin IC which can be used to run a set of two
DC motors at a time. To power itself it requires 5V voltage through VCC1
and can deliver up to 12 volts through VCC2.&lt;/p&gt;

&lt;p&gt;To understand the working of L293D, we first need to know about a
component called H-Bridge&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;H-Bridge&lt;/strong&gt;&lt;br /&gt;
A H-bridge looks like following :&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/l293d/image02.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;It is used to apply voltage across a load( here, a motor ) in both the
directions. So we can easily infer from this if the voltage across the
motor is reversed , its direction of rotation is also reversed and hence
this is used to drive the motor in both the directions.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;If switches S1 and S4 are closed then motor rotates clockwise.&lt;/li&gt;
  &lt;li&gt;If switches S2 and S3 are closed then motor rotates anticlockwise.&lt;/li&gt;
  &lt;li&gt;If S1 and S3 or S2 and S4 are closed then motor stops rotating.&lt;/li&gt;
  &lt;li&gt;If all are left open motor moves freely.&lt;/li&gt;
  &lt;li&gt;Never close S1 and S2 or S3 and S4 or all of them simultaneously.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;L293D is, infact, a dual H bridge IC used to drive motors in both
forward and backward direction through various combinations of inputs
that we will look later. The first H-Bridge is formed by Left Hand Side
pins of L293D (see diagram) while the second is formed by the right hand
side ones.&lt;/p&gt;

&lt;p&gt;To ensure that motor attach to it at both sides run, PIN 1 and PIN 9 (
ENABLE PINS ) should be high. Enable pins can be a considered as a
switch to this IC , if it’s high then switch is on and motor will work (
according to the provided proper input ) and if it is low, meaning
switch is off, the motors won’t respond to the corresponding inputs.&lt;/p&gt;

&lt;p&gt;The voltage we supply at VCC1 is used to power the L293D for its working
and at VCC2 we get the output used for driving its motors. Now the
output at VCC2 depends on the voltage you supplied at VCC1. The fraction
of voltage you supply at VCC1 appears in the same fraction at VCC2.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CONNECTIONS IN L293D&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Pin1 and Pin9 are “Enable” pins or the switch pins as you can say.
They should be connected to +5V for the drivers to function (for
the motor to follow the inputs). If they pulled low (GND), then
the outputs will be turned off regardless of the input states,
stopping the motors.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pin4, Pin5, Pin12 and Pin 13 are ground pins which should ideally be
connected to microcontroller’s ground.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pin2, Pin7, Pin10 and Pin15 are logic input pins. These are control
pins which should be connected to microcontroller pins or whatever
is the input to L293D. Pin2 and Pin7 control the left motor ;
Pin10 and Pin15 control the right motor. (as shown in diagram)&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pin3, Pin6, Pin11, and Pin 14 are output pins. Tie Pin3 and Pin6 to
the left motor, Pin11 and Pin 14 to right motor. Note that there
is a bijection between the input pins and output pins.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pin16 powers the IC and it should be connected to regulated +5Volts.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pin8 powers the two motors and should be connected to positive lead
 of a secondary battery. As per the datasheet, supply voltage can
be as high as 36 Volts.&lt;/p&gt;

    &lt;p&gt;As we can see the highest output is 36V so considerably larger
motor can also be driven using this IC. ( Oh I see this IC is
useful :P )&lt;/p&gt;

    &lt;p&gt;Keep in mind all these connections while making your bot as well
the reason behind these connections. This makes debugging easy.
I have experienced this, we randomly did all the connections and
wondering why our bot isn’t working until some told enable pin is
set too low!&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;LOGIC TABLE FOR L293D&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/l293d/image03.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Similarly for PIN 9 ( ~PIN 1 ) , PIN 10( ~PIN2 ) and PIN 15 ( ~PIN7 ).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;EXPLANATION OF THE TABLE&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Now no need to memorize the high and low , work on the logic !&lt;br /&gt;
PIN 1 and PIN 9 are your enable pins so they need to be kept high and
otherwise it doesn’t matter what your input is , your motors will not
move.&lt;br /&gt;
Now we should have a potential difference between the output terminals,
so that it appears across motor and it rotates. For that to happen there
should be a potential difference at the input terminals too (since there
is a bijection between the input and output pins) ! Hence, the truth
table is justified.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;DO’s AND DONT’s&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;You have learnt about L293D but before moving on to any kind of
tinkering you should know what to experiment and what not to ( unless
you are so enthusiastic to see whats like a blown up L293D). Here we go:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Make sure you connect all the pins properly such that no two pins are
shorted except the ground pins.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Make sure the IC is connected in proper orientation. The pin to the
left of the small semicircle of the IC at the top is the first pin.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Make sure the supply voltage is not greater than 5 volts for IC and
more than 36 volts for motor.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Remove the input pins when not required to avoid any unnecessary
heating of IC.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Happy tinkering ! :D&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Making a Sound Meter in Python</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/08/sound-meter/"/>
   <updated>2016-08-04T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/08/sound-meter</id>
   <content type="html">&lt;p&gt;Those who have seen the 3 blocks of audience in PCSA compete during the STAB Orientation for the loudest cheer, know what this Sound Meter is.&lt;/p&gt;

&lt;h2 id=&quot;target&quot;&gt;Target&lt;/h2&gt;

&lt;p&gt;To analyse any incoming sound(be it mic or laptop microphone) and find its maximum volume. Actually, using other detailed operations you can estimate the frequency etc. Basically, once we read the audio input stream we can use the desired computations on it.&lt;/p&gt;

&lt;h2 id=&quot;plan-of-action&quot;&gt;Plan of action&lt;/h2&gt;

&lt;p&gt;This is roughly what we need to do:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Read the input from the laptop microphone or the mic(in our case, that requires setting it to default recording device)&lt;/li&gt;
  &lt;li&gt;Find the maximum value of the sound channels over a chunk of inputs.&lt;/li&gt;
  &lt;li&gt;Display it!&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;libraries-used&quot;&gt;Libraries used:&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;pyaudio&lt;/strong&gt; for audio stream input.
&lt;strong&gt;audioop&lt;/strong&gt; for max value analysis.
&lt;strong&gt;pygame&lt;/strong&gt; for display.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-python&quot; data-lang=&quot;python&quot;&gt;&lt;span class=&quot;kn&quot;&gt;import&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;time&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;audioop&lt;/span&gt;
&lt;span class=&quot;kn&quot;&gt;import&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;pygame&lt;/span&gt;
&lt;span class=&quot;kn&quot;&gt;import&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;pyaudio&lt;/span&gt;
&lt;span class=&quot;kn&quot;&gt;import&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;wave&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;#Initialisation for PyAudio&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;CHUNK&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1024&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;FORMAT&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pyaudio&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;paInt16&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;CHANNELS&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;RATE&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;44100&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;RECORD_SECONDS&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;5&lt;/span&gt;
&lt;span class=&quot;c&quot;&gt;#Object&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pyaudio&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;PyAudio&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;stream&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;open&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;format&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FORMAT&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;channels&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CHANNELS&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;rate&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RATE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;input&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;bp&quot;&gt;True&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;frames_per_buffer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CHUNK&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;#PyGame initialisations and basic objects&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;init&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;900&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;600&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;screen&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;display&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;set_mode&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;display&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;set_caption&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Shout harder.. :D&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;#Defining colors&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;WHITE&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;RED&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;128&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;128&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;YELLOW&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;128&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;BLUE&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;#Loop till close button clicked&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;done&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;bp&quot;&gt;False&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;clock&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;time&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Clock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;#variables&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;score&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[]&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;width&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;0.8&lt;/span&gt;

&lt;span class=&quot;n&quot;&gt;margin&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;20&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;samples_per_section&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;margin&lt;/span&gt;

&lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;[[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;samples_per_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;

&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;while&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;not&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;done&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;

	&lt;span class=&quot;c&quot;&gt;#Limits CPU usage to max 10 times per second&lt;/span&gt;
	&lt;span class=&quot;c&quot;&gt;#Not required here because already the for loop takes averages over some time&lt;/span&gt;
	&lt;span class=&quot;c&quot;&gt;#clock.tick(10)&lt;/span&gt;

	&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;
	&lt;span class=&quot;c&quot;&gt;#Now we read data from device for around one second&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;range&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;):&lt;/span&gt;
            &lt;span class=&quot;c&quot;&gt;#l,data = inp.read()&lt;/span&gt;
			&lt;span class=&quot;n&quot;&gt;data&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;stream&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;read&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CHUNK&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
			&lt;span class=&quot;c&quot;&gt;#oreo_sound.append(data)&lt;/span&gt;
			&lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;bp&quot;&gt;True&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;
				&lt;span class=&quot;n&quot;&gt;reading&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;audioop&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;max&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;data&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
				&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;reading&lt;/span&gt;
			&lt;span class=&quot;n&quot;&gt;time&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;sleep&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mo&quot;&gt;0001&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

	&lt;span class=&quot;c&quot;&gt;#any scaling factor&lt;/span&gt;
	&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;100&lt;/span&gt;

	&lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
	&lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;max&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;total&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

	&lt;span class=&quot;n&quot;&gt;screen&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;fill&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;WHITE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;

    &lt;span class=&quot;c&quot;&gt;# draw highlighted section&lt;/span&gt;
	&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;draw&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;rect&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;YELLOW&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]))&lt;/span&gt;

	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;range&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;):&lt;/span&gt;
		&lt;span class=&quot;n&quot;&gt;sectionx&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;margin&lt;/span&gt;
            &lt;span class=&quot;c&quot;&gt;#add meet wala last year ka feature&lt;/span&gt;
		&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;draw&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;rect&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RED&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;sectionx&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;margin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]))&lt;/span&gt;

		&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;range&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;margin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;):&lt;/span&gt;
			&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sectionx&lt;/span&gt;
			&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
			&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;draw&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;rect&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;screen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;BLUE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]))&lt;/span&gt;

	&lt;span class=&quot;c&quot;&gt;#frame flip must happen after all drawing commands&lt;/span&gt;
	&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;display&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;flip&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;

	&lt;span class=&quot;c&quot;&gt;#Set close button event&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;():&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;type&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;==&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;QUIT&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;done&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;bp&quot;&gt;True&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;type&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;==&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;MOUSEBUTTONUP&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;button&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;c&quot;&gt;# right button pressed, clear all arrays&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;sound_tracks&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;[[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;samples_per_section&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;max_value&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;pos&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mouse&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;get_pos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;pos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;*&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;/&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;screensize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;print&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;current_section&lt;/span&gt;
	
&lt;span class=&quot;c&quot;&gt;#clearing the resources&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;quit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;stream&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;stop_stream&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;stream&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;close&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;terminate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;pygame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;quit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Have fun!&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Sudoku Solver</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/07/sudoku-solver/"/>
   <updated>2016-07-31T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/07/sudoku-solver</id>
   <content type="html">&lt;p&gt;&lt;strong&gt;Sudoku Solver&lt;/strong&gt; is the collection of very basic image processing techniques. A very good way to start is the OpenCV library which can be compiled on almost all the platforms. &lt;strong&gt;OpenCV&lt;/strong&gt;(open source computer vision )is a library of programming functions mainly aimed at real time computer vision. Through this project ,my main motivation was to explore what OpenCV offers in a little bit detail . There are already many blogs dealing with how to recognise a whole sudoku puzzle but it  was nevertheless  a pleasant experience doing it on my own and writing this blog ( It is pretty obvious that I too would have been lost without all those online resources , blogs , and documentations.)&lt;/p&gt;

&lt;h3 id=&quot;what-actually-this-project-does&quot;&gt;What actually this project does?&lt;/h3&gt;

&lt;p&gt;It takes an input image of a sudoku and processes the image and identifies the all the whole suduko and return the answer of the sudoku.
It involves two major challenges:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Image recognition&lt;/li&gt;
  &lt;li&gt;Solving the sudoku puzzle&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;I was more interested in the image processing part as there are fixed algorithm for solving  the sudoku puzzle so my main focus in this blog would be the image processing part.&lt;/p&gt;

&lt;h3 id=&quot;the-major-steps-this-will-involve-are&quot;&gt;&lt;strong&gt;The major steps this will involve are:&lt;/strong&gt;&lt;/h3&gt;

&lt;ol&gt;
  &lt;li&gt; Reading an image&lt;/li&gt;
  &lt;li&gt; Preprocessing the image ( removal of noises and thresholding the image)&lt;/li&gt;
  &lt;li&gt; Finding the sudoku square out of the whole image&lt;/li&gt;
  &lt;li&gt; Extracting the sub-grids of the sudoku.&lt;/li&gt;
  &lt;li&gt;Recognising the digits (OCR)&lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;we-also-need-to-make-a-few-assumptions-&quot;&gt;&lt;strong&gt;We also need to make a few assumptions :&lt;/strong&gt;&lt;/h3&gt;

&lt;ol&gt;
  &lt;li&gt;In the image , the largest square would be that of the sudoku image&lt;/li&gt;
  &lt;li&gt;The puzzle would be oriented reasonably oriented.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;So let’s get started, &lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;First of all we need is an input image.  We need to load a sudoku image .&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/sudoku-solver/image1.jpg&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;src&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;imread&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;sudoku.jpg&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CV_LOAD_IMAGE_UNCHANGED&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;After loading the image ,the first thing to do in any image processing problem is to reduce the amount of data you are dealing with.We started with a full colour high resolution image.The first thing we can do is to convert the image into a gray scale as looking at our sample image having colour is of no use to us.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;srcb&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;cvtColor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;src&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;srcb&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;COLOR_BGR2GRAY&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;h3 id=&quot;image-processing&quot;&gt;Image Processing:&lt;/h3&gt;

&lt;p&gt;After we have converted the image into a gray scale image we need to remove the noises from the image and smoothen the image as without smoothing the image we deal with extra objects which are not needed so it is necessary to remove the noises. There are many functions available in the OpenCV library for blurring the image like blur , GaussianBlur , MedianBlur . I tried them all and the best result I got out of them was with gaussian blur so I used it . Next , what we need to do is to remove other extra information . We are going to threshold the image that is we have either the foreground pixel or the background pixel. There are variety of thresholding techniques available to us in OpenCV library. My personal favourite is a simple adaptive threshold .For each pixel in the image it takes the average value of the surrounding area.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;    &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;smooth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thresholded&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;GaussianBlur&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;srcb&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;smooth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;11&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;11&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//removing noises
&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;adaptiveThreshold&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;smooth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thresholded&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ADAPTIVE_THRESH_MEAN_C&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;THRESH_BINARY_INV&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;15&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;5&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt; I  have done just noise removal and adaptive thresholding and  it is working so haven’t done anything extra. Below is the result:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/sudoku-solver/image2.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;h3 id=&quot;extracting-the-sudoku-&quot;&gt;Extracting the Sudoku :&lt;/h3&gt;

&lt;p&gt;Now after thresholding we need to find out the sudoku square , for this we made an assumption the main thing in our image would be the sudoku so we need to find the square with the largest area and it would be our sudoku.&lt;/p&gt;

&lt;p&gt;So one thing is very important the sudoku square should be largest otherwise our method fails.&lt;/p&gt;

&lt;p&gt;We start by finding the countours in our thresholded image.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;n&quot;&gt;vector&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;vector&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Point&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
     &lt;span class=&quot;n&quot;&gt;vector&lt;/span&gt;  &lt;span class=&quot;n&quot;&gt;heirarchy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;findContours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;thresholded2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;heirarchy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;CV_RETR_TREE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CV_CHAIN_APPROX_SIMPLE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we find the blob with maximum area .First we filter them by area . We consider the blob for the next processing only if its area is greater than a particular value (here , it is 50) . Next , we find out the area of each blob and hence extract the blob which has the maximum area.  &lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;area&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;maxarea&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
      &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;area&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contourArea&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;false&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;area&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;50&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
          &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;area&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;maxarea&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;maxarea&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;area&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;p&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now after finding the blob with maximum area we approximate the countour into a polygon. It removes the unwanted coordiante values in the countour and keeps only the corners.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;perimeter&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;arcLength&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;approxPolyDP&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;],&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mo&quot;&gt;01&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;perimeter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we draw the contour on our image just to check it.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;    &lt;span class=&quot;n&quot;&gt;drawContours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;src&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Scalar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;8&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;&lt;img src=&quot;/assets/sudoku-solver/image3.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now we have found out the boundary of the sudoku and next we need to to do is extract this much part and then work on it.&lt;/p&gt;

&lt;p&gt;As we have approximated the contours into a square or rectangle we will get only four coordinate that are the corners and now what we need to do is find out which coordinate is of the top-left corner , top-right corner , bottom-left corner , bottom-right corner. As the order of contours in all the image will not be fixed we need to find it out as we have to map the top-left to [0,0] for new image and bottom-right to [449,449]  , as we are creating an image of [450,450] you can do it of whichever size you want , therefore we need to identify the correct order of corners otherwise we will get rotated images. The logic I choose to find the respective corners was : First take the sum of x , y coordinates TOP -LEFT has least sum and BOTTOM-RIGHT has the maximum sum. Now the difference  i.e y-x TOP-RIGHT has minimum and BOTTOM-LEFT has maximum sum.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevsum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;a&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;b&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diff1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diff2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diffprev2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diffprev&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevsum2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

     &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;c&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;d&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
     &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
     &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;diff1&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;diff2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;diff1&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diffprev&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;diffprev&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diff1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;c&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;diff2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diffprev2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;diffprev2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;diff2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;d&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevsum&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;prevsum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;a&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevsum2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
         &lt;span class=&quot;n&quot;&gt;prevsum2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sum&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;b&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
       &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
     &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we have 4 points in order and now we need corresponding points where they should be mapped.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;a&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;b&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;c&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;][&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;d&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Point2f&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we have the input and output array both what we need to do is apply prespective transformation to get the sudoku part required. Prespective transformation maps a point given by x, y in one quadilateral to a new point X ,Y in another quadilateral.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;wrap&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;::&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;zeros&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;src&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;src&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;type&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;());&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;wrap&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;getPerspectiveTransform&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;in&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;warpPerspective&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;src&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;wrap&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;));&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;h3 id=&quot;the-result-we-get-is&quot;&gt;The result we get is:&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/assets/sudoku-solver/image4.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now apply the pre-processing as we did earlier and get the thresholded image and now we need to extract each grids centre the digit and then finally apply OCR.
So, we can extract each grids as we know our image is a matrix of 450&lt;em&gt;450 and therefore our every sub grids will be a matrix of 50&lt;/em&gt;50 so we can extract each grid by extracting the sub grids of 50*50 and store all the images in a vector.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;m&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;n&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;m&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;m&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;m&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;50&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;n&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;n&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;450&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;n&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;n&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;50&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
          &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
             &lt;span class=&quot;n&quot;&gt;smallimage&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;thresholded31&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cv&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;::&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Rect&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;n&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;m&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;50&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;50&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;));&lt;/span&gt;
             &lt;span class=&quot;n&quot;&gt;smallt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;push_back&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;smallimage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
           &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
     &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we have each small grid and it may contain digits or not so we will set a threshold pixel if the image contains pixels greater than that then it may contain a digit otherwise it doesnot and now the images with pixels greater than threshold you need to extract the digit and center it rather than testing the image directly as it will increase the changes of correct recogniton. We can extract the digit and centre it in same way as we extracted the main grid , find the  contour  and bound it by rectangle and find the bounding rectangle with greatest area then resize it.(Assumption : the subgrids containing digits will have the digits as the main part).&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;      &lt;span class=&quot;n&quot;&gt;thresholded32&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;smallt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;].&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;clone&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;vector&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;vector&lt;/span&gt;  &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;findContours&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;thresholded32&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;CV_RETR_LIST&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CV_CHAIN_APPROX_SIMPLE&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;Rect&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevb&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;areaprev&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;double&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;area2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;q&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;contours2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
         &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
             &lt;span class=&quot;n&quot;&gt;Rect&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bnd&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;boundingRect&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;contours2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]);&lt;/span&gt;
             &lt;span class=&quot;n&quot;&gt;area2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bnd&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;height&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bnd&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;width&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
               &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;area2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;areaprev&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
              &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
                       &lt;span class=&quot;n&quot;&gt;prevb&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bnd&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
                       &lt;span class=&quot;n&quot;&gt;areaprev&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;area2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
                       &lt;span class=&quot;n&quot;&gt;q&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
               &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
           &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;Rect&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;rec&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;prevb&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;regionOfInterest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;smallt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;](&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;rec&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;resize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;regionOfInterest&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;img12&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;INTER_NEAREST&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;h3 id=&quot;the-results-is-as-follows&quot;&gt;The results is as follows:&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/assets/sudoku-solver/image5.png&quot; alt=&quot;image&quot; /&gt;
&lt;img src=&quot;/assets/sudoku-solver/image6.png&quot; alt=&quot;image&quot; /&gt;
&lt;img src=&quot;/assets/sudoku-solver/image7.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now we have all the digits centered what we now need to do is apply OCR . There are huge number of techniques for implementing OCR and huge number of pattern recognition algorithm and for my implementation i choose K-Nearest Neighbour algorithm as it is already available in OpenCV library.The algorithm caches all training samples and predicts responses for new sample by analyzing a certain number of the nearest neighbour of the sample using voting and calculated mean. For it you need to create sample data and train those images and recognise digits from previously trained data. I created training samples by collecting images from various sudoku .My training data can be found out on this &lt;a href=&quot;https://drive.google.com/open?id=0ByDK_y_Ss5KbSFJkU19fSG15QXc&quot;&gt;link&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;This is the code for training the data :&lt;/strong&gt;&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c--&quot; data-lang=&quot;c++&quot;&gt;      &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;num&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;797&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;size&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;*&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;trainData&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;num&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;CV_32FC1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
      &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;responces&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;num&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;CV_32FC1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
      &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;counter&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
      &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;9&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
      &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// reading the images from the folder of tarining sample
&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;DIR&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dir&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;struct&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dirent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ent&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;char&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pathToImages&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[]&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;./digits3&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// name of the folder containing images;
&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;char&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;path&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;sprintf&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;path&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;%s/%d&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;pathToImages&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dir&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;opendir&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;path&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;!=&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;NULL&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
          &lt;span class=&quot;k&quot;&gt;while&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;readdir&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dir&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;!=&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;NULL&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
          &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;strcmp&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;d_name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;.&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;!=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;strcmp&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;d_name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;..&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;!=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
            &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
              &lt;span class=&quot;kt&quot;&gt;char&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;sprintf&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;/%s&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&amp;gt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;d_name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;digit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;digit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;path&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;digit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;Mat&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;imread&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;digit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//loading the image
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;cvtColor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CV_BGR2GRAY&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;  &lt;span class=&quot;c1&quot;&gt;//converting into grayscale
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;threshold&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;200&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;THRESH_OTSU&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// preprocessing
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;convertTo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CV_32FC1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;1.0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;255.0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//necessary to convert images to CV_32FC1 for using K nearest neighbour algorithm.
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;resize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;16&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;),&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;INTER_NEAREST&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// same size as our testing samples
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;reshape&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
              &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; 
              &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; 
               &lt;span class=&quot;n&quot;&gt;trainData&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;at&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;counter&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;*&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;at&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// storing the pixels of the image
&lt;/span&gt;
              &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;responces&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;at&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;counter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// stroing the responce corresponding to image
&lt;/span&gt;
              &lt;span class=&quot;n&quot;&gt;counter&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
             &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
            &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;closedir&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dir&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;KNearest&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;knearest&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;trainData&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;responces&lt;/span&gt;  &lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;knearest&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;train&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;trainData&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;responces&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;This trains the data and to recognise the number we use the find_nearest of the KNearest class in OpenCV library.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;     &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
     &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
     &lt;span class=&quot;n&quot;&gt;img123&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;at&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;img12&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;at&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;k&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// storing the pixels value of testing sample into a new mat for testing
&lt;/span&gt;
     &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
     &lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;p&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;knearest&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;find_nearest&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;img123&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;reshape&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;The accuracy of this method is upto 90% . So to increase the accuracy you may increase number of the training samples but it may not give very good results ,so to improve the accuracy try out other algorithms available which are more accurate.&lt;/p&gt;

&lt;p&gt;Although,I did not get 100% correct results but anyways it was overall a great learning experience.&lt;/p&gt;

&lt;p&gt;The whole source code can be found &lt;a href=&quot;https://drive.google.com/open?id=0ByDK_y_Ss5KbS2xtQ0pEOGxkV1E&quot;&gt;here&lt;/a&gt;.&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Switched Mode Power Supply Technology</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/07/smps/"/>
   <updated>2016-07-31T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/07/smps</id>
   <content type="html">&lt;p&gt;Switched Mode Power Supply or SMPS is an electronic power supply that incorporates a switching regulator to convert electrical power efficiently. Like other power supplies, an SMPS transfers power from a source, like mains power, to a load, such as a PC, while converting voltage and current characteristics. A typical SMPS is seen down here :&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;img src=&quot;/assets/smps/image1.png&quot; alt=&quot;image&quot; /&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;h2 id=&quot;circuit-diagram&quot;&gt;Circuit Diagram&lt;/h2&gt;

&lt;p&gt;&lt;img src=&quot;/assets/smps/image_2.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The components F1 and F2 are referred to as Fuse.&lt;/em&gt;&lt;/p&gt;

&lt;h2 id=&quot;the-components-of-smps&quot;&gt;The components of SMPS&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;EMI Filter :&lt;/strong&gt; The low-pass EMI filter is designed to reduce to an acceptable level high frequency currents getting back into the AC line. This is necessary to prevent interference on the other devices connected to the same electrical wiring. This is to comply some of the safety regulations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Rectifier Bridge :&lt;/strong&gt; It converts bipolar waveforms into unipolar pulsating ones. It has four diodes in a bridge arrangement to provide the same polarity of the output for both polarities of the input.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PFC Regulator :&lt;/strong&gt; The Power Factor (PF) of rectified input voltage is increased in this part of the circuit. The ratio of the actual electrical power dissipated by an AC circuit to the product of the r.m.s. values of current and voltage is called Power Factor.. The difference between the two is caused by reactance in the circuit and represents power that does no useful work.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;DC-DC Converter :&lt;/strong&gt; It is used to generate DC outputs from the PFC outputs.&lt;/p&gt;

&lt;h3 id=&quot;specifications-to-know-before-choosing-smps&quot;&gt;Specifications to know before choosing SMPS&lt;/h3&gt;

&lt;p&gt;Different SMPSs have different power ratings, different voltage outputs and thus different current ratings. It is thus important to decide upon these factors before choosing the SMPS of your choices.&lt;/p&gt;

&lt;h2 id=&quot;real-life-applications&quot;&gt;Real life applications&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Some of the places where SMPS can be found are as follows:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When we use an adapter-looking thing to power Arduino, it converts 220V supply to a 12V supply required to power the Arduino. This is achieved by the SMPS present inside the black part of the adapter.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/smps/image_3.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The black box looking thing attached to a laptop charger is actually an SMPS to convert the input to an output DC Voltage to charge the battery.&lt;/p&gt;

&lt;h3 id=&quot;how-to-use-it-with-arduino&quot;&gt;How to use it with Arduino&lt;/h3&gt;

&lt;p&gt;Suppose we need to power a device which works at a higher voltage and power supply than an arduino can provide, we can use an SMPS to power the circuit. But if we want to control the turning on and off of the device using arduino we might face a problem in this case. In this case a relay will work the best as relay can be used to control a higher rated circuit using Arduino’s lower rated circuit.&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Pulse Detection Circuit</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/07/pulse-detection-circuit/"/>
   <updated>2016-07-01T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/07/pulse-detection-circuit</id>
   <content type="html">&lt;p&gt;In my ITSP, our aim was to make a polygraph machine for which we needed to monitor pulse of the examinee continuously over time. So here is what we did.&lt;/p&gt;

&lt;h3 id=&quot;required-components&quot;&gt;Required Components&lt;/h3&gt;

&lt;p&gt;IC LM324 (quad op-amp), 
IR LED, 
IR Sensor, 
A red LED, 
Resistors, 
Capacitors.&lt;/p&gt;

&lt;p&gt;The technique used is called Photoplethysmography (PPG).
There is an IR LED whose light is reflected by the skin and received by an IR sensor. The changes in volume of blood over the time changes the amount of reflection which is detected by the IR sensor and it is amazing how we can filter and amplify to get the pulse in desired range.&lt;/p&gt;

&lt;h3 id=&quot;basic-idea&quot;&gt;Basic Idea&lt;/h3&gt;

&lt;p&gt;There are two types of unwanted voltage signals in the signal received from input: the constant DC voltage and the noise from surroundings. For removing the DC voltage, there is (passive) high pass RC filter with 0.7Hz as cut off frequency. To remove the noise, there is (active) low pass op-amp filter with 2.3Hz as cut off frequency and gain of nearly 100.&lt;/p&gt;

&lt;h4 id=&quot;here-is-the-final-circuit-i-used&quot;&gt;Here is the final circuit I used:&lt;/h4&gt;

&lt;p&gt;&lt;img src=&quot;/assets/pulse-detection-circuit/image01.jpg&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;h3 id=&quot;what-modifications-were-needed-in-the-basic-model&quot;&gt;What modifications were needed in the basic model?&lt;/h3&gt;

&lt;p&gt;So in this module, there is, in net effect, a band pass filter that allows 0.7Hz to 2.3Hz and amplifies the signal by 100. But this provides neither sufficient filtering nor sufficient amplification. To further filter and amplify the signal, the signal from first module is fed to an exact duplicate module containing passive high pass filter and active low pass filter. 
After this, amplification is nearly 10,000 and signal has frequency component only between 0.7Hz and 2.3Hz.&lt;/p&gt;

&lt;h4 id=&quot;further-amplification&quot;&gt;Further Amplification:&lt;/h4&gt;

&lt;p&gt;One can now see a pulse with little effort but only with amplitude of around 0.5V. So the signal is further fed to an op-amp with gain of 10.
This output can be fed to a red LED (voltage controlled by resistor) or analog pin of a microcontroller or DSO to observe the pulse clearly.&lt;/p&gt;

&lt;h4 id=&quot;have-a-look-at-the-working-video-here&quot;&gt;Have a look at the working video here:&lt;/h4&gt;

&lt;iframe width=&quot;420&quot; height=&quot;315&quot; src=&quot;https://www.youtube.com/embed/kgVUFpzo6lg&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;&quot;&gt;&lt;/iframe&gt;
&lt;p&gt;On placing our finger on the IR LED/IR Sensor, we accurately get the pulse.&lt;/p&gt;

&lt;p&gt;It is amazing how, using such a specific property of light reflection and fluctuating blood volumes, we can design a very basic electronic circuit to return our pulse!&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Using Eagle to design PCBs</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/06/using-eagle-to-design-pcbs/"/>
   <updated>2016-06-06T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/06/using-eagle-to-design-pcbs</id>
   <content type="html">&lt;p&gt;&lt;strong&gt;Why PCB Designing?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We often come across two scenarios where we need PCB designing.
Sometimes we need to fix a medium/large sized circuit with various
components into a smaller and more compact form. And sometimes we need
to use a specific circuit more number of times. In such cases, making a
Printed Circuit Board of the required circuit is very useful.&lt;/p&gt;

&lt;p&gt;Have a look:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/using-eagle-to-design-pcbs/image03.jpg&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is Eagle?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Eagle is a PCB Designing Software where you can use custom libraries for
using a variety of elements, from common Resistors, Capacitors etc to
specific ICs, Microcontrollers. It lets you add the elements you want,
design the circuit and the choose the physical connections the way you
want on your PCB.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Details Of Commands and usages in making the SCHEMATIC&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;There are basically two parts of our development in Eagle. First, the
Schematic, that shows all the connections(but not the way you physically
want on the PCB). Secondly, forming final connections and arranging them
in the final physical way we want.&lt;/p&gt;

&lt;p&gt;So, in the session, we decided to make a IC 555 circuit.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/using-eagle-to-design-pcbs/image01.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;h3 id=&quot;we-will-go-through-the-following-procedure&quot;&gt;We will go through the following procedure:&lt;/h3&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Making the Schematic&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Designing the physical connections&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Let us move on to using the software and its commands.&lt;/p&gt;

&lt;h3 id=&quot;1-making-the-schematic&quot;&gt;1. Making the Schematic&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;add:&lt;/strong&gt; Used to add any component. Type in the command bar on top&lt;/li&gt;
  &lt;li&gt;After performing add, lots of components will appear.
Type keywords to search components. Eg. &lt;strong&gt;RCL&lt;/strong&gt; in search box to find
Resistor, Capacitor, Inductor.(Take US Package for resistor.) (uF ==
Polarised, nF == ceramic)&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;For NE555N&lt;/strong&gt; type:&lt;strong&gt;add&lt;/strong&gt; on terminal&amp;gt; search &lt;strong&gt;timer&lt;/strong&gt; &amp;gt;
Find 555. Double click&amp;gt;Paste.&lt;/li&gt;
  &lt;li&gt;Note:- Whenever &lt;strong&gt;IC&lt;/strong&gt; not found, Google the &lt;strong&gt;.lbr&lt;/strong&gt; file for that
IC and copy paste in Eagle list.&lt;/li&gt;
  &lt;li&gt;Use Escape to go back to menu.&lt;/li&gt;
  &lt;li&gt;For our 555 circuit, we will take a &lt;strong&gt;5mm LED&lt;/strong&gt; for Output&lt;/li&gt;
  &lt;li&gt;Type &lt;strong&gt;Supply&lt;/strong&gt; in search bar to get 5V and Ground&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;move:&lt;/strong&gt; to move a component&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;net:&lt;/strong&gt; make connections. Net adds connection and side by side
makes a file(which denotes that there must be a physical
connection made for this pair in the second part of our designing)
too.&lt;/li&gt;
  &lt;li&gt;Make end to end connections and use &lt;strong&gt;name command&lt;/strong&gt; to name the
wires/components differently so as to differentiate
between connections.&lt;/li&gt;
  &lt;li&gt;Giving values&lt;strong&gt;:&lt;/strong&gt; Use &lt;strong&gt;value&lt;/strong&gt; command and then click on component
to enter value.&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Smash command:&lt;/strong&gt; to move around names.(Disassemble components to
move individually)&lt;/li&gt;
  &lt;li&gt;Search &lt;strong&gt;Pin Head&lt;/strong&gt; for Berg Pins!&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Right click&lt;/strong&gt; a component to rotate&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Delete&lt;/strong&gt; command and select the “plus” sign (appearing at centre
of component on zooming) denoting the component to delete it.&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Label&lt;/strong&gt; command to show the labels.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You are expected to be done with the schematic using these commands.&lt;/p&gt;

&lt;p&gt;Now Type &lt;strong&gt;Board&lt;/strong&gt; command and click Yes option to go to the next part.&lt;/p&gt;

&lt;h3 id=&quot;2-making-the-physical-connections&quot;&gt;2. Making the Physical Connections&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;Air Line&lt;/strong&gt;: denotes a connection that must be made(shows that
these two points ought to be physically connected).&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Tools&amp;gt;Ratnest:&lt;/strong&gt;Simplifies air wire connections(because the
connections change with the physical positions of components and
so, they can also overlap)&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Change package&lt;/strong&gt;: helps to change the &lt;strong&gt;type&lt;/strong&gt; of component.&lt;/li&gt;
  &lt;li&gt;Note: - If you made wrong connections and want to change a
component, do it in the schematic file (part 1) and not here.&lt;/li&gt;
  &lt;li&gt;Menu&amp;gt;Autorouter is used to find the possible physical routing by
eagle’s own algorithm. It will return certain best possibilities,
based on certain criteria.(Note:- Menu&amp;gt;Autorouter&amp;gt;Uncheck
Continuous Option while auto routing again). In case of &lt;strong&gt;Single
Layer PCBs&lt;/strong&gt;(we mostly have only single layered ones):Top is
Not Applicable.&lt;/li&gt;
  &lt;li&gt;We can do manual routing by &lt;strong&gt;Route Command.&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Width&lt;/strong&gt; of the connection is given in Inches, around 0.024 inches
is a preferred width(it shouldn’t be very small because not many
printing facilities may have that accuracy).&lt;/li&gt;
  &lt;li&gt;Change &lt;strong&gt;track shape&lt;/strong&gt; by &lt;strong&gt;Right click&lt;/strong&gt;(Avoid using right angles
because of some&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Ripoff&lt;/strong&gt; command changes a physical connection back to just an
air wire.&lt;/li&gt;
  &lt;li&gt;It might be useful to create a common ground/power line around the
PCB, it sometimes simplifies the complexity of connections.&lt;/li&gt;
  &lt;li&gt;Make sure to Save the file in the same folder as the project.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;to-make-final-output-files-for-gerbv&quot;&gt;To make final output files for Gerbv:&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;File &amp;gt; Cam Processor.&lt;/li&gt;
  &lt;li&gt;File &amp;gt; Open &amp;gt; Job == gerb274x.cam&lt;/li&gt;
  &lt;li&gt;Process Job In bottom&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;to-see-the-final-files-in-gerbv&quot;&gt;To see the final files in Gerbv:&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;Open the files with following extensions &lt;code class=&quot;highlighter-rouge&quot;&gt;.brd, .cmp, .plc, .sol, .stc, .sts&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;Using the &lt;strong&gt;text&lt;/strong&gt; command, you can write text anywhere. Use it for
specifying stuff to make circuit connection and component
placement easier. Add these names for reference by choosing layer
&lt;strong&gt;tNames&lt;/strong&gt; and adding text.&lt;/li&gt;
  &lt;li&gt;Change board size using &lt;strong&gt;move command&lt;/strong&gt; and moving the boundaries.&lt;/li&gt;
&lt;/ul&gt;
</content>
 </entry>
 
 <entry>
   <title>Path Finder Bot</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/path-finder-bot/"/>
   <updated>2016-05-30T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/path-finder-bot</id>
   <content type="html">&lt;p&gt;Okay, so my roomie cum best friend Mohit Kherwa wanted to build a bot which 
would crash land into some unknown location on Mars but still find its way to
the human base station. Since we were not getting a bot to Mars anytime soon, 
I suggested we build one that finds its way from our room to the next. And so 
we did. With help from wingies Shikhar Kothari and Harsh Meena.&lt;/p&gt;

&lt;h4 id=&quot;what-went-inside&quot;&gt;What went inside&lt;/h4&gt;

&lt;p&gt;We fixed IR sensors on the front and to the left. To measure the speed or the 
distance covered, we made white patches on the inside surface of the black wheel. 
Around 10 of them. There was an IR sensor pointed at the wheel. Essentially, we 
were receiving a square wave as input from the sensor. Measure the frequency, and 
voila, you have the bot’s speed! (We learnt later that this is the principle behind 
a tachometer.) The bot had three wheels, one freely rotating in the front(castor 
wheel), and two motors (standard 2W) with the rear two, for differential mechanism. 
And an Arduino, motor driver shield and a 12V battery. Well, so much for the hardware.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/path-finder-bot/image00.jpg&quot; alt=&quot;bot image 1&quot; /&gt;
&lt;img src=&quot;/assets/path-finder-bot/image01.jpg&quot; alt=&quot;bot image 2&quot; /&gt;
&lt;img src=&quot;/assets/path-finder-bot/image02.jpg&quot; alt=&quot;bot image 3&quot; /&gt;&lt;/p&gt;

&lt;h4 id=&quot;the-algorithm&quot;&gt;The Algorithm&lt;/h4&gt;

&lt;p&gt;The bot’s initial position was set to origin and thus it marked the coordinate system. 
Y axis was in the forward direction, and x to the right. We planned to put up an LCD 
display and buttons on the bot to enter the final coordinates. The coordinates of the 
destination was hard coded into the bot during testing. They were stored in variables 
x and y.&lt;/p&gt;

&lt;p&gt;Here’s the logic which we adopted in our arduino code:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;If y&amp;lt;0
Turn 180 degree. Change the sign of x and y. (This step is to make sure that the 
final position is always ahead of the bot.)
Else
Go to step 2.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;Move forward and decrease y accordingly until (y is decreased because the destination 
is getting closer)
    &lt;ol&gt;
      &lt;li&gt;y=0;
&lt;br /&gt;if x=0 as well,
Terminate the program. The bot has reached its destination.
Else go to step 5.&lt;/li&gt;
      &lt;li&gt;There is some obstacle ahead. (i.e, Front IR sensor goes off)
&lt;br /&gt;Go to Step 3.&lt;/li&gt;
    &lt;/ol&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Turn Right. Move forward and decrease x accordingly as long as the left IR sensor gives 
a high. Go to Step 4.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Turn Left. Go to Step 2.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;If x&amp;lt;0, turn left, set y= -x and x=0. 
&lt;br /&gt;Go to step 2. 
&lt;br /&gt;(The bot just rotated the coordinate system by 90 degree and started all over again)
&lt;br /&gt;If x&amp;gt;0, turn right, set y= x and x=0. 
&lt;br /&gt;Go to step 2.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;You can find the code &lt;a href=&quot;https://github.com/thariq-shanavas/Path-Finder-Bot&quot;&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;h3 id=&quot;sounds-straightforward-but&quot;&gt;Sounds straightforward, but…&lt;/h3&gt;

&lt;p&gt;The first real difficulty was the wheels slipping on the ground. This was sorted out by using rubberised wheels and bringing down the RPM of the motors by lowering the duty cycle of the PWM output to the motors.&lt;/p&gt;

&lt;p&gt;The second more serious difficulty was that due to manufacturing tolerances, the motors were not identical. Even when the same PWM signal was given to both motors, one tended to go slightly faster and this sometimes led to large cumulative error. We only had an IR sensor on one wheel, so only that wheel’s angular velocity could be measured.&lt;/p&gt;

&lt;p&gt;We tried to correct this error calibrating the duty cycle of the PWM signal to the motors but unfortunately this calibration was dependent on battery voltage- when the battery voltage dropped by half a volt, the bot had to be recalibrated. Then we tried adding an IR sensor to the other wheel and add a feedback system for self-calibration, but the Arduino was not fast enough to collect that much data and process it- angular frequencies of the wheels were wrongly calculated and the bot went haywire. The proposed workaround was to use stepper motors, but then we never got around to implementing it- this was done in the few days following the endsems and all of us had to go home by that time.&lt;/p&gt;

&lt;p&gt;The error was never great enough to defeat the purpose of the bot - the bot usually reached its target with a tolerance of a few centimeters. The error was noticeable only when the battery was heavily drained.&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Fundamentals of a SLAM Algorithm</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/fundamentals-of-a-slam-algorithm/"/>
   <updated>2016-05-30T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/fundamentals-of-a-slam-algorithm</id>
   <content type="html">&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;

&lt;p&gt;The term SLAM is as stated an acronym for &lt;strong&gt;Simultaneous Localization And Mapping&lt;/strong&gt;. Mapping is all about building maps of the environment. There are a number of different methods for building maps and some of them are quite sophisticated. All these methods have in common that they build a model of the environment while also addressing the fact that the robot itself accrues uncertainty while it moves.&lt;/p&gt;

&lt;h2 id=&quot;steps-involved-in-slam-algorithms&quot;&gt;Steps involved in SLAM Algorithms&lt;/h2&gt;
&lt;p&gt;The various algorithm consists of multiple parts; Landmark extraction, data association, state estimation, state update and landmark update. This post will explain what happens in each step. There are many different algorithms to accomplish each of these steps and one can follow any one of the methods. The fundamentals of each algorithm is what this post will explain.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;&lt;em&gt;Landmark Extraction&lt;/em&gt;&lt;/strong&gt;:&lt;br /&gt;
&lt;img src=&quot;/assets/fundamentals-of-a-slam-algorithm/image_2.jpg&quot; alt=&quot;Landmark-Extraction&quot; /&gt;&lt;br /&gt;
Landmarks are distinct, salient features like blobs or corners within an image/frame. Salient features in computer vision are an art in itself. There are dozens of different approaches to extract, describe and match such features. Once extracted they help the robot keep track of where it is by measuring its position relative to the landmark. Landmarks act as memory and helps the robot identify whether it has visited a certain place in the past or not. This leads us to the next part.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;&lt;em&gt;Data association&lt;/em&gt;&lt;/strong&gt;:&lt;br /&gt;
&lt;img src=&quot;/assets/fundamentals-of-a-slam-algorithm/image_3.png&quot; alt=&quot;Data-Association&quot; /&gt;&lt;br /&gt;
The problem of data association is that of matching observed landmarks from different (laser) scans with each other. We have to accurately tell whether we have seen a landmark or if it’s a new landmark. If it’s new we add it to the list of observed landmarks, if it’s old we we can measure the relative position of the robot and then accordingly update the position of the robot as well as the landmark on the map. This brings us to the next logical step.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;strong&gt;&lt;em&gt;State Estimation and State Update&lt;/em&gt;&lt;/strong&gt;:&lt;br /&gt;
Here we try to estimate position of the robot using input from number of sensors. There are two types of sensors, internal and external sensors:&lt;/p&gt;
    &lt;ol&gt;
      &lt;li&gt;Internal sensors - These are sensors that are attached to the robot. They include &lt;strong&gt;accelerometer&lt;/strong&gt;, &lt;strong&gt;gyroscopes&lt;/strong&gt;, &lt;strong&gt;motor encoders&lt;/strong&gt;, &lt;strong&gt;cameras&lt;/strong&gt; which help the robot localize itself without any external interference.&lt;/li&gt;
      &lt;li&gt;External sensors: As the name suggests these the robot gets its input from sources not attached to the robot. It includes navigation systems like &lt;strong&gt;GPS&lt;/strong&gt;, &lt;strong&gt;electric beacons&lt;/strong&gt; etc.&lt;/li&gt;
    &lt;/ol&gt;

    &lt;p&gt;Using just internal sensors usually gives small amount of error which over time adds up to produce significant errors. This is why we also employ the use of external sensors to facilitate internal sensors. 
We update the estimated state using sensor data. Using observed landmarks we calculate what should have been our position. Usually there is some difference between the estimated state and the calculated state, this is called the &lt;strong&gt;innovation&lt;/strong&gt;.
Finally depending upon how sure are we about the landmarks and the sensor data we update the robot position to be somewhere between estimated state and calculated state.
The flowchart shown below depicts the above process :-&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;img src=&quot;/assets/fundamentals-of-a-slam-algorithm/image_1.jpg&quot; alt=&quot;State-Update&quot; style=&quot;margin-left:37px;&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;&lt;em&gt;Landmark update&lt;/em&gt;&lt;/strong&gt;:&lt;br /&gt; 
When we observe a previously unseen feature we update the list of landmarks to include this new feature. Also when we observe a old landmark, if it appears at the same position as in the previous measurement our confidence in that Landmark is increased. This used to decide if we should trust the sensors more than the landmarks or vice-versa.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;After Landmark update the robot moves and then the whole cycle repeats again. When the robot moves the uncertainty of its position increases. After the cycle not only the robot is confident of its position but has also extracted information about the environment and associated itself with it. In this way the robot not only &lt;strong&gt;maps the environment but also knows where it is in it&lt;/strong&gt;.&lt;/p&gt;

&lt;h2 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/assets/fundamentals-of-a-slam-algorithm/image_0.png&quot; alt=&quot;Application&quot; /&gt;&lt;br /&gt;
The main aim of this post was to familiarize one with the basics of a SLAM Algorithm to the level that he/she is now able to go further, read tutorials from the internet and implement a SLAM based robot. The applications of this technology are infinite. It is the key to &lt;strong&gt;self-driving cars&lt;/strong&gt;, &lt;strong&gt;unmanned aerial vehicles&lt;/strong&gt;, &lt;strong&gt;autonomous underwater vehicles&lt;/strong&gt;, &lt;strong&gt;planetary rovers&lt;/strong&gt;, &lt;strong&gt;newly emerging domestic robots&lt;/strong&gt; and even &lt;strong&gt;robots inside the human body&lt;/strong&gt;. It is a big and active research field with many unsolved problems.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;em&gt;Hope you had a good time reading this blog and were able to learn something new!!&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Deep Learning Based Image Classification</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/deep-learning-based-image-classification/"/>
   <updated>2016-05-20T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/deep-learning-based-image-classification</id>
   <content type="html">&lt;h4 id=&quot;pre-requisites&quot;&gt;Pre-requisites&lt;/h4&gt;

&lt;p&gt;Idea about Artificial Neural Networks, good if you
have familiarity with the ideas of supervised learning, logistic
regression, gradient descent, SVM-based classification, k-means
clustering, kernel tricks like KPCA, etc.&lt;/p&gt;

&lt;h4 id=&quot;motivation&quot;&gt;Motivation&lt;/h4&gt;

&lt;p&gt;Deep neural networks (DNNs) trained via backpropagation
were recently shown to perform well on image classification tasks with
lakhs of training images and lot of categories. The feature
representation learned by these networks achieves state-of-the-art
performance not only on the classification task for which the network
was trained, but also on various other visual recognition tasks, for
example: classification on various dataset; scene recognition, etc. This
capability to generalize to new datasets makes supervised CNN
(Convolutional Neural Networks) training an attractive approach for
generic visual feature learning.&lt;/p&gt;

&lt;h3 id=&quot;what-is-deep-learning--what-makes-it-deep1&quot;&gt;What is Deep Learning / What makes it “deep”&lt;a href=&quot;http://www.nvidia.com/content/events/geoInt2015/LBrown_DL_Image_ClassificationGEOINT.pdf&quot;&gt;&lt;sup&gt;1&lt;/sup&gt;&lt;/a&gt;?&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/assets/deep-learning-based-image-classification/image02.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;1 million parameters&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;10 mil images&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;10 layers!!&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That’s what makes it “deep”!&lt;/p&gt;

&lt;p&gt;Deep learning methods aim at learning feature hierarchies with features
from higher levels of the hierarchy formed by the composition of lower
level features. For image classification tasks, the most effective deep
networks used nowadays are the Convolutional Neural Networks (others
include corrNets, restricted Boltzmann machines, Recurrent Neural
Networks, etc.).&lt;/p&gt;

&lt;h3 id=&quot;image-classification-with-cnns&quot;&gt;Image Classification with CNNs&lt;/h3&gt;

&lt;p&gt;Each CNN has its own architecture - convolution layers, pooling layers
(max pooling, weighted mean pooling, etc), fully connected layers et al.&lt;/p&gt;

&lt;p&gt;Three methods of training using a Conv Net:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Supervised&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Unsupervised&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Reinforcement&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;img src=&quot;/assets/deep-learning-based-image-classification/image05.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The most common method is to learn the network using a huge set of
training images. This approach is called the supervised learning of the
network. To learn the network implied learning the filters in the
convolution layer (filters are also called weights)&lt;/p&gt;

&lt;p&gt;It involves 2 phases - &lt;em&gt;Training&lt;/em&gt; run and a accuracy &lt;em&gt;testing&lt;/em&gt; run&lt;/p&gt;

&lt;p&gt;1) &lt;strong&gt;Training run:&lt;/strong&gt; Pick a CNN architecture -&amp;gt; Input a million
training images spanning all categories -&amp;gt; One or days of GPU
computation&lt;/p&gt;

&lt;p&gt;2) &lt;strong&gt;Accuracy testing:&lt;/strong&gt; If the accuracy is bad, fix the training set,
tweak the training parameters -&amp;gt; do it again&lt;/p&gt;

&lt;p&gt;CNN learnt with supervised learning give a high accuracy for
classification tasks and the same network can be used for other tasks
too, like scene detection.&lt;/p&gt;

&lt;h3 id=&quot;introduction-of-discriminative-unsupervised-learning-in-neural-networks&quot;&gt;Introduction of discriminative Unsupervised learning in Neural Networks&lt;/h3&gt;

&lt;p&gt;The downside of supervised training is the need for expensive labeling,
as the amount of required labeled samples grows quickly the larger the
model gets. For this reason, unsupervised learning remains an appealing
paradigm, since it can make use of raw unlabeled images and videos.
Furthermore, on vision tasks outside classification it is not even
certain whether training based on object class labels is advantageous.
For example, recent results show that it outperforms supervised feature
learning also on descriptor matching.&lt;/p&gt;

&lt;p&gt;In Unsupervised learning, the filter (or weights) are not learnt
directly from the training images. Sometimes, a predefined set of
filters is chosen - best example being the Gabor filters - or the
filters are extracted from the images ‘patches’ with some processing
done on them.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/deep-learning-based-image-classification/image04.png&quot; alt=&quot;image&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;fig: MNIST dataset classification using k-means clustering&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A common framework used in unsupervised feature learning is &lt;a href=&quot;http://ai.stanford.edu/~ang/papers/aistats11-AnalysisSingleLayerUnsupervisedFeatureLearning.pdf&quot;&gt;&lt;sup&gt;2&lt;/sup&gt;&lt;/a&gt; :&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Extract random patches from unlabeled training images.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Apply a pre-processing stage to the patches.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Learn a feature-mapping using an unsupervised learning algorithm.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Given the learned feature mapping and a set of labeled training images
we can then perform feature extraction and classification:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Extract features from equally spaced sub-patches covering the
input image.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Pool features together over regions of the input image to reduce the
number of feature values.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Train a classifier to predict the labels given the feature vectors.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h3&gt;

&lt;p&gt;Image classification results can be hugely increased using some
preprocessing (can be anything depending on the application). It is
common practice to perform several simple normalization steps before
attempting to generate features from data. In Unsupervised feature
extraction, there are also some tricks like the &lt;em&gt;‘kernel trick’&lt;/em&gt; which
can improve the classification results.&lt;/p&gt;

&lt;p&gt;The feature vector length can always be reduced using some fully
connected layers in the network. This can help speed-up the
classification, but must be used carefully as to not compromise the
accuracy. Much future work is going on in the direction of using
unsupervised or semi-supervised neural networks, since as of now they
are not very scalable.&lt;/p&gt;

&lt;p&gt;Deep learning, CNNs, corrNets, etc are THE most active fields in data
analytics. And I believe can be learnt only through experimentation! So
feel free to explore this ocean of deep learning! Enjoy!&lt;/p&gt;

&lt;p&gt;Regards,&lt;/p&gt;

&lt;p&gt;Yash Bhalgat.&lt;/p&gt;

&lt;p&gt;[1]: &lt;a href=&quot;http://www.nvidia.com/content/events/geoInt2015/LBrown_DL_Image_ClassificationGEOINT.pdf&quot;&gt;deep learning for image classification - Nvidia. 2015. 15 May.&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;[2]: &lt;a href=&quot;http://ai.stanford.edu/~ang/papers/aistats11-AnalysisSingleLayerUnsupervisedFeatureLearning.pdf&quot;&gt;Coates, A. “An Analysis of Single-Layer Networks in Unsupervised Feature Learning.” 2011.&lt;/a&gt;&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>The Making of Burglar Alarm</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/burglar-alarm/"/>
   <updated>2016-05-13T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/burglar-alarm</id>
   <content type="html">&lt;p&gt;In the First semester along with Pranav, I tried to design a burglar alarm circuit that would go off if the burglar tripped over a copper wire. We built a small scale working model of the circuit and presented it in one of the How Things Work Session which is organised by the Robotics Club in association with the Electronics Club of IIT Bombay.&lt;/p&gt;

&lt;p&gt;This how we went about designing and building the circuit.&lt;/p&gt;

&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;

&lt;p&gt;A burglar alarm is basically an intruder alert system used to prevent theft/robbery and protect one’s premises. The circuit that we have built over here can be easily built and understood by anyone who has &lt;strong&gt;enthu!!&lt;/strong&gt; Most of the components will be available at Tinkerer’s Lab so take a good look before buying anything.&lt;/p&gt;

&lt;p&gt;So, Let’s dive in&lt;/p&gt;

&lt;h2 id=&quot;concepts-and-basic-principles&quot;&gt;Concepts and Basic Principles&lt;/h2&gt;
&lt;p&gt;Well, the basic idea is that when someone trips over the copper wire and it snaps the circuit is broken which then triggers an impulse and the speaker starts buzzing.&lt;/p&gt;

&lt;p&gt;How is the impulse triggered?&lt;br /&gt;
Here we make use of &lt;strong&gt;555 timer IC&lt;/strong&gt;. 
The figure shown below shows us the basic circuit.
&lt;br /&gt;
&lt;img src=&quot;/assets/the-making-of-burglar-alarm/image_0.jpg&quot; alt=&quot;Timer-circuit&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;
The main pin which is of interest to us is &lt;strong&gt;PIN 2&lt;/strong&gt; - It turns on the output when the voltage supplied to it drops below 1/3 of Vcc.&lt;/p&gt;

&lt;p&gt;So one can imagine one end of the copper wire being connected to &lt;strong&gt;PIN 2&lt;/strong&gt; and one end of the speaker being connected to &lt;strong&gt;PIN 3&lt;/strong&gt;. The other end of both these entities would obviously be connected to the ground. When the circuit breaks the voltage at &lt;strong&gt;PIN 2&lt;/strong&gt; drops below the threshold which triggers an output at &lt;strong&gt;PIN 3&lt;/strong&gt; due to which the speaker starts buzzing.&lt;/p&gt;

&lt;p&gt;The only question now remaining is how does the 555 Timer work?&lt;br /&gt;
In this project we operate the 555 timer in &lt;strong&gt;Monostable&lt;/strong&gt; mode.&lt;/p&gt;

&lt;p&gt;And what is &lt;strong&gt;Monostable&lt;/strong&gt; mode?&lt;br /&gt;
This mode works on the principles of Monostable multivibrator. A monostable multivibrator is an electronic circuit that generates an output pulse. When triggered, a pulse of pre-defined duration is produced. The circuit then returns to its quiescent state and produces no more output until triggered again.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;em&gt;And this is exactly what we need!!&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;So now having our concepts on solid foundations we can move on to actually building the circuit!&lt;/p&gt;

&lt;h2 id=&quot;components-required&quot;&gt;Components Required&lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;555 Timer IC&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Speaker&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Copper wire pf appropriate resistance&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Resistance and Capacitors&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;burglar-alarm-circuit-diagram&quot;&gt;Burglar Alarm Circuit Diagram&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/assets/the-making-of-burglar-alarm/image_1.gif&quot; alt=&quot;alarm-circuit&quot; /&gt;&lt;/p&gt;

&lt;h2 id=&quot;build-the-circuit&quot;&gt;Build the Circuit&lt;/h2&gt;
&lt;p&gt;What you need to do is produce the exact replica of the above schematic diagram on your breadboard. In theory this sounds simple but we faced a number of problems and we hope to document all of them down in high hopes that you don’t run into them.&lt;/p&gt;

&lt;p&gt;After making it try detaching one connection of the copper wire. If you’re speaker buzzes &lt;strong&gt;&lt;em&gt;Yayy!!! You’ve done it!&lt;/em&gt;&lt;/strong&gt;. Although the circuit was simple the underlying concepts lay the foundations for a number of complicated projects.&lt;/p&gt;

&lt;h2 id=&quot;problems-faced-by-us&quot;&gt;Problems faced by us&lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;Use the exact values of capacitors and resistances or any other values based on precise calculations as the working of the circuit is greatly dependent on these variables&lt;/li&gt;
  &lt;li&gt;Even the type of copper wire has been specifically chosen and we did run into lot of debugging problems due to this. Just make sure &lt;strong&gt;NOT&lt;/strong&gt; to use the thin copper wire that is available in wires.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;extend-this-project&quot;&gt;Extend this project&lt;/h2&gt;
&lt;p&gt;The concepts we laid down here are the foundations of any burglar alarm systems in general. Burglar alarms or alert systems can be designed in different ways; from very simple sound alarm system (the one we made) to the advanced and feature rich system which will send SMS alerts, activate sound alarm, turn ON lights, turn ON CCTV cameras, close the main gate etc. We hope you can take on the more advanced ones!&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;em&gt;Hope you had a great time reading this and were able to learn something new!!&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;

</content>
 </entry>
 
 <entry>
   <title>Game Of Pong</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/game-of-pong/"/>
   <updated>2016-05-08T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/game-of-pong</id>
   <content type="html">&lt;p&gt;What is the best time for lukha? After the mid-sem or end-sem
examinations. I and my friends, Dhrumil and Manas wanted to have some
fun with the arduino, so we decided to make some game using it. After a
long discussion, we chose to make the classic arcade game ‘ PONG ‘.&lt;/p&gt;

&lt;p&gt;The first thing we had to do was build a screen to play the game. So, we
chose to make a 7*5 LED array(matrix) for our screen.&lt;/p&gt;

&lt;p&gt;The Circuit Diagram for the Screen :&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/game-of-pong/image08.gif&quot; alt=&quot;LED Array&quot; /&gt;&lt;/p&gt;

&lt;p&gt;To check whether the LED matrix was working properly, we tried to make a
scrolling LED display(Like the one in a Railway Station).&lt;/p&gt;

&lt;p&gt;It was after we did this that we realized a major flaw in the circuit
design of the above LED matrix.&lt;/p&gt;

&lt;p&gt;Suppose we want to on the LED ROW 3 and COL 3, and LED ROW 4 COL 4, we
will ground COL 3 and COL 4 and give HIGH to ROW 3 and ROW 4. But in
this process, the LED’s in ROW 3 COL 4 and COL 3 ROW 4 will also light
up as they have received the power supply as well.&lt;/p&gt;

&lt;p&gt;In fact, if we try to light up all the diagonal LED’s in a square
matrix, the whole matrix will light up because we are effectively
powering up the whole matrix.&lt;/p&gt;

&lt;p&gt;So, because of this glitch, we were forced to temporarily give up on
this idea.&lt;/p&gt;

&lt;p&gt;Another thing we could have done was power up each LED individually,
that is control each LED individually. But, this would need 35 pins on
the arduino, and the arduino does not have that many pins. So, we had to
either use an Arduino Mega board with more pins, or we would have to
come up with some other idea. So while coming up with alternatives, we
came across an IC called a ‘Shift Register’. What it basically does is
allow us to control as many LED’s as we want using only 3 pins of the
arduino board. So, we modified our circuit and connected each LED
individually using the shift registers. This way, we were able to
control each LED individually.&lt;/p&gt;

&lt;p&gt;Overall, it was an excellent learning experience for all of us, as we
learnt a lot, mainly how to debug such circuits, and, we also learned
how to use shift registers in circuits.&lt;/p&gt;

&lt;h3 id=&quot;how-shift-registers-work&quot;&gt;How Shift Registers Work&lt;/h3&gt;

&lt;p&gt;Learning such an amazing and useful device such as a shift register has
been a wonderful experience in itself. Controlling how many ever outputs
you want using only 3 pins of the arduino is something very useful for
folks who are short of pins(like us).&lt;/p&gt;

&lt;p&gt;A Shift Register is basically a cascade of flip-flops in which the
output of one flip-flop is connected to the input of the next one.&lt;/p&gt;

&lt;h4 id=&quot;pin-layout-and-function-table--ic-is-74hc595&quot;&gt;Pin Layout and Function Table : (IC is 74HC595)&lt;/h4&gt;

&lt;p&gt;&lt;img src=&quot;/assets/game-of-pong/image04.png&quot; alt=&quot;IC Connections 1&quot; /&gt;
&lt;img src=&quot;/assets/game-of-pong/image09.png&quot; alt=&quot;IC Connections 2&quot; /&gt;&lt;/p&gt;

&lt;h4 id=&quot;circuit-diagram-&quot;&gt;Circuit Diagram :&lt;/h4&gt;

&lt;p&gt;&lt;img src=&quot;/assets/game-of-pong/image02.png&quot; alt=&quot;Update Circuit&quot; /&gt;&lt;/p&gt;

&lt;h4 id=&quot;arduino-connection-diagram-&quot;&gt;Arduino Connection Diagram :&lt;/h4&gt;

&lt;p&gt;&lt;img src=&quot;/assets/game-of-pong/image06.png&quot; alt=&quot;Arduino Connections&quot; /&gt;&lt;/p&gt;

&lt;h4 id=&quot;this-is-how-the-ic-works-&quot;&gt;This is how the IC works :&lt;/h4&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;We have three main pins, STCP(Latch), DS(Data), SHCP(Clock). We
transfer the data to the first pin of the shift register. The
value of the bit transferred is the same as the input given to
the data(DS) pin , if the DS pin is high, a high(1) bit is
transferred to the first pin, whereas if the DS pin is LOW,
a low(0) bit is transferred.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Now, the next thing we have to do is shift this bit to the
next register. This is achieved by pulsing the clock(SHCP) pin (
Giving it a low to high voltage transition ). Thus, the bit which
is stored in one register is shifted to the next one.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Then, we continue pulsing the Clock Pin, until we have set the
required output on all the shift registers.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;After all the data has been stored in the registers, it is time to
put them on their respective output pins. This is achieved by
pulsing the latch(STCP) pin( Giving it a low to high voltage
transition ).&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Using one Shift Register, 8 outputs can be controlled. If we want more
outputs, we have to attach more than one shift registers by connecting
the Serial Out pin of one shift register to the DATA pin of the next
register. Thus, using 5 shift registers, we were able to control 35
LED’s for our game.&lt;/p&gt;

&lt;h3 id=&quot;references&quot;&gt;References:&lt;/h3&gt;

&lt;p&gt;You can refer to the following video to get a clearer understanding of
the working principle of shift registers.&lt;/p&gt;

&lt;p&gt;&lt;a href=&quot;https://www.youtube.com/watch?v=6fVbJbNPrEU&quot;&gt;https://www.youtube.com/watch?v=6fVbJbNPrEU&lt;/a&gt;&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Working of a Digital Light Processing Projector</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/05/working-of-a-dlp-projector/"/>
   <updated>2016-05-03T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/05/working-of-a-dlp-projector</id>
   <content type="html">&lt;p&gt;The Robotics Club in association of The Electronics Club of IIT Bombay conducts regular sessions named “How Things Work?” where we open up a device used in everyday life and try to understand how it works.&lt;/p&gt;

&lt;p&gt;On a particular session we opened up a DLP projector.&lt;/p&gt;

&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;

&lt;p&gt;Digital light processing is a display device based on optical micro-electro-mechanical technology. In simple words, it is the device which is used inside the projectors used for showing films in theatres. It was originally developed in 1987 by Dr.Larry Hornbeck of Texas Instruments. While the DLP imaging device was invented by Texas Instruments, the first DLP-based projector was introduced by Digital Projection Ltd in 1997&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;
&lt;img src=&quot;/assets/working-of-a-dlp-projector/image_0.jpg&quot; alt=&quot;Components&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;h2 id=&quot;components&quot;&gt;Components&lt;/h2&gt;

&lt;p&gt;&lt;img src=&quot;/assets/working-of-a-dlp-projector/image_1.jpg&quot; alt=&quot;diagram&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;Lamp&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Condensing lens&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Colour Filter&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Shaping Lens&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;DMD (digital micromirror device)&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;working-of-the-projector&quot;&gt;Working of the Projector&lt;/h2&gt;

&lt;h4 id=&quot;lamp-&quot;&gt;Lamp :&lt;/h4&gt;
&lt;p&gt;The lamp is generally a Xenon arch lamp which is ignited by a 5000 - 20,000 volt pulse from a current-regulating ballast to initiate an arc between two electrodes in the quartz tube.&lt;/p&gt;

&lt;h4 id=&quot;condensing-lens-&quot;&gt;Condensing Lens :&lt;/h4&gt;
&lt;p&gt;The light passes through the condensing lens which converges light on the colour wheel.&lt;/p&gt;

&lt;h4 id=&quot;colour-wheel-&quot;&gt;Colour Wheel :&lt;/h4&gt;
&lt;p&gt;Now let’s understand what this colour wheel is. You can see in the diagram given above that there is a chip (DMD) which sends light to the screen. All that the chip can do is either send or not send light – making it black-and-white only. To create colour images, projector manufacturers include a colour wheel which rotates in synchronization over the DLP chip. As it rotates between red, blue and green, the DLP chip sends the correct pattern of light. Because the images go on and off the screen so quickly, the brain puts them together into one full-colour image. It gives us a sense of a continuous motion picture going on, a phenomenon known as &lt;a href=&quot;https://en.wikipedia.org/wiki/Persistence_of_vision&quot;&gt;Persistence&lt;/a&gt;.&lt;/p&gt;

&lt;h4 id=&quot;dmd-chip-&quot;&gt;DMD Chip :&lt;/h4&gt;
&lt;p&gt;After passing through colour wheel light falls on the DMD chip. A DMD chip has on its surface several hundred thousand microscopic mirrors arranged in a rectangular array which correspond to the pixels in the image to be displayed. The mirrors can be individually rotated ±10-12°, to an on or off state. In the on state, light from the projector bulb is reflected into the lens making the pixel appear bright on the screen. In the off state, the light is directed elsewhere (usually onto a heatsink), making the pixel appear dark.&lt;/p&gt;

&lt;h2 id=&quot;working-of-the-dmd-chip&quot;&gt;Working of the DMD chip&lt;/h2&gt;

&lt;p&gt;The working mechanisms of a DMD chip is a very interesting combination of application of mechanical, electrical and optical engineering.&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;
&lt;img src=&quot;/assets/working-of-a-dlp-projector/image_2.jpg&quot; alt=&quot;DMD chip&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;
The DMD chip has millions of small mirrors. Before any of the mirrors in the DMD chip switch to their on or off positions, the chip will rapidly decode a bit-streamed image code that enters through the semiconductor. It then converts the data from interlaced to progressive, allowing the picture to fade in. Next, the chip sizes the picture to fit the screen and makes any necessary adjustments to the picture, including brightness, sharpness and colour quality. Finally, it relays all the information to the mirrors, completing the whole process in just 16 microseconds.&lt;/p&gt;

&lt;p&gt;The mirrors are mounted on tiny mechanical hinges that enable them to tilt either toward the light source (ON) or away from it (OFF) up to +/- 12°, and as often as 5,000 times per second. When a mirror is switched on more than off, it creates a light gray pixel. Conversely, if a mirror is off more than on, the pixel will be a dark gray. Now combining this with the colour wheel, we can get all the colours we want. In simple words, the proportion of time the mirror is ON decides the intensity of the color which is sent to it by the color wheel.&lt;/p&gt;

&lt;h4 id=&quot;lens&quot;&gt;Lens&lt;/h4&gt;
&lt;p&gt;Finally all the data (pixels) obtained from the DMD chip is projected on screen after passing the light through a diverging lens and thus we get the desired visual output on the screen.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;NOTE&lt;/strong&gt;: The lens arrangement is made such that light from the lamp is passed through the condenser which focuses the beam on colour wheel and then the same beam has to be de-focussed in order to project it on the screen.&lt;/p&gt;

&lt;p&gt;For getting a better understanding of how a DLP works, you can watch this &lt;a href=&quot;https://youtu.be/CI0cwk25CAs&quot;&gt;YouTube video&lt;/a&gt;&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Getting Started with Beaglebone Black</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/04/getting-started-with-beaglebone-black/"/>
   <updated>2016-04-26T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/04/getting-started-with-beaglebone-black</id>
   <content type="html">&lt;p&gt;&lt;strong&gt;&lt;u&gt;You will need&lt;/u&gt;&lt;/strong&gt; - A BeagleBone Black AM335x (an older version should also do.), a PC (I have used a Linux distribution), Ethernet Cables and Ports &lt;i&gt;and lots of patience.&lt;/i&gt;
&lt;img src=&quot;/assets/getting-started-with-beaglebone-black/bbb.jpg&quot; alt=&quot;The BeagleBone Black&quot; /&gt;
The BeagleBone Black is an embedded development board, just like the &lt;a href=&quot;http://www.raspberrypi.org&quot;&gt;Raspberry Pi&lt;/a&gt;, &lt;a href=&quot;https://www.arduino.cc/en/ArduinoCertified/IntelGalileo&quot;&gt;Intel Galileo&lt;/a&gt; etc. It offers several advantages over the others in the category, and also has its own demerits. We’ll get to that in the end. &lt;br /&gt;
For the specs, the BBB has a 1Ghz ARM Cortex-A8 and 512MB of DDR3 RAM on board - almost as capable as a medium range smartphone. It houses an on-board 8-bit 4GB flash memory which comes preloaded with the &lt;em&gt;Angstrom&lt;/em&gt;. It has a total of 92 pins, of which 66 can be used as GPIO pins. For more specification, you may refer &lt;a href=&quot;http://beagleboard.org/support/bone101&quot;&gt;here&lt;/a&gt;.
&lt;br /&gt;&lt;/p&gt;

&lt;h2 id=&quot;getting-started&quot;&gt;Getting Started&lt;/h2&gt;
&lt;p&gt;The BeagleBone is amazingly simple to start off with, and is indeed the most convenient of any embedded board, since it comes with a preloaded OS. There are multiple ways to access the BBB from your system, each of which will be described briefly.&lt;/p&gt;

&lt;p&gt;Connect the BBB via the USB cable provided in the box. The BBB can be directly accessed using the web browser, and programs can be executed using Bonescript, which is similar to JS. By default, your BBB comes with it’s IP address on &lt;em&gt;usb0&lt;/em&gt; port as &lt;code class=&quot;highlighter-rouge&quot;&gt;192.168.7.2&lt;/code&gt;. Enter this in your browser, and you are good to go. You can access the GPIO, and run programs with the BBB as your microcontroller, just like you run scripts in Arduino. A sample of the available functions can be seen &lt;a href=&quot;http://beagleboard.org/support/bone101&quot;&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;For accessing the &lt;em&gt;real capabilities of the board&lt;/em&gt; as a computer in itself, you will need to do a little more, but fear not! Plug in the BBB using the USB cable, and go to your &lt;em&gt;terminal&lt;/em&gt; (Windows users may have to use &lt;a href=&quot;http://www.putty.org/&quot;&gt;PuTTY&lt;/a&gt;) and type:&lt;/p&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nx&quot;&gt;ssh&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;yourIP&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;l&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;root&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//or&lt;/span&gt;
&lt;span class=&quot;nx&quot;&gt;ssh&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;root&lt;/span&gt;&lt;span class=&quot;err&quot;&gt;@&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;yourIP&lt;/span&gt;
&lt;span class=&quot;c1&quot;&gt;//You may have to use sudo, if permissions are an issue.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;This will enable you to use the BBB as the root user. You will notice that the files and structure of the memory is similar to any other Linux distro. &lt;em&gt;The BBB is your very own credit-card sized computer!&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Now that you have entered the system, there exist no bounds to what can be done. Some packages as pre-installed, like &lt;code class=&quot;highlighter-rouge&quot;&gt;Python&lt;/code&gt;, and can be used directly. Have fun tinkering with your cute little pup. To burn bonescripts, the browser sure is a cool bet!&lt;/p&gt;

&lt;h2 id=&quot;using-the-beaglebone-black-remotely&quot;&gt;Using the BeagleBone Black remotely&lt;/h2&gt;
&lt;p&gt;You have used the BBB by connecting it to your PC, but what if you want it to act independently, or on the network? There must be a way to access the board via a network, and not just USB. Turns out, there is - and much simpler than the R-Pi in this case! Here’s what you must do:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;Connect the BBB to your system, as stated above. Enter the system using SSH and login as root (use the Terminal or PuTTY)&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Run &lt;code class=&quot;highlighter-rouge&quot;&gt;cd /etc/network&lt;/code&gt; and open the file &lt;em&gt;interfaces&lt;/em&gt; using VI or nano.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nx&quot;&gt;sudo&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;vi&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;etc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;network&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;interfaces&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//or&lt;/span&gt;
&lt;span class=&quot;nx&quot;&gt;sudo&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;nano&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;etc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;network&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;interfaces&lt;/span&gt;
&lt;span class=&quot;c1&quot;&gt;//sudo would be used if the user is not root.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;ul&gt;
  &lt;li&gt;This opens the file interfaces. You will see the following lines written in the end.&lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; &lt;span class=&quot;nx&quot;&gt;iface&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;usb0&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;inet&lt;/span&gt; &lt;span class=&quot;kr&quot;&gt;static&lt;/span&gt;
     &lt;span class=&quot;nx&quot;&gt;address&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;192.168&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;7.2&lt;/span&gt;
     &lt;span class=&quot;nx&quot;&gt;netmask&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;255.255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;255.0&lt;/span&gt;
     &lt;span class=&quot;nx&quot;&gt;network&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;192.168&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;7.0&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;This defines the action performed when the BBB is connected via USB. (Note &lt;code class=&quot;highlighter-rouge&quot;&gt;usb0&lt;/code&gt;) You can choose to keep this or comment it out depending on usage. Now, let’s go on with the task of setting it up remotely.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Here, I’m using LAN for that purpose. Before starting, create a backup of the file so that you have something to go back to - messing up is allowed!&lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nx&quot;&gt;cd&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;etc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;/&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;network&lt;/span&gt;
&lt;span class=&quot;nx&quot;&gt;cp&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;interfaces&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;interfaces&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;backup&lt;/span&gt;
&lt;span class=&quot;nx&quot;&gt;vi&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;interfaces&lt;/span&gt;
&lt;span class=&quot;c1&quot;&gt;//The file opens up. Now, we must edit it.&lt;/span&gt;
&lt;span class=&quot;c1&quot;&gt;//Add the following lines in it.NOTE, add values according to your ethernet/router settings. These are the ones appropriate for me.&lt;/span&gt;
&lt;span class=&quot;nx&quot;&gt;iface&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;eth0&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;inet&lt;/span&gt; &lt;span class=&quot;kr&quot;&gt;static&lt;/span&gt;
       &lt;span class=&quot;nx&quot;&gt;address&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;10.173&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;24.69&lt;/span&gt;
       &lt;span class=&quot;nx&quot;&gt;netmask&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;255.255&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;255.0&lt;/span&gt;
       &lt;span class=&quot;nx&quot;&gt;gateway&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;10.173&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;24.250&lt;/span&gt;
       &lt;span class=&quot;nx&quot;&gt;dns&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;nameservers&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;10.200&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;1.11&lt;/span&gt;
       &lt;span class=&quot;nx&quot;&gt;dns&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;nameservers&lt;/span&gt; &lt;span class=&quot;mf&quot;&gt;10.200&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;11.1&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;Here, we declared the &lt;code class=&quot;highlighter-rouge&quot;&gt;static&lt;/code&gt; IP for the Ethernet port &lt;code class=&quot;highlighter-rouge&quot;&gt;eth0&lt;/code&gt;. According to your Service Provider, you may replace &lt;code class=&quot;highlighter-rouge&quot;&gt;static&lt;/code&gt; with &lt;code class=&quot;highlighter-rouge&quot;&gt;dhcp&lt;/code&gt;. Thus, the definition of the port is set.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;To check whether you have established connection, run &lt;code class=&quot;highlighter-rouge&quot;&gt;ping 10.173.24.69&lt;/code&gt;(IP address) or &lt;code class=&quot;highlighter-rouge&quot;&gt;ping 10.200.1.11&lt;/code&gt;(DNS Server).&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Now, leave the BBB with an independent power source, connected to Ethernet. With a system connected to the same network, you can now access the BBB. Say, you have a laptop connected to the router or LAN network. Fire the Terminal/PuTTY and type :&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nx&quot;&gt;sudo&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;ssh&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;root&lt;/span&gt;&lt;span class=&quot;err&quot;&gt;@&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;10.173&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;mf&quot;&gt;24.69&lt;/span&gt;
&lt;span class=&quot;c1&quot;&gt;//basic syntax is 'sudo ssh user@yourIP'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;This would take a while, but is sure to get you into the BBB considering that your Bone and laptop are both connected and active. You can control and run the BBB remotely, and also share/install packages over the network.&lt;/p&gt;

&lt;p&gt;Now that you have connected to the Bone directly and remotely, you can do almost anything with the Processor. Tried and tested ideas include using the remote computer to run as a portable unit running heavy Mathematica/MATLAB scripts, or Python codes, or even a host/router. And with 66 GPIO pins, Electronics Projects would surely be cooler, and cleaner! :)&lt;/p&gt;

&lt;h2 id=&quot;merits--demerits&quot;&gt;Merits &amp;amp; Demerits&lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;The BeagleBone is a favorable choice for beginners because it is a direct plug-and-play unit (R-Pi needs you to install Raspbian OS before use). Also, the higher no. of GPIO pins ensure that you’re never short of pins for your sensors! Also, for the geeks and performance freaks, it packs the best processor and graphics accelerator in the range. The on-board Flash is also very fast.&lt;/li&gt;
  &lt;li&gt;That said, the main issue you’d face would be lack of online support (one of the reasons I wanted to make a beginner tutorial!) for your minor bugs and queries. Also, the basic use over the web may require some use of JavaScript and hence, some background. Also, in general, using any such development board requires immense amount of patience. You don’t really get ready-made solutions online. More so with the BBB, than the R-Pi. but it’s certainly better than starting off with the Intel Galleo.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Hope you have a good time tinkering around with the BeagleBone Black.&lt;/p&gt;

&lt;p&gt;Cheers.&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Meanshift Algorithm for Image Processing</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/03/meanshift-algorithm-for-image-processing/"/>
   <updated>2016-03-24T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/03/meanshift-algorithm-for-image-processing</id>
   <content type="html">&lt;p&gt;&lt;strong&gt;&lt;u&gt;Pre-requisites&lt;/u&gt;&lt;/strong&gt; - Basic idea of matrices(wrt pixels), a &lt;a href=&quot;https://en.wikipedia.org/wiki/Kernel_(image_processing)&quot;&gt;kernel or convolution matrix&lt;/a&gt;, local binary patterns, high-school statistics principles and &lt;em&gt;enthu&lt;/em&gt;!
&lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/demo_org.png&quot; alt=&quot;Original Image&quot; /&gt; &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/demo_4.png&quot; alt=&quot;Image after using the algorithm&quot; /&gt; &lt;br /&gt;
One of the most common and important applications of Image Processing remains &lt;em&gt;Edge-Detection&lt;/em&gt;. The ‘algorithm’ followed for &lt;a href=&quot;https://en.wikipedia.org/wiki/Canny_edge_detector&quot;&gt;Canny-edge Detection&lt;/a&gt; is as follows:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Apply a suitable filter to smooth the image in order to remove the noise&lt;/li&gt;
  &lt;li&gt;Find the intensity gradients of the image&lt;/li&gt;
  &lt;li&gt;Apply non-maximum suppression to get rid of spurious response to edge detection&lt;/li&gt;
  &lt;li&gt;Apply double threshold to determine potential edges&lt;/li&gt;
  &lt;li&gt;Track edge by hysteresis: Finalize the detection of edges by suppressing all the other edges that are weak and not connected to strong edges&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;As you can see, the most very first step involves filtering and removal of the noise. &lt;br /&gt;
&lt;strong&gt;WHAT IS THIS &lt;em&gt;NOISE&lt;/em&gt;?&lt;/strong&gt;
In the sense used here, &lt;em&gt;noise&lt;/em&gt; refers to subtle variations in pixel definitions, that may be recognised as an edge, but is most certainly not one. In the same sense as signals, it is unwanted in this purpose and needs to reduced.&lt;/p&gt;

&lt;h2 id=&quot;the-statistics&quot;&gt;The Statistics&lt;/h2&gt;
&lt;p&gt;The algorithm, in simple words, involves replacing each pixel definition with one obtained by applying the kernel on it - in general, forming a sort of mean application - which is similar to averaging out and minimising the noise.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/meanshift_fx.png&quot; alt=&quot;Meanshift Principle&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Here, &lt;em&gt;g&lt;/em&gt; refers to the Kernel operation applied on each element Xi, where X is an assumed mean and &lt;em&gt;h&lt;/em&gt; is a parameter called &lt;u&gt;resolution&lt;/u&gt;. The obtained expression m(x) is referred to as the Mean Shift, on following this procedure for a large number of times, this m(x) converges to zero. We wish to minimise this m(x), without losing much information, so that further techniques of gradient can be applied for edge-detection. This is similar to &lt;a href=&quot;http://mathworld.wolfram.com/JacobiMethod.html&quot;&gt;Jacobi’s Method&lt;/a&gt; of iteration.&lt;/p&gt;

&lt;h2 id=&quot;the-algorithm&quot;&gt;The Algorithm&lt;/h2&gt;
&lt;p&gt;Now, coming to the real application part of the algorithm, this method involves applying a suitable convulation matrix to the image matrix to smoothen out the edges. This matrix can be of various types, and optimised for better results. Some simple types include:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Flat Kernel (linear)&lt;/li&gt;
  &lt;li&gt;Gaussian Kernel (exponential)&lt;/li&gt;
  &lt;li&gt;Epanechikov Kernel (quadratic)&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The simplest of these is the Flat Kernel, in which the pixel’s value is changed to the averaged value of it’s surroundings, with equal weight to each pixel. &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/flat_kernel.png&quot; alt=&quot;Flat Kernel&quot; /&gt;&lt;/p&gt;

&lt;p&gt;A sample code for this algorithm, implemented in ‘MATLAB’,  is as follows:&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-matlab&quot; data-lang=&quot;matlab&quot;&gt;	&lt;span class=&quot;n&quot;&gt;it&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;10000&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;%set the number of iterations of the algorithm&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;k&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;it&lt;/span&gt;
    	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;nx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;
        	&lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ny&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;
            	&lt;span class=&quot;n&quot;&gt;Vt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;V&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;V&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;V&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;V&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;j&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))/&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;% Kernel Definition&lt;/span&gt;
        	&lt;span class=&quot;k&quot;&gt;end&lt;/span&gt;        
    	&lt;span class=&quot;k&quot;&gt;end&lt;/span&gt;
    	&lt;span class=&quot;n&quot;&gt;V&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Vt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;end&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Here, V is the image matrix of ‘nx X ny’ and Vt is a dummy matrix of same size, used during the loop. The filter can be changed by altering the line marked as &lt;em&gt;Kernel Definition&lt;/em&gt;.
Basically, the algorithm can be used to merge modes and generate clusters.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;em&gt;Modes&lt;/em&gt;- Modes refer to the peaks in color intensities in the pixel map. When plotted, these are the peaks in ‘3D-plot’.&lt;/li&gt;
  &lt;li&gt;&lt;em&gt;Clusters&lt;/em&gt;- Clusters refer to the groups of similarly defined pixels, ie, groups with similar color or compositon.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;As you can see in the images below, as the number of iterations increase, modes get merged and a cluser is formed.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;THE PARAMETERS:&lt;/strong&gt; The alterable parameters include:
*‘it’ or the number of iterations. Increasing ‘it’ would increase the merge rate, but also increase the computational cost as number of iterations would increase. Hence, there is an optimised upper bound for this value.
&lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/Meanshift0.jpg&quot; alt=&quot;Original Image - 2 modes&quot; /&gt; &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/Meanshift100.jpg&quot; alt=&quot;100 Iterations&quot; /&gt; &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/Meanshift500.jpg&quot; alt=&quot;500 Iterations&quot; /&gt;&lt;/p&gt;

&lt;p&gt;*‘h’ or resolution is a parameter used in the statistical definition. Since it is in the denominator, it can play a huge role in the smoothening effect as shown. In general, a large ‘h’ would mean faster convergence, larger clusters and more loss of information. This value can be tweaked as desired, for optimal results.
&lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/meanshift_H_org.png&quot; alt=&quot;Original Image&quot; /&gt; &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/meanshift_H_6.png&quot; alt=&quot;h = 6&quot; /&gt; &lt;img src=&quot;/assets/meanshift-algorithm-for-image-processing/meanshift_H_16.png&quot; alt=&quot;h = 16&quot; /&gt;&lt;/p&gt;

&lt;p&gt;For more such example, you can refer to &lt;a href=&quot;https://www.inf.tu-dresden.de/content/institutes/ki/is/VORTRAG/Vortrag_Huong_Nguyen.pdf&quot;&gt;this PDF&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ADVANTAGES&lt;/strong&gt;
Comparing with other clustering algo K-means, it does not ASSUME any cluster etc. and the algo ensures that clusters are sorted automatically. Also, it is robust and works for any no. of (non-predefined) modes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;DRAWBACKS&lt;/strong&gt;
The iterative technique is highly redundant and computationally expensive; also, the method doesnt work well in free space (3D), as there may exist many local maximas that converge to optimas and mode isolation cannot be done.&lt;/p&gt;

&lt;p&gt;This concludes the summary of an essential algorithm in the art of Image Processing. Hope you enjoyed it!&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Glimpse Of The Naive Bayes' Classifier</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/03/glimpse-of-the-naive-bayes-classifier/"/>
   <updated>2016-03-15T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/03/glimpse-of-the-naive-bayes-classifier</id>
   <content type="html">&lt;p&gt;&lt;img src=&quot;/assets/glimpse-of-the-naive-bayes-classifier/joke.png&quot; alt=&quot;joke&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The are numerous applications of machine learning out in the world and many more are being developed, I particularly like the clustering algorithms. In this post I would like to explore one of the most useful of supervised clustering algorithm, The Naive Bayes’ Classifier.&lt;/p&gt;

&lt;p&gt;In the post I will be using an example project that I am working upon as the default example. So what does the algorithm do.&lt;br /&gt;
In simple words it computes the probabilities of the the test case to lie in one of “clusters” with a specific probability. Let me go with the example to describe at what we are trying to achieve.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;u&gt;Problem:&lt;/u&gt;&lt;/strong&gt; Given an input paragraph we need to classify it as Argumentative, Narrative, Expository or Descriptive&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;u&gt;Solution:&lt;/u&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;u&gt;Training Set&lt;/u&gt;&lt;br /&gt;
Collected the training data set of different paragraphs already classified already in the given four categories.&lt;/li&gt;
  &lt;li&gt;&lt;u&gt;Feature Extraction&lt;/u&gt;&lt;br /&gt;
We Extract the features from the training database to generate a feature vector &lt;math&gt;v&lt;/math&gt;&lt;sub&gt;i&lt;/sub&gt; = (f&lt;sub&gt;1&lt;/sub&gt;,f&lt;sub&gt;2&lt;/sub&gt;,….)&lt;sub&gt;i&lt;/sub&gt; for each i&lt;sup&gt;th&lt;/sup&gt; point in the training dataset, this in our case are language features.&lt;/li&gt;
  &lt;li&gt;&lt;u&gt;Supervised Clustering Algorithm(Naive Bayes')&lt;/u&gt;&lt;br /&gt;
This is what the tutorial is about, we need to make four clusters(one for each para type) in the feature vector space. And this is what we will talk about in the tutorial.&lt;/li&gt;
  &lt;li&gt;&lt;u&gt;Input Result&lt;/u&gt;&lt;br /&gt;
This is the moment of truth we put in few known test cases we get their probabilities of lying in the clusters and see the accuracy of our algorithm, based on these results we decide on the modification that might be required in the training dataset.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So let’s first go through what the Bayesian approach of classification!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/glimpse-of-the-naive-bayes-classifier/bayes.png&quot; alt=&quot;bayes&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now, you might be thinking yeah this makes sense we take the classes in our example as the types of paragraphs and the data being the input. But we cannot input an paragraph we input a set of features which makes d a vector. So the next thing we look at is how to deal with the multidimensional input, that is like in our case a number of features.&lt;/p&gt;

&lt;p&gt;There are many methods to approach this problem, but one of the most simple being is that &lt;strong&gt;we assume that each feature have an independent distribution (or is Naive).&lt;/strong&gt; In our example the features we are likely to choose are something like, “number of certain punctuation per total words”,”number of stress adjectives per total words”,”average sentence length” etc. What we notice is that these all intuitively are more or less not dependent on each other, there will be few dependencies obviously but nothing that we can’t ignore :P. To summarize we have the probabilities expressed as.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/glimpse-of-the-naive-bayes-classifier/bayes2.jpg&quot; alt=&quot;bayes2&quot; /&gt;&lt;/p&gt;

&lt;p&gt;This settles the defining of our model and this is what the Naive Bayes’ Classifier is. Now we just need to predict the probability distribution of the features, this is usually chosen to be a Gaussian model with some w=varying parameter, we need to tune the parameter using some kind of techniques like maximum likelihood estimation. For more insight on this topic I suggest you have a look at few YouTube videos which are really amazing, one such short explanation is given &lt;a href=&quot;https://www.youtube.com/watch?v=8yvBqhm92xA&quot;&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Lets put this tutorial to test, I have four clusters and many features for classifying the paragraphs, the project is still ongoing and will get finished real soon.&lt;/p&gt;

&lt;p&gt;Finally let us discuss the advantages and limitations of this classifier&lt;br /&gt;
&lt;strong&gt;ADVANTAGES&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Fast to train. Fast to classify.&lt;/li&gt;
  &lt;li&gt;Not sensitive to irrelevant features.&lt;/li&gt;
  &lt;li&gt;Handles real as well as discrete data.&lt;/li&gt;
  &lt;li&gt;Handles data streaming well.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;LIMITATION&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Assumes independence of features and hence it does not capture the mutual dependence of features which might be present.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This concludes this really brief introduction!&lt;br /&gt;
Thank You!&lt;/p&gt;
</content>
 </entry>
 
 <entry>
   <title>Remote Controlling a bot with Android</title>
   <link href="https://elec-club-iitb.github.io/blog/2016/03/remote-controlling-a-bot-with-android/"/>
   <updated>2016-03-12T00:00:00+00:00</updated>
   <id>https://elec-club-iitb.github.io/blog/2016/03/remote-controlling-a-bot-with-android</id>
   <content type="html">&lt;!-- content goes below this --&gt;

&lt;p&gt;For the XLR8 competition 2015, we had made a remote control on android for the teams to operate their bots. The remote control used the android phone’s bluetooth to connect to an HC-05, followed by an ATtiny 2313 chip to decode the incoming bits. The XLR8 bots usually run on differential drive mechanism, so they require four inputs namely:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Left Front&lt;/li&gt;
  &lt;li&gt;Left Back&lt;/li&gt;
  &lt;li&gt;Right Front&lt;/li&gt;
  &lt;li&gt;Right Back&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;More on differential drive here: &lt;a href=&quot;https://en.wikipedia.org/wiki/Differential_wheeled_robot&quot;&gt;wiki/Differential_wheeled_robot&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Each can be represented by one bit. So we had four output pins of the ATtiny going to four inputs of the Motor Driver (L293D in our case). After that it just boils down send the correct bit sequence from the phone based on the button pressed (i.e. control expected).&lt;/p&gt;

&lt;h1 id=&quot;attiny-board&quot;&gt;ATtiny Board&lt;/h1&gt;
&lt;p&gt;&lt;em&gt;Designed by Ajinkya Gorad&lt;/em&gt;&lt;/p&gt;

&lt;h2 id=&quot;schematic&quot;&gt;Schematic:&lt;/h2&gt;

&lt;p&gt;&lt;img src=&quot;/assets/remote-controlling-a-bot-with-android/schematic.png&quot; alt=&quot;Schematic&quot; /&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;JP1 is where the programmer head attaches&lt;/li&gt;
  &lt;li&gt;JP3 is where HC-05 is attached&lt;/li&gt;
  &lt;li&gt;JP5 is the 4 bit output which is sent to motor driver&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Connections are pretty straight forward. The RX/TX from HC-05 are joined with TX/RX of ATtiny (PD0 and PD1), and PB0-PB3 are designated the output pins. You should check the programming header connections in the datasheet. One thing we observed while testing was that due to loose connections in the voltage supply, the ATtiny would restart even if the connection went loose for a moment. This happened quite frequently while the bot was running, and this would stop the bot (the init conditions were to set all output pins to 0). For this we soldered a 47uF capacitor externally on the voltage supply pins (polarity matching).&lt;/p&gt;

&lt;p&gt;We designed a PCB with respect to this schematic. You can find the necessary Gerber files on the github repo &lt;a href=&quot;http://github.com/elec-club-iitb/xlr8-remote-control/tree/master/avr-receiver&quot;&gt;here&lt;/a&gt;. This is how it finally looks like:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/remote-controlling-a-bot-with-android/avr_rec.jpg&quot; alt=&quot;Final product&quot; /&gt;&lt;/p&gt;

&lt;h2 id=&quot;avr-code&quot;&gt;AVR Code:&lt;/h2&gt;

&lt;p&gt;Code is pretty straight forward too. Take the bit-sequence from HC-05 through UART and output it on the four pins of PORTB. I have posted the relevant &lt;code class=&quot;highlighter-rouge&quot;&gt;main()&lt;/code&gt; function here. Entire code can be found on github.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-c&quot; data-lang=&quot;c&quot;&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    
    &lt;span class=&quot;n&quot;&gt;USARTInit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;5&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// initialise uart to baud rate 9600, no parity , 1 stopbit
&lt;/span&gt;    &lt;span class=&quot;n&quot;&gt;DDRB&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;mh&quot;&gt;0xFF&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;			&lt;span class=&quot;c1&quot;&gt;// make all pins on port B as output
&lt;/span&gt;    &lt;span class=&quot;n&quot;&gt;PORTB&lt;/span&gt;  &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mh&quot;&gt;0x00&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;		&lt;span class=&quot;c1&quot;&gt;// initially make all pins low
&lt;/span&gt;    
    &lt;span class=&quot;k&quot;&gt;while&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;){&lt;/span&gt;		&lt;span class=&quot;c1&quot;&gt;//endless loop
&lt;/span&gt;        &lt;span class=&quot;k&quot;&gt;while&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;!&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;UCSRA&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RXC&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)))&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;	&lt;span class=&quot;c1&quot;&gt;// wait for data to be received in uart UDR register
&lt;/span&gt;        &lt;span class=&quot;kt&quot;&gt;char&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;temp&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;UDR&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;PORTB&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;temp&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;		&lt;span class=&quot;c1&quot;&gt;//directly write value of uart data to port
&lt;/span&gt;    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;h1 id=&quot;android-app&quot;&gt;Android App:&lt;/h1&gt;

&lt;p&gt;The ATtiny is programmed to output the bit sequence as is. So once you send a bit sequence corresponding to “move forward”, the bot wont stop until you send another bit sequence corresponding to “stop”. The UI consist of three control modes:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Motion Control: Front, Back, Left, Right control&lt;/li&gt;
  &lt;li&gt;Individual Motor control: Left Front, Left Back, Right Front, Right Back&lt;/li&gt;
  &lt;li&gt;Swag Mode :D: Hand-tilt based control. Tilt phone forward to move forward, and so on&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Motion and Individual Motor control have buttons which on pressed send the bit sequence corresponding to the motion, and on released send bit sequence “stop”. In tilt control mode it check tilt on each axis x and y, if it is beyond a threshold (positive or negative) it sends that motions bit sequence else it sends “stop”.&lt;/p&gt;

&lt;p&gt;We also need to consider cases when two buttons are pressed together (which is necessary in Individual Control mode). So we controlled each bit individually on pressed and released rather than sending the whole bit sequence entirely. And we also made a function which would send the latest updated bit sequence which could be called after every update. The entire code is available on &lt;a href=&quot;http://github.com/elec-club-iitb/xlr8-remote-control/tree/master/avr-receiver&quot;&gt;github&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Here is the &lt;code class=&quot;highlighter-rouge&quot;&gt;onTouch&lt;/code&gt; button code. You can see how the on pressed and on released events ( represented by &lt;code class=&quot;highlighter-rouge&quot;&gt;ACTION_DOWN&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;ACTION_UP&lt;/code&gt; respectively). Rest of the functions used are quite obviously named. For the entire file, check the github repo.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-java&quot; data-lang=&quot;java&quot;&gt;&lt;span class=&quot;nd&quot;&gt;@Override&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;boolean&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;onTouch&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;View&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;v&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MotionEvent&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;boolean&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;updated&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;kc&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;switch&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getAction&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;())&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MotionEvent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ACTION_DOWN&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;Log&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;d&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TAG&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;Action Down&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;v&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setPressed&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kc&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;

            &lt;span class=&quot;c1&quot;&gt;// Switch case to set a corresponding&lt;/span&gt;
            &lt;span class=&quot;c1&quot;&gt;// bit sequence according to the button pressed&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;switch&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;v&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getId&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;())&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;forward&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;backward&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left_fwd&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left_bck&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right_fwd&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right_bck&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
            &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MotionEvent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ACTION_UP&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MotionEvent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ACTION_CANCEL&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MotionEvent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ACTION_OUTSIDE&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;Log&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;d&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TAG&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;Action Up&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;v&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setPressed&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kc&quot;&gt;false&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;

            &lt;span class=&quot;c1&quot;&gt;// Similar switch case to reset bits when button is left&lt;/span&gt;
            &lt;span class=&quot;c1&quot;&gt;// In effect the motion of bot will last till the button is pressed&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;switch&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;v&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getId&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;())&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;forward&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;backward&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;reset&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left_fwd&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;left_bck&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right_fwd&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;case&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;right_bck&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
                    &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
            &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;default&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;updated&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;kc&quot;&gt;false&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;break&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;c1&quot;&gt;// Check if updated, and then only send&lt;/span&gt;
    &lt;span class=&quot;c1&quot;&gt;// We don want to unnecessarily send data&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;updated&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sendMessage&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mMotorState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;kc&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;R.id.&amp;lt;forward|backward|left|right&amp;gt;&lt;/code&gt; correspond to the Motion Control buttons. &lt;code class=&quot;highlighter-rouge&quot;&gt;R.id.&amp;lt;left_fwd|left_bck|right_fwd|right_bck&amp;gt;&lt;/code&gt; correspond to the Individual Motor control.&lt;/p&gt;

&lt;p&gt;The code responsible for Swag mode:&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-java&quot; data-lang=&quot;java&quot;&gt;&lt;span class=&quot;nd&quot;&gt;@Override&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;onSensorChanged&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SensorEvent&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kt&quot;&gt;float&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;values&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SensorManager&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;DATA_X&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;],&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;y&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;values&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SensorManager&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;DATA_Y&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;],&lt;/span&gt;
          &lt;span class=&quot;n&quot;&gt;z&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;values&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SensorManager&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;DATA_Z&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;];&lt;/span&gt;

    &lt;span class=&quot;o&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TextView&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mContext&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;findViewById&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;swag_x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setText&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;x: &quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TextView&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mContext&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;findViewById&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;swag_y&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setText&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;y: &quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TextView&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mContext&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;findViewById&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;swag_z&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setText&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;z: &quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;z&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;

    &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;old&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mMotorState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;6&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;6&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;gt;&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;y&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;-&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;){&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;LT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_FWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;setBit&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RT_MOTOR_BCK&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;reset&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
            &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;o&quot;&gt;((&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TextView&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mContext&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;findViewById&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;R&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;swag_bits&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setText&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;bits: &quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;toBinaryString&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mMotorState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;old&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;!=&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mMotorState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mChatService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;BluetoothChatService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;STATE_CONNECTED&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;sendMessage&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mMotorState&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;This code has a little complicated logic. So the first two &lt;code class=&quot;highlighter-rouge&quot;&gt;if&lt;/code&gt;s check if there is a hard-tilt (high angle), then we send hard-left/hard-right control bit sequence. If not we check for soft-tilt and send those corresponding bit sequences if true. These tilts are in the x-axis i.e. the left-right axis. Now we go on to the front-back axis i.e. y-axis which is the last nested &lt;code class=&quot;highlighter-rouge&quot;&gt;if&lt;/code&gt; in the &lt;code class=&quot;highlighter-rouge&quot;&gt;else&lt;/code&gt; condition.&lt;/p&gt;

&lt;p&gt;The bluetooth relevant code was taken from the BluetoothChat sample app provided by android. These two functions above are part of the BotControl class which is used in the UI as an &lt;code class=&quot;highlighter-rouge&quot;&gt;onTouchListener&lt;/code&gt; and  &lt;code class=&quot;highlighter-rouge&quot;&gt;SensorEventListener&lt;/code&gt; to capture both touches and tilt changes.&lt;/p&gt;
</content>
 </entry>
 

</feed>