Controlando seu RoboARM

Bem-vindo ao tutorial de controle do seu RoboARM

A seguir você irá aprender:

Como fazer a ligação dos servos e joysticks no Sensor Shield V5;

Fazer o upload do código na placa;
Como alimentar corretamente todo o conjunto;
Quais direções do joystick controlam os diferentes movimentos do servo.

O código e ligações deste tutorial são otimizados para os produtos:

LISTA COMPLETA DE
PRODUTOS

 COMPRAR

BRAÇO ROBÓTICO
ROBOARM

R$249.90

ELETRÔNICA
ROBOARM

R$199.90

Conectando os componentes no Sensor Shield V5

Já com a estrutura completa do braço robótico montada e sua placa Arduino fixada na base, encaixe o Sensor Shield V5 no topo de sua placa.

Como estamos tratando de um conjunto de 4 servos, precisaremos utilizar o Sensor Shield V5 para alimentar todo o sistema e fornecer a corrente necessária
para os servos sem passar pelo regulador de 1 A da placa Arduino (caso você esteja usando o RoboARM com uma Julieta, basta alimentá-la diretamente com
uma fonte de pelo menos 3 A que a própria Julieta possui um regulador que irá fornecer até 3 A para os servos).

A conexão dos componentes ficará como na imagem abaixo.

 Caso esteja utilizando com uma Julieta: conecte os servos nos pinos A0 até A3 e os direcionais e alimentação dos joysticks nos pinos A4 em diante.

Upload do código na placa

Antes de alimentar o conjunto com a fonte (veremos no próximo passo como alimentar o projeto corretamente), precisamos programar a placa Arduino
para controlar os servos do RoboARM. Para isso precisaremos da Arduino IDE 1.8.x no computador, que é o programa que irá fazer o upload do nosso
código para a placa.

Se essa é sua primeira vez utilizando um Arduino, clique na imagem abaixo para ver o tutorial que irá te ensinar como fazer o download e instalar a Arduino
IDE em seu computador.

Com a Arduino IDE instalada, conecte sua placa Arduino em seu computador, copie e cole o código abaixo dentro da IDE.

/*************************************************************

RoboARM Demo
(v1.2 - 14/07/2022)

Control the RoboARM with two joysticks.

> https://www.robocore.net/loja/produtos/braco-robotico-roboarm.html
> https://www.robocore.net/loja/produtos/eletronica-braco-robotico-roboarm.html

Website: http://robocore.net
 Follow RoboCore: http://facebook.com/robocore
http://youtube.com/robocore
http://instagram.com/robocore

Copyright (C) 2022 RoboCore ( http://www.RoboCore.net )

> @Francois

------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
raw RoboARM_Demo.ino hosted with ❤ by GitHub
------------------------------------------------------------
view

**************************************************************/
Caso esteja utilizando com uma Julieta: lembre-se de alterar no código acima os pinos dos servos e joysticks para os novos pinos que estão
conectados (servos nos pinos digitais entre 13 e 2 e os direcionais e botões dos joysticks nos pinos analógicos entre A0 e A7).
//#define RESET_CONFIG # comment to read the configuration from the EEPROM
//#define DISABLE_ANGLE_CORRECTION # comment to enable the angle correction

Antes de fazer o upload do código na placa, certifique-se de que as configurações do menu de ferramentas estão iguais às da imagem abaixo.
// ---------------------------------------------------------------
// ---------------------------------------------------------------
// Libraries

#include <EEPROM.h>
#include <Servo.h>

// ---------------------------------------------------------------
// ---------------------------------------------------------------
// Class - Joystick

