Robot controller arduino

Robot controller arduino DEFAULT

Getting Started with the Arduino Robot

This is a retired product.

With the Arduino Robot, you can learn about electronics, mechanics, and software. It is a tiny computer on wheels. It comes with a number of of project examples you can easily replicate, and it is a powerful robotics platform that you can hack to perform all sorts of tasks.

The robot comes with a large number of inputs; two potentiometers, five buttons, a digital compass, five floor sensors, and an SD card reader. It also has a speaker, two motors, and a color screen as outputs. You can control all these sensors and actuators through the Robot library.

There are two different boards on the Robot: the Control Board (top) and the Motor Board (bottom). If you're just getting started with electronics and programming, you should work with the Control Board. As you become more experienced, you may want to tinker with the Motor Board.

Robot Control board

Robot Motor Board

On this page... (hide)

Setting up the Robot

When you first open the robot, you'll need to set up a pair of things before it is ready to roll.

First, you'll need to insert the SD card into the slot on the backside of the TFT screen, and then insert the screen into the socket on the control board of the robot. The screen should be oriented so that the blue text with the text "SD Card" is close to the buttons and speaker.

Once that's in place, you'll need to attach the protective cover for the botom board. This will help prevent any objects on the ground from damaging the motor board. Attach the protective covering to the underside of the robot as shown below.

Content on the SD card

The SD card is used to store information for the robot to read. It comes preloaded with images and sound files used in the Explore examples. Once comfortable with the robot's functionality, you should be able to add your own files. If you ever accidentally remove files used by the explore sketches, you can copy them over from the SDcontent directory found in the robot library. Alternatively you can download the files here.

Connecting the robot to your computer

Each board on the robot has a microcontroller, which is programmed independently of the other. It is recommended that you should only program the control board (the top board) until you are familiar with the robot's functionality. The motor board (the bottom board) has a stock firmware that fulfills most general purpose applications.

Connect the control board to your computer with a USB cable.

After you have connected the board, the green LED labelled as PWR on the Control Board will be on. LED1 beneath it will flash a few times. On the Motor Board, the red LEDs labelled as LED1 to LED5 (opposite side to the power switch) should be on as well.

If the LEDs on either board do not turn on, check if the flat 10-pin communication cable next to the power switch is connected to both boards.

Installing the drivers

OSX

  • The first time you plug a robot into a computer running OSX, the "Keyboard Setup Assistant" will launch. There's nothing to configure with the robot, so you can close this dialogue by clicking the red button in the top left of the window.

Windows

The following instructions are for Windows 7. They are valid also for Windows XP, with small differences in the dialog windows.

  • Plug in your board and wait for Windows to begin its driver installation process. If the installer does not launch automatically, navigate to the Windows Device Manager (Start>Control Panel>Hardware) and find the Arduino Robot listing. Right click and choose Update driver.
  • At the next screen, choose "Browse my computer for driver software", and click Next.
  • Click the Browse... button. Another dialog appears: navigate to the folder with the Arduino software that you just downloaded. Select the drivers folder an click OK, then click Next.
  • You will receive a notification that the board has not passed Windows Logo testing. Click on the button Continue Anyway.
  • After a few moments, a window will tell you the wizard has finished installing software for Arduino Robot. Press the Close button.

Linux

There is no need to install drivers for Linux. (Tested with Ubuntu 12.04)

Hello User!

The Arduino Robot comes with a preloaded application that will ask for your name, what you want to name the robot, and where you are located. Look at the screen on the robot for information on how to input your information using the buttons and potentiometer.

You can power the robot by with 4 AAA batteries, or connect a USB cable to either the motor or control board.

Once you have gone through the setup process with the robot, you can start writing your own programs to control it.

Uploading a test sketch

To program the robot, connect the Control Board to your computer via USB. Open the Arduino IDE, and load the sketch located in File > Examples > Robot_Control > learn > MotorTest.

You need to tell the IDE which Arduino board you are targeting with your software, so open the Tools > Board menu and choose Arduino Robot Control.

The Arduino IDE must know which of your USB ports the robot is connected to. The Tools > Serial menu lists the available ports.

  • if only one item is shown, click on that one.
  • if two or more are shown, you can disconnect the Control Board and re-open the menu; the entry that disappears should be the robot. Reconnect the board and select that serial port.

