Line follower is an autonomous robot which can detect a specific colored line painted on a surface of different contrast, such as white on black. In this project I used infrared transmitters and receivers to track the black strip on white surface. Due to the difference of infrared reflection on black and white surfaces, it provides two voltages which can be amplified and used as logic states.
Step 1: Electronics
Flow chart above explains the working of the robot. There are eight IR transmitters and receivers to detect the path and junctions. Analog values from those receivers are amplified by LM324 operational amplifier. A microcontroller is used to detect the amplified digital values and to make decisions. It provides control signals to the H-Bridge motor driver (L293). More details are explained below.
Step 2: Op-Amplifier (LM324)
If the rays received by the IR receiver are above a particular threshold then an amplified signal is generated by the amplifier (LM324). In this project I used eight separate transmitters, receivers and amplifiers to make the tracking smooth (Fig.1) Note that the sensors cannot directly send a signal to the microcontroller as the signal voltage generated by them is too low and even when sensors are on white surfaces signal generated by them will be interpreted low by the microcontroller.
Step 3: Microcontroller(PIC16F876A)
Microcontroller receives the eight amplified signals from op-amps and it decides how to control the directions of the motors as shown in Fig.
Step 4: H-bridge Motor Driver(L293)
Microcontroller sends signal to the motor driver so that it can control the rotating directions. PCB layout and schematic diagram of main circuit is shown.
Last year 2016 I altered my garden and planted some new stock. Half way through the growing season I noticed that the right hand Carnation had grown far more vigorously than its twin only 20” away. The only differences to the plants was that a solar powered battery light had been placed by chance to shine directly down on the right hand plant.
I’m not sure why the three low powered LED’s would have made such a marked difference but I am going to try and see if I can create the same effect in my failing greenhouse.
As I am powering this project with a solar powered 7ah battery I want to make sure that I am not wasting power so I have created three light “zones”.
Sunshine , its pointless using light’s during direct sunshine, lights off.
Night time, I don’t want too attract unwanted two legged visitors so, lights sleeping.
Low light, times of low light dawn till dusk etc, lights on.
Sunshine and Low light are fairly straight forward on/off software controls, but Night time is a little different, I will show why in the software.
As I require the same sensor to control these zones I have used a Picaxe 8m2 micro controller and 8m2 project board to do the work. The circuits I have made are fairly straightforward and I have included circuit diagrams, I’m not an expert in circuit drawing but I think its all pretty straightforward.
Step 1: Picaxe Circuit
The Picaxe project board kit is reasonably cheap and for simple circuits is adequate. I will describe the circuit by using the pin designations.
CO.0 is the serial output and it joins the 5v and 0v supply at the 3 pin connector. I use this connector to display the sensor value and unit conditions on a LCD unit.
CO.1 is the impulse line that controls the mosfet. It only needs a single line but I’ve used a double connector as it was all I had.
CO.2 is a LED indicator used to indicate that the unit is in test mode.
CO.3 this line is used to set pin 3 high when a jumper is connected across, this puts the software into test mode. The 10k resistor is used to pull down the line when the jumper is removed.
CO.4 a light dependant resistor and the 1k resistor form a voltage divider at pin 4 the pic then converts this analogue voltage to a digital number.
I have used the supplied battery cable so I can use battery power if I remove the Picaxe from the main board but I will be using the regulated 5v from the power circuit board via the 2 pin connector normally.
Step 2: Power
I’ve made a “normal” type of voltage regulator plus Mosfet circuit and all the information is on the diagram.
Pic+ and neg is the power connector for the Picaxe
C1 is the impulse line from CO.1 and the 10k resistor is the pull down for this line, again I had to use a double connector but its a single wire.
Step 3: Software Main Loop
I’ve written the software using Blocky a facility in the Picaxe Editor software plus some basic inserts. The main part is contained in a loop but first every good Picaxe program should start with a blinking LED and that is created with a 12 step for next loop (that sequence is not a part of the main loop).
VarN (night) and varS (sunshine) are then given their set points i.e. an average sensor reading below 50 will call the night procedure.
VarV and varAV are set to zero
A for next 12 step loop is next.
With each step C.3 is checked to see if it set on (on would call the test procedure.)
The analogue value is taken from C.4 and placed as a digital number into varB.
VarB is then added to varV.
The program then sleeps for 10 seconds. A second in this particular Picaxe is actually 2.1 seconds long so sleep 5 = 10 / 2.1 then rounded up.
After the 12 steps and around 120 seconds have passed varV is divided by 12 and the resulting average is placed in varAV.
The average varAV is then compared to 3 statements and the relative procedure is called
Step 4: Software Procedures
Sunshine and Lights procedures are very similar. These procedures turn C.1 either on or off and print a message on a LCD if fitted then return to the main loop.
Night is also simular to the previous two the main difference being that the program sleeps for 30 minute periods during the night to save power.
Step 5: Test Procedure and Set Up
To get a readout from the unit I use a simple LCD supplied in kit form from the Picaxe Store but to get the initial setting the unit can be connected with the download cable and the analogue sensor facility in the Picaxe Editor will give a real time reading from the sensor.
To get the high and low cut of points (varN and varS) to initially set the unit the jumper is used and C.3 goes high then a note is taken of the sensor value, i.e. when the natural light level has dropped or risen to the point were I want the unit to switch off I take a note of the sensor value from the test screen then update the program with that setting.
During the test procedure shading the LDR or illuminating it will cause the lights to turn on and off so that I can actually see that the unit is working.
Step 6: Complete
The unit works as planned in the R&D dept and it is now ready for fitting in the greenhouse for its trial run.
I don’t imagine I will get it right first time so I think my Research and Development Dept (my wife calls it the back bedroom) could be busy over the coming weeks.
I also hope that people can understand my steps and diagrams and if not I’m always open to questions .
More patents for bicycle improvements have been issued than for any other machine. It is no wonder that the simplest of mechanical devices invites constant tinkering. If you do a search for speedometers for bikes you can come up with the old style mechanical contrivance with a gear driving a cable into a solid style housing that can still be bought on the web. While I have no great love for “retro” git I do like Analog as output rather than a number and my brain seems to like it better too. The instant picture of a state of being rather than the awkward pause of your brain circuitry going through translation hoops to get to a picture of time or speed. Anyway its rather neat to cruise down the street with a wizzy needle pointing out your lack of speed or short ride. Using GPS is nice because it makes it self contained with no umbilical cord to the wheel. Its a little slow off the start –a second or two and it takes a minute or so to get its bearings right but if you are really OCD and must have a downloaded file of every inch that you traveled having a goofy dial on your bike is probably not for you. But for those who take some joy in the ride and want to fun-up their commute with their very own customized dial this may be a good project.
Step 1: Grab Some Hardware
The Hardware is pretty simple. All of it can be ordered from Adafruit. You use one of their new Feather boards with a GPS Feather attached directly above it. The battery is a 500 mAh unit that provides about 6 hours of use in my testing. But you can fit whatever you want in the case. The Feather is nice because it has built in charging so when you take it off your bike you can flip it on the charger overnight. This is not something that your going to leave on your bike anyway–its too attractive. The stepper motor is one normally sourced for speedometers in cars and Adafruit has a nice one for reasonable cost with a needle but you can get piles of these for cheap on the web. The motor driver is necessary because GPS and steppers don’t play nicely together on these small computers. The plastic cases I ordered on the web work well for a solid weather tight enclosure but you can also just carve a stackable grouping out of raw plexiglass.
1. Adafruit Feather 32u4 Basic Proto
2. Adafruit Ultimate GPS FeatherWing
3. Lithium Ion Polymer Battery – 3.7v 500mAh
4. Breadboard-friendly SPDT Slide Switch
5. Adafruit TB6612 1.2A DC/Stepper Motor Driver Breakout Board
6. Automotive Gauge Stepper Motor – x27.168
7. Break-Resistant Plastic Drawer Organizers 3″ x 3″ x 2″ l Set of 12
8. Adafruit LED Sequins – Ruby Red, Green
Step 2: Wire It Up…
The usual–use a breadboard. Follow the instructions on the Adafruit web site for stacking the GPS Feather with the main protoboard and soldering the connections as noted. The hardware serial connects the TX of the GPS feather with the RX of the main Feather board and the RX of the GPS to the TX of the main board. These plus ground and power are the only connections this board needs with its mating partner. Its a wonderful idea to check that the GPS data and the main board are working correctly and transmitting parsed data so use the demos on the Adafruit web page to make sure these guys are up and running. Once you have seen the miracle of data streaming from these units–something we now take for granted–wire up the motor shield and the stepper motor and test it with the motor shield demo tutorial just to make sure its working. I wired the stepper motor with the lipo-battery output fully expecting it not to work and thinking I would need a voltage booster, but it works fine surprisingly. Be very careful of the tiny solder pins on the stepper motor–they are really fragile and break off just where they come out of the case so as soon as you solder them to wires add some hot glue to the wire to stop any tension from torquing the connections. The switch in the diagram is for On/Off of the unit and the LED sequins are for various software defined uses.
Step 3: Enclose It
I built several different enclosures for the speedometer. The first was just a series of stacked cut plexiglass sheets with nylon spacers. The components were held on to the plates with double sided clear tape. It worked well for Maui where it doesn’t rain much but for Alaska I needed a more substantial plexiglass box. The components were held on to a carefully seated plate that mated nicely with the constriction 2/3 into the box providing a protected area for the needle to move in. Make sure you create an opening for the charging/programming cable to the computer. The GPS unit should be positioned so it has a good view of the sky.
Step 4: Your Dial
The stepper is not really a stepper but goes around 300 degrees. There are 600 steps in this range and you have to design your dial accordingly. The GPS puts out Altitude, Speed and Distance and I programmed the unit to display any of these. The download software is currently configured to display speed in MPH when moving and distance in Miles when stopped–I hate nested button pushing….so the skies the limit in terms of what you want for output with a needle–for biking up Haleakala in Maui(10,000 feet elevation gain) change up your dial for an airplane altimeter dial. Say you have a bad boring commute with your favorite dog on one side of the dial and your pointy haired boss at the other–or if you have to do the middle earth commute from the Shire to Mordor every day. Anyway just do up whatever you want in photoshop or hand drawn in sand on the beach and send it off to the printer–it should be about 2.75 inches in size like your housings. I encased mine in packing tape for added protection and punch a nice size hole in the center for the needle bearing. The needle is funny–run the program and it will initialize the starting position and hold–then place the needle on the bearing to match up with zero or the shire or your dog. Push down firmly to get it to seat…its a little funky. To remove it use a fork to wedge it up. You may have to trim the needle to fit the enclosure box.
Step 5: Software
The software uses TinyGPS plus for the parsing of the GPS data. I used this because calculating distance is a very easy function in this Library. The comments in the software should help you figure out how to configure it to your needs. Currently the software starts by racking the stepper back and forth to its limits and then coming to a rest at zero on my dial–but your dial will be different so you may have to adjust. If you want to measure all distance from a fixed site just set it in homeLat and homeLng. The unit sits until it has a good fix and is parsing non-zero lat and long and sets these as your initial position. For distance it chews off 200 meters before it changes to the next lat/lng stacking up 200 meter bits in a straight line to gain your total distance. There is a commented out section in case you want to run the LED’s to tell how the battery is doing. (See Adafruits description of how this is done…). I use mode to control what output you want at the end of the loop section. Currently as it is set the Green LED sequin comes on when you are moving and the dial is displaying speed and the Red LED comes on when you stop and your total total distance is displayed.
Step 6: Using It
I dressed the plexiglass enclosure with some leather and Aluminum. Its easily mounted to your handlebars with a bike-light attachment holder. Or you can use one of those iPhone bike mounts that are so cheap now on the web. To charge just plug it in for a while(with switch on…battery has to be connected) When its mounted on your bike it will quickly sweep the limits of the dial and then stop until it gets a GPS fix–this is indicated by the slow blink of the GPS board. Peddling starts the speedometer and stopping brings up total distance. The LED’s will even light the dial for night commutes.
In this project, it is aimed to make a contribution to this dream. Controlling the machines and environment with speech makes human life easier and more comfortable. This project is a simple implementation of this approach. A robot is controlled by voice commands. Voice command is taken through a microphone, processed in computer and sent to the robot and finally the robot acts accordingly.
When we say voice control, the first term to be considered is Speech Recognition i.e. making the system to understand human voice. Speech recognition is a technology where the system understands the words (not its meaning) given through speech.
This guide will show you all the steps required to build your own voice operated robot vehicle.
The robot consists of 5 sections:
1. Power supply system
2. Analog to digital converter
3. 8051 micro-controller
4. An LCD display
5. Bluetooth module (HC-05)
6. Motor driver section
FULL REPORT:
Step 1: Gather the Components
In total, this project will cost about $40-50, depending on where you get the parts.
Here is the materials list:
1. 12V TRANSFORMER
2. ATMEL AT89S52 microcontroller
3. JHD 162A LCD display
4. 7805 Voltage regulator
5. XTAL KDS11.0592 CRYSTAL OSCILLATOR
6. 1000uf, capacitor(3)
7. 10uf capacitor
8. 100uf capacitor
9. 0.01uf capacitors(2)
10. L293D Motor driver
11. HC-05 Bluetooth-module
12. 100RPM DC-Motors
13. LED
14. smart phone with amr voice app.
…And you’re ready to start!
Step 2: Connecting the Circuit
By using the above diagram we can easily connect the circuit and make sure connecting do not overlap one on another wires while soldering.
In total it will 2-3 hours to solder and to connect the components
while soldering the holding caps of the components do not place the components on the caps
Total soldering work will be done on a pcb or if u r a starter u can use bread board and check whether the steps are working or not
Step 3: Connecting the Components
Connect the components to the pcb correctly as per the pins that u have soldered.
About the components:
A. HC Serial Bluetooth:
HC Serial Bluetooth product consists of Bluetooth serial interface module and Bluetooth adapter. Bluetooth serial module is used for converting serial port to Bluetooth. This module has two modes: master and slaver device.
B. L293D
The L293 and L293D are quadruple high-current half H-drivers. The L293 IS designed to provide bidirectional drive currents of up to 1A at voltage from 4.5V to 36V.
C. DC MOTOR
Almost every mechanical movement that we see around us is accomplished by an electric motor. Electric machines are means of converting energy. Motors take electrical energy and produce mechanical energy.
D .Step Down transformer
The transformer is the first part of the power supply, it will reduce AC to DC current and will give the circuit low voltage
Step 4: Download the APP
It is the APP which is used in our project to control or commanding the robot.
Uses android mobiles internal voice recognition to pass voice commands to your robot Pairs with Bluetooth Serial Modules and sends in the recognized voice as a string.
It will be available on the play store in the android phone as AMR_voice.
Step 5: Coding
The coding for this project is in below file u can download and directly code on the micro controller.
if u r having any problems while just put a comment below.
Step 6: Final Testing
Switch on the power supply.then
open the app
connect to the Bluetooth module
internet connection should be necessary
by giving the commands to the google voice recognition it will send the data to the micro controller and then it will send the data to the motor driver and motor driver will send the necessary actions to motors and the motors will work accordingly.
we can give five commands left,right,front,back,stop by using these commands we will control the robot vehicle
Welcome to our group instructables page. Here, we’ll break down all the steps you’ll need to build the “It’s 5 O’Clock Somewhere” portable clock.
What is it?
It’s a portable clock, connected to your local wifi, or paired with your phone, to show you the current time and where in the world it’s 5 o’clock. A tongue in cheek take on the expression “it’s 5 o’clock somewhere”, which alludes to the time in which the end of the work day has arrived, and happy hour has begun. Our device is a constant reminder that somewhere, someone is enjoying the end of their day.
What does it do?
It displays the name of a city in which it is currently 5 pm, along with the current time in your timezone. The electronics are visible through a pyramid shaped case, made from laser cut acrylic. This makes for a great portable desktop show piece.
How Does it do it?
The device makes use of the Particle Photon to connect to WIFI and determine the user’s location. The photon is programmed to capture the user’s time and location, and then determine other timezones accordingly. The time and city then gets displayed on a 0.96″ OLED screen.
3mm thick acrylic sheet (one sheet of 15″x13″ acrylic allows for enough material for 4 of these boxes)
Double sided tape
(see step 4 for complete bill of materials)
Tools list
Soldering Iron
Lead-free Solder
Sponge
Flux
A laser cutter (we recommend finding a local shop that can do this for you).
Exacto knife
Gorilla brand super glue
This project was created in collaboration by Jacob Cram, Colin Borins, Nathaniel Leslie, and Luke Garwood.
Step 1: Soldering
Since there are two protoboards, we’re going to call them protoboard1 and protoboard2 for clarity. Also, we’re assuming you’re working with the adafruit 1/4 sized protoboards, if you’ve chosen another set of protoboards then the rows and numbers may not line up exactly, but hopefully you can follow along anyway.
Connect your OLED screen to protoboard1. Solder the OLED screen’s pins to protoboard1’s row B, holes 5 through 11. B5 — CS, B6 — DC, B7 — RES, B8 — D1, B9 — D0, B10 — VCC, B11 — GND.
Solder one end of approximately 2 inches of wire to A5
Repeat this with the 6 other pieces of wire, connecting one end of each wire to A6 through A11.
Now take your lipo breakout module and line it up with the holes of protoboard2 (we’ll be inserting the wires through both the protoboard and the breakout module and soldering them in place). *the reason we need the second protoboard is so that the device sits evenly on both sides. If you’d like to alter the design, you may not need this.
Take the wire connected to A5 (or CS on the screen) and thread through to D4 on the breakout, solder in place.
Take the wire connected to A6 (or DC on the screen) and thread through to D3 on the breakout, solder in place.
Take the wire connected to A7 (or RST on the screen) and thread through to D5 on the breakout, solder in place.
Take the wire connected to A8 (or D1 on the screen) and thread through to A5 on the breakout, solder in place.
Take the wire connected to A9 (or D0 on the screen) and thread through to A3 on the breakout, solder in place.
Take the wire connected to A10 (or VCC on the screen) and thread through to 3V3 on the breakout, solder in place.
Take the wire connected to A11 (or GND on the screen) and thread through to GND on the breakout, solder in place.
That’s it! You’re electronics are all set!
Step 2: Acrylic Box
Download the file we’ve provided in the Files and References section
Take that file to your local laser cutter.
Once you have the pieces, start by peeling away the protective vinyl from the acrylic
Once all the pieces are peeled, take one of the triangular pieces, and apply glue to one of the edges.
Take the rectangular piece with the hole cut out, and connect it with the notched side on the triangular piece you just put glue on.
Once dry, look to see which end of the rectangle the hole is closer to. This edge is where the bottom of the device will go, we want to attach the bottom last, so apply glue to the other edge of the triangle.
Connect the rectangular piece again.
When dry, apply glue to two sides of the second triangular piece, and connect it opposite to the first triangle.
*Suggestion for when you put the electronics in the box. We’ve scored two slits the width of the electronics (a little wider than your battery), on the bottom piece with an exacto knife. This forms two grooves for the protoboards to sit it. Now you can apply glue to the bottom edge of the protoboards and set them in those two grooves for a better stick. We also applied a bit of double sided tape to the bottom of the Lipo battery so that it can also be stuck to the bottom piece of the box.
Step 3: Programing the Photon
If you’re brand new to Particle Photons and you’ve opened yours up for the first time, we recommend following the steps outlined in Particle’s documentation to help get you started and connected to WIFI. You can find directions at https://docs.particle.io/guide/getting-started/start/photon/ .
From the Photon IDE, open the folder entitled “5oclocksomewhere-BranchOne” from the unpacked zip file. Opening this folder will allow you to integrate all the required libraries.
On the left hand side, there’s a list of all the files included in the “5oclocksomewhere-BranchOne” folder, you’ll want to open the fivepm.ino file if you want to make any modifications.
Make sure your device is connected to your computer, and that it’s selected in the bottom toolbar (click to add it from the list if it’s not).
Compile and flash the code to your device by clicking the lightning bolt in the top left corner.
And there you go!
Step 4: Files and References
Files included here are a bill of materials, a fritzing file with the circuit diagram (http://fritzing.org/home/), and the illustrator file for the acrylic pyramid case
Having already experimented with creating a robot using a cheap motor driver board, I decided to look at the one provided by Kitronik, I liked the look of it as it came with easy to use screw terminals to attach wires and had 4 inputs by default.
The nicest thing is that if you get the v2 board (second version) it also has an expanded section which allows you to solder a 20 pin header onto it and use the full range of extended Microbit ports.
Aims
Create the robot chassis keeping costs to a minimum or allowing to reuse old parts you may have available.
Reuse old motors I had (in this case Tamiya motor gearbox combinations)
Create a good base I could provide in simple kits to students attending one of the workshops I plan to run this year.
Add IR sensors to create a way for the robot to avoid close objects.
Add neopixels so it can use different colours and sequences to show what the bot is doing
Allow more sensors to use the expanded pins on the motor driver board perhaps in future updates
2 x motors and wheels of your choice, I used Tamiya motors with gearboxes as I had some already. link
4 x AA battery box for the motors, rechargable batteries or a power supply of your choice
Some plastic strips or other to make a chassis out of. I used a couple of these link
female to female jump leads to connect microbit edge connector to IR sensors and Motor board
1 x caster wheel from DIY shop / store
Some plastic sheet, I used some A4 sheet plastic sheets 1.5mm thick, which you can score with a knife and snap, or can cut with scissors. This is great for panels on your chassis to to build sides later on and enclose all the electronics. link
For the chassis I wanted to start with a basic frame that would give me options later to perhaps build upon, so adding a body to cover the electronic could be a future option.
I started with 2 plastic strips and cut them to a length I thought my bot with 2 wheel drive and a caster wheel would need.
I placed the motors in place to work out the width I would need and attached them using the 2 fixing holes available. I cut the chassis to allow the motor shafts to stick through the middle of these two side struts of the chassis.
Next I fitted the front and back struts connecting with a single screw and nut at each corner. I had to drill these holes with my dremel as the holes already there were not exactly where I needed them.
I decided to put it on my chassis with the expanded pins section at the front, and face the microbit that way as well when slotted in place. Like many microbit expansion boards they allow the microbit to be fitted in either direction. Its important to read the expansion boards notes to see if there are any limitations when doing this such as some pins not available.
I also added the wheels to the motor gearbox output shafts and fitted a rear castor wheel.
Step 3: Adding an IR Distance Sensor
Initially I wanted to get used to using just one of these sensors, I had tried before using Arduinos and the Crumble controllers however I had found them very sensitive, and they come with a sensitivity adjustment available by screwing in or out an onboard potentiometer. My plan this time was to find settings that worked and try and get them to work each time and not need constant readjustment before use. My thoughts here were if I can use the accelerometer as a backup I can then not be too concerned if a sensor doesn’t behave as I should have another way of detecting movement and potentially cutting power to the motors.
Step 4: Complete Wiring
The wiring is reasonably straight forward, refer to the image here as a guide on what I did.
Step 5: Add the Neopixels
I also wanted to add some neopixel lights so the bot could tell me by colour what was happening as well as using the built in microbit’s display.
The neopixels I used were sold as a Crumble microcontroller accessory, I like these as they are not too small to work with and have holes to add male ended pins or wires, or can be used with crocodile ended leads.
I decided to use two side by side so first soldered 3 pieces of wire between them connecting the 3 connections required.
Positive, negative and signal
I then soldered 3 jump lead wires which were female to female so they would connect easily to the extended motor controller connections, where I had earlier soldered the header pins.
These I pushed in so I connected a Positive, negative and signal connection to these extended pins.
The pin you use on the extended header needs to be capable of analog output, so for this I used Pin 0.
I tested this with a simple micro python script (see image), this allowed me to test both neopixels, you could add more and the loop here would cycle through them all.
Step 6: Battery Power Supply, Holder and Power Switch
The good news is the Kitronik motor driver board also powers the plugged in Microbit. So using a 4 x rechargeable AA battery pack in a holder and adding a switch is the perfect combination, If you have some Lipo battery pack that would be lighter than this, but its what I already had available.
I hot glued some metal angle brackets used for small shelfs from a DIY store. These would stop the battery pack to slide about when the robot moved, but would be easy to remove to recharge or to access other parts of the chassis.
I added a switch and attached it to the chassis by creating a hole to push it through, and then soldered the wiring required.
Step 7: Basic Testing
Initially I wrote a simple program that did the following:
If nothing detected in front of robot then driver forward, display a tick(YES) on the microbit. Turn both neopixels greenIf IR detects an object reverse motors, and change display on microbit to an X (NO), and turn the neopixels to red.I also had it so that when you press the A button it simple cycled blue lights between the neopixels and displayed a Happy face on the microbit.I ran to initial problems with this basic test I found that the IR sensor could not seem get a reliable reading and constantly flickered between forward and reverse biased in the forwards direction.
I thought I had a wiring problem until I added a small sleep of 200 milliseconds to each IF test for the IR detector. This smoothed out the flickering and allowed the motors to finally run at full speed.
Its probably worth mentioning at this stage that the default behaviour of the motor driver board is on or off, there is no pwm speed control available at this time.
Once my initial very basic code was working I was ready to expand the logic and add more to the robot, this I will detail in future updates.
I have attached my really basic test code which uses the neopixels, IR sensor and the Microbit 5 x5 display matrix
I intend to add more sensors next to add some more accurate object avoidance and maybe PIR to detect when a human or animal is present and then do something based on this.
My 6 year old son likes to sleep with the lights on. Eventhough I fitted his bed side lamp with a 4 Watt led bulb , I still thought I needed a way to control the lamp without getting up in the middle of the night and manually switching the lamp off.
I like to tinker with electronics and I had some wemos D1 esp8266 compatible boards lying around, a relay switch (from a 37 sensor kit bought for my Arduino compatible board), and thought about using them to control the lamp wirelessly with the use of a web server.
The build is straight forward, but fitting them in the project box, proved quite a task.
Step 1: Requirements
You will need:
– Some sort of esp8266 board or I suppose and Ethernet capable Arduino. I got mine from Aliexpress searching for wemos d1. Eventually I got a compatible board, but it works, so no big deal.
– An on-on rocker switch, or on-off-on rocker switch. Take note that the switch must support at least two on states and should have at least 3 pins. The first rocker switches I bought had three pins but one of them was used to light a led inside the switch to indicate power. The one I eventually ended up using is an on-off-on one and thus the off state is unused, but again no big deal (I’ll change it in the 2nd revision!)
– A usb charger. I suppose you have some lying around. I opened it up and got the circuit board from inside.
– A typical Arduino relay (Aliexpress)
– A short Usb to micro Usb cable
– A project box (I used a 10cm x 10 cm x 3 cm (The Wemos compatible is around 6x7cm)
– Wire, some nuts and bolts, jumper wires, screwdrivers, hot glue, wire cutters, shrink tubing etc.
Step 2: The Hardware Sketch
You will need a circuit that has the “ability” to provide 4 states, because the user can interact with the lamp in four ways:
The user switches the light On or off manually , or On-Off via Wifi
So the states are:
Switch: ON , Relay: ON
Switch: ON , Relay: OFF
Switch: OFF, Relay: ON
Switch: OFF, Relay: OFF
That way you can interact with the lamp independently (eg if the Wemos doesn’t work you can still use the switch and vice versa)
A rough sketch is shown (sorry about the quality). On the left is the relay, and on top the switch. The sketch shows the 4 states we need
Step 3: The Hardware Build
Since I wanted to make the box “self sufficient”, I had to clip both wires coming from the mains and connect the usb charger. It doesn’t matter which lead you connect from the mains to which lead of the charger because we use AC current.
I put the switch on a corner of the box and connected three leads to it. I couldn’t get solder to stick to the pins ,so I twisted the wire, put it through a hole on the pins and used heat shrink tubing to secure the leads.
The power circuit is hot glued on the opposite corner of the switch.
It had started to get a bit crammed so I thought of screwing the relay to the Wemos, to save on cable and space. Thankfully they both had holes for that purpose and they aligned perfectly. I used M3 screws and bolts to secure the relay on the bottom of the board.
I used the cable to connect the charger board to the wemos. I had to bend it a bit to fit. It now provides a bit of “needed” tension on the wemos to keep it in place without glue and also provides easy access to it in case of upgrade.
I also bent the jumper wires at 90 degrees so that I could close the box.
Step 4: The Software
The hardest part was finding something to create the UI. On my first draft I could control the relay using a specific URL eg. 192.168.1.201/gpio/1 or 192.168.1.201/gpio/0 but it was user unfriendly. So I searched around and found the aREST library and the aREST_UI library which creates a simple user interface with an on/off button. The arduino sketch is the following:
/* This a simple example of the aREST UI Library for the ESP8266. See the README file for more details.
Written in 2014-2016 by Marco Schwartz under a GPL license. *
// The port to listen for incoming TCP connections
define LISTEN_PORT 80
// Create an instance of the server WiFiServer server(LISTEN_PORT);
// Variables to be exposed to the API
int ledControl(String command);
void setup(void) {
// Start Serial Serial.begin(115200);
// Set the title
rest.title(“Dimitris’ Room”);
// Create button to control pin 5
rest.button(5);
// Init variables and expose them to REST API
// Labels
// Function to be exposed
rest.function(“led”, ledControl);
// Give name and ID to device
rest.set_id(“1”); rest.set_name(“esp8266”);
// Connect to WiFi
WiFi.begin(ssid, password);
WiFi.config(ip, gateway, subnet);
while (WiFi.status() != WL_CONNECTED) {
delay(500); Serial.print(“.”);
}
Serial.println(“”);
Serial.println(“WiFi connected”);
// Start the server
server.begin();
Serial.println(“Server started”);
// Print the IP address
Serial.println(WiFi.localIP());
}
void loop() {
// Handle REST calls
WiFiClient client = server.available();
if (!client) {
return;
}
while (!client.available()) {
delay(1);
}
rest.handle(client);
}
int ledControl(String command) {
// Print command
Serial.println(command);
// Get state from command
int state = command.toInt();
digitalWrite(5, state);
return 1; }
What this does is connect to a specific IP address (192.168.1.201), wait for a user to connect and create an aREST object. When the user clicks the ON or OFF button it “flips” the state of pin 5 which is connected to the relay. The pin assignment is not the same on the wemos as the arduino , so you can just poke the pwm pins until the relay “clicks”. On mine, pin 5 corresponds to pin D5 which is also marked D13/SCK.
Just edit the provided sketch with your SSID and Password and the pin you want to use.
Step 5: Issues and Code Update
The first time the board worked for 2-3 hours and then it “lost” its IP (I couldn’t connect to it). Since this is the first revision (!), I hadn’t thought I would need an outside reset switch, so I had to open the box and press the reset manually. Then it worked flawlessly for 2 days and “lost” the IP again. I am thinking of an alternative way to control it just as a fail safe method (eg include bluetooth connectivity). Also the aREST library allows for cloud connectivity, so I could theoretically control it from the web, but I haven’t gotten there yet.
Update:
After it continued to loose it’s IP , I tinkered with the lease time from my router decreasing it from 1440 minutes (1 day), to 5 minutes. That way the situation improved but after a day, it lost it’s IP again. So I tweaked the code a bit. I used the Timer and ESP8266Ping libraries to generate a ping signal to my router every 10 seconds (I know it’s too short, but I’m still testing). If the ESP8266 gets a response ,all is OK, but if the response is missing it uses the ESP.reset() function to restart the wifi server and the connection to the router. The ESP.reset function can be replaced with the ESP.restart() one. The first time I used it and deliberately pinged an “unknown” address (192.168.0.1), the ESP.reset() kicked in ,but the board hanged and I had to manually press the reset switch. After that it worked flawlessly.
This guide is going to show you how to create a Bluetooth Temperature sensor to connect to your cellphone
For my “Dry-Active” project I worked with Nordic nRF51822 chipset.
This process is not a single day exercise but it’s pretty straightforward and “solid” experience
Looking online I didn’t find all info required to accomplish my task collected on a single site so I’m thinking to sharing my experience may be beneficial for others as well.
Let’s start!
This is the list of the components I used to create the final BlueTempSense
Misc electrical wires (desirable with different colors)
A proto-board to assemble the system
Check here some pictures of my final setup
Step 2: Software Environment Setup
J-Link comes with it’s own software and you are supposed to install and became familiar with that To write code for nRF51822 you should download the free SDK available on Nordic Semiconductors website
I developed my application using SDK version 10
You can download a different version but the you’ll need to adjust the makefile I’m using to compile the code
As a starting point I’m recommanding to install the same version I have and once you are familiar with the process you can come to a more updated version if you need to.
To download Nordic SDK Ver 10 you can do the following
go to Nordic nRF51822 product’s webpage (http://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF51822)
Click “Download” Tab
Click on current SDK “version number” (check picture above)
Download SDK version 10 (check picture above)
Unzip in a folder without spaces in pathname
Nordic has a good guide to setup GCC toolchain for your development BUT in my experience having a path containing SPACEs is not a good idea (possible because I’m developing using Windows VISTA).To avoid potential issue make sure you are going to install GNU gcc toolchain in a simple path with no spaces.Something like C:\nRF51_DEV\gcc_toolchainBasically replace all the references to/GNU Tools ARM Embedded/4.9 2015q3with\nRF51_DEV\gcc_toolchain
Follow Nordic “Development with GCC and Eclipse” step by step guide to setup GCC environment (I didn’t use Eclipse so I did stop at”Setting up Eclipse the first time”)https://devzone.nordicsemi.com/tutorials/7/
Now you should have a full nRF51 development environment
Step 3: NRF51822 Firmware
To make things easy I have a working example you can download and install to test on your platform soliditec_bluetempsens-1.zip
My 6 year old nephew wanted to have a robot to guard his room, so I decided to build one for / with him. It was supposed to have green eyes that turn red when an intruder is detected. And an alarm siren should go off. In the video you can see the final result.
Each robot needs a central circuit or “brain” which in this case is an Adafruit Trinket 5V. Hidden in the robot’s chest there is a PIR sensor to detect motion. As soon as the sensor is triggered, two green LEDs need to be switched off and two red ones are switched on – together with a piezo buzzer.
Well, that shouldn’t be too hard to program on the trinket – and it sure is a lot of fun!
By the way: The robot is powered by a 4 AA battery backpack.
This instructable is structured in several parts, so you can only build the tin robot without any electronics, and if you want to, you can add the electro stuff later. The parts are
Building the robot body
Putting together the electronics
Programming the robot
Let’s get started!
Step 1: Building the Robot Body
Friends, a real robot is made from METAL, and except for the feet, I stuck to that unwritten law. Here is what I used, but feel free to use anything else:
ROBOT BODY:
The torso is made from a tin soap box covered by a 2.5″ hard drive plate
The arms and legs are made from a flexible shower hose
The head is made from a bezel covering a server’s spare power supply slot (kindly ask your company’s IT department to search their scrap or electronics dumpster – or simply substitute the head with some other tin box… your imagination is the limit)
The only thing that is not metal are the feet, it is a piece of wood that I wrapped with silverish duck tape to make it look metallic…
Tools and materials needed:
hack saw
Dremel multi tool
screw driver
Screws and accompanying nuts, disk washers
scrap wood
silver Duck Tape
Add whatever you like to be on your robot! I can think of several ways already to improve the looks: Antennae, buttons, gauges, hands, …
A word of caution before you start:
Real metal looks cool on a robot, but drill holes and cut surfaces can have sharp edges. I always tried to smoothen them, file them down or cover them with tape. Wear protective gloves and safety goggles when using the Dremel multitool to cut metal.
The building process:
I am a visual guy. Please klick through the images, I attached instruction and notes there where I saw the need to explain something. I am thankful for hints if another detail image is needed or something needs to be clarified. As I said – this is my first instructable.
Step 2: Putting Together the Electronics
Circuit Overview
Look at the Fritzing drawing. We have three main parts we need to consider:
A head with the LED eyes and the speaker
The torso where the PIR sensor and the microcontroller (brain) are located
The powersource: a 4 AA battery backback which will power the robot.
The Head
We basically need 6 wires from head to torso:
+ and Gnd for the red eyes
+ and Gnd for the green eyes
+ and Gnd for the piezo speaker.
I hid these six wires inside a “spine” in form of a scrap DB9 / RJ45 console cable that I cut apart. These cables have eight wires. Note that old Ethernet cables can also be used for this purpose – which I think is a great way of recycling old cables that would otherwise be thrown away. So you cut a convenient piece of cable, remove the outer insulation and lay bare the eight wires. Carefully reemove about 5mm of the rubber mantle insulation. Do this on both ends of the spine.
Now pick six of the wires and note down which color you want to use for + and – for the red and green LEDs as well as the piezo speaker. All of these parts will be soldered to a permanent breadboard in the head. It helps to mark on the breadboard where exactly you will locate the LEDs. Also draw a + and – where you will attach the corresponding wires. Notice that I took a protoboard all holes in a row are connected through the copper on the back side. That helped to wire the red LEDs in a row and also the green ones. Notice: it is important to interrupt the red and green LEDs’ GND lane, otherwise you would get a short circuit.
Now is a good time to solder your red and green LEDs to their final position. Double check that the GND leg (cathode) coming from the first LED is connected to the + leg (anode) of the second LED!
Now take a sharp knife or cutter to scratch away the copper that would close the loop between the 2nd LEDs cathode and the anode of the 1st LED.
Once the eyes are done, you can procede to solder the + and – of the piezo speaker; that should be easy now.
In the final step you take your spine and connect your 6 colorful wires that you noted down and solder them to the correct protoboard lane. Your robot’s head (the hardest part) is done, congratulations!
The Torso
The most important part in the torso is of course the microcontroller. It is plugged into a solderless breadboard which is glued to the tin box belly. We go on to prepare the wires on the torso end of the spine to plug into the solderless breadboard. For that purpose I soldered a breadboard-friendly tip to each of the six wires (cf. the green cable in the foto). Once you’re done with that you can plug the spine wires into the correct breadboard location one by one. Just stick to the Trinket’s Pins that are used in the program (in the next step):
Pin 2: Piezo buzzer +
Pin 3: Green eyes +
Pin 4: Red eyes +
GND: All 3 GND wires coming from the head connect to this Pin
The PIR movement sensor only has three connectors: VCC, OUT and GND. You can take female-female jumper wires to connect it to the Trinket:
VCC on PIR —> Trinket’s 5V Pin
OUT on PIR —> Trinket’s Pin 0
GND on PIR —> Trinket’s GND
That is it! Now we need to power the robot.
Power Backpack
The Trinket 5V runs on (you guess it) 5 Volts. For this purpose you could either use a 5V micro USB charger which would render the robot quite immobile, or you can equip it with a backpack of 4 AA batteries of 1.5 V each which are connected in a row. This adds up to roughly 6V which is also fine for the Trinket.
If you take the power pack approach you need to solder two wires to the battery holder’s anode (preferrably red) and cathode (preferrably black). Connect the + pole (red) to the Trinket’s BAT pin and the – pole (black) to the Trinket’s GND pin.
In my design I did not (yet) include a power switch due to time constraints, but this would definitely be a valuable addition to the robot! At the moment the only way to put it to sleep is to remove one of the batteries. That will drop the current to ~4.5 V which is not enough to power the Trinket. As I said – a power switch will improve the robot a lot.
Step 3: Programming the Robot
The electronics are connected, now the robotic brain only needs to know how to use all of its parts…
The Adafruit Trinket is programmed via a USB cable that is connected to your computer. If you need help setting up the programming environment, refer to Adafruit’s very comprehensive how-to guides.
Open your Arduino programming IDE and simply import the attached sentinel-robot.ino file and upload it to your trinket. The code is quite simple with explanations
#define EYES_GREEN 3 // GPIO Pin 3 #define EYES_RED 4 // GPIO Pin 4
#define PIR 0 // Movement Sensor GPIO Pin 0
#define ALARM 2 // Piezo-buzzer GPIO Pin 2
void setup() {
// We want to OUTPUT power to the LEDs and the buzzer,
// We want to read the INPUT from the PIR sensor:
pinMode (EYES_GREEN, OUTPUT);
pinMode (EYES_RED, OUTPUT);
pinMode (ALARM, OUTPUT);
pinMode (PIR, INPUT);
// initially the red eyes and the alarm are off and the green eyes are on:
digitalWrite (PIR, LOW);
digitalWrite (EYES_RED, LOW);
digitalWrite (EYES_GREEN, HIGH);
digitalWrite (ALARM, LOW);
} // Here is a function to produce the alarm siren.
// I borrowed this from <a href="http://web.media.mit.edu/~leah/LilyPad/07_sound_code.html" rel="nofollow"> http://web.media.mit.edu/~leah/LilyPad/07_sound_c...>
void beep (unsigned chEYES_RED speakerPin, int frequencyInHertz=523, long timeInMilliseconds=500)
{
long delayAmount = (long)(1000000 / frequencyInHertz);
long loopTime = (long)((timeInMilliseconds * 1000) / (delayAmount * 2));
for (int x = 0; x < loopTime; x++)
{
delayAmount -= 1;
digitalWrite(speakerPin, HIGH);
delayMicroseconds(delayAmount);
digitalWrite(speakerPin, LOW);
delayMicroseconds(delayAmount);
}
}<br>void loop() {
// this is run indefinitely:
if (digitalRead(PIR)) { // motion is detected
digitalWrite(EYES_RED, HIGH); // turn red eyes on
digitalWrite(EYES_GREEN, LOW); // turn green eyes off
beep (ALARM, 1046); // sound the alarm once
} else {
digitalWrite(EYES_GREEN, HIGH); // turn green eyes back on
digitalWrite(EYES_RED, LOW); // switch red eyes off
}
}
If your trinket is still connected to your robot and all of its cables, your robot should now come to life and react to movement by beeping and turning its eyes red for a few seconds until everything is “green” and quiet again.
The Intel® Quark™ microcontroller D2000, is a low power, battery-operated, 32-bit microcontroller with a more robust instruction set than other entry-level microcontrollers. The first x86-based Intel® Quark™ microcontroller, Intel® Quark™ microcontroller D2000 also increases input/output options over other entry-level microcontrollers. Within its small footprint, the Intel® Quark™ microcontroller D2000 includes an Intel® Quark™ ultra-low-power core running at 32 MHz, with 32 KB integrated flash and 8 KB SRAM.
What we are going to do with it? If you are from engineering background (or you are a tech geek) in programming when we start learning a new programming language we always start with “Hello World” program. Same as programming when we start hands on microcontrollers or development boards we test “Blink LED” test at the very first. So in this tutorial I am going to explain how to setup the environment.
So lets get started…
Step 1: What You Need?
Hardware 1. Intel® Quark™ D2000 Microcontroller Development Board – Buy Link 2. Micro USB Cable (although it included in package)
Software (IDE) 1. Intel® System Studio for Microcontrollers – Download Link
Step 2: How to Connect D2000 With Computer?
It is very simple just plug the micro USB port in the D2000 board and the other side in the computer’s USB port. The green LED confirms connection. Make sure you have correct drivers.
Step 3: How to Install Intel System Studio for Microcontrollers?
As we have just done with all the installations and connections. Its time to install ROM on the board. Every board comes with empty ROM and you have to install ROM at very first.
1. From the menu toolbar select Project > Update Microcontroller ROM
You can see this process in attached video for more convenience.
Step 5: Let’s Play With LED
First you need a Project so create a new project from “File” menu. And then select “Intel Project for Microcontrollers”. New window will appear select our development board from the select screen, press “Next >”. It will ask you for “Project Type”, as we installed QMSI 1.1 in previous step. So select “QMSI 1.1”, press “Next >”. Then connction type as “USB-Onboard”.
On next screen you will have to give a name to your new project. Give a nice and relevant (because lots of newbies user names like “TEST”, “TEST 1” etc… lol) name to your project.
The cool part is Intel has already embedded some of the example projects. So select “LED_Blink” from the examples and press finish. Trust me this program is absolutely complete you not even have to change any variable for test run.
So you just have to run you project from the Run menu and press Run the select configuration as “flashing”.
voilà! If all goes good you will see Flashing blue LED on the board itself. How ever some times this process fails with “device not found error” but don’t worry it just driver issue. Just follow the link.
Please do watch the video add in this tutorial as I have covered all the steps for better visualisation.
This instructables show how to flash NodeMCU firmware to WeMos D1 mini Pro.
Step 1: Introduction
WeMos D1 mini Pro is a new ESP8266 dev board.
It is thin, light weight, built-in USB to serial chip and 16 MB flash!
Recently, it is the only board with built-in 16 MB flash (at least 4 times of flash space compare with other ESP board). However, there are still no one on the web know how to utilize all 16 MB flash space. (In Arduino, you can treat it as a normal 4 MB version ESP board but nothing more)
I can flash an older version (1.5.1 SDK) NodeMCU firmware to a 16 MB ESP board in my previous instructables. But when I flash the most recent version (1.5.4.1 SDK) of NodeMCU firmware to this board, it will loop forever on the rf_cal_size reboot.
After days of subsequent test, I found the SDK limitation and know the workaround to overcome this. This instructables show how to do that.
you may have to install pySerial manually by running something like pip install pyserial, easy_install pyserial or apt-get install python-serial, depending on your platform.
ESP8266 NONOS SDK V1.5.4.1 use the flash memory last 5 sectors (@4096 bytes) to store the system data. The SDK can detect the flash size correctly while the flash size within the range from 256 KB to 4 MB. I guess because there are no ESP board with flash larger than 4 MB before, the SDK not defined 8 MB and 16 MB flash size. So, SDK failed to detect 8 MB and 16 MB flash correctly and fall back to the default size (512 KB).
The screen capture is the boot up message after flashed latest (2016/11/11) dev branch. The message “rf cal sector: 123” should mean the last 5th sector of 512 KB.
SDK use the 5 sectors just before 512 KB to store the system data is ok, but it introduce some rules on flashing firmware:
firmware size cannot over 491 KB (the space before the system data)
remember treat it as 512 KB flash size while flashing
manual flash the esp_init_data (part of system data) to the correct place (last 4th sector)
After SDK boot process, NodeMCU firmware is intelligent enough to detect the correct flash size and format the remained ~15.48 MB flash size to SPIFFS. It can store Lua code and other resource files, GREAT!
Kinoma Element can power 3.3V sensors, but some projects call for the use of higher-current devices. The Tessel Relay module makes it easy to toggle externally-powered devices on and off. In this project, we control a network of two lamps using Kinoma Element, capacitive touch sensors, and relays.
A short touch (less than 2 seconds) will toggle a single lamp on and off. See image 2.
A long touch on either one will turn both lamps on/off. See image 3.
Step 1: Wiring
The relay is used to open and close the circuit of the lamp. The PAD pin on the capacitive touch sensor is attached to a metal plate, which makes the base of the lamp act as an external electrode. See image 1 for a wiring diagram.
You’ll need to disassemble the lamp cord that is usually plugged into a wall outlet. Cut the end off of the power wire, strip the ends, and insert the two exposed ends into the port on the relay. Pressing down on the connectors with a ballpoint pen is helpful when inserting and removing the wires. See image 2.
Step 2: Scripting
In the application’s onLaunch function, we use the Pins module to set up the hardware and connection to the other lamp. This is done in four parts:
A call to Pins.configure to set up the connection to the pins on the local device. This is where the pin numbering and types are specified. It is also where we specify which BLL each sensor requires; because we only need simple read and write functions, we use the built-in Digital BLL. See image 1.
A call to the relay’s BLL to toggle the switch on using Pins.invoke. This turns the lamp on to signal that everything was configured properly. See image 2.
A call to Pins.share to make the hardware capabilities of this device accessible to the others on the same network. Here we specify that other devices can connect to this device using WebSockets and request that the shared pins be advertised using Zeroconf. See image 3.
A call to Pins.discover, which begins the search for devices being advertised using Zeroconf.
The first argument passed into this is a function that is called when a device is discovered. We check the name property of the description of the device to make sure it’s the twin lamp, and establish the connection to it by calling Pins.connect. See image 4.
The second argument is a function that is called when a device is lost. If it’s the other lamp in our network, we remove the reference to the remote device by setting main.remote back to undefined.See image 5.
Once the pins are all set up, we call the startReading function. This is where we begin to make repeated calls to the read function of the capacitive touch sensor’s BLL. The read function returns 1 if the sensor is being touched and 0 otherwise. See image 6.
If the sensor is being touched, we change the state of the local relay and wait for 2 seconds. If the sensor is still being touched, we also change the state of the remote relay to match. In both cases we want to call the write function in a relay’s BLL; for the local relay we use Pins.invoke. See image 7.
The reference to the remote device’s pins is stored in main.remote, but the rest of the call looks identical to the local sensor call. See image 8.
If you want to change the length of time that defines a ‘long’ touch, simply edit the main.hold object to the desired value, in milliseconds. See image 9.
Step 3: Cut Wooden Bases
In order to make this project look more like a real product, we put additional effort into crafting a wooden base that nests all the parts for the lamp.
We used the removable bottom of a pie tin as the metal surface of the lamp to get a perfect circle. Two pieces of 1″ wood were roughed out to a circle then using a top bearing bit were cut on a router to match the metal circle. The piece we used for the bottom was center bored to hold the components.
With a rabbet bit we routed a 1/8″ grove in the lower piece to hold an acrylic plate to protect the components. We were able to purchase acrylic disc’s from a local plastics vendor.
Step 4: Drill Holes for Lamp Post and Attachment Nut
A nut to hold the lamp post was pressed flush into a tight fit hole in the upper wooden piece. A wire was attached to the bottom side of the metal and passed through a hole in the top piece to conduct the touch to the capitative touch sensor board.
Step 5: Install Components and Glue Base Together
Glue the 2 wooden pieces and metal plate together to make the base as illustrated in image 1.
Components were installed as illustrated in image 2. Be sure to make good connections on the 110v relay with no bare wire showing. Add stress relief to the power cord for safety, and screw in rubber feet give the lamp stabilty and secure the acrylic plate.
Step 6: Finish
Once you’ve wired everything up, download the element-twin-lamps sample application and open it in Kinoma Code. Run it on both of your Kinoma Elements and tap the touch sensor to switch the lamps on and off.
Keep in mind that you are not limited to creating a network of just two lamps. You can add additional lamps to the network with just a few changes to the code, and the relay can be attached to other devices. Perhaps you want to turn on your coffee machine when you touch your alarm clock, or wirelessly control the fan, speakers and lamp in your room with a touch pad on your desk.
The ESP8266 is a wonderful microcontroller. They can be purchased cheaply and have built in wifi.
In this guide I will not go over how to flash the ESP8266 module with the basic firmware as this is covered on the http://ESP8266basic.com web site in detail.
All the parts to build this project can be found on ebay for less than $10 shipped to the US.
Step 2: Assemble the Circuit Using the DU-PONT Wires.
I hooked up my entire circuit using only female du-pont wires. You could get a bit more phansy but this worked well for me.
Use the circuit diagram as reference.
Step 3: Program the Module
Goto the esp8266 Basic program editor in your browser and past the following code in.
Then save your program and click run.
dim irButtons(6) as string dim irCodes(6) as string
x = 0ir.recv.setup(5)
ir.send.setup(4)
IRBRANCH [received]for x = 1 to 6
irButtons(x) = read("irbut" & str(x))
irCodes(x) = read("ircode" & str(x))
if irButtons(x) = "" then irButtons(x) = "UNUSED"
next x[top]
cls
cssclass "button", "background-color: powderblue;height: 20%;width: 30%;"
Print "ESP8266 Basic Learning IR remote"
print "Last IR recvd"
textbox ircode
print "Text for button"
textbox newtxt
print "Button number"
dropdown x, "1,2,3,4,5,6"
Button "Program Code to button", [program]
print button irButtons(1), [bu1]
button irButtons(2), [bu2]
button irButtons(3), [bu3]
print
button irButtons(4), [bu4]
button irButtons(5), [bu5]
button irButtons(6), [bu6]IRBRANCH [received]
wait[received]
ircode = ir.recv.full()
return[bu1]
ir.send(irCodes(1))
x = 1
wait[bu2]
ir.send(irCodes(2))
x = 2
wait[bu3]
ir.send(irCodes(3))
x = 3
wait[bu4]
ir.send(irCodes(4))
x = 4
wait[bu5]
ir.send(irCodes(5))
x = 5
wait[bu6]
ir.send(irCodes(6))
x = 6
wait[program]
irButtons(x) = newtxt
irCodes(x) = ircode
write("irbut" & str(x),irButtons(x) )
write("ircode" & str(x),irCodes(x))
goto [top]
Step 4: Start Teaching Your Remote.
Click the button you wish to program. There will be 6 available for you to use.
Next on your TV remote hit the button you wish for the module to learn.
In the “Last IR Recvd” text box you should see a remote code pop up. If it says unknown press the button on your remote again.
Currently this will only work with codes that say sony or nec.
Once a good code is showing in the textbox type the text you would like for your button in to the “Text for button” textbox and click the “Program code to button” button.
The button has now been set up and can be used to control the TV. Press the button in your browser and test to make sure it works.
Repeat for each of the 6 programmable buttons.
Don’t worry. If you reset the module it will remember your button text and codes as they are stored in the flash memory.
Now you are done. You have an awesome tv remote that can be controlled via wifi from your computer or smart phone.
The ESP8266-01 only has a limited number of I/O pins (only 4). Fortunately these pins can be used for I2C communication, allowing us to add a hoist of other chips. I wanted to add an RTC to the ESP8266-01 and for testing purposes I did not want to always have to go to an ESP8266 generated webpage to check the output and I found keeping it attached to the USB port too cumbersome, so I needed to add some sort of output device.
Ofcourse there is the LCD and people have been adding that to the ESP8266, but it is 5 Volt. Though apparently the voltage on the I2C pins of the LCD falls within the tolerance of the ESP8266, I did not want to risk that, so I would need a voltage leveler, which I found too cumbersome just for testing purposes. Therefore I decided to use a simple and relatively cheap OLED display. These are I2C by nature and work on 3.3 Volt. Anyway, for this project the shopping list is as follows:
With regard to the OLED library, Adafruit also provides one, but it requires instalation of the GFX library as well, so I opted for another library. Also I understood some people having trouble with it that needed changes in the *.h file. It is said to work though on the ESP8266.
Just some remarks on the BOM:
If you still need to buy an ESP8266-01, consider buying a newer one. The 01 version is not particularly cheaper than say the 12 version and for a few euro more you even have a micro USB connection integrated on it as e.g. in the NodeMCU
When I mention the DS3231 or DS1307, I mean a fully integrated module that has likely also an EEPROM on board. Pricewise it is foolish to buy a separate DS3231/DS1307 chip and a x-tal and battery holder. When buying a module, watch out as the come with or without battery and the price difference might be minimal. I would advise getting the DS3231 as that is more accurate than the DS1307. The DS1307 has some on chip NonVolatileRam though that may come in handy if you have to do a lot of writes to memory, which would eventually kill an EEPROM
The female and male headers and the piece of veroboard I used to make a breadboard friendly converter for the ESP8266-01 pin header. You may have your own solution for it. However, discussing the adapter in depth is not my goal here, basically it turns the 2 row header base into a 4 row header base that fits around the separator in the breadboard
Make sure you use a 3.3Volt USB to TTL converter. There are some switchable ones. Check if the switch is set to 3.3Volt. A very handy programming device for the ESP8266-01 is this one. Especially if you plan to program a lot of chips.
There are different color OLEDs, mostly blue ones and white ones (I refer to the text color) there are some however that have to top half a different color (often yellow) than the bottom half. If you see that your OLED is not broken, it was designed for a special application, like a cellphone
Step 1: The Connections
This couldn’t be simpler: I used GPIO0 as SDA and GPIO2 as SCL. The RTC and OLED have the pin nominations clearly stamped on them so you only need to connect as follows All Vcc-s together All Grounds together RTC and OLED SDA pins to GPIO0 RTC and OLED SCL pins to GPIO2
Finally connect the CH_PD pin with Vcc Make sure you identify the proper pins. Your modules may have a pin sequence that differs from mine.
I did not add any pull-up resistors as my RTC has those and as far as I could see my OLED has too. If your modules do not, you need 2 pull up resistors on the SDA and SCL lines 2k2 to 4k7 is a good value. If you plan to add more modules that may have an internal pull up already… chose 4k7
Step 2: The Code
I presume you do know how to program the ESP8266. In short: Connect Tx<->Rx (meaning the Tx of your ESP to the Rx of your USB-TTL converter) Connect Rx<->Tx Connect CH_PD<->Vcc Connect GPIO0 <->Grnd
/* ************************************
Read the time from RTC and display on OLED
with an ESP8266<br> sda=0, scl=2
* *************************************/
// Libraries
#include <Wire.h>
#include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
#include "RTClib.h" // Lady Ada
//Object declarations
RTC_DS1307 rtc; // RTC
SSD1306 display(0x3c, 0, 2);//0x3C being the usual address of the OLED
//Month and Day Arrays. Put in Language of your choice, omitt the 'day' part of the weekdays
char *maand[] =
{
"Januari", "Februari", "Maart", "April", "Mei", "Juni", "Juli", "Augustus", "September", "Oktober", "November", "December"
};
char *dagen[] = {"Zon", "Maan", "Dins", "Woens", "Donder", "Vrij", "Zater" };
// date and time variables
byte m = 0; // contains the minutes, refreshed each loop
byte h = 0; // contains the hours, refreshed each loop
byte s = 0; // contains the seconds, refreshed each loop
byte mo = 0; // contains the month, refreshes each loop
int j = 0; // contains the year, refreshed each loop
byte d = 0; // contains the day (1-31)
byte dag = 0; // contains day of week (0-6)
void setup() {
Wire.pins(0, 2);// yes, see text
Wire.begin(0,2);// 0=sda, 2=scl
rtc.begin();
// reading of time here only necessary if you want to use it in setup
DateTime now = rtc.now();
dag = now.dayOfTheWeek();
j = now.year();
mo = now.month();
d = now.day();
h = now.hour();
m = now.minute();
s = now.second();
DateTime compiled = DateTime(__DATE__, __TIME__);
if (now.unixtime() < compiled.unixtime())
{
Serial.print(F("Current Unix time"));
Serial.println(now.unixtime());
Serial.print(F("Compiled Unix time"));
Serial.println(compiled.unixtime());
Serial.println("RTC is older than compile time! Updating");
// following line sets the RTC to the date & time this sketch was compiled<br> // uncomment to set the time
// rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
// Initialise the display.
display.init();
display.flipScreenVertically();// flipping came in handy for me with regard
// to screen position
display.setFont(ArialMT_Plain_10);
}
void loop() {
display.clear();
DateTime now = rtc.now();
dag = now.dayOfTheWeek();
j = now.year();
mo = now.month();
d = now.day();
h = now.hour();
m = now.minute();
s = now.second();
display.setTextAlignment(TEXT_ALIGN_LEFT);
display.setFont(ArialMT_Plain_16);
String t = String(h) + ":" + String(m) + ":" + String(s);
String t2 = String(d) + ":" + String(mo) + ":" + String(j);
display.drawString(0, 10, t);//
display.drawString(0, 24, t2);
display.drawString(0, 38, maand[mo - 1]);
String d = dagen[dag];
d = d + "dag";//adding the word 'dag' (=day) to the names of the days
display.drawString(0, 52, d);
// write the buffer to the display
display.display();
delay(10);
}
The last line, with the day on it, may be just a bit too much size for your OLED: set the font smaller (say ‘Plain_10’) and alter the print positions (the second digits in the display.drawString(0, x, string); statements)
I love astronomy and astrophotography very much. I am sure that like me, all amateur astronomers would want a inexpensive personal observatory for taking pictures of the fabulous universe.
Astrophotography, especially deep-sky photography, requires high precision in tracking (to counter the earth’s rotation) and focusing. A decent equatorial mount plus autoguider can take care of tracking while a motorized focuser can achieve high precision in focusing. They are all quite expensive! There isn’t really any reliable substitute for a good mount and autoguider but a motorized focuser is relatively easy to DIY at a very low price.
Also, It would be convenient to be able to control the mount remotely. I am from China and I am currently studying in US for college. It would be nice if my high school astronomy teacher can access my telescope remotely and show her class the real time images for planets or star clusters. There exists some solutions to control the telescope remotely but I am not satisfied with them.
So, I started this proof of concept project that allows user to remotely control the equatorial mount, the focus of the telescope and the camera via a webpage.
Introduction:
You can watch the demo video above to see how the project works. The project consists of 4 parts
Micro-controller communicates with other devices via a custom made serial JSON string protocol
A webpage as an interface to control the mount, the focuser, and the camera
In this tutorial, I will lead you through the process of creating a focuser and running my code to control the telescope.
Step 1: Everything You Need
I made this project based on the equipment I have. If you have the same equipment I have, you can follow my exact steps, but if you don’t, you may need to tweak things or implement your own code to get it to work.
Tools:
A set of Allen keys
Caliper
Hand drill
Access to a 3D printer
A CAD software (I used Fusion 360 student version)
Astronomy equipment you may already have:
A telescope with a decent manual focuser (I have a sharpstar CF90-II)
A sky-watcher equatorial mount with synscan v3 or v4 (I have an EQ6-pro with syscan v4)
Raspberry pi (for remote DSLR control, I have a rpi2)
A wifi dongle for the raspberry pi (unless you have a rpi3)
Teensy3.2 (communicate with the mount and other device)
Long good quality usb micro cable * 2 (for powering rpi, and teensy)
Long good quality usb mini cable (for your DSLR)
RJ-11 jack and cable (connect teensy with syscan)
Max232 chip (convert syscan’s RS-232 level to teensy’s ttl level)
10 uf capacitors * 4 (work with max232 chip)
LCD screen 1602a
28YBJ-48 Stepper motor
ULN2003 stepper motor driver board
MXL 45 teeth timing belt pulley (replace the focuser knob)
MXL 15 teeth timing belt pulley (attached to the stepper motor)
Timing belt
Buttons * 3 (control focuser)
Potentiometer * 3 (change speed of stepper motor and adjust brightness/contrast of LCD)
#6 screws and nuts (install 3D printed focuser)
breadboard * 2
Lots of jumper wires
5V2A power supply for the rpi, and 12V 2A power supply for the mount
Note:
If you don’t have a DSLR, you can skip the parts related to it and build a mount controller.
The value of the capacitors for max232 does not matter that much, I have seen several diagrams with different values. As long as it is not too small, you are fine. If you have a breakout board, that is even better.
When you buy the timing belt pulley, make sure the bore diameter matches your focuser and stepper motor.
Do not buy long opening timing belt and attempt to glue it into a circle. I have done that and I have tried everything but nothing works. I got mime from McMaster-Carr.
A good quality usb cable can save you hours debugging weird issues.
I used teensy3.2 micro-controller. It is an Arduino compatible but more powerful. Some of my code is Teensy specific (for example IntervalTimer). If you want to use the code on an Arduino, you need to make some modification.
Step 2: Design the Electronic Focuser
My design is partially inspired by this post. The general idea is to make a device that lets the motor turn the focus knob instead of hand. I chose to use stepper motor because it is very precise and my testing shows that with the timing belt mechanism to increase the torque, it is powerful enough to adjust the focus when using a DSLR. I used the timing belt mechanism because it offers an easy switch between manual focus control and motorized focus control by changing the tension in the belt. In my design the body of the electronic focuser consists of 3 pieces. A piece that attaches to the focuser of the telescope (inner), a piece that serves as a spacer (middle) , and a piece that holds the stepper motor (outer). All three pieces are connected together using four long #6 screws and nuts embedded in the outer piece. In addition, there is another piece that is used to adjust the tension in the belt. This separation makes 3D printing easier later and for different telescope, all you need to do is to design a different inner piece.
The stepper motor holder I designed is based on my telescope. Yours may have slightly different parameters. So it is always nice if you can CAD the whole thing and verify it works before printing.
Step 3: Print and Assemble the Electronic Focuser
After you finish your design, you can 3D print the part and install it on your telescope. The installation is straight forward. Just follow the pictures and the CAD design (try the exploded view). The 1st image above shows the situation when the belt is tightened and the 2nd image shows when the belt is loose.
Here is a list of tips that may help you:
In most cases you can use Allen key to take off the hand knob on the focuser. When you install the large timing belt pulley, make sure the screw goes into the little tab on the axis.
Always pre-drill pilot holes before drilling the actual hole.
You can wrap the tension adjust piece with rubber band so it auto retracts.
For connecting the stepper motor and the outer piece, you can pre-drill a hole that is slightly smaller than the screw and thread the screw in for a tight connection.
Step 4: Driving the Stepper Motor
The stepper motor is connected to the driver board, which is connected to the teensy micro controller. If you are not familiar with stepper motor, this Wikipedia page and this link can be helpful. In writing the code to control the stepper motor. I referred to this link. I implemented 2 driving mode: two phase full step and half stepping. Two phase full step provides more torque but less precision, while half stepping provides twice the precision but less torque. The following array contains the state of the four stepper motor pins.
In half stepping mode, the states of the 4 pins cycle through all 8 combinations in the array, but in two phase full stepping mode, the 4 pins cycles through index 1,3,5,7 of the array. Two push buttons control the direction of the motor by cycling through the array in different direction.
When using a particular driving mode the speed of a stepper motor depends on the interval between the states of the pins changes. Stepper motor requires very precise timing to drive, so I used a timer interrupt to drive the motor. The interrupt is triggered at a fixed interval. Every time an interrupt is triggered, the code sets the stepper motor pins to the next combination in the array. A potentiometer is used to change the interval of the interrupt, thus changing the speed of the stepper motor.
Please refer to step 5 for wiring and step 6 for the code
Side note: It is a bad idea to use a raspberry pi to drive stepper motor. The motor would misbehave under short step interval because a raspberry pi runs an OS and is hard to achieve hard real time control.
Step 5: Connect the Circuit
Connect the circuit board based on the diagram shown above. For the motor control mode wire and display setting wire, you can add switches to make it easier to use. For switches and potentiometers, you can also add additional capacitors to smooth the input if you want.
For the entire system to work, you also need to connect the teensy and the DSLR to the raspberry pi, connect the syscan hand control with the RJ11 jack, and power the rpi using a 2A power supply.
Step 6: Teensy Code
To compile this code, you need to install the aJSON library. Just download the zip here: https://github.com/interactive-matter/aJson . In the arduino IDE, Sketch -> Include Library -> Add .ZIP Library to add the library. Then, go to ~/Arduino/libraries/aJson-master and replace the aJSON.cpp file with my version (attached below). It addresses this issue.
This code controls the stepper motor, talk to syscan hand control using the syscan serial protocol and communicate with other device using serial JSON string protocol. It has a circular buffer that queues up outside request and execute commands in the buffer at a fixed time interval. Though, here I am connecting the teensy to a raspberry pi, but you can easily modify my code to make it talk to a wifi module or a bluetooth module if you don’t want the camera control part.
The serial JSON string protocol I implemented here is quite interesting. The device has an internal JSON like tree structure that has getters and setters for different properties. Below is what it looks like.
Any subset of this JSON tree structure is a valid command, with empty object being get and non-empty values being set. For example, a command like {telescope:{EQ_Coord:{}}} means getting the current equatorial coordinate of the mount. The teensy would reply with the sub tree filled in, for example: {telescope:{EQ_Coord:{RA: 50.5, DEC: 85.5}}} . For goto a target, you can simply send {telescope:{EQ_Coord:{RA: 70.2, DEC: 40.8}}} and the teensy would interpret it as goto that coordinate. The parser is recursive so you can send {telescope:{}} to get all status about telescope, or do multiple get/set in one command. The code would also validate the input value in your set command and prompt you API error.
Aside from this project, If you want to achieve similar things, definitely take a look at my code.
I used a webpage as an interface because it works on all smart devices. Theoretical, any browser that supports HTML5 should be able to access the page and control everything.
After the server is running, you can open a browser and go to the local IP address of your raspberry pi using port 8080. For example, in my case, my rpi’s local ip address is 192.168.0.15 . I can access the page by putting 192.168.0.15:8080 in my browser. You can login to your router or hover the mouse on the network icon in the raspberry pi to get its local IP address.
a. First of all, get your box and mark down four holes the size of your buttons. Please remember to leave space for the makey makey to go inside the box, like the picture above.
b. Using a scissor or a needle, cut down those holes, so the buttons can fit exactly on it.
c. Insert the button in one side and the nut in the other side. Make sure the button is fixed properly.
d. Using the baking clay, design three button caps of about one inch (or the size you think it is better for you) and paint them in different colors.
e. Using super glue, glue those buttons caps to the buttons. Let stand still for about 5 minutes.
f. Draw on paper labels “water”, “food” and “Help” (or something else you want – we will discuss this later).
* If you want you can use anything as a button cap, not necessarily baking clay. Use your imagination!!! (:
Step 2: Getting Makey Makey Ready!
a. Inside the box, fix the makey makey board using tape (remember to fix it in the spot that you reserved to the board previously!)
b. After the board is settled, it is time to connect everything! For each button, connect one wire in the “earth” and the other wire in the “WASD” part, like the image below. If you are following the same model that I used, connect: W for Water, A for Food, S for Help and D for Back buttons.
c. For last but not least, connect the USB cable into the board. Make a small hole on the bottom of the box, so the other side of the cable can be connected to the computer (like a “tale” of the box).
Step 3: Get the Software Ready!
Now that you should have all set, the only missing part is the software. So, my friend Andre and I designed a simple software that should work just fine for simple necessities. The software can be downloaded here, and all you need to do is download it and run it.
This is how it works: when you press a button on the box, the software recognizes and shows it what you press, and also makes a sound in case that the patient doesn’t have any one around at the moment. Therefore, the patient can have his own privacy for some moments, and the relatives don’t need to worry about them.
If you need anything different from Water, Food and Help, together with the application, there is the programming code that you can edit to better fit your needs.
If you have any questions or suggestions, please feel free to contact me through email at gustavo_k@outlook.com !
This project was made by Gustavo Leite Kobayakawa with a BIG help of my friend Andre Marinho, under supervision of Dr. Jeremy Rickli, at Wayne State University, Detroit, MI, and sponsored by CAPES, Brazilian government and Institute of International Education (IIE).
In these days we’re here with our subsequent assignment that is RFID and keypad primarily based security machine. This assignment is implemented by means of the use of 8051. often we are able to see RFID tags or card in metro teach when we’re going to someplace then we need to apply a RFID tag has some records and RFID readers, that may read and write statistics to RFID tags. RFID carries a RFID tag which has 12 digit serial wide variety that’s read by using FRID Reader.
Step 1: Sections of Project
RFID Reader Section: This phase contains a RFID, which is an electronics tool which has part one is RFID Reader and other is RFID tag or Card. while we placed RFID tag to close to the RFID reader it reads tag information serially. RFID tag which we have used has 12 digit man or woman code or serial range. This RFID is running at baud fee of 9600 bps.
Keypad: 4×4 matrix keypad is used for entering the password for the system.
Control section: 8051 microcontroller is used for controlling entire the procedure of this project. here by way of using 8051 we are receiving RFID data and sending results or messages to liquid crystal display.
Display section: and 16×2 LCD is used in this project for displaying results and messages on it.
Driver section: this Section has a motor driver L293D for open and closed the gate and a buzzer with a BC547 NPN transistor for alert.
Step 2: Working
Operating of this project is easy. When someone put their RFID tag over RFID reader then RFID reads tag’s data and ship to 8051 microcontroller after it, microcontroller compares this received data with predefined data or records. If data is matched with predefined data or records then microcontroller ask for password and after coming password into microcontroller it starts to examine password with predefined password. If password in correct then gate will opened and in any other case liquid crystal display displayed access denied and buzzer begin beeping for a while.
Step 3: Circuit
liquid crystal display is hooked up in 4 bit mode with microcontroller. lcd’s RS, RW and EN pins are connected at PORT 1 pin number P1.0, P1.1 and P1.2. D4, D5, D6 and D7 pins of lcd are linked at pin P1.4, P1.5, P1.6 and P1.7 of port 1. Motor is hooked up at PORT pin number P2.4 and P2.5. And buzzer is hooked up at P2.6 at PORT2. And keypad is hooked up at PORT0. Keypad row are connected at P0.4 – P0.7 and Columns are linked at P0.0 – P0.3.
First, you need to know that a lightstrip is a bunch of LEDs daisychained together. The three contacts are +5v, GND and DI (data in, AKA DIN). If you are using the same lightstrip, you can solder just 3 wires… Now on to building
Step 1: Tinning Your Contacts
Before soldering anything, you need to tin, or cover the contacts on solder. In order to do this you need to hold down the iron on the contact and slowly push solder at it.
Time required: 10 mins, dependent on skill Tools: Soldering Iron, Solder Materials: lightstrip, Adafruit Flora
Step 2: Soldering Wires to and From Your Flora
This is simple. Use a soldering iron and some cut lengths of wire in order to connect the 2. Solder black wires to GND, red to VBATT, and yellow to D6.
Time: 5-10 mins Tools: Soldering iron, solder Materials: Lightstrip, Flora
Step 3: Soldering to the Lightstrip
Same process as the flora. Solder black to GND, red +5v and yellow to DI Time: 5-10 mins