class Joystick {
// -----------------------
public:
// -----------------------
// Constructor
// @params {pinX} : the pin for the X axis [int]
// {pinY} : the pin for the Y axis [int]
// {pinBtn} : the pin for the button [int] (default -1)
Joystick(int pinX, int pinY, int pinBtn = -1){
_pinX = pinX;
_pinY = pinY;
_pinBtn = pinBtn;
pinMode(_pinX, INPUT);
pinMode(_pinY, INPUT);
if(_pinBtn > -1)
pinMode(_pinBtn, INPUT_PULLUP);

_meanX = 500; // default

_meanY = 500; // default
}

// -----------------------
// Calibrate the mean axis of both axis
O número atrelado à Porta COM pode mudar de sistema para sistema: fique tranquilo caso o número seja diferente, mas certifique-se de escolher a
// @params {stream} : the stream to output the debug messages [Stream*] (default NULL)
Porta COM que está conectada sua placa.
void calibrate(Stream *stream = NULL){
if(stream != NULL)
stream->print(F("Calibrating axis..."));
Após igualar as configurações, você já pode carregar o código para a sua placa clicando no ícone .

// calibrate
_meanX = 0; // reset
_meanY = 0; // reset
const int iterations = 10;
for(int i=0 ; i < iterations ; i++){
_meanX += getX();
_meanY += getY();
}
_meanX /= iterations;
_meanY /= iterations;

if(stream != NULL)
stream->println(F(" done!"));
Se você
} seguiu todos os passos corretamente até aqui, você verá a mensagem "Carregado" no painel inferior da IDE informando que o código foi carregado
com sucesso para a sua placa.
// -----------------------
// Get the value of the X axis
// @returns the X axis value [int]
int getX(void){
return get(&_pinX);
}

// -----------------------
// Get the value of the Y axis
Alimentando o projeto
// @returns the Y axis value [int]
Agoraint
quegetY(void){
já carregou o código do braço robótico, desconecte sua placa Arduino do computador para que possamos alimentar o projeto com uma
fonte. return get(&_pinY);
}
O pacote Eletrônica RoboARM contém uma Fonte 5V 5A e um Extensor DC P4 Fêmea que você utilizará agora para fornecer energia para todo o Braço
Robótico: com a fonte ainda desconectada da tomada, insira o conector P4 da fonte no Extensor DC P4 Fêmea, como na foto abaixo.
// -----------------------
// Get the value of the button
// @returns the button value [int]
int getButton(void){
return get(&_pinBtn);
}

// -----------------------
// Get the mean value of the X axis
// @returns the X axis mean value [int]
int meanX(void){
return _meanX;
}

// -----------------------
// Get the mean value of the Y axis
// @returns the Y axis mean value [int]
int meanY(void){
return _meanY;
}

// -----------------------
// Print method overriden
size_t printTo(Print& p){
size_t size = 0;
size += p.print(F("x{ "));
size += p.print(getX());
size += p.print(F(" ; "));
size += p.print(meanX());
size += p.print(F(" } y{ "));
O Extensor
sizeDC+= P4 Fêmea nos permite separar os polos positivo e negativo da fonte (VCC e GND) sem precisarmos cortar o conector para ter acesso aos
p.print(getY());
cabos, legal né?
size += p.print(F(" ; "));
size += p.print(meanY());
Iremos alimentar todo o RoboARM através do borne de conexão do Sensor Shield V5: com a chave Phillips, desaperte os parafusos do borne e insira o fio
if(_pinBtn > -1){
preto no borne indicado como GND e aperte o parafuso para firmar a conexão. Agora, insira o fio vermelho no borne indicado como VCC e aperte o
sizefirmar
parafuso para += p.print(F("
a conexão. } b{ "));
size += p.print(getButton());
}
size += p.println(F(" }"));
return size;
}

// -----------------------
private:
int _pinX, _pinY, _pinBtn;
int _meanX, _meanY;

// -----------------------
// Get the value of a pin
// @params {pin*} : the pointer to the pin [int*]
// @returns [int]
// > [0 - 1023] for an analog pin
// > [HIGH / LOW] for a digital pin
int get(int *pin){
if(pin == &_pinBtn){
return digitalRead(*pin);
} else {
analogRead(*pin); // firt call to change the channel
delay(5); // pause to charge the sample & hold circuit
return analogRead(*pin);
}
}
 };

// ---------------------------------------------------------------
// Class - RoboServo

#define ROBOSERVO_MIN 0
#define ROBOSERVO_MAX 1

class RoboServo : public Printable, public Servo {

// -----------------------
public:
// -----------------------
// Constructor
RoboServo(int pin) : Servo() {
_limits[ROBOSERVO_MIN] = 0; // default - MIN
_limits[ROBOSERVO_MAX] = 180; // default - MAX
_pin = pin;
pinMode(pin, INPUT); // leave floating until attached
}

// -----------------------
// Attach the servo to the predefined pin
// @returns [uint8_t] : the index in the servo vector
uint8_t attach(void){
uint8_t res = Servo::attach(_pin); // attach the pin
int mean = _limits[ROBOSERVO_MIN] + _limits[ROBOSERVO_MAX];
mean /= 2;
Servo::write(mean); // default angle
return res;
}

// -----------------------
// Get the MAX limit
// @returns [int]
int getMAX(void){
return getLimit(ROBOSERVO_MAX);
}

// -----------------------
// Get the MIN limit
// @returns [int]
int getMIN(void){
return getLimit(ROBOSERVO_MIN);
IMPORTANTE: certifique-se de que o jumper esteja conectado nos pinos ao lado do borne para que a fonte alimente todo o sistema.
}

Hora de se divertir
// -----------------------
Já estamos na etapa
// Print final!
method Se você seguiu corretamente os passos anteriores, agora é só conectar sua fonte na tomada para o RoboARM iniciar.
overriden
size_t printTo(Print& p) const {
Abaixo você confere o que cada joystick irá controlar na movimentação do seu RoboARM.
size_t size = 0;
size += p.print(attached());
size += p.print(F(" { "));
size += p.print(_limits[ROBOSERVO_MIN]);
size += p.print(F(" ; "));
size += p.print(read());
size += p.print(F(" ; "));
size += p.print(_limits[ROBOSERVO_MAX]);
size += p.println(F(" }"));
return size;
}

// -----------------------
// Set the MAX limit
// @params {value} : the maximum angle [int]
void setMAX(int value){
setLimit(ROBOSERVO_MAX, value);
}

// -----------------------
// Set the MIN limit
// @params {value} : the minimum angle [int]
void setMIN(int value){
setLimit(ROBOSERVO_MIN, value);
}

// -----------------------
// Write the angle
// @params {value} : the desired angle [int]
 void write(int value){
// constrain to limits
if(value < _limits[ROBOSERVO_MIN])
value = _limits[ROBOSERVO_MIN];
if(value > _limits[ROBOSERVO_MAX])
value = _limits[ROBOSERVO_MAX];

Servo::write(value); // write the angle

}

// -----------------------
private:
int _limits[2]; // { min , max }
int _pin;

// -----------------------
// Get an angle limit
// @params {index} : the desired limit [byte]
// @returns [int]
int getLimit(byte index){
if(index == ROBOSERVO_MAX){
return _limits[ROBOSERVO_MAX];
} else {
return _limits[ROBOSERVO_MIN]; // default
}
}

// -----------------------
// Set an angle limit
// @params
ATENÇÃO: {index}
o código : the
proposto nestedesired limit
tutorial conta[byte]
com algumas medidas de segurança para evitar o travamento e esforço excessivo dos servos, a fim de
prever//que os mesmos
{value} : therisco
corram desired angle [int]
de queimar. Se perceber que algum servo está fazendo muito esforço e/ou esquentando demais, realize o
movimento contrário ou corte
void setLimit(byte a alimentação
index, int value){ do conjunto para destravar o eixo e prevenir que ele queime.
// check the index (redundant)
Boa diversão ;) > ROBOSERVO_MAX)
if(index
return;

// constrain the value

if(value < 0)
value = 0;
if(value > 180)
value = 180;

_limits[index] = value; // set

// change the limits if necessary

if(_limits[ROBOSERVO_MAX] < _limits[ROBOSERVO_MIN]){
int value = _limits[ROBOSERVO_MIN];
_limits[ROBOSERVO_MIN] = _limits[ROBOSERVO_MAX];
_limits[ROBOSERVO_MIN] = value;
}
}
};

#undef ROBOSERVO_MIN
#undef ROBOSERVO_MAX

// ---------------------------------------------------------------
// ---------------------------------------------------------------
// Variables

#define JOYSTICK_DEADBAND 200

Joystick jLeft(A2, A1, A0);
Joystick jRight(A5, A4, A3);

#define SERVO_STEP 5
enum Motor { Base , Reach , Height , Claw };
RoboServo servos[] = { RoboServo(8) , RoboServo(9) , RoboServo(10) , RoboServo(11) };
Comentários

const int delay_loop = 20; // [ms]

Para fazer comentários é necessário estar logado. Efetuar login.

int current_motor = Motor::Base;
Você ainda nao é cadastrado? Cadastre-se agora!
int jValue; // auxiliary variable

// ---------------------------------------------------------------
enzovisintin25
// ---------------------------------------------------------------
Enviado 2023-06-11 18:43:54
// Prototypes
O que vocês querem dizer no diagrama de alimentação do shield através do extensor dc p4? Está lá indicado os bornes onde conectamos cada fio da
placa, até aí ok, mas e essa estrutura amarela ao lado, legendada no diagrama como: "jumper conectado"? Significa alguma coisa? Obrigado.
int AngleCorrection(Motor, int);
void ReadConfig(void);
luan.ferreira Resposta Oficial
Enviado 2023-06-13 08:08:58
// ---------------------------------------------------------------
 enzovisintin25
// ---------------------------------------------------------------

Para o projeto funcionar corretamente, é necessário que esse jumper ( https://www.robocore.net/conector/jumper-para-pci-2pinos ) esteja conectado
nossetup(){
void pinos indicados, pois ele é necessário para que a fonte alimente o circuito. Vale dizer que esse jumper pode ter outras cores.
// configure the serial output
Serial.begin(115200);
Serial.println(F("RoboARM - Demo"));
vinicflores
Serial.println(F("\tv1.2 - 14/07/2022\n"));
Enviado 2023-03-02 15:39:02

#ifndef RESET_CONFIG
FizSerial.println(F("Reading
a montagem do braço robótico, mas não
EEPROM estou encontrando o código. Poderia passar o link para acessar o código? Obrigado!
configuration"));
ReadConfig();
#endif luan.ferreira Resposta Oficial
Enviado 2023-03-02 16:24:03
 vinicflores
// calibrate the joysticks
jLeft.calibrate(&Serial);
O código utilizado neste tutorial, está presente abaixo do trecho “Upload do código na placa” no texto acima, mas ele também pode ser encontrado
no nosso GitHub https://gist.github.com/RoboCore/332011f7ffd4b0f57849379d68dab257#file-roboarm_demo-ino .
jRight.calibrate(&Serial);

// attach the servos and get the current angles

for(int i=0 ; i <= Motor::Claw ; i++){
sena.gerson
servos[i].attach();
Enviado 2023-02-08 23:27:51
}
}
Amigos, fiz a montagem completa deste braço robótico no meu canal. Quem precisar conferir outros detalhes ou também tirar outras dúvidas, será bem-
vindo.
-//https://youtu.be/QEjbvY-npIY
---------------------------------------------------------------

void loop(){ luan.ferreira Resposta Oficial

Enviado 2023-02-09 08:26:10
 sena.gerson
// -----------------------
// -----------------------
Olá! Obrigado por compartilhar esses links conosco, pois eles podem servir de referência para outros usuários!

if(Serial.available()){
sena.gerson
char c = Enviado
Serial.read();
2023-02-09 23:31:26
switch(c){
 sena.gerson
// INFO
Valeu, Luan. Fico feliz em poder contribuir com a comunidade Robocore pela relação de longa data. Não são os primeiros e nem serão os últimos
case
nessa boa'i': {
parceria.
Serial.print(F("Left: "));
jLeft.printTo(Serial);
Serial.print(F("Right: "));
jRight.printTo(Serial);
bajbruce
Serial.println(F("-----"));
Enviado 2022-10-19 14:35:30
for(int i=0 ; i <= Motor::Claw ; i++){
Serial.print('[');
Olá, boa tarde!
Montagem bemSerial.print(i);
explicada e funcionamento perfeitos, seguindo o manual e explicações, mas notei que na parte da base as esferas (bolinhas brancas) não
está encostando direito, alguém saberia regular pra baixar mais? pra a rotação ficar mais suave, usei uma fonte de 5V 2A e funcionou perfeitamente.
Serial.print("] ");
servos[i].printTo(Serial);
Giovanni5 Resposta Oficial
}
Enviado 2022-10-20 08:05:38
break;
 bajbruce
}
Não é crítico as esferas ficarem desencostadas, mas a solução pode seguir uma destas duas possibilidades: Ou o parafuso que fixa o braço de servo
em cruz da base está solto. Ou a Placa amarela de acrílico veio um pouco fina. Caso o servo esteja com o parafuso central folgado, basta apertar e
// SERVO
testar. SELECTION
Se isso não resolver pode ser que a placa de acrílico está um pouco fina o que é uma variação de produção do acrílico de fábrica. Uma
solução
casepara
'1':isso seria usar algum espaçador entre a placa amarela e o braço de servo em cruz.
current_motor = Motor::Base;
Giovanni5 Resposta
Serial.println(F("Base Oficial
selected"));
Enviado 2022-10-20 08:05:48
break;
bajbruce
case '2':
current_motor
Como na pagina 27 do = Motor::Reach;
manual, remova o Braço de servo e coloque entre ele e o fundo uma cartolina grossa ou outro material para afastar a cruz da
placa Serial.println(F("Reach
amarela. selected"));
Isso deve puxar ela para baixo e com isso trazer o conjunto com ela pressionando as esferas.
break;
case '3':
fdacio
current_motor = Motor::Height;
Enviado 2023-01-06 14:10:51
Serial.println(F("Height
 bajbruce selected"));
break;
O meu também
case '4':nãp encosta a base bas esferas, vou seguir essa diga da cartolina. Valeu Giovanni
current_motor = Motor::Claw;
Serial.println(F("Claw selected"));
break;
filipertp
Enviado 2022-08-30 12:42:29
// ANGLE
case 'a': {
Olá, boa tarde!
Fiz todosint angle = contudo
os passos, servos[current_motor].read();
na hora de ligar o roboarm ficou meio maluco. Ele tem uns comando involuntários e não responde aos comandos do
controle.Serial.print(F("Current angle: "));
Carreguei outra vez e o mesmo problema persiste. Como não deveria haver comandos sem utilizar o controle, sinceramente não sei se é problema de
Serial.println(angle);
sensor, código ou alimentação (utilizo uma fonte de 9V 2A, e não uma 5V 5A como indicado no kit com o Shield - e não entendo pq, uma vez que o
Arduino ébreak;
7-12V).
Tenho as pilhas do robo Explorer, e alimentei o kit roboarm no arduíno uno + Shield. O mesmo problema persistiu. Mesmo com USB.
}

filipertp
// ANGLE +
Enviado 2022-08-30 12:45:34
case '+': {
filipertp
int angle = servos[current_motor].read();
Vou tentar com a placa vespa e fazer o controle pelo wi-fi.
angle += SERVO_STEP;
Estou angle
achando= muito
AngleCorrection(static_cast<Motor>(current_motor), angle);
estranho esse comportamento, pois mesmo com alimentação // validateele
insuficiente, thenão
angle
deveria fazer movimentos aleatórios, indicando
talvez problemas no carregamento não indicado na IDE.
servos[current_motor].write(angle);
Serial.print(F("Current
Vcs tem angle:Se"));
alguma sugestão do que fazer? possível sem desmontar todo o roboarm? Hehehe
Serial.println(angle);
break;luan.ferreira Resposta Oficial
} Enviado 2022-08-30 15:55:10
 filipertp
// ANGLE -
Olá! Neste projeto não é indicado o uso de fontes acima de 5V, pois neste caso, além da fonte está alimentando a placa (pelo shield), ela também
estácase '-': { diretamente os servomotores. Como os servos funcionam em 5V, alimentar eles e o Arduino nessa configuração com uma tensão maior
alimentado
que isso,
int pode
angleos= danificar. Se a alimentação for direta no Arduino, pode ser que os servos não tenham corrente suficiente para funcionarem
servos[current_motor].read();
corretamente, por isso neste projeto usamos uma fonte de alimentação 5V 5A, pois essa fonte é capaz de suprir a alimentação do projeto.
angle -= SERVO_STEP;
angle = AngleCorrection(static_cast<Motor>(current_motor), angle); // validate the angle
filipertp
servos[current_motor].write(angle);
Enviado 2022-09-01 17:07:20
 filipertp
Serial.print(F("Current angle: "));
Serial.println(angle);
Ok, a questão é? Isso é um problema de alimentação?
break; mais básica seria! É possível alimentar o roboarm pelo USB, por exemplo?
Uma pergunta
Ele }está dando comandos sincronizados de tempo em tempo, sem mexer nos controles. Pequenos movimentos em alguns dos servos?
Isso é características de alimentação. Testei com uma fonte 5V 3A e nada.

// SAVE - MIN
Francois
case '<': { Resposta Oficial
Enviado 2022-09-02 11:22:05
int angle = servos[current_motor].read();
 filipertp
servos[current_motor].setMIN(angle);
A alimentação do conjunto é uma parte importante do projeto. Os quatro servomotores do RoboARM requerem uma corrente elevada demais para que eles
servos[current_motor].printTo(Serial);
sejam alimentados pela USB ou pelo regulador de tensão do Arduino/BlackBoard. É por isso que o projeto é alimentado diretamente por uma fonte de 5
break;
V com uma corrente maior.
}
// SAVE - MAX
Francois Resposta Oficial
case '>': {
Enviado 2022-09-02 11:22:23
int
 angle
filipertp= servos[current_motor].read();
servos[current_motor].setMAX(angle);
A sua fonte de 5V/3A deve funcionar, porém a alimentação deve ser feita pelo Sensor Shield V5. Isso faz com que ela alimente os motores
servos[current_motor].printTo(Serial);
diretamente, assim como a placa Arduino. Porém, nessa configuração, não se pode conectar uma fonte no Arduino, seja pelo conector J4 (preto - para
7 a 12break;
V) ou pela USB, senão haverá um conflito nas tensões internas. Além disso, a alimentação pelo Sensor Shield deve ser de exatamente 5 V,
senão o Arduino pode ser danificado.
}
}
} filipertp
Enviado 2022-09-11 14:05:24
 filipertp
// -----------------------
Bom,
// sinceramente tentei de tudo.
-----------------------
Como tenho o kit básico, refiz o projeto da garra para cada um dos servos que vieram no kit roboarm. Somente UM funciona com alimentação USB e com
alimentação 9V 2A que comprei tbm no site.
Os outros,
jValue respondem bem- pouco
= jLeft.getX() ao potenciômetro mas dá pra ver que estão se mexendo.
jLeft.meanX();
Dos 4 servos que vieram no kit, somente um funciona corretamente. Fui verificar no site o modelo DS-S006 foi descontinuado.
if(abs(jValue) > JOYSTICK_DEADBAND){
Tenho um servo Tower Pro SG90 que veio no kit básico e funciona perfeitamente.
Gostaria da troca
int angle desses servos, pois vieram com problemas.
= servos[Height].read();
if(jValue > 0){
angle = Giovanni5 Resposta Oficial(angle - SERVO_STEP)); // validate the angle
AngleCorrection(Height,
Enviado 2022-09-12 08:08:53
servos[Height].write(angle);
} else { filipertp
angle por
Encaminhe = AngleCorrection(Height,
gentileza um e-mail para (angle + SERVO_STEP));
suporte@robocore.net, com//algumas
validate thedoangle
fotos circuito montado, e um vídeo demonstrando o funcionamento
individual de cada servo com o exemplo "Sweep" da Arduino IDE, para que possamos entender melhor o problema dos servos e prosseguir com a melhor
servos[Height].write(angle);
solução para o seu caso.
}
}

jValue = jLeft.getY() - jLeft.meanY();

helder.hlo
if(abs(jValue) > JOYSTICK_DEADBAND){
Enviado 2022-06-04 14:49:42
int angle = servos[Base].read();
if(jValue > 0){
Boa tarde. Roboarm funcionando muito bem com um Brackboard uno R3... Contudo a garra não tem uma grande abertura.. Busquei no código e confesso que
angle localizar
não consegui = AngleCorrection(Base, (angle + aSERVO_STEP));
o argumento que restringe // validate the angle
sua abertura...
Poderiaservos[Base].write(angle);
me dar uma força nessa questão?
Grato.
} else {
angle = AngleCorrection(Base, (angle - SERVO_STEP)); // validate the angle
luan.ferreira Resposta Oficial
servos[Base].write(angle);
Enviado 2022-06-06 13:08:39
}  helder.hlo
}
Olá! Se for só para a sessão, você pode usar os comandos pela porta serial (em 115200 bps) para validar as posições.
“1” a “4” para selecionar o motor.
jValue = jRight.getX()
“+” e “-” - jRight.meanX();
para incrementar e decrementar o ângulo atual do motor selecionado.
“<”e “>” para salvar
if(abs(jValue) os limites mínimo e máximo do motor selecionado com base na posição atual.
> JOYSTICK_DEADBAND){
int angle = servos[Reach].read();
if(jValue luan.ferreira
> 0){ Resposta Oficial
angle =Enviado 2022-06-06 13:10:47 (angle - SERVO_STEP)); // validate the angle
AngleCorrection(Reach,
 helder.hlo
servos[Reach].write(angle);
} else
Mas, {
se quiser uma alteração permanente, você terá que configurar os valores na EEPROM, que são as linhas “EEPROM_DEFAULT_MAX_CLAW” e a
“EEPROM_DEFAULT_MIN_CLAW”. Além disso,(angle
angle = AngleCorrection(Reach, é necessário alterar a linha
+ SERVO_STEP)); que verifica
// validate se é necessário gravar os novos valores para a memória. Ou seja,
the angle
basta alterar o valor em (v1 == 131) , gravar o programa e depois gravar por cima o programa com 131 de novo (senão o programa sobrescreverá a
 memória toda vez, o que não é indicado).
servos[Reach].write(angle);
}
Outra opção é corrigir mecanicamente o posicionamento do servo em relação à garra.
}

luan.ferreira Resposta Oficial

jValue = jRight.getY() - jRight.meanY();
Enviado 2022-06-06 13:14:13
 helder.hlo
if(abs(jValue) > JOYSTICK_DEADBAND){
int angle = servos[Claw].read();
Se optar por alterar os limites no código, recomendamos que primeiro faça um controle pela porta serial (em 115200 bps) para garantir que não
if(jValue
forçará > 0){
o motor durante a execução do programa (é fácil dar problema na tentativa e erro da EEPROM).
angle = AngleCorrection(Claw, (angle + SERVO_STEP)); // validate the angle
servos[Claw].write(angle);
} else {
angle = AngleCorrection(Claw, (angle - SERVO_STEP)); // validate the angle
rafaelsantiagonovo
Enviado 2022-05-20 10:34:06
servos[Claw].write(angle);
}
} estamos com esse erro
Olá,

Arduino: 1.8.20 Hourly Build 2022/04/25 09:33 (Windows 8.1), Placa:"Arduino Uno"
// -----------------------
C:\Users\batman\Documents\Arduino\sketch_may20a\sketch_may20a.ino: In member function &#39;size_t Joystick::printTo(Print&) const&#39;:

// open the claw

C:\Users\batman\Documents\Arduino\sketch_may20a\sketch_may20a.ino:128:28: warning: passing &#39;const Joystick&#39; as &#39;this&#39; argument
discards
jValuequalifiers [-fpermissive]
= jRight.getButton();
if(jValue
size +===p.print(getX());
LOW){
delay(20);
^
if(jRight.getButton() == LOW){
C:\Users\batman\Documents\Arduino\sketch_may20a\sketch_may20a.ino:91:9:
int angle = servos[Claw].getMIN(); // get the minimum angle note: in call to &#39;int Joystick::getX()&#39;

angle
int = AngleCorrection(Claw, angle); // validate the angle
getX(void
servos[Claw].write(angle);
} luan.ferreira Resposta Oficial
} Enviado 2022-05-20 11:00:09
 rafaelsantiagonovo
// -----------------------
Olá! Esta mensagem é apenas um aviso, que não interfere na compilação do código. Sendo assim, o código deve compilar corretamente. Aliás, você
// -----------------------
pode optar por não ver esses avisos, basta ir na sua Arduino IDE > Arquivo > Preferências > Avisos do compilador, e selecionar a opção “Nenhum”.
Com isso, você não verá mais os avisos do compilador.

delay(delay_loop);

}
juliano4
Enviado 2022-02-12 17:05:38
// ---------------------------------------------------------------
// ---------------------------------------------------------------
COMO FAÇO P GRAVAR POSIÇÕES SEM OPERAR COM JOYSTICK?
OBRIGADO
// height = (1/a) * reach + b
#define ANGLE_CORRECTION_A -0.75
Giovanni5 Resposta Oficial
#define ANGLE_CORRECTION_B 165
Enviado 2022-02-14 08:10:04
 juliano4
#ifdef RESET_CONFIG
Basicamente você deve utilizar diversas funções <servo.write(posicao)> com as posições e as temporizações que deseja para cada um dos servos do
#define DISABLE_ANGLE_CORRECTION
braço, para que ele execute a animação/movimentação programada.
#endif

// Correct the angle according to the motor

// @params {motor} : the motor being controlled [Motor]
fernando_fgc
// {angle}
Enviado : the angle
2021-02-26 being sent [int]
09:59:50
// @returns the corrected angle [int]
int AngleCorrection(Motor
Quero motor, int recomendada
entender uma coisa. A alimentação angle){ para as placas Arduino Uno e Julieta é de 7 a 12V. Mas se alimentarmos tanto o shield quanto o
Uno ou a Julieta, teremos 5V , isso não faz o Uno ou a Julieta ficarem instáveis ?
#ifndef DISABLE_ANGLE_CORRECTION
if(motor == Giovanni5
Height){ Resposta Oficial
Enviado=2021-02-26
int max_angle 10:35:07
servos[Reach].read();
 fernando_fgc
max_angle = (float)max_angle * ANGLE_CORRECTION_A;
A max_angle
alimentação+=deANGLE_CORRECTION_B;
7/12V é feita pelo pino plug P4 (que é conectado ao pino Vin da placa), com a alimentação de 5V do Shield, estamos fornecendo 5V
diretamente para o pino de 5V da placa (quando o jumper está conectado). Quando o jumper está desconectado a alimentação do Shield e da placa (Uno
ou Julieta) é independente, o que permite a conexão USB ou alimentação externa (de 7/12V) da placa. Se essa conexão USB ou alimentação externa da
if(angle
placa < max_angle)
for feita enquanto o jumper do Shield estiver conectado, haverá um curto circuito na alimentação da placa, e ela pode ser danificada.
angle = max_angle;
} else if(motor == Reach){
Giovanni5 Resposta Oficial
int max_angle
Enviado=2021-02-26
servos[Height].read();
10:37:59
max_angle -= ANGLE_CORRECTION_B;
 fernando_fgc
max_angle = (float)max_angle / ANGLE_CORRECTION_A;
A alimentação de 5V nas placas não faz elas ficarem instáveis, na verdade elas funcionam normalmente. Vale lembrar que, a placa Julieta não
precisa ser conectada à um Sensor Shield V5, pois ela já possui os conectores que facilita a montagem do circuito de controle do RoboARM, e já é
capaz de fornecer
if(angle a corrente necessária para os servomotores enquanto é alimentada por uma fonte externa (7/12V).
< max_angle)
angle = max_angle;
}
#endif // DISABLE_ANGLE_CORRECTION
pedrobrasil11.pb
// check Enviado 2020-11-24 20:52:07
angle limits
if(angle > servos[motor].getMAX())
teriaangle
alguma= forma de utilizar um controle de um ps4 por exemplo?
servos[motor].getMAX();
if(angle < servos[motor].getMIN())
Giovanni5 Resposta Oficial
angle = servos[motor].getMIN();
Enviado 2020-11-25 08:23:15
  pedrobrasil11.pb
return angle;
}
É possível controlar o RoboARM por um controle de PS4, porém é necessário o uso de um Shield USB Host (que não trabalhamos) com um Dongle USB
Bluetooth conectado ao controle (ou através de um cabo USB), para receber os comandos do controle e mover o RoboARM de acordo com as leituras do
// Joystick, por exemplo.
---------------------------------------------------------------

#define EEPROM_ADDRESS_START 10

#define EEPROM_DEFAULT_MIN_BASE 10
#define EEPROM_DEFAULT_MIN_REACH 60
#define EEPROM_DEFAULT_MIN_HEIGHT 60
#define EEPROM_DEFAULT_MIN_CLAW 100
#define EEPROM_DEFAULT_MAX_BASE 170
#define EEPROM_DEFAULT_MAX_REACH 170
#define EEPROM_DEFAULT_MAX_HEIGHT 170
#define EEPROM_DEFAULT_MAX_CLAW 170

// Read the configuration data from the EEPROM

void ReadConfig(void){
int address = EEPROM_ADDRESS_START;
byte v1 = EEPROM.read(address++);
byte v2 = EEPROM.read(address++);

bool blank = ((v1 == 131) && (v2 == 237)) ? false : true;

if(blank){
// write data
EEPROM.write(address++, EEPROM_DEFAULT_MIN_BASE);
EEPROM.write(address++, EEPROM_DEFAULT_MIN_REACH);
EEPROM.write(address++, EEPROM_DEFAULT_MIN_HEIGHT);
EEPROM.write(address++, EEPROM_DEFAULT_MIN_CLAW);
EEPROM.write(address++, EEPROM_DEFAULT_MAX_BASE);
EEPROM.write(address++, EEPROM_DEFAULT_MAX_REACH);
EEPROM.write(address++, EEPROM_DEFAULT_MAX_HEIGHT);
EEPROM.write(address++, EEPROM_DEFAULT_MAX_CLAW);

address = EEPROM_ADDRESS_START; // reset

EEPROM.write(address++, 131);
EEPROM.write(address++, 237);
}

// read data
servos[Base].setMIN(EEPROM.read(address++));
servos[Reach].setMIN(EEPROM.read(address++));
servos[Height].setMIN(EEPROM.read(address++));
servos[Claw].setMIN(EEPROM.read(address++));
servos[Base].setMAX(EEPROM.read(address++));
servos[Reach].setMAX(EEPROM.read(address++));
servos[Height].setMAX(EEPROM.read(address++));
servos[Claw].setMAX(EEPROM.read(address++));
}

#undef EEPROM_ADDRESS_START

// ---------------------------------------------------------------