Click the "Upload" button in the top left of the IDE window. Wait a few seconds - you should see the RX and TX leds on the board flashing. If the upload is successful, the message "Done uploading." will appear in the status bar of the software. Once this appears, you can disconnect the robot from the USB cable

With batteries in the robot, turn on the power switch and put it on the ground. The robot should show you a few basic moves. Congratulations! You've gotten the robot up and running.

If the robot is not moving, turn the power switch off. Connect the motor board to the computer with a USB cable. Load the File > Examples > Robot_Motor > Robot_Motor_Core sketch in the IDE, and select Arduino Robot Motor from the Boards menu. Upload this sketch, disconnect from the computer and try turning it on again.

Note: If no Serial port shows up after you plug in the robot, and restarting the IDE/unplug-replug the robot does not help, follow the steps below:

  • Open a very simple sketch, like Blink or BareMinimum
  • Press the upload button
  • When the status bar shows "Uploading...", double press the reset button on the Control Board
  • The Serial port should appear as normally.

Moving the Robot

This sketch moves the robot back and forth repeatedly.

Whenever you're writing code for the robot, make sure to include <ArduinoRobot.h> at the beginning of the sketch. This imports the necessary libraries to control the robot.

There's no need to initialize the Robot object.

To get the wheels to move, call Robot.motorsWrite(). motorsWrite() requires 2 arguments, the speed of the left motor, and the speed of the right motor. These values range from -255 to 255, where -255 is full reverse, and 255 is full speed forward. If you pass a value of 0, the motor will stop spinning the wheel.

Once you've uploaded the sketch, unplug the USB cable for the robot. Whenever the USB is connected, the robot's motors are disengaged. Turn on the power and watch it move around!

#include <ArduinoRobot.h> // import the robot library

voidsetup(){
  Robot.begin();// initialize the library
}

voidloop(){
  // move forward for one second
  Robot.motorsWrite(255,255);
  delay(1000);

  Robot.motorsWrite(0,0);// stop moving
  delay(1000);

  // move backwards for one second
  Robot.motorsWrite(-255,-255);
  delay(1000);

  Robot.motorsWrite(0,0);// stop moving
  delay(1000);
}

[Get Code]

Read the buttons

You'll be writing a sketch that prints the button presses to the screen.

First, you need to include the Robot library.

In , start the robot and the screen.

voidsetup(){
  Robot.begin();
  Robot.beginTFT();
}

[Get Code]

In , every 100ms, read the state of the buttons. If one is being pressed, write the name to the screen.

voidloop(){
  Robot.debugPrint(Robot.keyboardRead(),10,10);
  delay(100);
}

[Get Code]

In the explore folder of the robot examples, there is a sketch called Logo, which incorporates this example with the robot movement from above.

Change the motor speed with the potentiometer

This lets you control the speed at which the robot moves in a straight line. By turning the knob and mapping the values to -255 to 255, you will set the speed and direction (forward or backwards) of the robot.

First, you need to include the Robot library.

In , you must call to initialize the robot's functions. Also call to initialize the screen.

voidsetup(){

  Robot.begin();
  Robot.beginTFT();
}

[Get Code]

In , read the value of the potentiometer with . Map its value (a number between 0 and 1023) to -255 to 255. Print this value to the screen, and use it to change the speed of the motors.

voidloop(){
  int val=map(Robot.knobRead(),0,1023,-255,255);
  Robot.debugPrint(val);
  Robot.motorsWrite(val,val);
  delay(10);
}

[Get Code]

The robot's motor is disengaged when plugged in via USB. After programming the robot, unplug the USB cable and add batteries. Turn on the power switch and watch the robot move. Catch the robot, and change the knob to change its speed.

Making some noise

The robot has two different means of producing sounds. There's simple beeping, but the robot can also create more complex sounds by reading sequenced music off the SD card. In this example you'll start with the beeping. To learn about the more complex playback, see the Melody example in the learn folder.

First, you need to include the Robot library.

In , you must call to initialize the robot's functions. Also call to initialize the speaker.

voidsetup(){
  Robot.begin();
  Robot.beginSpeaker();
}

[Get Code]

In , you can call to create a beep. There are three different kinds of beeping; a simple beep, a double beep, and a long beep.

