DIY 3D Printer PANDORA DXs

DIY 3D Printer – PANDORA DXs (Design eXtreme single)
3D Design Tool: SketchUp Pro


Technical Specifications


Printing


Technology: FFF(Fused Filament Fabrication) / H-Bot(CoreXY)
Build Volume: 223 (W) x 225 (D) x 165 (H) mm

  • Heatbed
    Layer Resolution: 50-200 microns
    Filament: ABS or PLA, Nyron, HIPS, PVA… 1.75 mm diameter
    Nozzle Diameter: 0.4 mm (0.2mm, 0.3mm, 0.8mm)
    Print File Type: .Gcode, .STL
    Layer Resolutions:
  • Fast: 200 micron (0.2 mm)
  • Normal: 100 micron (0.1 mm)
  • hHigh: 0.06 micron (0.06 mm)
  • Ultra High: 0,04 micron (0.04 mm)

    Size and Weight


    Product Dimensions: 426 (W) x 433 (D) x 500 (H) mm
    Product Weight: 11 kg


    Software


    Software Bundle: Cura, Slic3r, KISSlicer / Octoprint, Printrun, Repetier-Host, MatterControl
    Supported File Types: .STL, .OBJ, .AMF, .Gcode
    Operating Systems: All (Web-based): Windows, Mac OS, Linux


    Firmware


    Arduino: Modified Marlin v1.0.0
    Raspberry Pi: Rasbian, Octoprint, SSH, Samba, VNC, WiringPi


    Hardware


    Base Plate: Profile DRF 3030, Acrylic
    Step Motor: NEMA 17 – Phase: 4, Step Angle: 1.8 Deg/Step, Holding Torque: 2.6Kg.cm

  • X/Y/Z/E – 4EA
    Cartesian (xyz): X/Y Head: LM Guide, Z Bed: 10mm Linear Shaft and 8D Screw Rod


    Electrical


    Control Board: Arduino Mega 2560
    Control Shield: Ramps 1.4 Board
    Display Board: Reprap Discount Smart Controller LCD 2004
    Raspberry Pi: Raspberry Pi B
    Camera: Raspberry Camera
    Power Requirements: AC 100 – 240 V, 1.4 Amps, 50-60 Hz, 220 W
    Connectivity: USB, SD Card, Wi-Fi (Web-based)
    Temperature:

  • Nozzle temperature: 170 – 270
  • Heated bed temperature: 50 – 100
  • Operational temperature: 10 – 40
  • Storage temperature: 0 – 32

    https://www.thingiverse.com/thing:917718


    Thanks for watching!……..Coming soon!……..Updating……

The open source PANDORA DXs hardware and software is free and made with love. Please show your level of support with a voluntary donation.

Donate:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=RDN7ZGAVFS5UE

MobBob V2 Remix Upgrade – Smart Phone Controlled Robot

[Update 20160212]
Add MobBob2_Remix_PowerBank_Hook.stl
Add MobBob2_Remix_Jacket.stl
Add MobBob2_Remix_Nano_Shield_Mount.stl

[Update 20160120]
Add Test #3 Video

[Update 20160119]
Add Test #1, #2 Video
Add MobBob2_Remix_Hand_Back_L.stl, MobBob2_Remix_Hand_Front_L.stl
Add MobBob2_Remix_Arm_Back_L.stl, MobBob2_Remix_Arm_Front_L.stl
Add MobBob2_Remix_Shoulder_L.stl
Add MobBob2_Remix_Hand_Back_R.stl, MobBob2_Remix_Hand_Front_R.stl
Add MobBob2_Remix_Arm_Back_R.stl, MobBob2_Remix_Arm_Front_R.stl
Add MobBob2_Remix_Shoulder_R.stl

[Update 20160105]
Printing errors corrected
MobBob2_Remix_Foot_L_Top.stl, MobBob2_Remix_Foot_R_Top.stl

[Upgrade 20160104]
Redesign Foot
MobBob2_Remix_Foot_L_Top.stl, MobBob2_Remix_Foot_L_Floor.stl
MobBob2_Remix_Foot_R_Top.stl, MobBob2_Remix_Foot_R_Floor.stl
Base Design: http://www.thingiverse.com/thing:1232619


Smart Phone Controlled Robot – MobBob V2 Remix Upgrade


3D Design Tool: SketchUp Pro
Design concept: RAPIRO – The Humanoid Robot and Gundam

This is an upgrade version of my MobBob V2 Remix robot.

MobBob is a smart phone controlled robot. By harnessing the power of your smart phone, MobBob is a walking, talking robot with voice recognition and computer vision that you can build for around $35. I will be continuing to extend his features over time. I want MobBob to be a companion robot that everyone can afford and have fun with.

You can see videos of MobBob V2 Remix upgrade in action here:
https://youtu.be/8nO0kziJvsk – 3D Design
https://youtu.be/ehrsIDJcVZY – Test #1
https://youtu.be/j0oz8OPYhNs – Test #2
https://youtu.be/5z4Ps11t-vE – Test #3
…..
Coming soon!!

The main aims of the V2 remix were to:

Support standard 9g servos [previously I was using Tower Pro SG90 servos]
Make everything easier to assemble [no more need for glue]
Make it easier to adapt/modify for other phones. The new bracket system made it easier to exchange a new phone / the battery holder.

Also, in my V2 Remix Upgrade build, I’m also using the Arduino Nano instead of the DIY Nano shield, so the entire build is smaller and tidier. 🙂

MobBob V2 Remix Upgrade uses the same software as the original RAPIRO.

You can find the latest Arduino code here: https://github.com/Ishiwatari/RAPIRO
The modified code is included: http://www.thingiverse.com/thing:1235865

You can download the latest version of the Android from Google Play – it is free, ad-free, and without IAP:
https://play.google.com/store/apps/details?id=com.github.luzhuomi.rapicommand

You can find more detailed build and wiring instructions here:
…coming soon…

The parts that you need to print:

1 x Leg Left
1 x Leg Right
1 x Foot Left Floor
1 x Foot Right Floor
1 x Foot Left Top
1 x Foot Right Top
1 x Waist
1 x Arduino Nano Holder
1 x Phone Mount Base
2 x Phone Mount Side
1 x Phone Mount Gear
1 x Phone Mount Back Plate
1 x Phone Mount Conn
2 x Phone Mount Bolt
2 x Phone Mount Nut
1 x Battery Bank Rack [18650 x 2] or Power Bank
1 x Battery Mount Cover or PowerBank Hook
1 x Jacket
1 x Cap
1 x Hand Back Left
1 x Hand Front Left
1 x Arm Back Left
1 x Arm Front Left
1 x Shoulder Left
1 x Hand Back Right
1 x Hand Front Right
1 x Arm Back Right
1 x Arm Front Right
1 x Shoulder Right

The non-3D printed parts you need are:

6 x Tower Pro SG90 servos [for Shoulders, Arms and Hands]
4 x EMAX ES08MA II Mini Metal Gear Analog Servo [Strengthening the power of the Legs and Foots]
1 x Arduino Nano ATmega328 [see note below]
1 x HM-10 BLE Bluetooth 4.0 CC2540 CC2541 Serial Wireless Module [or HC-05]
1 x 5V Micro USB 1A Lithium Battery Charging Board [see note below]
1 x DC-DC Converter Step Up Boost Module 2-5V to 5V 1.2A
1 x Rectangle On/Off Long Rocker Switch SPST
2 x Snap-In Single ‘A’-‘AA’ Battery Contacts 209 [KEYSTONE ELECTRONICS CORP.]
2 x Snap-In Single ‘A’-‘AA’ Battery Contacts 228 [KEYSTONE ELECTRONICS CORP.]
2 x 18650 Lithium ion Batteries
1 x 300mm USB 2.0 A Male to Micro USB B 5pin + Mini B Male Y Splitter Cable
1 x Smart Phone [see note below]
4 x M3 5mm [for Foot Cover]
2 x M2 10mm [for Phone Connect]
4 x M2 5mm [for Phone Mount Back Plate]
2 x 2mm 5mm Tapping screw [for Foot servos]
2 x 2mm 8mm Tapping screw [for Hip servos]
2 x 1mm 5mm Tapping screw [for Foot servos hone]
2 x 1mm 8mm Tapping screw [for Hip servos hone and Shoulder]
2 x M3 15mm [for Jacket]
2 x M3 Nut [for Jacket]
4 x 2mm 15mm Tapping screw [for Jacket]
12 x M2 15mm [for Arm and Hand]
[Note: I got the servos, Arduino Nano, Bluetooth Module and Battery for under $30.]

Arduino Nano:

This is a small, Arduino compatible ATmega328 board with DIY extension board. MobBob V2 app connects to the Bluetooth module using its Bluetooth LE service. The app to support other Bluetooth cards.

Battery Extender:

You can use other batteries that provide 5V with a steady current. If you use other batteries, you may need to adapt the battery rack for your battery’s size.
Use 18650 Lithium Battery Charging Board With Protection Charger Module and Step Up Boost Module 3.7V to 5V for Smart Phone
http://www.thingiverse.com/thing:1235749

Smart Phone:

You can use other Android Smart Phones with This app.
You do not need to adapt the size of the phone holder for your phone. The app has been successfully tested with Nexus and Samsung, LG phones, but should work on other Android phones.

Instructions:

Print all the required parts
Get all the non-3D printed parts
Assemble as per the photos – I’ll be writing some more detailed instructions on my website soon!
Install the Arduino code from the GitHub link in the description – You will need to update the Arduino pins in the code to match yours, and probably update the centering values for the servos.
Install the Android app from the link in the description.

Have fun!