voidloop(){
  Robot.beep(BEEP_SIMPLE);
  delay(1000);
  Robot.beep(BEEP_DOUBLE);
  delay(1000);
  Robot.beep(BEEP_LONG);
  delay(1000);
}

[Get Code]

Next steps

There are many things you can do with the robot. The few examples on this page don't do it justice. To see some more complex examples that of what the robot can do, look at the sketches found in the Explore folder of the robot examples. These are more complete examples that show you some different applications for the robot.

You'll need to calibrate the compass module of the robot so it rotates smoothly. If you're using an old model, which has Honeywell HMC 6352, you can refer to this tutorial: Calibrate Compass

To learn about more of the functionality of the specific inputs and outputs of the robot, look at the learn folder in the robot examples.

Be sure to check out the Robot's library page and the hardware page for more information about the technical aspects of the Robot.

The text of the Arduino getting started guide is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the guide are released into the public domain.

Sours: https://www.arduino.cc/en/guide/robot

Romeo V2 - a Robot Control Board with Motor Driver (Compatible with Arduino)

Features

*Designed for domestic Arduino fans. Full compatible with Arduino UNO R3.

*Suitable for Arduino Beginners.

*Low-cost main controller board. The main difference from the official one is that this board offers XBee socket and SPI directly-plugged interface, making the best of UART ports. 

*For low-cost project, and Arduino communication module development.

*DFRduino Mega 2560 comes with plenty of IO ports, 54 digital ports, 16 analog ports, and 4 UARTs. 

*Applicable to large projects that require many sensors.

*Mega1280has as many IO ports as Mega256 but comes with a smaller Flash. Besides, its price is lower than Mega2560.

*Suitable for low-cost projects requiring many sensors.

*Romeo V1 is specially designed for robot fans. It integrates motor driver, all sorts of communication ports, IO expansion port, and so on. 

*Extremely suitable for robot fans.

*The only difference between V1 and V2 is that Romeo V2 adopts ATmega32u4 chip, which provides 2 UARTs, convenient for wireless communication.

*For robot fans to build up projects with wireless communication.

*The first Arduino compatible controller board that integrates Bluetooth 4.0, brings much more flexibility and possibility for Android and IOS mobile development.

*For Android and IOS mobile App BLE developers.

*Integrated CC3000 wifi core and SD card function. Can store a large number of collected data. Compared with Wifi shield, wido is more lightweight and low-cost.

*For IoT developers.

Sours: https://www.dfrobot.com/product-844.html
  1. Frozen samsung s7
  2. Fa01 samsung
  3. Love nikki bobo

Nano Robot Controller and How to Use It © CC BY-NC-SA

Previously we have made a few robots using Arduino and ESP boards. If you remember, it takes a lot of components along side the microcontroller itself to make a robot. There are Motor Drivers, Servo Controllers and voltage regulators. To connect all these components we need breadboard or Perf board to solder everything together. This may take a considerable amount of time and makes a mess with wires. This makes it hard for people debug the connections if something goes wrong. Moreover it demotivates beginners.

To avoid this problem, Robot Controllers are used. These are compact boards with most of the important components and Pins one will need to make a robot. There are many Robot controllers on the market but the one we are going to use here is a little different, a little special. This particular board is called "Nano Robot Controller" it is designed by me and manufactured by BPI factory.

In this tutorial we shall see what a robot controller is, what is it used for and how to get started with the Nano Robot controller. So without any further ado, let's begin.

Supplies:

Here is a list of all the things we will need for this tutorial.

Although I have used here the chassis of KeyBot (more about KeyBot here). You can also build a chassis yourself, here is an ebook that will tech you in details: Mini WiFi Robot

Step 1: What Is a Robot Controller?

The first question one might ask is, What really is a robot controller? Well in short term, robot controller is nothing but a PCB with components you might need to build a fully functioning robot. There are different types of robot controllers ranging from $10 all the way up to $500. Most cheap ones are in the form of a shield for Arduino or Raspberry Pi. Which has Motor driver and other ICs soldered on and it just snaps on to the headers of the Arduino or Pi.

Robot controllers usually have motor drivers and PWM controllers on board along with some GPIOs where you can hook up different peripherals and sensors. Some might even have a microcontroller on board eliminating the need of Arduino.

The Robot controller we are going to learn about today is called Nano Robot Controller which is a compact board designed to work with Arduino Nano and Nano compatible boards. Lets see the board in more details.

Step 2: Nano Robot Controller Board

Nano Robot Controller is a compact board consisting of all the basic components you will need along with GPIO to add sensors. Below are the hardware specifications you must know before using the board.

  • L293D dual H-bridge motor driver. It can control 2 DC motors speed and direction independently.
  • Analog pins: Which can be used to hook-up multiple sensors like IR, Ultrasonic, and more.
  • Digital pins: Six pins, out of which four are PWM enabled (D6, D9, D10, D11).
  • I2C: There are two sets of I2C pins one is 3.3V and other is 5V. These pins allow I2C communication with other devices and sensors.
  • Bluetooth: HC-05 or HC-06 can be connected to add wireless control.
  • Logical working voltage: 5V DC.
  • Motor drive voltage: 7v-12v DC.
  • Maximum driving current: 1A
  • Size: 75mm x 45mm (2.9" x 1.7")

To use this board, we have to know the pin configuration, The motor driver is connected to six digital pins, two of which are PWM.

Pin Configuration for Motor Controller:

Where ENA controls the speed of Motor 1 and ENB controls the speed of Motor 2.

  • IN1 = D2
  • IN2 = D4
  • IN3 = D7
  • IN4 = D8

Where D2, D4 controls the direction of "Motor 1" and D7, D8 controls the direction of "Motor 2". The I2C pins are connected to A4 and A5. Where SDA is A4 and SDL is A5. All the other pins are marked on the board itself. The board also has Bluetooth connector which is connected serially to the Nano i.e TX and RX. Here TX is D1 and RX is D0.

Now that we are familiar with the Robot Control Board, we can start making our first project with it.

Step 3: Building a Simple Robot:

Now that we have a better understanding of what a Robot Controller is and the necessary pinouts, we can start building our first robot.

We will need a chassis first. I have reused the chassis from KeyBot as it is a very well built frame. For adding the Robot board I mounted a peace of hard foam board on 4 pillars and mounted the board on top with 4 standoffs.You can refer to the images above for better understanding.

Once we have a chassis ready with the board secured on top, we can start connecting the wires. Follow the instructions below:

  • Connect the Left motor to "Motor 2" terminal.
  • Connect the Right motor to "Motor 1" terminal.
  • Connect the battery to the power terminal.

Note that the power terminal is not labeled. The screw connector closest to the mounting hole is Positive.Other way you can check the pin is by using continuity checker of a multi-meter. Just touch one lead to any GND pin on the board and connect other lead of multi-meter to each terminals of the Power block. The multi-meter will beep when the connection is completed and that is the GND or negative terminal.

Use 7V-12V battery pack to power the robot.

Step 4: Programming:

Finally we need to write a code and upload it to the nano which will bring our robot to life. To program the robot first make sure you have Arduino IDE installed on your computer, if now then download and install the latest version from here.

Now let's start writing the code.

First we declare the required variable. These will control our motor driver. ENA and ENB are PWM pins which will help use control the speed of our robot. IN pins control the direction in which motors will turn.

Setup function will be the first function to execute in a code. Here we will set the mode of each pin. First I like to include the serial functionality to debug but it is optional. All the pins are set as outputs as we are not connecting any sensor to our robot in this project.

Next we will write movement functions, this will make the code a lot easier to understand and modify.We need five movement functions in general, Forward, Backward, Left and Right.

Here also I have used the serial print to print the action on serial monitor.The ENA and ENB pins both are set to 75. Notice here I have used "analogWrite" function which will set the speed of our motor. To lower or increase the speed you can lower or increase the value anywhere between 0-255, where 0 will stop the motor and 255 will run it in full speed.

For going forward we want both the motors to move in same direction at the same speed. We set the speed to 75. Also we set the pins IN1 and IN3 to HIGH. This will make both the motors to move in same direction.

The above code is pretty similar to the last one. Here only one pin IN3 is high, this will just make 'Motor 1' run forward at the speed of 50. This will cause the robot to turn Left.

Here IN1 is high which will make 'Motor 2' run forward at speed of 50. This will cause the robot to turn Right.