If you hit any problems, please post a question on this website: [http://www.rapiro.com], here, or on YouTube channel. A few people have built RAPIRO now, so there are people around who can help.

Coming soon update!!

The open source Mobbob V2 software and hardware is free and made with love. Please show your level of support with a voluntary donation.

Donate:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=RDN7ZGAVFS5UE

Post-Printing

How I Designed This

Design Tool

Google SketchUp Pro 8

Print Settints

Printer Model: PANDORA DXs – DIY 3D Pronter
Slicer: Cura 15.04.2


Layer height (mm): 0.1
Shell thickness (mm): 0.8

Bottom/Top thickness (mm): 1.2
Fill Density (%): 00

Print speed (mm/s): 50
Print temperature: 200
Bed temperature: 70

Support type:

  • Touching buildplate:
    MobBob2_Remix_Phone_Mount_Side.stl,
    MobBob2_Remix_Phone_Mount_Nut_L.stl, MobBob2_Remix_Phone_Mount_Nut_R.stl,
    MobBob2_Remix_Phone_Mount_Conn.stl,
    18650_Battery_Bank_2x_Cover_swC_r01.stl
  • Everywhere:
    MobBob2_Remix_Nano_Shield_Holder.stl,
    MobBob2_Remix_Battery_Mount_Cover.stl,
    MobBob2_Remix_Jacket.stl,
    MobBob2_Remix_Hand_Back_L.stl, MobBob2_Remix_Hand_Front_L.stl,
    MobBob2_Remix_Arm_Back_L.stl, MobBob2_Remix_Arm_Front_L.stl,
    MobBob2_Remix_Shoulder_L.stl,
    MobBob2_Remix_Hand_Back_R.stl, MobBob2_Remix_Hand_Front_R.stl,
    MobBob2_Remix_Arm_Back_R.stl, MobBob2_Remix_Arm_Front_R.stl,
    MobBob2_Remix_Shoulder_R.stl

Platform adhesion type: Brim

Filament: PLA
Filament Diameter (mm): 1.75


3D Files:

https://www.thingiverse.com/thing:1235865

Custom Section

Source code

by ShotaIshiwatari is licensed under the Creative Commons – Public Domain Dedication license.
modified by Zalophus

on the command line, enter:
// #M1 – robot will move forward
// #M2 – robot will move backward
// #M3 – robot will turn right
// #M4 – robot will turn left
// #M5 – robot will raise his hand and wave the left hand. LED will become green and flashing
// #M6 – robot will lower his left hand. LED will become Yellow
// #M7 – robot will move both arm and contract his hands. LED will become Blue
// #M8 – robot will wave goodbye with his left arm. LED will become RED.
// #M9 – robot will raise its right arm and move its waist. LED will become BLUE
// #M0 – robot will go to initial position

CAPS LOCK is important when you input a command via the serial monitor..
Reading through the source code.
Each movement of the preset (# M1 ~ # M9), consists of pattern of 8 frames.
Each frame is defined values ​​uint8_t type sixteen (motion).
This can be changed modifying the number of frame per pattern.MAXFN
Lets take #M0 for example:

uint8_t motion[MAXMN][MAXFN][16]={
{ // 0 Stop
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0,255, 10},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0},
{ 90, 90, 0,130, 90,180, 50, 90, 90, 90, 90, 90, 0, 0, 0, 0}
},

I put numbers so you can visualy make sense of what a pattern is, and what a frame contain.
Movements consist of pattern. Pattern are made of frames. Each frame contrain the rotation angle of every servo, the values of the RGB LED and a Time to perform the action.

Head horizontal rotation angle (Head yaw) (left) 180 <—> 0 (right)
Hip horizontal rotation angle (Waist yaw) (left) 180 <—> 0 (right)
Right shoulder up and down angle (R Shoulder yaw) (bottom) 0 <—> 180 (above)
Open right shoulder angle (R Shoulder pitch) (closed) 90 <—> 180 (open)
Right hand opening and closing angle (R Hand grip) (closed) 50 <—> 110 (open)
Left shoulder up and down angle (L Shoulder yaw) (bottom) 180 <—> 0 (top)
Open left shoulder angle (L Shoulder pitch) (closed) 90 <-> 0 (open)
Left hand opening and closing angle (L Hand grip) (closed) 130 <—> 70 (open)
Right foot horizontal rotation angle (R Foot yaw) (left) 0 <—> 180 (right)
Twist angle of the right foot ankle (R Foot pitch) () 0 <—> 180 (outside)
Left foot horizontal rotation angle (L Foot yaw) (left) 0 <—> 180 (right)
Twist angle of the left foot ankle (R Foot pitch) (within) 180 <—> 0 (outside)
Red component of the eye (R) 0 <—> 255
Green component of the eye (G) 0 <—> 255
Blue component of the eye (B) 0 <—> 255

Here are some other helpful commands that can be used to control the LED and each servos individually.

LED CODE sample

// #PR000G255B000T010 – MAX GREEN COLOR
R,G,B values between 0 and 255
T is the time component to get to desired color

LIMBS MOVEMENT
Sxx refers to one of the 12 motors (from S00 to S11),
A000 up to A180 is the angle where to servo incline,
Txxx is the time to perform the movement.
you can combine two commands, i tried more but it didn’t work..

// #PS00A000T010#PS00A180T010 – full head movement from side to side
// #PS01A000T010#PS01A180T010 – Waist
// #PS02A000T010#PS02A180T010 – r Shoulder
// #PS03A050T010#PS03A180T010 – r Arm
// #PS04A030T010#PS04A140T010 – r HAND
// #PS05A000T010#PS05A180T010 – l Shoulder
// #PS06A130T010#PS06A010T010 – l Arm
// #PS07A030T010#PS07A180T010 – l hand
// #PS08A000T010#PS08A180T010 – r Foot yaw
// #PS09A000T010#PS09A180T010 – r Foot pitch
// #PS10A000T010#PS10A180T010 – l Foot yaw
// #PS11A000T010#PS11A180T010 – l Foot pitch

// #PS00A090S01A090S02A000S03A090S04A090S05A180S06A090S07A090S08A090S09A090S10A090S11A090R000G000B000T005

Project Humanoid Robot – M1 – Design concept

[ Upload design concept 20161001]

https://youtu.be/u6r7p0gS-Hc

Working……………………….
Coming soon…….

The open source Humanoid Robot M1 hardware and software is free and made with love. Please show your level of support with a voluntary donation.

Donate:
https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=RDN7ZGAVFS5UE

How I Designed This

TerraControl – With NodeMCU Webserver

UPDATE 3: Version 1.3

I’m working on making the code as user friendly as possible but it’s going to be a long run. I’d like to have separate html and css files but I’m still figuring it out. For now, few changes…:

  • ! ! ! included mDNS protocol, so from now on you don’t need IP address to connect to your NodeMCU, simply put terracontrol.local in your browser and you are done (you have to be on the same network, of course)
  • separate file for setting up the variables (setting.h). Unzip the file to your Projects folder, when you open the *.ino file, setting.h should be opened as well.

UPDATE 2: Version 1.2

  • improved graph displaying range
  • new values in graphs are moved to the end of array, not starting from the beginning again
  • improved light setting – it is now unlimited (ON time can now be later than OFF time)
  • code for manual defining your own server is in one place and commented by default (i.e. it is on automatic setting)
  • clearer information in serial monitor
  • unified function for min/max values in array
  • new function for printing out minute values

UPDATE 1: Please see the version 1.1 I got the graphs and statistics working! Well, sort of…the range is still not as I want it to be, but at least now it is correctly displaying min and max. Plus new mouseover feature for the individual values in the graph.

After my first attempt to create controlled terrarium using Arduino board I got my hands on NodeMCU 12E board and I knew it was going to be a big step up!

I took me a few days before I began to understand how this board works (thanks to a lot of instructables here and google of course) and the possibilities it had. It think I’m on the right path to create exactly what I was dreaming about for several years…

So what is TerraControl v1.2 capable of?

  1. 2 automatically controlled relays (light timer and heating)
  2. 2 manually controlled relays (fan, second heating)
  3. GMT time change
  4. Simple graphs with highest/lowest temperature/humidity over the last 24 hours
  5. Monitoring temperature and humidity in terrarium
  6. All accessible and adjustable through webserver using HTML and CSS

What is necessary:

  • given the nature of NodeMCU board (its output is only 3.3v) you will either have to buy 3.3V relay board, or modify 5v board, or buy I2C logic converter module – for example – $0.9
  • 5V source (I’m using older usb charger)
  • wires
  • solder
  • case/box
  • Arduino IDE

Step 1: Getting the Parts Together

Connecting these parts is easy, just look at the source code and keep in mind that GPIO’s of the NodeMCU board is different from the actual boards description (as seen on the trird picture):

//Define sensor pins
#define SENSOR_IN 15 //D8
#define SENSOR_IN_Type DHT22

//Define Relay pins
#define relayLight 5 //D1
#define relayHeat 4 //D2
#define relayFan 12 //D6
#define relayHeat2 14 //D5

i.e. DHT sensor pin goes to D8 (board’s D3, D4, D8 can’t be used as output but can be used as input), and the relay pins accordingly to the code. Remember, if you are using 5V relay, you need to modify the relay board or use I2C logic converter.

! ! ! IMPORTANT! When uploading the code to the board, you have to disconnect the DHT sensor, otherwise you will get an error when attempting to upload ! ! !

All parts can be powered with 5v power adapter

Step 2: Setup and Customization

Before we upload the code, there are few things that needs to be set up in setting.h:

//You WiFi AP
const char ssid[] = “SSID Name”; // insert your WiFi AP name
const char pass[] = “password”; // insert your WiFi password

// T E R R A R I U M S E T T I N G
float tempMin = 24; // temperature in Celsius for switching the heating ON
float tempMax = 30; // temperature in Celsius for switching the heating OFF

int humMin = 50; // minimum humidity in %
int humMax = 70; // maximum humidity in %

// hour and minute for light to go ON
int lightOn_hour = 7;
int lightOn_min = 0;

// hour and minute for light to go OFF
int lightOff_hour = 20;
int lightOff_min = 30;

// Central European Time (1 for winter time)
int timeZone = 2;

Uncomment the following part of the code if you know how to define your server manually or just run the code and get addresses from the serial monitor.

/*— UNCOMMENT THIS FOR MANUAL SETTING —
IPAddress ip(192, 168, 0, 111); //Node static IP
IPAddress gateway(192, 168, 0, 1);
IPAddress subnet(255, 255, 255, 0);
WiFi.config(ip, gateway, subnet);
*/

All done? Great, let’s move on…

Step 3: Alwas ON/OFF Relay Connection

One thing I wanted was the relay board to be used as little as possible. As you probably know, relays have two possible ways of connection: ON when not used and ON when used. So I connected the light and heating to “ON when not used” (heating is almost always ON and lights are ON for about 13-14 hours every day) and fan and heating 2 to “ON when used” (I barely need to use one of them).

That is why the code for the same function is using different values:

if (heatVal == 1) {
client.println(“ON”);
} else {
client.println(“OFF”); }

AND

if (heat2Val == 1) {
client.println(“OFF”);
} else {
client.println(“ON”); }

You can of course modify the code according to your needs.

Now just connect the DHT sensor and let’s look at the result!

Step 4: Webserver

When you open the webserver you will see simple page with all information about your terrarium and some features:

  • Light ON/OFF time can be adjusted (step are: 1 hour for hour setting and 5 min for minute setting). At the moment ON time has to be earlier that OFF time (ON 22:30 and OFF 0:30 will not work – yet) – fixed in version 1.2
  • Temperature setting (steps are 0.5 degree Celsius)
  • Manualy turn ON/OFF other two relays – Fan and Heat 2 and adjust timezone when the time changes

if needed, change your timezones in following part of the code:

if (request.indexOf(“/TIMEZONE_SWITCH”) != -1) {
if (timeZone == 1) {
timeZone = 2;
setSyncProvider(getNtpTime);
} else {
timeZone = 1;
setSyncProvider(getNtpTime);
} }

  • Webserver is using automatic time synchronization

Step 5: Disclosure

I know that the HTML and CSS code could be much more simple and the coding is not really user friendly but for the moment it works as it is supposed to (only the graphs are not very accurate but I’m still working on them) and I will get to these points when I start working on version number two. I have already decided to use external power supply (in this version I just stripped the 5v adapter and soldered it inside the box) and I also want the power cables to be more accessible and easier to connect/disconnect. I hope you guys (and your pets) will appreciate this instructable, if you do, please leave a short comment. And of course, suggestions are more than welcome! Thank you

ESPway | 로봇 제어 세그웨이 스타일 와이파이 ESP8266 구축

내가 아두 이노와 임베디드 시스템 땜질 시작 이후로, 나는 자기 밸런싱, 세그웨이 같은 로봇을 구축하는 방법에 대해 매우 흥분했습니다. 인터넷의 주위에 유사한 프로젝트 및 리소스는 매우 풍부하다.

첫 번째 프로토 타입은 플라스틱 도시락 상자 안에 지어졌습니다. 그것은 아두 이노 나노 사용 원격 제어를 적외선. 그것은 사용 MPU6050 로봇의 방향을 검출하기위한 관성 측정 유닛. 균형은 매우 잘 작동하지만, 적외선 원격 제어는 매우 비실용적이고 신뢰할 수 있었다.

내가 대해 알게되었을 때이 프로젝트는 부활 ESP8266 , 매우 강력한 코어의 저렴한, 와이파이 활성화 마이크로 컨트롤러. 웹 개발에 대한 배경을 갖는, 와이파이 연결이 나에게 가능성의 세계처럼 보였다.

전통적 아두 이노 커뮤니티 원격 제어 로봇은 블루투스 통신을 이용하여 구현되어왔다. 그러나, 이것은 실질적으로 컨트롤러 소프트웨어를 각 플랫폼에 개별적으로 구현되어야한다는 것을 의미한다 (안드로이드, 아이폰 OS, PC 등)

HTML과 자바 스크립트로 구현 웹 애플리케이션은 점점 더 인기를 끌고있다. 이유 중 하나는 휴대 성이다. 웹 응용 프로그램을 한 번 작성되면, 그것은 충분히 좋은 웹 브라우저가있는 모든 플랫폼에서 실행할 수 있습니다.

ESP8266은 WiFi 액세스 포인트로 구성 될 수있다. 하나는 웹 응용 프로그램 서비스를 제공하기 ESP8266이 가능하고, 정적 페이지를 제공하는 HTTP 서버를 설정할 수 있습니다. 로봇 제어 소프트웨어는 웹 응용 프로그램으로 구현 된 경우 이제 상상! 그건 내 프로젝트 ESPway 뒤에 키 생각이다.

이 작은 로봇에 대한 코드와 회로도를 찾을 수 있습니다 GitHub의에 . 구축 개발 및 소프트웨어 사용에 대한 사전 설명이 있습니다. 또한이 사용자 설명서의 어떤 종류를 짓고 있어요. 이 프로젝트는 또한 한 레딧에 논의 나는 비디오를 게시 할 때 얼마 전에.

안전 제일

깊은 기술적 인 세부 사항에 다이빙하기 전에, 그래도 난 당신이 스스로를 구축하려고하는 경우 안전에 대해 경고한다.

전자 및 소프트웨어는이 글을 쓰는 현재의 (저전압 차단 제외) 안전 기능이 포함되어 있지 않습니다. ESP8266의 펌웨어 (이것은 아마도 수 / 노점을 충돌하는 경우  일), 회전에서 모터를 중지 아무것도 없다. 이 로봇은 작은 및 그 주변을 손상하지 충분히 빛이 내 경우에는 특별한 문제가되지 않습니다. 그러나,이 로봇의 크고 무거운 버전을 제작하기 전에 안전을 고려하시기 바랍니다. 하나는 아마도 소프트웨어 오류의 경우에 모터를 차단 할 몇 가지 안전 장치 시스템을 구현할 수 있습니다.

전자 및 기계

이 로봇 부품의 대부분은 이베이 나 AliExpress에서 공급된다. 전체 회로도는 GitHub의에서 찾을 수 있습니다. 이 프로젝트의 목표 중 하나는 가능한 한 간단하고 저렴한 전자를 유지했다.

로봇의 핵심은 ESP8266 마이크로 컨트롤러가있다. 그것은 독립 구성 요소로 사용되지하지만 거기 WEMOS D1 미니보드. 그것은 USB 커넥터와 펌웨어를 업로드하기위한 USB-에-UART 컨버터를 가지고있다.

MPU6050는 방위 센서로서 사용된다. 그것은 I2C를 통해 통신, 사용 가능한 저렴한 브레이크 아웃 보드의 많음이있다. 나는 GY-521라는 하나를 데 사용합니다.

모터는 통합 금속 기어 박스와 평범한 오래된 DC 모터입니다. 공칭 회전 속도는 300 rpm으로, 그리고 그들은 6V에 대한 평가된다. 하나는 “N20의 300RPM”또는 “12ga의 300RPM”를 검색하여 이러한 모터를 찾을 수 있습니다.

모터가 구동되어 L293D 듀얼 H 브리지 모터 드라이버 IC. 그 로봇을 구축 할 때 내가 손에 가지고 무엇 때문에이 IC는 주로 선택되었다. 바이폴라 트랜지스터의 출력은 다리를 건너 큰 전압 강하를 생산 이제 나는 배웠다. 결국 내가 가진 드라이버 교체 할 수 있습니다 DRV8833 MOSFET 출력을 가지고있다.

나는 로봇에 전력을 공급하기 위해 2 셀 리튬 폴리머 배터리를 사용하고 있습니다. 완전히 충전 된 때 ~ 8.4 볼트를 제공합니다. 전지 전압은 ESP8266의 아날로그 입력을 통해 모니터되고, 배터리 전압이 소정의 임계 값 아래로 떨어질 때, 모터를 차단하는 선택적인 특징이있다. 즉 리튬 폴리머 배터리를 사용하는 것이 일반적이다. 아날로그 입력 범위는 0-1 볼트이다. 3.3 다음 D1 미니 보드, 이미 1의 비율로 분압기있다. 따라서 I은 아날로그 입력 범위에 적합하도록 배터리 전압 스케일링 1:10 비율로 수정 한 저항을 추가했다.

마지막으로,이 WS2812B의 NeoPixels은 로봇의 “눈”으로 추가됩니다. 그들은 (OTA 업데이트 등을 진행있을 경우이 떨어진 경우) 로봇의 현재 상태를보고 매우 유용 증명

크기와 무게의 최적화를 설계 목표로 설정 한 것을 다른 역학에 대해 말을 많이가 아니다. 프로토 타입 몸은 4mm 합판의 일부 조각의 내장 및 에폭시와 함께 붙어있다.

로봇의 일반보기

소프트웨어 플랫폼

현재 자원과 ESP8266에 소프트웨어를 개발하기위한 지원의 재산이있다. 제조업체 Espressif하는 RTOS없이 운영 체제와 다른 하나 하나가 제공하는 두 개의 SDK가 있습니다. 도있다 아두 이노 코어 의 심바 크로스 플랫폼 RTOS 프레임 워크와 MicroPython은 . 새로운 언어와 프레임 워크가 큰 인 지금 가끔씩 튀어 나올 것 같다!

이 로봇에 대한 몇 가지 프로토 타입을 사용하여 아두 이노 코어에서 수행 된 PlatformIO를 빌드 시스템으로. 프로토 타입 작업은에서 찾을 수 있습니다 해당 지점 GitHub의의 REPO의.

그러나 최대의 유연성과 제어를 위해, 나는 제조업체의 “비 OS”SDK로 전환. 하나는이 마이크로 컨트롤러와 함께 얻을 수있는 즉 약으로 기본입니다. 나는 특히,이 SDK에 사용할 멋진 도서관이 있었다 찾을 수 기쁘게 생각 libesphttpd 간단한 HTTP 서버와 파일 시스템을 구현한다. 그것은 또한 웹 소켓 통신 시설을 갖추고으로이 프로젝트를위한 안성맞춤이었다.

모바일 웹 UI

로봇에 전원을 공급하고, WiFi 액세스 포인트에 클라이언트 장치를 연결 한 후, 하나는 기본 IP 주소에서 웹 브라우저 사용자 인터페이스를 열 수 있습니다 192.168.4.1.

나는 가능한 한 간단하게 UI를 유지하기 위해 노력했다. 그것은 본질적으로 HTML5 캔버스에 그려진 가상 “조이스틱”로 구성되어 있습니다. 터치 디바이스에서 휴대 전화 등, 꽤 직관적 인 느낌.

조정에 사용되는 사용자 인터페이스.

의 URL에서 로봇의 PID 매개 변수의 온라인 튜닝을위한 UI도 있습니다 /pid. 그것은 진행중인 작품이지만, 반 사용 가능한 상태에서 이미. 그것은 본질적으로 펌웨어를 매개 변수가 변경 될 때마다 다시 깜박하지 않고 한 번에 로봇을 조정 할 수 있습니다. 하나는 UI를 통해 플래시 메모리에 조정 매개 변수를 저장할 수 있습니다.

초기 PID 튜닝 사용자 인터페이스를 제공합니다.

웹 소켓을 통해 대기 시간이 짧은 통신

아마이 프로젝트의 가장 흥미로운 부분은 낮은 지연 시간 원격 제어를 달성하는 방법이다.

전통적으로 사람들은 ESP8266에 HTTP API가 어떤 종류의를 구현하고있다. 그것은 각 명령에 대해 별도의 URL가 있다는 것을 의미한다. 예는 로봇 차, 같은 URL이있을 것 /forward/backward/stop/turn-left/turn-right등 다음 만들 것 클라이언트 응용 프로그램 AJAX의 로봇을 제어하는 요청을. 그러나, TCP 연결을 열고 모든 명령에 구문 분석 HTTP 헤더가있을 것입니다 의미합니다. 즉, 불필요한 오버 헤드 및 지연을 도입한다. 이 컨트롤은 그런 식으로 매우 부드러운 없을 것이다.

더 나은 대안은 열려있는 TCP 소켓을 유지하고 두 방향으로 그것을 통해 정보를 전송하는 것입니다. ESP8266 원시 TCP 통신을위한 일류 지원을하고 있지만, 자바 스크립트 하나는 원시 TCP 소켓을 열 수 없습니다. 대신있다 WebSockets를 정의 된 핸드 쉐이킹 프로토콜 및 데이터 프레임 포맷 첨가 TCP 소켓이다. 때문에 libesphttpd웹 소켓 구현을 가지고, 나는이 세부 사항에 대해 걱정하지 않았지만, 단지 데이터 패킷을 교환한다.

데이터 패킷의 첫 번째 바이트에 해당되는 명령을 표시하고, 이후의 추가 바이트 데이터이다 : 거기 로봇와 UI 사이에 통신하는 매우 단순한 프로토콜이다. 부가 데이터의 길이는 각각의 명령에 대한 알려진 고정된다. 예를 들어, 클라이언트에 의해 전송 된 “스티어링”데이터 패킷은 3 바이트로 구성 첫 번째 바이트 (즉, 같은 코드로 정의되어 제로 STEERING). 두번째 바이트는 원하는 속도를 나타내고, 세 번째는 회전 속도를 나타내는 (네거티브 = 좌, 포지티브 = 우측). 이 경우, 두 번째 및 세 번째 바이트는 8 비트 부호있는 정수로 해석된다. 데이터 바이트의 해석은 문제의 명령에 따라 달라집니다.

부드러운 양방향 통신을 감안할 때, 하나는 멋진 모든 종류의 것들을 구현할 수 있습니다. 예를 들어, 로봇은 클라이언트 웹 응용 프로그램에서 배터리 모니터링을 허용, 연결된 모든 클라이언트에 현재 배터리 독서를 보낼 수 있습니다. 또한, 가장 실용적인 것들 중 하나는 PID 컨트롤러 매개 변수의 온라인 튜닝이다.

데이터 바이트의 C 코드, 조작 및 천연 재 해석된다. 자바 스크립트에서는, 이진 데이터는로 표현되는 ArrayBuffer원시 이진 데이터의 블록의 표현은 본질적이다. 액세스 및 수정하려면, 하나는 사용할 수 있습니다 DataView기본 바이너리 버퍼에 바이트 수준의 액세스를 제공한다. 하나는 예를 들어 “바이트의 16 비트 부호없는 정수 (리틀 엔디안)로 13 쓰기 버퍼의 처음부터 오프셋 2″라고 할 수있다. 나는 자바 스크립트 API를 제공 낮은 수준의 제어가 찾을 수 놀랐다.

고정 소수점 센서 퓨전

I2C를 통해 MPU6050와 통신하는 것은 쉽다. 하나는 1 kHz에서 업데이트되는 세 축의 가속도와 자이로 측정치를 포함하는 하드웨어 레지스터를 판독 할 수있다. 배향으로이 값을 변환하는 과정은 “센서 퓨전”라고한다. 거기를 수행하는데 사용될 수 센서 자체로 신호 처리 코어이고,이 우수한 I2Cdevlib것을 구현한다. 그러나, 내가하고 싶지 않은 무언가 센서에 바이너리 펌웨어 덩어리를 업로드해야합니다. 또한, 그 알고리즘은 미가공 데이터는 1 kHz에서 사용할 경우에도 200 Hz의 샘플링 레이트만을 할 수있다.

주어진 ESP8266가 가진 32 비트 코어를 가지고 16 * 16 -> 32 비트 곱셈 확대, I 센서 융합하는 대신에 구현 될 수 있다고 생각. 가장 특히, 선택할 수있는 많은 알고리즘이 있습니다 보완 필터 , 칼만 필터 와 Madgwick 필터 . 후자는 독창적으로 작동 최첨단 신규 알고리즘 쿼터니온 방향의 표현. 또한이 시작하는 데 사용할 수 몇 가지 예제 코드이었다, 그래서 Madgwick 알고리즘이 선택되었다.

ESP8266는 부동 소수점 유닛이 골대를 벗어났습니다하고, 부동 소수점 연산은 소프트웨어로 구현해야합니다. 즉, 복잡한 비즈니스 컴파일러 지원 라이브러리에서 수행되었지만, 그것은 아주 느리다. 따라서, 나는 완전히 알고리즘의 부동 소수점 숫자의 사용을 방지하기 위해 원했다. 따라서 나는 Q16.16에 샘플 코드를 번역하기로 결정했습니다 고정 소수점 숫자 표현을 . 고정 점은 우리가 기본적으로 정수를 위해 노력하고 있지만, 16 최하위 바이트가 소수 부분으로 촬영 한 것을 의미한다.

구현에 대한 하나 개의 좋은 실용적인 세부 다음 Madgwick 알고리즘에, 하나는 어떤 경우에 벡터와 사원 수를 정상화해야한다. 이 경우 정규화는 제곱근으로 나눈 것을 의미한다. ESP8266의 핵심은 하드웨어 부문을 가지고 있지 않기 때문에이 소프트웨어에서 구현 될 필요가 있습니다. 동일은 제곱근에 적용됩니다. 우리는 어떻게 든 그것을 피할 수있는 경우에 따라서는 개별적으로 두 작업을 수행하는 것이 훨씬 이해가되지 않습니다. 반면에, 곱셈 연산의 측면에서 상대적으로 저렴합니다. 제곱근 나누면 제곱근의 역수를 곱한 것과 같다. 즉 여기에서 이루어졌다 무슨 – 상호 제곱근 함수의 라인을 따라 구현 이 StackOverflow의 대답 .

캐스케이드 PID 제어

어떻게 로봇이 실제로 균형을 유지합니까? 지금까지 우리는 로봇의 방향의 좋은 평가가 있습니다. 어떻게 든 적합한 모터 출력 신호로 변환되어야한다.

대답 할 두 가지 질문이 있습니다 :

  1. 로봇의 기울기 각도는 균형을 유지하기 위해 무엇을해야 하는가?
  2. 어떤 모터 출력 전력은 소정 경사각을 달성해야 하는가?

캐스 캐 이드 :이 자연스럽게 종종 자기 밸런싱 로봇에 구현 된 제어 전략에 이르게 PID 컨트롤러 . PID 제어에 대한 소개, 나는 기사 추천 박사 학위없이 PID를 팀 웨스콧에 의해. 본질적으로, 제 제어부는 입력으로서 원하는 속도를 취득하는 속도를 달성하기 위해 경사 각도를 제어한다. 바람직한 경사각은 그 각도를 달성하기 위해 모터 출력을 조정하는 제 제어기에 공급된다.

물론, 상기 제 2 제어부는 MPU6050 관성 측정 유닛을 통해 피드백을 얻는다. 한편, 현재 속도의 피드백을 얻는 것은 사소한 일이 아니다. 하나는 모터 샤프트에 회전 인코더를 설치하여 그것을 달성 할 수있다. 비용을 최소화하고 회로를 단순화하기 위해, 나는 그것을 밖으로 떠났다. 대신에, 내 코드에 사용되는 조 근사있다 : 속도 피드백이 단기 변동을 취소하기 위해 평활화 모터 구동 신호로부터 취해진 다. 이 사실은 놀라 울 정도로 잘 작동합니다!

또한, 단순한 형태의 게인 스케줄링은 로봇이 낙하하려고하는 상황에서 사용된다. 높은 비례 이득 PID 계수들의 상이한 세트는 다시 안정성을 달성하기 위해로드된다. 아래의 비디오 (일부 fallovers와 함께) 당신은 행동에서 볼 수 있습니다.

여기에 설명 된 제어 방식은 자기 밸런싱 로봇을 구현하는 유일한 방법은 아니다. 참고 이 문서 로봇의 동적 모델을 기반으로 제어 방식과 비교합니다.

소프트웨어 드라이버

마지막으로을의이 ESP8266 프로그래밍의 일부 실용성을 논의하자.

이 마이크로 컨트롤러에 하나의 문제는 하드웨어 주변의 부족이다. 특히, 칩상의 I2C 또는 PWM 어떠한 하드웨어 구현은 없다. 그들은 소프트웨어로 구현되어야한다. 문제는 매우 동일한 프로세서 코어 끊임없이 무선 통신을 처리하는 것으로한다. 그래서, 다른 소프트웨어 루틴은 와이파이 인터럽트에 의해 중단 얻을 수 있습니다. I2C 및 PWM 모두 타이밍에 대한 중요하기 때문에 그것은 약간의 문제입니다.

PWM 및 I2C의 소프트웨어 구현은 Espressif SDK와 함께 번들로 제공됩니다. 그러나 글을 쓰는, 그들은 어떤 식 으로든하거나 비효율적에 결함이 있습니다. 다행히, 지역 사회에서 어떤 똑똑한 사람들은 자신의 드라이버를 출시했다. I 사용하여 결국 ESP8266_new_pwm정확한 타이밍 안정된 PWM 신호를 실현할 NMI 인터럽트를 사용 스테판 브루엔스 의해. 모터는 2 kHz에서 PWM으로 공급된다.

I2C를 들어,라는 빠른 조립 구현 brzo_i2c파스칼 커턴스키으로 사용 하였다. 나는 I2C 거래 중에 완전히 비활성화 인터럽트 때문에 처음에는 I2C 드라이버에 약간의 문제가 있었다. 이는 결국 일부 WiFi를 발사 할 수없는 방해 아마도에, 펌웨어 충돌로했다. 즉, 쉽게 인터럽트를 비활성화 명령을 주석에 의해 수정되었습니다. 즉, I2C 타이밍을 타협하지만, 실제로는 모든 것이 매우 잘 작동하고있다.

피드백

이 문서에서 설명하는 무언가의 더 정교한 설명을 좋아하거나 해결하기 위해 발견 뭔가를했을 경우,이 사이트에 문제를 제기하십시오 GitHub의의의 repo . 당신은 또한에 연락처 찾을 수 있습니다 이 페이지를 . 모든 의견은 매우 환영하고 감사합니다.

ESPway | A Segway-style WiFi controlled robot built on ESP8266

Ever since I started tinkering with Arduino and embedded systems, I’ve been pretty excited about building a self-balancing, Segway-like robot. There’s a wealth of similar projects and resources around the Internet.

The first prototype was built inside a plastic lunch box. It used an Arduino Nano and infrared remote control. It used the MPU6050 inertial measurement unit for detecting the orientation of the robot. The balancing worked very well, but the infrared remote control was quite impractical and unreliable.

The project was revived when I learned about ESP8266, a cheap, WiFi enabled microcontroller with a pretty powerful core. Having some background in web development, the WiFi connectivity looked like a world of possibilities to me.

Traditionally in the Arduino community, remote controlled robots have been implemented using Bluetooth for the communication. However, this practically means that the controller software has to be implemented separately on each platform (Android, iOS, PC, etc.)

Web applications implemented with HTML and JavaScript are becoming more and more popular. One of the reasons is the portability. When the web app has been written once, it can be run on any platform which has a good enough web browser.

The ESP8266 can be configured as a WiFi access point. One can set up a HTTP server serving static pages, making the ESP8266 able to serve web apps. Now imagine if the robot control software was implemented as a web application! That is the key idea behind my project ESPway.

The code and schematics for this little robot can be found on GitHub. There are preliminary instructions on building, developing and using the software. I’m also building some kind of a user manual there. The project was also discussed on Reddit a while ago when I posted the video.

Safety first

Before diving deeper in the technical details, I though I should warn you about safety in case you are going to build this yourself.

The electronics and software don’t contain any safety features (except low voltage cutoff) as of writing this. If the firmware on the ESP8266 crashes / stalls (it can and probably will happen), there’s nothing stopping the motors from spinning. This is not a particular issue in my case where the robot is small and light enough to not damage its surroundings. However, please consider the safety before building a larger and heavier version of this robot. One could probably implement some failsafe system which would shut off the motors in case of a software failure.

Electronics and mechanics

Most of the parts for this robot are sourced from eBay or AliExpress. The complete schematic can be found on GitHub. One of the goals of this project was to keep the electronics as simple and cheap as possible.

At the core of the robot there is the ESP8266 microcontroller. It is not used as a standalone component but there’s a WEMOS D1 mini board. It has a USB connector and a USB-to-UART converter for uploading the firmware.

The MPU6050 is used as the orientation sensor. It communicates via I2C, and there’s a plenty of affordable breakout boards available. I used one called GY-521.

The motors are plain old DC motors with an integrated metal gearbox. The nominal revolution rate is 300 rpm, and they are rated for 6V. One can find these motors by searching for “n20 300rpm” or “12ga 300rpm”.

The motors are driven by the L293D dual H-bridge motor driver IC. This IC was chosen mostly because that’s what I had at hand when building the robot. Now I’ve learned that the bipolar transistor outputs produce a significant voltage drop across the bridge. Eventually I’ll replace the driver with a DRV8833 which has MOSFET outputs.

I’m using a 2-cell LiPo battery for powering the robot. It gives ~8.4 volts when fully charged. The battery voltage is monitored via the analog input of the ESP8266, and there’s an optional feature to cut off the motors when the battery voltage falls under a certain threshold. That’s common practice used with LiPo batteries. The analog input range is 0-1 volts. On the D1 mini board, there already is a voltage divider with a ratio of 1:3.3. Hence I only had to add one resistor to modify the ratio to 1:10, which scales the battery voltage to fit the analog input range.

Finally, two WS2812B NeoPixels are added as the “eyes” of the robot. They have proven quite useful for reporting the current state of the robot (if it has fallen, if there’s OTA update in progress etc.)

There’s not much to say about the mechanics, other that that optimization of size and weight were set as design goals. The prototype body was built out of some pieces of 4mm plywood and glued together with epoxy.

A general view of the robot

Software platform

Nowadays there is a wealth of resources and support for developing software on the ESP8266. There are two SDKs offered by the manufacturer Espressif, one with a RTOS and the other one with no operating system. There is also an Arduino core, the Simba cross-platform RTOS framework and MicroPython. New languages and frameworks seem to pop out every now and then, which is great!

Some prototyping for this robot was done on the Arduino core, using PlatformIO as the build system. The prototyping work can be found in the corresponding branch of the GitHub repo.

However, for maximum flexibility and control, I switched to the manufacturer’s “non-OS” SDK. That is about as native as one can get with this microcontroller. I was pleased to find there were some great libraries available for this SDK, particularly libesphttpd which implements a simple HTTP server and a filesystem. It was a great fit for this project as it also features WebSocket communication facilities.

Mobile web UI

After powering on the robot and connecting a client device to the WiFi access point, one can open the user interface with a web browser at the default IP address 192.168.4.1.

I tried to keep the UI as simple as possible. It essentially consists of a virtual “joystick” drawn on a HTML5 canvas. On a touch device such as a mobile phone, it feels quite intuitive.

The user interface used for steering.

There is also a UI for on-line tuning of the robot’s PID parameters at the url /pid. It is a work in progress, but it’s already in a semi-usable state. It essentially allows tuning the robot in one pass without re-flashing the firmware every time the parameters are changed. One can save the tuned parameters to the flash memory via the UI.

The initial PID tuning user interface.

Low latency communications via a WebSocket

Probably the most interesting part of this project is the method of achieving low latency remote control.

Traditionally people have been implementing some kind of HTTP APIs on the ESP8266. It means that there’s a separate URL for each command. E.g. for a robot car, there would be URLs like /forward/backward/stop/turn-left/turn-right etc. The client application would then make AJAX requests to control the robot. However, that means there would be a TCP connection opened and a HTTP header parsed on every command. That introduces unnecessary overhead and latency. The control would not be very smooth that way.

A better alternative is to keep the TCP socket open and send information over it in two directions. While the ESP8266 has first-class support for raw TCP communication, in JavaScript one can’t open raw TCP sockets. Instead there are WebSockets which are TCP sockets added with a defined handshaking protocol and a data frame format. Because libesphttpd has a WebSocket implementation, I didn’t have to care about these details but just exchange data packets.

There’s a very simple protocol in the communication between the robot and the UI: the first byte of a data packet indicates which command is in question, and the subsequent bytes are additional data. The length of the additional data is known and fixed for each command. For example, a “steering” data packet sent by the client consists of three bytes: the first byte is zero (that’s defined in the code as STEERING). The second byte indicates the desired speed and the third one indicates turning rate (negative = left, positive = right). In this case the second and third byte are interpreted as 8-bit signed integers. The interpretation of the data bytes depends on the command in question.

Given smooth two-way communication, one can implement all kinds of cool things. For example, the robot can send the current battery reading to all connected clients, allowing battery monitoring in the client web app. Also, one of the most practical things is on-line tuning of the PID controller parameters.

In the C code, manipulation and reinterpretation of the data bytes is natural. In JavaScript, binary data is represented as an ArrayBuffer which is essentially a representation of a block of raw binary data. To access and modify it, one can use a DataView, which gives byte level access to the underlying binary buffer. One can e.g. say “write 13 as a 16-bit unsigned integer (little Endian) at byte offset 2 from the beginning of the buffer”. I was actually surprised to find there is such low level control available in the JavaScript APIs.

Fixed-point sensor fusion

Communicating with the MPU6050 via I2C is easy. One can read the hardware registers which contain acceleration and gyro readings on three axes that are updated at 1 kHz. The process of translating these values into an orientation is called “sensor fusion”. There is a signal processing core in the sensor itself that could be used to do that, and the excellent I2Cdevlib implements that. However, that requires uploading a binary firmware blob on the sensor, which is something I did not want to do. In addition, that algorithm is only capable of 200 Hz sample rate even though the raw data is available at 1 kHz.

Given that the ESP8266 has a 32-bit core with 16*16 -> 32-bit widening multiplication, I thought the sensor fusion could be implemented on that instead. There are many algorithms to choose from, most notably the complementary filterKalman filter and Madgwick filter. The latter is a state-of-the-art novel algorithm which works cleverly with the quaternion representation of the orientation. Additionally there was some sample code available to get started with, so the Madgwick algorithm was chosen.

The ESP8266 misses a floating point unit, and the floating point operations must be implemented in software. That complex business has been done in the compiler support libraries, but it is quite slow. Hence, I wanted to entirely avoid the usage of floating point numbers in the algorithm. Therefore I chose to translate the sample code to the Q16.16 fixed point number representation. Fixed point means that we’re essentially working integers but the 16 least significant bytes are taken to be the fractional part.

One nice practical detail about the implementation: in the Madgwick algorithm, one has to normalize vectors and quaternions on some occasions. Normalization in this case means dividing by a square root. ESP8266’s core doesn’t have hardware division, so it has to be implemented in the software. The same applies for the square root. Thus it doesn’t make much sense to do both operations individually if we could avoid it somehow. On the other hand, multiplication is relatively cheap in terms of operations. Dividing by the square root is equivalent to multiplying by the reciprocal of the square root. That’s what was done here – a reciprocal square root function was implemented along the lines of this StackOverflow answer.

Cascade PID control

How does the robot actually maintain the balance? So far we have a nice estimate of the orientation of the robot. It has to be somehow translated to a suitable motor output signal.

There are two questions to answer:

  1. What should the tilt angle of the robot be in order to stay balanced?
  2. What should the motor output power be to achieve the desired tilt angle?

This naturally leads to a control strategy that is often implemented in self-balancing robots: a cascaded PID controller. For an introduction on PID control, I recommend the article PID without a PhD by Tim Wescott. Essentially, the first controller gets the desired velocity as an input and controls the inclination angle to achieve that velocity. The desired inclination angle is fed to a second controller which regulates the motor output power to achieve that angle.

Naturally, the second controller gets feedback via the MPU6050 inertial measurement unit. On the other hand, getting feedback of the current velocity is not a trivial task. One could achieve that by installing rotation encoders on the motor shafts. In order to minimize the cost and simplify the circuitry, I left that out. Instead, there’s a crude approximation used in my code: the velocity feedback is taken from the motor drive signal which is smoothed in order to cancel short-term variations. This actually works surprisingly well!

In addition, a simple form of gain scheduling is used in situations where the robot is about to fall. A different set of PID coefficients with higher proportional gain is loaded in order to reach stability again. You can see this in action (along with some fallovers 😉 in the video below.

The control scheme described here is not the only way to implement self-balancing robots. See this articlefor comparison with a control scheme based on a dynamic model of the robot.

Software drivers

Last but not least, let’s discuss some practicalities of programming the ESP8266.

One problem with this microcontroller is the lack of hardware peripherals. In particular, there are no hardware implementations of I2C or PWM on the chip. They have to be implemented in software. The problem is that the very same processor core has constantly handle the WiFi communication. So, any other software routine might get interrupted by the WiFi interrupts. That’s a bit of a problem since both I2C and PWM are critical about timing.

Software implementations of PWM and I2C are bundled with the Espressif SDK. However, as of writing, they are flawed in some way or just inefficient. Luckily, some smart people in the community have rolled their own drivers. I ended up using ESP8266_new_pwm by Stefan Bruens, which uses NMI interrupts to realize a stable PWM signal with correct timing. The motors are fed with 2 kHz PWM.

For I2C, a fast assembly implementation called brzo_i2c by Pascal Kurtansky was used. I had some problems with the I2C driver at first since it completely disabled interrupts during I2C transactions. That eventually led to the firmware crashing, probably due to some WiFi interrupt not being able to fire. That was easily fixed by commenting out the instruction that disabled the interrupts. That compromises the I2C timing, but in practice everything has been working very well.

Feedback

If you would like a more elaborate description of something described in this article or have found something to fix, please file an issue on this site’s GitHub repo. You can also find contact details on this page. Any feedback is very welcome and appreciated.

Internet 제어 Raspberry Pi Camera Rover (Robot)

소개

이 프로젝트의 아이디어는 상기 프로세서로 라즈베리 파이를 사용하여 인터넷을 통해 완전히 제어 로봇을 생성하는 것이다. 로봇은 HTML로 작성된 웹 페이지에 의해 직접 제어 턴에있는 쉘 스크립트 작성 저수준의 명령을 사용하여 제어된다. 우리는 예를 들면 파이썬 같은 고급 언어를 사용하는 사실은, 로봇이 페이지 (인터넷 속도가 느린 경우에도)에 의해 수신 된 명령에 빠르게 반응하도록 야기된다.

아래 링크에서는 어떻게 완성 된 프로젝트를 볼 수 있습니다

이 프로젝트는 두 부분으로 분할하고, 배울 것 1 부에서한다 :

설치 및 GPIO가 RPI를 제어하는 라이브러리 WiringPi를 사용

는 H-Bridge를 사용하여 제어 모터

웹 서버의 RPI 변형

인터넷을 통해 상기 로봇을 제어하기 위해 HTML (자바 스크립트)에 페이지를 만들기

더 나아가 로봇이 현실 세계의 “비전”을 가지고 있는지 확인하기 위해, 당신은 당신이 배울이 튜토리얼의 두 번째 부분에 갈 수 있습니다 :

물어와 비디오 스트림을 생성하는 방법

설치 및 라이브러리 ServoBlaster를 사용하는 방법

서보 모터를 제어하고, 카메라의 수직 및 수평 위치 (WFP / 틸트기구) 메커니즘을 구축하는 방법

인터넷을 통해 카메라의 위치를 제어하기 위하여 HTML 페이지를 작성

 

블록 다이어그램은 아래 날개 프로젝트의 두 부분에 대한 일반적인 생각을 보여줍니다

부 : 인터넷을 통해 조명 및 모터 제어

RPI는 웹 서버로 정의하고 HTML 페이지로부터 명령을 수신한다. 이러한 명령은 RPI 로봇 (방향과 속도)의 모터를 제어 일으키는 개의 GPIO의 상태를 변경 및 / 떨어져 LED에 (시뮬레이션 디지털 제어 시스템을 더)한다. 당신이 볼 수 있듯이, 로봇은 실제로 만약 IoT 프로젝트의 특별한 경우이다. 당신은 실제로 당신이 원하는 것을 제어 할 수 있으며,이 튜토리얼은 새로운 아이디어가 미래에 구현 될위한 출발점이 될하기위한 것입니다.

아래의 그림, 우리는이 첫 번째 부분에서 개발되는의 개요에서 :

자료의 목록

라즈베리 파이 모델 2 또는 3

H 브리지 L293-D

DC 모터 (2 배)

드라이버 9V 배터리

RPI에 배터리 5V

LED와 30 옴의 저항

브레드 보드 및 전선

아크릴 엔진 / 전자 제품에 대한 지원 (키트, CD를, 등을 할 수 있습니다)

도서관 WIRINGPI의 설치

WiringPi는 C로 작성된 라이브러리가 GPIO가의 RPI에 직접 액세스하는 데 사용됩니다. 매우 쉽게 쓸 수 있으며 크게 ( “embebeda 시스템”) RPI 및 전자 관련된 모든 프로젝트를 단순화합니다.

라이브러리 WiringPi는 “GPIO”프로그램 및 GPIO 핀을 구성 할 수 있습니다 (wiringpi.com/the-gpio-utility)라는 유틸리티가 포함되어 있습니다. 당신은 읽기 및 / 또는 쉘 스크립트와 같은 명령의 RPI의 핀에 직접 작성하는 유틸리티를 사용할 수 있습니다. 당신은 GPIO 쉘 스크립트에 명령 정수를 사용하여 프로그램을 작성할 수 있습니다.

WiringPi를 설치하려면 :

git clone git://git.drogon.net/wiringPi

cd wiringPi

./build

유틸리티의 화면 버전을 표시하려면 다음 명령을 사용합니다 :

gpio -v

일반적으로 액세스 모든 핀을 읽고 그 모드를 상호 참조 표를 작성하는 다른 포맷 (wiringPi, BCM_GPIO 핀 및 물리적)의 핀의 상태가 “GPIO의 ReadAll 메쏘드를”명령어를 사용할 수있는 테이블을 제시 현재 값을 표시합니다. 이 명령은 RPI와 파이에 적합한 인쇄도 소나무의 버전 / 모델을 감지합니다.

gpio readall

모니터 화면 아래 위의 두 명령의 항목의 결과를 나타낸다.

예를 들면, 출력으로서 BCM_GPIO 방식을 사용하여 하나의 GPIO를 설정하는 명령을 사용하는 것 :

gpio mode -g 10 out

가능 GPIO 핀이 정의 모드가되면, 당신은 동일한의 논리 상태를 정의 할 수 있습니다. 예에서, 핀은 논리 하이 상태로 이동한다 :

gpio write -g 10 1

그 양극과 GND 사이에 330ohm 저항을 부가 LED GPIO.10 핀의 음극을 설치 테스트합니다. 확실히 모든 것이 작동하는지 확인하기 위해 몇 가지 검사를 수행합니다.

출력 또는 입력으로 핀을 설정할 수있는 것 외에도 PWM 형식의 출력으로서 그 중 일부를 설정할 수있다. 이것은 물리적 핀 12 GPIO.18의 경우이다.

핀을 설정하려면 :

gpio -g mode 18 pwm

또는

gpio mode 1 pwm     참고 : ( “1”) GPIO.18에 WPI ID입니다

PWM 값을 설정합니다 :

gpio pwm 1 XXX     참고 : [XXX 0 사이의 값입니다 -> 1023]

예. :

gpio pwm 1 512       참고 : (50 % 듀티 cicle)

이 핀 particularmante의 구성을 제거하려면 :

gpio unexport 1

모든 핀 구성을 제거하려면 :

gpio unexportall

라즈베리 PI 및 LIBRARY WIRINGPI WITH 제어 모터

이 시점에서, WiringPi 라이브러리가 설치되어 있고 당신은 당신의 RPI의 모니터에 명령 줄에서 직접 GPIO를 제어 할 수 있습니다. 다음 단계는 모터를 제어하기위한 로직을 생성하는 것이다. 이를 위해, 우리는 H-다리의 L-293-D를 사용합니다. 이 H- 브리지는 2 개의 모터를 제어 할 수 있고, 모터의 각각에 대해 입력 3 필수 :

왼쪽 엔진 : “활성화”; “모터 +”와 “모터 -”

모터 오른쪽 : “활성화”; “모터 +”와 “모터 -”

항목에서 두 엔진은 서로 연결되어 “사용”GPIO.18에 의해 제어된다. 이 핀은 속도 제어에 대한 책임이 있습니다. 만약, 속도를 제어하는 “1”로 핀을하게 할 필요가없는 경우, 예를 들어 (+ 5V에 연결).

우리는 왼쪽 엔진이 “앞으로”이동하려는 경우, 우리는 + 모터 (M의 +)를 설정해야합니다, 협약 “1”과 모터 – (M-) “0”. 모터가 반대 방향으로 회전되도록 우리가 대향 할 것이다 : 엔진 + (M +)을 “0”으로 모터 – (M-) “1”이다. 실제로, 엔진의 방향을 정확하게 제어 입력을 정의하는 가장 좋은 방법은 동일한 조립하여 테스트하는 것이다.

우리는 항목의 다리에 개의 GPIO를 할당합니다 :

왼쪽 엔진 + : GPIO.5

왼쪽 모터 : GPIO.6

오른쪽 엔진 + : GPIO.13

오른쪽 엔진 – : GPIO.19

위의 가정에 기초하여, 논리는 GPIO를 테이블에 할당 될 수 수준 (표 화상을 참조)로 구축 할 수있다.

다음 단계는 엔진을 구동하기 위해 쉘 스크립트를 생성하는 것이다.

각 스크립트는 기본적으로 단순 텍스트 파일 형식이다. 텍스트 파일을 실행하려고하면, 운영 체제는 스크립트인지 아닌지를 결정하는 단서를 검색하며, 어떻게 적절하게 처리. 이 때문에, 당신이 알아야 할 몇 가지 지침이있다.

각 스크립트로 시작해야합니다 “#!/bin/bash”(해쉬 – 뱅 해킹}

각각의 새로운 라인은 새로운 명령입니다

주석 행은 #로 시작

명령은 ()에 의해 둘러싸여있다

운영체제 (쉘)은 텍스트 파일을 분석하면 스크립트의 첫 줄이 제작 될 때, 가장 직접적인 방법은 파일을 식별하기 #! / 빈이 / 떠들썩한 파티! 주석 행은 해시 (#)로 시작하지만 다음 OS를 강제 뱅 (!)와 쉘 경로를 추가하는 스크립트를 실행합니다.

예를 들어, “앞으로”이동합니다 모터를 제어하는​​ 쉘 스크립트를 작성하고, 위의 테이블을 기반으로, 우리는 텍스트 편집기를 수행해야하고 I를 사용하고 당신을 위해 가장 적합한 편집기를 사용하여 (아래의 파일을 생성 이것에 대한 NANO) :

sudo nano forward.cgi

#!/bin/bash

gpio -g write 5 1

gpio -g write 6 0

gpio -g write 13 1

gpio -g write 19 0

스크립트가 생성되면, 우리는 당신에게 실행할 수있는 권한을 부여해야합니다 :

sudo chmod 755 forward.cgi

이제 스크립트를 실행합니다 :

sudo ./forward.cgi

LED가 스크립트를 테스트하는 데 사용하고, 실제 엔진은 이후의 단계에서 첨가 될 것이다.

파일 확장자와 같은 것을 사용 .cgi로 참고. CGI는 “공용 게이트웨이 인터페이스”를 의미합니다. 이 웹 서버는 동적 웹 페이지를 생성하는 서버에 설치 실행 프로그램과 상호 작용하는 표준 방법입니다. 이러한 프로그램은 CGI하거나 CGI를 스크립트로 알려져 있습니다; 그들은 일반적으로 스크립팅 언어로 기술되지만, 임의의 프로그래밍 언어로 기록 될 수있다.

계속해서, 같은 아이디어는 상기 테이블의 다른 조합에 적용한다 :

sudo nano stop.cgi

#!/bin/bash

gpio -g write 5 0

gpio -g write 6 0

gpio -g write 13 0

gpio -g write 19 0

sudo nano reverse.cgi

#!/bin/bash

gpio -g write 5 0

gpio -g write 6 1

gpio -g write 13 0

gpio -g write 19 1

sudo nano left.cgi

#!/bin/bash

gpio -g write 5 0

gpio -g write 6 1

gpio -g write 13 1

gpio -g write 19 0

sudo nano right.cgi

#!/bin/bash

gpio -g write 5 1

gpio -g write 6 0

gpio -g write 13 0

gpio -g write 19 1

스크립트를 작성하면 forward.cgi으로 수행되었을 때, 당신은 그들에게 동일하게 실행할 수있는 권한을 부여해야합니다

    sudo chmod 755 stop.cgi

sudo chmod 755 reverse.cgi

sudo chmod 755 left.cgi

sudo chmod 755 right.cgi

이제 모든 것이 작동하는지 확인하기 위해 몇 가지 테스트를 실행합니다 :

./forward.cgi

./left.cgi

./reverse.cgi

./right.cgi

./stop.cgi

좋은 방법은 자주 사용하는 프로그램에 대한 특정 디렉토리가 있고 “빈”을 호출하는 것입니다. 그래서, 우리는 프로젝트에서 사용하는 스크립트를 저장하려면, 우리는 예를 들어, 모든 실행 스크립트를 포함하는 CGI-빈 (또는 바이너리 파일)에 대해 디렉토리를 작성해야합니다.

우리가 우리의 웹 사이트가 위치하며 “VAR”에서 “WWW”디렉토리를 만들어 보자 그 아래, 스크립트 디렉토리 “CGI – bin에”

sudo mkdir /var/www

sudo mkdir /var/www/cgi-bin

이제, 우리는 새로운 디렉토리에있는 모든 파일을 이동 :

sudo mv /*.sgi /var/www/cgi-bin

cd /var/www/cgi-bin

ls 명령을 사용하여 만든 파일을 볼 수 있습니다 :

/ 오프 LED 및 제어 엔진 속도 ON (선택 사항)

우리는 H 브리지 모터 제어를위한 oL293-D로 사용하기 때문에, 우리는 방향을 넘어, 우리는 또한 속도를 제어 할 것인지 여부를 결정해야합니다.

두 가지 가능성이 여기에 :

고정 속도 : 두 개의 저항으로 전압 분배기를 사용하여 연결 핀 1과 + 5V (최대 속도) 또는 다른 비례 값의 다리 (활성화) 9

나무 딸기 파이 GPIO.18에 연결 핀 1과 9 (PWM 출력)

우리는 우리가 조향 제어를 설정했던 것과 같은 방식으로 스크립트의 그룹을 생성합니다 :

sudo nano nospeed.cgi

#!/bin/bash

gpio pwm 1 0

sudo nano lowspeed.cgi

#!/bin/bash

gpio pwm 1 250

sudo nano regularspeed.cgi

#!/bin/bash

gpio pwm 1 512

sudo noano highspeed.cgi

#!/bin/bash

gpio pwm 1 1023

스크립트가 생성되면, 당신은 그들에게 실행할 수있는 권한을 부여해야합니다 :

sudo chmod 755 nospeed.cgi

sudo chmod 755 lowspeed.cgi

sudo chmod 755 regularspeed.cgi

sudo chmod 755 highspeed.cgi

자, 그냥 모든 것이 작동하는지 확인하기 위해 몇 가지 테스트를 실행합니다 :

./lowspeedcgi

./regularspeed.cgi

./highspeed.cgi

./nospeedcgi

테스트를 위해, 우리는 그의 섬광의 강도는 명령이 작동 볼 수 GPIO.18에 LED를 연결합니다.

마지막으로, 우리는 예를 들어, 나 램프를 끄려면 사용되는 디지털 출력을 제어하는​​ 별도의 스크립트를 생성합니다. 우리는이에 대한 GPIO.10을 사용합니다 :

sudo nano llighton.cgi

#!/bin/bash

gpio -g write 10 1

sudo nano llightoff.cgi

#!/bin/bash

gpio -g write 10 0

sudo chmod 755 lighton.cgi

sudo chmod 755 lightoff.cgi

마지막 한가지 다른 단계로 이동하기 전에. 당신이 RPI를 다시 시작하면 개의 GPIO는 입력 기본 상태로 돌아갑니다. 그래서 우리는 모든 부팅의 시작 부분에 실행을 /etc/rc.local 스크립트를 변경해야합니다.

그냥 스크립트의 마지막 명령 (종료 0) 전에 GPIO가 모드 설정 명령을 포함합니다 :

sudo nano /etc/rc.local

gpio -g mode 5 out

gpio -g mode 6 out

gpio -g mode 13 out

gpio -g mode 19 out

gpio -g mode 10 out

gpio mode 1 pwm

exit 0

“출구 0″직전의 커맨드 라인으로서 PWM 명령을 갖는 것이 좋다.

RPI를 시작할 때마다 이제 영사 출력을 제어 할 준비가 될 것이다.

즐길 이제 시스템을 다시 부팅합니다

sudo reboot

설치하기 WEBSERVER

매우 가볍고 빠른 웹 서버입니다 lighttpd를 설치합니다 (예를 들어 대신 아파치 사용할 수 있습니다). 그 위키 페이지에 기재된 바와 같이 “이 Lighttpd 고성능 환경에 최적화 빠르고 유연한 보안 웹 서버가있다. 그것은 다른 웹 서버에 비해 낮은 메모리 풋 프린트를 가지고 있으며, 너무 CPU를로드 할주의하십시오.

이제이 Lighttpd 및 해당 구성 요소를 설치하자 :

sudo apt-get -y install lighttpd

sudo lighttpd-enable-mod cgi

sudo lighttpd-enable-mod fastcgi

기본적으로,이 Lighttpd 디렉토리에 index.html 페이지를 찾을 경우 : / var / www /에서 HTML을. index.html을이 폴더에 직접 저장할 수 있도록하자,이를 변경하자의 경우 : / var / www가. 이를 위해, 당신은이 Lighttpd 구성 파일을 편집해야합니다 :

sudo nano /etc/lighttpd/lighttpd.conf

변경:

server.document-root =“/var/www/html”

으로:

server.document-root =“/var/www”

이 변경 사항을 적용하기 위해 중지하고 웹 서버를 다시 시작해야합니다 :

sudo /etc/init.d/lighttpd stop

sudo /etc/init.d/lighttpd start

이때, 웹 서버가 실행되고 index.html 페이지는 단지 IP 어드레스를 입력 RPI,은 / var / www가, 우리는 브라우저로부터 액세스 할 수 있습니다.

우리는 테스트 목적으로 간단한 페이지를 작성합니다.

첫째, 우리는 페이지 이미지를 저장하는 디렉토리를 작성 :

mkdir /var/www/images

(시험, 난 이미 디렉토리 (/images/robot52.png)에 나에게 .PNG 파일을 보낸 있습니다 :

cd / var / www

sudo index.html nano

<html>

<head>

</head>

<style>

body {background-color: lightyellow}

h1 {color:blue}

</style>

<body>

<div style=”text-align:center”>

<h1>MJRoBot RPi Web Robot Control</h1>

<br><br>

<img src=”/images/robot52.png”>

</body>

</html>

페이지를 편집 완료 후, 저장 및 사용 권한을 변경 :

sudo chmod 755 index.html

지금 내 경우 예를 들어, IP 주소 라즈베리 파이를 브라우저를 열고 입력 : 10.0.0.31을

최종 결과는 아래에 볼 수있다 :

로봇을 제어하기 ONE PAGE의 HTML을 생성하기

의 우리의 웹 사이트를위한 심플한 디자인을 생각하자. 무엇을 할 수 명령?

lighton.cgi 및 lighoff.cgi : 두 개의 버튼은 ==> 스크립트로 작동 켜고 불을 끕니다

모터 제어 방향 다섯 버튼 ==> 스크립트로 작동합니다 forward.cgi, stop.cgi, left.cgi, right.cgi 및 reverse.cgi

모터 속도 제어를위한 네 개의 버튼 ==> escripts 작동합니다 : nospeed.cgi, lowspeed.cgi, regularspeed.cgi 및 highspeed.cgi

우리가 마지막 단계에서 생성 된 HTML의 index.html 파일을 사용하여, 우리는 자신의 스크립트 구현을위한 통화 기능을 설정 버튼이 포함됩니다.

예를 들어,이 LED (GPIO.10)을 점등하는 버튼을 만들 수 있습니다 :

button {

color: blue;

background:lightgrey;

border: 1px solid #000;

border-radius: 8px;

position: center;

}

<button style=”height: 50.0px;width: 100.0px;”><img src=”/images/lighton.png” style=”height: 40.0px;”></button>

HTML 코드는 위의와 둥근 버튼을 만들 것 “밝은 빛.”

버튼을 누를 때, 명령 “의 onclick = LIGHTON는 ()”은 “LIGHTON는 ()”함수를 호출하기 때문에 :

function lighton()

{

xmlhttp.open(“GET”,”cgi-bin/lighton.cgi”,true

xmlhttp.send();

}

LIGHTON () 함수가 호출되기 때문에 그리고, 스크립트가 lighton.cgi와 “짜잔는”LED가 켜집니다 실행됩니다.

동일한 절차가 다른 버튼을 사용한다. 외관을 구성하고 페이지를 작성하는 데 사용되는 다른 HTML 태그가있다.

HTML 소스 파일 (이전 단계에서 사용되는 LED의 구성의 테스트 페이지)에서 볼 수있다 :

HTML 페이지에 링크

ROBOT BODY ASSEMBLY

우선 플랫폼을 찾는 것입니다. 나는 4 DC 모터와 4WD 키트를하기로 결정했다. 이동성 분석은 4WD가 (코너링을 위해) 여기에서 생각하기 때문에 제어가 용이 아니라고하지 않습니다 실현, 우리는 완전한 로봇을 설정하지만, 실제 테스트는 나는 “코스터”를 추가하여 후륜을 사용 just’ll 전면에 ( “rolon”와 같은 탈취제 남아).

몸과 엔진이 제자리에 후에는, 브레드 보드를 포함 모터 연결하고 테스트하는 시간이다. 각각의 모터를 테스트하기 위해 외부 배터리를 사용합니다.

아래 그림과 같이 엔진은 H 브리지 D-L293에 의해 제어됩니다

이 시점에서, 당신은 또한 RPI의 GPIO가 시뮬레이션, 다리의 입력에 + 5V와 GND를 사용하여 모터를 제어, 테스트를 수행 할 수 있습니다.

RPI 설치

모든 corretamante 작동되면, 그것은 라즈베리 파이를 추가하는 시간이다. 전체 회로는 다음과 같습니다 :

작은 섀시와 엔진 사이의 RPI 5V 배터리를 설치합니다. RPI는 상단에 있습니다.

은 RPI를 켜기 전에 모든 케이블 연결을 확인합니다.

이전의 모든 단계가 OK 인 경우에, 당신은 IP 주소 RPI를 사용하여 로봇을 제어 할 수 있습니다.

당신의 마음에 드는 웹 브라우저와 안전한 여행을 엽니 다!

이하, 로봇이 웹 페이지를 사용하여 테스트가 비디오 :

파트 2 : 인터넷 카메라의 비디오 스트리밍 및 원격 제어 (팬 / 틸트)

도입에서 설명하고있는 바와 같이, 로봇은 사물의 인터넷 사업을 개발하는 변명은 거의이다. 우리가 여기 짓을하면 거기에서, 우리는 거의 모든 것을 제어 할 수 있습니다 Internet.The를 통해 GPIO가 RPI를 제어하는 것입니다!

이 두 번째 부분에서, 우리는 고통을 탐구 비디오를 스트리밍하는 방법도 서보 모터를 사용하여 카메라의 위치를 제어하는 방법을 찾을 수 있습니다. 인터넷을 통해 카메라를 제어하는 것은 보안에 사용하기 위해 포함, 여러 용도를 가질 수 있습니다.

궁극적 인 목적은 상기 프로젝트의 두 부분을 결합 만이 인터넷을 통해 제어 할 수없는 로봇을 만들뿐만 아니라, 스트리밍 비디오를 전송하는 것이다.

블록 다이어그램은이 프로젝트의 두 번째 부분의 개념을 도시한다.

RPI는 웹 서버로 프로그래밍 및 HTML 페이지로부터 명령을 수신한다. 이 명령은 위치는 서보 모터 (팬 / 틸트와 수평 / 수직)를 통해 파고, GPIO가 RPI를 제어합니다.

자료리스트

이전 재료의 목록, 우리는 고통과 두 개의 미니 서보 180도를 추가합니다. 그것은 Voltagen 6V 레귤레이터 (7806)는 엔진 전원 같은 이미 설치된 9V 배터리를 사용할 수있게하는 것이 필요하다.

스트리밍 비디오

튜토리얼을 기반으로 비디오 트리머 물기를 설치합니다 :

엘 모타 (업데이트 2014년 1월 19일)가 개발 라즈베리 파이 보드 카메라 비디오 스트리밍.

먼저, 운영 체제를 업데이트 할 수 있도록 :

    sudo apt-get update
    sudo apt-get upgrade
버전 dev에 libjpeg를 설치합니다 :
     sudo apt-get install libjpeg62-turbo-dev
 참고 : libjpeg62-DEV는 현재 무효이며,)이로 대체되었습니다
cmake를 설치합니다 :
    sudo apt-get install cmake
플러그인 raspicam와 MJPG – 유영 다운로드 :
    git clone https://github.com/jacksonliam/mjpg-streamer.git ~/mjpg-streamer
디렉토리를 변경 :
    make clean all
이전  jpg-streamer를 장착합니다 :
    sudo rm -rf /opt/mjpg-streamer
    sudo mv ~/mjpg-streamer/mjpg-streamer-experimental /opt/mjpg-streamer
    sudo rm -rf ~/mjpg-streamer
전송을 시작합니다
    LD_LIBRARY_PATH=/opt/mjpg-streamer/ /opt/mjpg-streamer/mjpg_streamer -i “input_raspicam.so -fps 15 -q 50 -x 640 -y 480” -o “output_http.so -p 9000 -w /opt/mjpg-streamer/www” &
모니터에서는 스트리밍에 대한 정보를 볼 수 있습니다
MJPG Streamer Version.: 2.0
i: fps………….: 15
i: resolution……..: 640 x 480
i: camera parameters…………..:
Sharpness 0, Contrast 0, Brightness 50, Saturation 0,
ISO 400, Video Stabilisation No, Exposure compensation 0
Exposure Mode ‘auto’, AWB Mode ‘auto’,
Image Effect ‘none’, Metering Mode ‘average’,
Colour Effect Enabled No with U = 128, V = 128
Rotation 0, hflip No, flip No
www-folder-path…: /opt/mjpg-streamer/www/
HTTP TCP port…..: 9000
username:password.: disabled
commands……….: enabled
Starting Camera
Encoder Buffer Size 81920
카메라가 작동되어야한다. 브라우저 및 유형으로 이동
    http : // 당신의 IP 주소 : 9000 / stream.html
것과 같은 테스트 페이지 아래 (카메라에 의해 촬영 된 이미지) 표시됩니다.

참고 당신은 당신을 위해 가장 적합한 하나, 통신 포트를 변경하면 RPI 모니터를 입력 한 명령 줄에서 매개 변수 “9000”를 변경하려는 경우. 우리 15 초당 프레임 수 (fps) 640 × 480의 해상도로 작업합니다. 또한 명령 행에 이러한 매개 변수를 변경할 수 있습니다.

당신은 당신이하는 /etc/rc.local 스크립트에 명령을 포함하지 않으면 다음과 같이 드라이브를 시스템이 다시 시작할 때마다 (재부팅)을 시작하려면 위의 명령 줄을 다시 입력해야합니다 :

sudo nano /etc/rc.local

LD_LIBRARY_PATH=/opt/mjpg-streamer/ /opt/mjpg-streamer/mjpg_streamer -i “input_raspicam.so -fps 15 -q 50 -x 640 -y 480” -o “output_http.so -p 9000 -w /opt/mjpg-streamer/www” &

웹 서버가 이미 설치되어있는 반면, 우리는 우리의 페이지에 표시하는 비디오를 스트리밍 다음 줄을 입력해야합니다 :

<iframe src=”http://Your IP Adress:9000/javascript_simple.html” frameborder=”0″ align=”middle” width=”640″ height=”480″ align=”middle” scrolling=”no”>$

위의 라인을 포함하여 아래, 우리는 간단한 HTML 페이지를 볼 수 있습니다

<html>

<head>

</head>

<style>

body {background-color: lightyellow}

h1 {color:blue}

</style>

<body>

<div style=”text-align:center”>

<h1> MJRoBot RPi Web Robot Control   <img style=”height: 100px”src=”/images/robot52.png”> </h1>

<br><br>

<iframe src=”http://10.0.1.31:9000/javascript_simple.html” frameborder=”0″ align=”middle” width=”640″ height=”480″ align=”middle” scrolling=”no”>$

</body>

</html>

브라우저에서 RPI IP를 입력, 우리는 결과 아래에 도달 :

SERVOBLASTER 라이브러리 설치

큰 라이브러리가 서보 모터를 제어하기 위해 사용될 수있다 ServoBlaster

이는 GPIO 핀을 통해 복수의 서보 모터를 제어하기위한 인터페이스를 제공 라즈베리 파이위한 특정 소프트웨어이다. 사용자는, 출력의 펄스 폭을 변경 명령​​을 전송하여 종의 위치를​​ 제어한다. GPIO는 이전 값을 변경하는 새로운 명령을 전달하는 당신에게 펄스 폭을 유지합니다.

기본적으로 ServoBlaster 8 서보 모터를 제어하도록 구성되어 있지만 21 서보로 설정 일반적으로 펄스 폭의 위치를​​ 제어 0.5 밀리 초 2.5 밀리 초 사이 어딘가에 활성 펄스를 필요로 할 수 있습니다 종. 주파수가 중요하지는 않지만 펄스는 약 20 밀리 초마다 반복한다. 펄스는이 서보 위치로 직접 번역이기 네, 그것은 중요 폭.

서보 제어에 더하여, ServoBlaster은 적합한 예를 들면 최대 21 개의 LED의 밝기를 제어하게 0 ~ 100 % (듀티) 사이의 펄스 폭을 생성하도록 구성 될 수있다.

ServoBlaster 당신이 명령을 보낼 수있는 장치 파일은 / dev / servoblaster을 만듭니다. 이 명령의 형식은 다음과 같습니다

[서보 번호] = [서보 위치]

(Ex .: echo P1-11 = 80% >/dev/servoblaster)

또는

P [header] – [pin] = [servo-position]

(Ex: echo P0 = 80% >/dev/servoblaster)

첫째, clonemos는 GitHub의 프로젝트를 Richardghirst :

cd /

sudo git clone https://github.com/richardghirst/PiBits

디렉토리를 변경 :

cd PiBits

cd ServoBlaster

cd user

내용을 나열하고 디렉토리 파일 “servod.c”를 포함하는지 확인

ls

컴파일하고 servod.c 파일을 설치합니다 :

sudo make servod

sudo make install

이 때, servod 프로그램이 설치됩니다. 권한을 변경하고 테스트 할 수 있도록 프로그램을 실행합니다 :

sudo chmod 755 servod

sudo ./servod

모든 것이 OK 경우, 모니터, 다음의 정보에 표시되어야합니다 :

Board model:                     2

GPIO configuration:            P1 (40 pins)

Using hardware:                PWM

Using DMA channel:              14

Idle timeout:             Disabled

Number of servos:                8

Servo cycle time:            20000us

Pulse increment step size:      10us

Minimum width value:            50 (500us)

Maximum width value:           250 (2500us)

Output levels:              Normal

Using P1 pins:               7,11,12,13,15,16,18,22

Servo mapping:

0 on P1-7           GPIO-4

1 on P1-11          GPIO-17

2 on P1-12          GPIO-18

3 on P1-13          GPIO-27

4 on P1-15          GPIO-22

5 on P1-16          GPIO-23

6 on P1-18          GPIO-24

7 on P1-22          GPIO-25

위의 종의 매핑을합니다. 우리는 기본 서보 모터에 의해 구성되어 있지만 카메라 제어의 경우, 예를 들어 단지 우리가에 사용되는 핀을 제한해야하며, (2) 필요 8. 그냥 생각 :

GPIO.17 (P1-11)이 TILT에 사용되는 (수직 제어)

GPIO.23 (P1-16)는 PAN에 사용되는 (수평 제어)

구성 할 핀을 설정하려면 다음 매개 변수를 입력 :

sudo ./servod –p1pins = 11,16

위의 명령을 실행하면, 모니터는 이제 하단에 표시한다 :

사용 P1 핀 : 11.16

서보 매핑 :

0 on P1-11 GPIO-17

1 on P1-16 GPIO-23

또한 당신은 RPI를 다시 시작하면, 설정이 손실 될 수 있습니다, 그래서 /etc/rc.local에의 마지막 명령을 포함하는 것이 중요하다

sudo nano /etc/rc.local

cd /PiBits/ServoBlaster/user

sudo ./servod –p1pins=11,16

cd

아래의 스크립트를 변경하는 것도 중요하다 :

sudo nano /etc/init.d/servoblaster

case “$1” in

start)

/usr/local/sbin/servod $OPTS >/dev/null

change to:

/usr/local/sbin/servod –p1pins=11,16 $OPTS >/dev/null

참조에 대한 전체 스크립트 아래 :

#!/bin/sh

### BEGIN INIT INFO

# Provides:          servoblaster

# Required-Start:    hostname $local_fs

# Required-Stop:

# Should-Start:

# Default-Start:     2 3 4 5

# Default-Stop:      0 1 6

# Short-Description: Start/stop servod.

# Description:       This script starts/stops servod.

### END INIT INFO

PATH=/sbin:/usr/sbin:/bin:/usr/bin

. /lib/init/vars.sh

OPTS=”–idle-timeout=2000″

STATUSFILE=”/tmp/servoblaster-status”

if [ $( id -u ) != 0 ]; then

echo “ERROR: Must be run as root”

exit 1

fi

case “$1” in

start)

/usr/local/sbin/servod –p1pins=11,16 $OPTS >/dev/null<br>        ;;

restart|reload|force-reload)

killall servod

/usr/local/sbin/servod $OPTS >/dev/null

;;

stop)

killall servod

;;

status)

if [ ! -e /dev/servoblaster ]; then

echo “ERROR: /dev/servoblaster does not exist”

exit 2

fi

rm -f $STATUSFILE

echo “status $STATUSFILE” > /dev/servoblaster

sleep 0.2

if [ ! -e $STATUSFILE ]; then

echo “ERROR: servod not responding”

exit 3

elif grep -q “^OK” $STATUSFILE; then

echo “OK”

exit 0

elif grep “^ERROR:” $STATUSFILE; then

exit 4

else

echo “ERROR: No status from servod”

exit 5

fi

;;

*)

echo “Usage: servoblaster [start|stop|status]” >&2

exit 6

;;

esac

exit 0

변경 사항을 영구적 될 수 있도록 지금 시스템을 다시 시작

sudo reboot

이게 다예요. 서보 블래스터가 설치됩니다. 이 순간부터, ServoBlaster이 두 종을 인식 할 수 있습니다 :

servo 0 ==> p1-11

servo 1 ==> p1-16

에코 명령은 동일한 결과로, 위의 형식 중 하나로 실행할 수 있습니다 :

echo P1-11=40% >/dev/servoblaster

echo P1-16=60% >/dev/servoblaster

or

echo 0=40% >/dev/servoblaster

echo 1=60% >/dev/servoblaster

기구 조립 PAN / TILT

이 시장에 여러 팬 / 틸트 메커니즘이 있지만, 난 그냥 종을 묶는 당신이 아래의 사진에서 볼 수 있듯이 물린 함께 매우 간단한을 넣어하기로 결정했다 :

서보를 RPI에 설치하기

위와 같이, RPI에 종의 데이터 케이블을 연결합니다.

은 RPI에 별도의 전압 소스에 + V 두 종을 연결합니다 (물론, GNDS이 연결되어 있어야합니다). 당신이 로봇의 팬 / 틸트 메커니즘을 설치합니다 후에는 DC 모터에 사용 된 것과 동일한 배터리 (9V)를 사용할 수 있습니다. 이 경우에있어서, 6V의 전압 레귤레이터가 요구된다.

서보을 테스트하려면, Servoblaster의 명령 “에코”를 사용합니다. 당신은 백분율로 어느 각도 값을 사용할 수 있습니다. 당신의 팬 / 틸트 메커니즘 최선의 범위를 테스트 :

TILT Servo:

echo P1-11=20% >/dev/servoblaster (looking down)

echo P1-11=60% >/dev/servoblaster (looking front)

echo P1-11=90% >/dev/servoblaster (looking up)

PAN Servo:

echo P1-16=30% >/dev/servoblaster

echo P1-16=62% >/dev/servoblaster

echo P1-16=90% >/dev/servoblaster

우리는 쉽게 스크립트는 종의 위치를​​ 제어 할 수 있습니다. 예를 들어, 우리는 아래의 파일을 작성해야합니다 발견 된 값을 기준으로 카메라 “기대”를 위치 쉘 스크립트를 만들 수 있습니다 :

sudo nano cam_view_front.cgi

#!/bin/bash

echo P1-11=60% >/dev/servoblaster

echo P1-16=62% >/dev/servoblaster

스크립트가 생성되면, 우리는 당신에게 실행할 수있는 권한을 부여해야합니다 :

sudo chmod 755 cam_view_front.cgi

이제 스크립트를 실행합니다 :

./cam_view_front.cgi

에코 명령을 사용하여 임의의 위치에 카메라를 이동 한 다음 새 스크립트를 실행합니다. 당신은 카메라가 자동으로 위치 “정면”으로 돌아갑니다 것을 볼 수 있습니다.

계속해서, 같은 아이디어는 다른 가능한 카메라 위치에 도포한다.

내 페이지를 생성하기 위해, 나는 TILT 5 중간 위치 및 이동하려면 5 중간 위치를 만들하기로 결정했습니다. 당신은 또한 더 단단한 위치의 변화에​​ 대해 “슬라이더”를 사용하도록 선택할 수 있습니다. 당신이 결정한다.

스크립트 “cam_view_front.cgi”에 기재 한 바와 같이 10 개의 새로운 스크립트를 작성, 같은 원리를합니다 사용 :

leftpan.cgi                 ==> 90%

leftcenterpan.cgi     ==> 76%

centerpan.cgi            ==> 62%

rightcenterpan.cgi  ==> 46%

rightpan.cgi               ==> 30%

downtilt.cgi               ==> 20%

downcentertilt.cgi   ==> 40%

centertilt.cgi              ==> 60%

upcentertilt.cgi         ==> 75%

uptilt.cgi                     ==> 90%

카메라를 제어 ONE PAGE의 HTML을 생성하기

우리는 카메라의 스트리밍 만든 index.html을 사용, 우리가 이전에 만든 스크립트를 실행하는 함수를 호출 10 버튼이 포함됩니다.

이하, 전체 HTML 코드 페이지를 만들 수 있습니다 :

index.html을 페이지에 HTML 코드

로봇에 카메라와 종들을 포용.

이제 우리는 우리의 RPI 스트리밍 비디오가 인터넷을 통해 카메라를 배치 할 수 있습니다, 우리는 첫 번째 부분에서 만든 로봇 프로젝트의 두 번째 부분을 통합 할 것이다.

포스트의 선두의 블록도, 프로젝트가 통합 될 수있는 방법을 설명하고 아래 회로 접속 방법을 보여

이어서 두 번째 부분 및 부분의 추가 버튼 및 모터의 제어를위한 제 1 생성 함수로 개발 된 웹 페이지를 가지고.

최종 HTML 페이지로 링크

ROBOT FULL은 생명을 걸립니다!

마지막 단계는 통합기구가 PAN / 로봇의베이스를 기울이다 :

아래 동영상은 어떻게 완전한 로봇을 설명합니다.