This function is just opposite of the first function 'front()'. Here the pins IN2 and IN4 are High, this will make both the motors run backwards.

This function will stop both the motors, as you can notice all the pins are set as Low and the ENA, ENB pins are also set as 0. Finally we need the loop function which will carry out particular actions in a loop until the board is powered off or reset.

Here as you can see, we will just call all the functions and loop will run them one by one from top to bottom.I have also added a second of delay after every function.

With that been done, we can now upload this code onto the Microcontroller. In this case Arduino Nano using the IDE.

Step 5: Final Note:

Now all we have to do is power up the board and watch the Robot perform the maneuvers as codded in the loop function. You can interchange the movement functions to achieve different results.

This was just a basic tutorial to introduce you to the Nano Robot Board. In future we will make different robots and explore all the other features the board offers, so make sure you follow for updates.

Also if you are interested in robotics and want to build a simple WiFi controlled robot from scratch, Do checkout my eBook "Mini WiFi Robot". It covers everything designing, building and programming a compact robot.

Sours: https://create.arduino.cc/projecthub/WolfxPac/nano-robot-controller-and-how-to-use-it-56a12d?ref=part&ref_id=10308&offset=20
Make 5 in 1 Robot

The Robot library is included with Arduino IDE 1.0.5 and later.

The Robot has a number of built in sensors and actuators. The library is designed to easily access the robot's functionality.

The robot has two boards, a motor board and control board. Each board has a separate programmable processor.

The library allows you to interface with the various sensors and peripherals on the control board :

  • potentiometer
  • 5 momentary switches
  • 160x120 pixel color screen
  • 512Kbit EEPROM
  • speaker
  • compass
  • 3 I2C connectors
  • 8 TinkerKit input connectors

The library also enables you to do a number of things with the motor board :

  • control motor speed and direction
  • sense the current used by each motor
  • read the state of the 5 floor sensors (also known as line detection sensors)
  • access I/O pins on the board
  • control an I2C port
  • read the state of 4 TinkerKit inputs

For more information about the Robot, visit the getting started guide and the hardware page.

Library structure

This library enables easy access to the functionality of the Arduino Robot. It relies on a number of 3rd party libraries including Fat16, EasyTransfer, Squawk, and IRRemote. It also relies on a number of Arduino libraries like TFT, SPI, and Wire. Their functionality has been replicated inside the robot's library to optimize the code's size.

It is possible to program both the Control and the Motor boards. However, it is recommended that novice programmers begin with programming the control board, leaving the motor board for later. The library exposes the sensors on both boards through a single object.

There are two main classes that command the robot:

  • RobotControl: commands the Control Board as well as the I/Os and motors on the Motor Board, when running the default firmware.
  • RobotMotor: commands the Motor Board. Use it to make your own custom version of the Motor Board firmware

Examples

These illustrate the possibilities of the robot to help you get up and running quickly with the basic functionality.

  • Logo - tell your robot where to go through the on-board keyboard
  • Line Following - draw a racing track and get your robot to run on it
  • Disco Bot - turn your robot into an 8-bit jukebox and dance to the beat
  • Compass - plan a treasure hunt with this digital compass
  • Inputs - learn how to control the knob and the keyboard
  • Wheel Calibration - tune the wheels to perform even better
  • Runaway Robot - play tag with your robot using a distance sensor
  • Remote control - reuse that old tv-remote to command the bot on distance
  • Picture browser - want to use your own images? This is how
  • Rescue - train your robot to look for hidden pearls in a maze
  • Hello User - hack the robot's welcome demo and make your own
Sours: https://www.arduino.cc/en/Reference/RobotLibrary

Controller arduino robot

Control Board Summary

MicrocontrollerATmega32u4
Operating Voltage5V
Input Voltage5V through flat cable
Digital I/O Pins5
PWM Channels6
Analog Input Channels4 (of the Digital I/O pins)
Analog Input Channels (multiplexed)8
DC Current per I/O Pin40 mA
Flash Memory32 KB (ATmega32u4) of which 4 KB used by bootloader
SRAM2.5 KB (ATmega32u4)
EEPROM (internal)1 KB (ATmega32u4)
EEPROM (external)512 Kbit (I2C)
Clock Speed16 MHz
Keypad5 keys
Knobpotentiomenter attached to analog pin
Full color LCDover SPI communication
SD card readerfor FAT16 formatted cards
Speaker8 Ohm
Digital Compassprovides deviation from the geographical north in degrees
I2C soldering ports3
Prototyping areas4
Radius185 mm
Heigth85 mm

Motor Board Summary

MicrocontrollerATmega32u4
Operating Voltage5V
Input Voltage9V to battery charger
AA battery slot4 alkaline or NiMh rechargeable batteries
Digital I/O Pins4
PWM Channels1
Analog Input Channles4 (same as the Digital I/O pins)
DC Current per I/O Pin40 mA
DC-DC convertergenerates 5V to power up the whole robot
Flash Memory32 KB (ATmega32u4) of which 4 KB used by bootloader
SRAM2.5 KB (ATmega32u4)
EEPROM1 KB (ATmega32u4)
Clock Speed16 MHz
Trimmerfor movement calibration
IR line following sensors5
I2C soldering ports1
Prototyping areas2

Power


The Arduino Robot can be powered via the USB connection or with 4 AA batteries. The power source is selected automatically. The battery holder holds 4 rechargeable NiMhAA batteries. NB : Do not use non-rechargeable batteries with the robotFor safety purposes, the motors are disabled when the robot is powered from the USB connection. The robot has an on-board battery charger that requires 9V external power coming from an AC-to-DC adapter (wall-wart). The adapter can be connected by plugging a 2.1mm center-positive plug into the Motor Board's power jack. The charger will not operate if powered by USB. The Control Board is powered by the power supply on the Motor Board.

Memory


The ATmega32u4 has 32 KB (with 4 KB used for the bootloader). It also has 2.5 KB of SRAM and 1 KB of EEPROM (which can be read and written with the EEPROM library). The Control Board has an extra 512 Kbit EEPROM that can be accessed via I2C. There is an external SD card reader attached to the GTFT screen that can be accessed by the Control Board's processor for additional storage.


Input and Output


The Robot comes with a series of pre-soldered connectors. There are a number of additional spots for you to install additional parts if needed. All the connectors are labelled on the boards and mapped to named ports through the Robot libraryallowing access to standard Arduino functions. Each pin can provide or receive a maximum of 40mA at 5V. Some pins have specialized functions :
  • Control Board TK0 to TK7: these pins are multiplexed to a single analog pin on theControl Board's microprocessor. They can be used as analog inputs for sensors like distance sensors, analog ultrasound sensors, or mechanical switches to detect collisions.
  • Control Board TKD0 to TKD5: these are digital I/O pins directly connected to the processor, addressed using Robot.digitalRead() and Robot.digitalWrite) functions. Pins TKD0 to TKD3 can also be used as analog inputs with Robot.analogRead()
    Note: if you have one of the first generation robots, you will see that the TKD* pins are named TDK* on the Robot's silkscreen. TKD* is the proper name for them and is how we address them on the software.
  • Serial Communication: The boards communicate with each other using the processors' serial port. A 10-pin connector connects both boards carries the serial communication, as well as power and additional information like the battery's current charge.
  • Control Board SPI: SPI is used to control the GTFT and SD card. If you want to flash the processor using an external programmer, you need to disconnect the screen first.
  • Control Board LEDs: the Control Board has three on-board LEDs. One indicates the board is powered (PWR). The other two indicate communication over the USB port (LED1/RX and TX). LED1 is also accessible via software.
  • Both boards have I2C connectors available: 3 on the Control Board and 1 on the Motor Board.

Control Board Pin Mapping

ARDUINO LEONARDOARDUINO ROBOT CONTROLATMEGA 32U4FUNCTIONREGISTER
D0RXPD2RXRXD1/INT2
D1TXPD3TXTXD1/INT3
D2SDAPD1SDASDA/INT1
D3#SCLPD0PWM8/SCLOC0B/SCL/INT0
D4MUX_IN A6PD4 ADC8
D5#BUZZPC6???OC3A/#OC4A
D6#MUXA/TKD4 A7PD7FastPWM#OC4D/ADC10
D7RST_LCDPE6 INT6/AIN0
D8CARD_CS A8PB4 ADC11/PCINT4
D9#LCD_CS A9PB5PWM16OC1A/#OC4B/ADC12/PCINT5
D10#DC_LCD A10PB6PWM16OC1B/0c4B/ADC13/PCINT6
D11#MUXBPB7PWM8/160C0A/OC1C/#RTS/PCINT7
D12MUXC/TKD5 A11PD6 T1/#OC4D/ADC9
D13#MUXDPC7PWM10CLK0/OC4A
A0KEY D18PF7 ADC7
A1TKD0 D19PF6 ADC6
A2TKD1 D20PF5 ADC5
A3TKD2 D21PF4 ADC4
A4TKD3 D22PF1 ADC1
A5POT D23PF0 ADC0
MISOMISO D14PB3 MISO,PCINT3
SCKSCK D15PB1 SCK,PCINT1
MOSIMOSI D16PB2 MOSI,PCINT2
SSRX_LED D17PB0 RXLED,SS/PCINT0
TXLEDTX_LEDPD5  
HWB PE2 HWB

Motor Board Pin Mapping

ARDUINO LEONARDOARDUINO ROBOT CONTROLATMEGA 32U4FUNCTIONREGISTER
D0RXPD2RXRXD1/INT2
D1TXPD3TXTXD1/INT3
D2SDAPD1SDASDA/INT1
D3#SCLPD0PWM8/SCLOC0B/SCL/INT0
D4TK3 A6PD4 ADC8
D5#INA2PC6???OC3A/#OC4A
D6#INA1 A7PD7FastPWM#OC4D/ADC10
D7MUXAPE6 INT6/AIN0
D8MUXB A8PB4 ADC11/PCINT4
D9#INB2 A9PB5PWM16OC1A/#OC4B/ADC12/PCINT5
D10#INB1 A10PB6PWM16OC1B/0c4B/ADC13/PCINT6
D11#MUXCPB7PWM8/160C0A/OC1C/#RTS/PCINT7
D12TK4 A11PD6 T1/#OC4D/ADC9
D13#MUXIPC7PWM10CLK0/OC4A
A0TK1 D18PF7 ADC7
A1TK2 D19PF6 ADC6
A2MUX_IN D20PF5 ADC5
A3TRIM D21PF4 ADC4
A4SENSE_A D22PF1 ADC1
A5SENSE_B D23PF0 ADC0
MISOMISO D14PB3 MISO,PCINT3
SCKSCK D15PB1 SCK,PCINT1
MOSIMOSI D16PB2 MOSI,PCINT2
SSRX_LED D17PB0 RXLED,SS/PCINT0
TXLEDTX_LEDPD5  
HWB PE2 HWB

Communication


The Robot has a number of facilities for communicating with a computer, another Arduino, or other microcontrollers. The ATmega32U4 provides UART TTL (5V) serial communication, which is available on digital the 10-pin board-to-board connector. The 32U4 also allows for serial (CDC) communication over USB and appears as a virtual com port to software on the computer. The chip also acts as a full speed USB 2.0 device, using standard USB COM drivers. On Windows, a .inf file is required. The Arduino software includes a serial monitor which allows simple textual data to be sent to and from the Robot board. The RX (LED1) and TX LEDs on the board will flash when data is being transmitted via the USB connection to the computer (but not for serial communication between boards). Each one of the boards has a separate USB product identifier and will show up as different ports on you IDE. Make sure you choose the right one when programming. The ATmega32U4 also supports I2C (TWI) and SPI communication. The Arduino software includes a Wire library to simplify use of the I2C bus; see the documentation for details. For SPI communication, use the SPI library.


Programming


The Robot can be programmed with the Arduino software (download). Select "Arduino Robot Control Board" or "Arduino Robot Motor Board" from the Tools > Boardmenu. For details, see the getting started pageand tutorials. The ATmega32U4processors on the Arduino Robot come preburned with a bootloaderthat allows you to upload new code to it without the use of an external hardware programmer. It communicates using the AVR109protocol. You can bypass the bootloader and program the microcontroller through the ICSP (In-Circuit Serial Programming) header; see these instructionsfor details.

Automatic (Software) Reset and Bootloader initiation


Rather than requiring a physical press of the reset button before an upload, the Robot is designed in a way that allows it to be reset by software running on a connected computer. The reset is triggered when the Robot's virtual (CDC) serial / COM port is opened at 1200 baud and then closed. When this happens, the processor will reset, breaking the USB connection to the computer (meaning that the virtual serial / COM port will disappear). After the processor resets, the bootloader starts, remaining active for about 8 seconds. The bootloader can also be initiated by double-pressing the reset button on the Robot. Note that when the board first powers up, it will jump straight to the user sketch, if present, rather than initiating the bootloader. Because of the way the Robot handles reset it's best to let the Arduino software try to initiate the reset before uploading, especially if you are in the habit of pressing the reset button before uploading on other boards. If the software can't reset the board you can always start the bootloader by double-pressing the reset button on the board. A single press on the reset will restart the user sketch, a double press will initiate the bootloader.

USB Overcurrent Protection


Both of the Robot boards have a resettable polyfuse that protects your computer's USB ports from shorts and overcurrent. Although most computers provide their own internal protection, the fuse provides an extra layer of protection. If more than 500 mA is applied to the USB port, the fuse will automatically break the connection until the short or overload is removed.


Physical Characteristics


The Robot is 19cm in diameter. Including wheels, GTFT screen and other connectors it can be up to 10cm tall.


To Learn More


To calibrate the compass module, if you're using an old model of the robot (which uses Honeywell HMC 6352), refer to this tutorial: Calibrate Compass See also: getting started with the Arduino Robot and the Robot's library pages.

Sours: https://www.arduino.cc/en/Main.Robot
How To Make A DIY Arduino Joystick Control Car At Home

Romeo BLE - A Control Board for Robot - Arduino Compatible - Bluetooth 4.0

Romeo family is an All-in-One Arduino based control board specially designed for robotics applications from DFRobot. It benefits from the Arduino open-source platform, it is supported by thousands of open source codes, and can easily be expanded with your Arduino shields. The integrated 2 way DC motor driver and wireless socket allows you to start your own robot project immediately without the need for an additional motor driver. Not just has the motor driver, Romeo is also designed to have extra power for servos which need more current.

Romeo is also featured with DFRobot's standard 3Pin-out designed and compatible with Gravity series sensors and actuators. Hundreds of sensors are now plug-play with Romeo. You may also check Bluetooth Microcontrollor Selection Guide to get more information.

The Romeo BLE is a new member of Romeo Family. This robot controller inherits all functions of Romeo all-in-one controller, the Romeo BLE has integrated bluetooth 4.0,  it is the first time to give a robot control board the power of easy setup. Thanks to the bluetooth 4.0,  Romeo BLE supports uploading sketch wireless which means you do not need to plug a cable to upload new code.  Just need a USB Bluno Link adapter, Romeo BLE is ready to be updated through the Air which is so convenient for robot application.

With Romeo BLE, all DFRobot's mobile platforms and robots can now be played with iOS devices by APP "GoBle".  Also, the Romeo BLE supports Visual Programming APP (WhenDo).

What did others say about this Romeo BLE? 

"I have the Romeo BLE and consider it to be a huge step up from the standard Arduino boards I have. All those extra headers for the standard connections and the motor hookups make it a dream to work with." From Drew.

Specification

  • Microcontroller: ATmega328P
  • Bootloader: Arduino UNO
  • On-board BLE chip: TI CC2540
  • Transmission range: 70m in free space
  • Support Bluetooth remote update the Arduino program
  • Support Bluetooth HID
  • Support iBeacons
  • Support AT command to config the BLE
  • Support Transparent communication through Serial
  • Support the master-slave machine switch
  • Support USB update BLE chip program
  • 14 Digital I/O ports
  • 6 PWM Outputs (Pin11, Pin10, Pin9, Pin6, Pin5, Pin3)
  • 8 10-bit analog input ports
  • 3 I2Cs
  • Two-way H-bridged Motor Driver with 2A maximum current
  • 5 Buttons
  • Support Male and Female Pin Header
  • Integrated sockets for APC220 RF Module
  • Power Supply Port: USB or DC2.1
  • External Power Supply Range: 5-23V
  • DC output: 5V/3.3V
  • Auto-sensing/switching external power input
  • Size: 94mm x 80mm(3.70"x3.15")

Documents

Shipping List

  • Romeo BLE (Arduino Compatible Atmega 328) x1
Sours: https://www.dfrobot.com/product-1176.html

Now discussing:

.



561 562 563 564 565