Do Zero a um Robô

Do Zero a um robô é uma seção da WPILib que faz com que você consiga criar um robô do zero, sem conhecimento da linguagem de programação

Introdução

Seja bem vindo a casa da documentação oficial para o sistema de controle da FIRST® Robotics Competition e os pacotes de software da WPILib. Essa página é o recurso de documentação primária do uso do sistema de controle da FRC® (incluindo fiação, configuração e software) assim como as bibliotecas e ferramentas da WPILib.

Novato em programação?

Essas páginas cobrem partes específicas das bibliotecas da WPILib e do sistema de controle da FRC e não descrevem o uso básico das linguagens de programação suportadas. Se você gostaria de acessar recursos de aprendizado para as linguagens de programação suportadas, de uma olhada nas recomendações abaixo:

Você pode continuar com essa seção Zero-ao-Robô para conseguir um robô básico funcionando, sem conhecimento sobre as linguagens de programação. Para ir além disso você precisará estar familiarizado com a linguagem na qual você escolheu programar.

Java

C++

LabVIEW

Zero ao Robô

As próximas páginas deste tutorial foram desenhadas para irem completamente do zero a um robô básico funcional. Os documentos irão acompanhá-lo durante a fiação do seu robô, instalação de todos os programas necessários, configuração do hardware, e carregar um exemplo de código básico que deve permitir que seu robô seja capaz de operar.




Declaração de isenção de responsabilidade

Todo este material foi traduzido e adaptado, pela curadoria da stemOS, da página oficial da WPILib disponível em (https://docs.wpilib.org/pt/stable/docs/zero-to-robot/introduction.html)

Etapa 1: Construindo seu robô

Etapa 1: Construindo seu robô

Introdução

Uma visão geral do hardware do sistema de controle disponível pode ser encontrada aqui.

Introdução ao cabeamento de um robô de FRC

Etapa 1: Construindo seu robô

Introdução a fiação de robôs na FRC - REV

Grupo 176.png

Diagrama cortesia da equipe de FRC® 3161 e Stefen Acepcion

Junte os materiais

Localiza os itens do sistema de control e ferramentas a seguir:

Etapa 2: Instalando os programas

Etapa 2: Instalando os programas

Preparação de instalação offline

Esta página contém instruções/links para componentes que você vai precisar se você quiser instalar um programa do FRC® Control System software de forma offline.

Este documento reúne todos os links de download para facilitar a instalação em computadores offlines ou em múltiplos computadores. Se você estiver instalando em um único computador que está conectado a internet, pode passar para a próxima página.

A ordem com que essas ferramentas são instaladas não importa para times que usam Java ou C++. LabVIEW deve ser instalado antes da FRC Game Tools ou bibliotecas de terceiros.

Documentação

Está documentação pode ser baixada para ser vista sem internet. O link para baixar o PDF pode ser encontrado aqui (documentação em inglês)

Instaladores

Todos times

Times que usam LabVIEW

Times que usam Java/C++

Na página de lançamentos do github suba até o topo.

github-release.webp

Então na sessão de "assets" clique no binário correto para seu SO para começar a instalação.

github-assets.webp

Bibliotecas de terceiros

Um diretório das bibliotecas de terceiros que funcionam com a WPILib pode ser encontrado aqui.

Etapa 2: Instalando os programas

Instalando LabVIEW para FRC (Apenas LabVIEW)

Está instalação é **apenas** para times que programam em LabVIEW ou utilizam NI Vision Assistant. Times que usam C++ e Java não precisam dessas ferramentas, e devem apenas seguir para instalar as FRC Game Tools.

O tempo de instalação irá variar dependendo do computador e da conexão a internet, de toda forma, esse processo envolve uma grande quantidade de arquivos, por isso é esperado no minímo uma hora para completar a instalação.

Requisitos

Desinstale as versões antigas (recomendado)

Se você continua programando em cRIOs você deve manter o *software* de LabVIEW de FRC® 2014. A licença para o FRC 2014 foi extendida. Por enquanto essas versões devem ser capazes de coexistirem em um mesmo computador, isso não é uma configuração que foi extensivamente testada.

Antes de instalar uma nova versão do LabVIEW é recomendado remover qualquer versão antiga. A nova versão pode coexistir com a versão anterior, mas foram apenas testadas no FRC de 2023. Tenha certeza de salvar qualquer código do time alocado no diretório «User\LabVIEW Data» antes de desinstalar. Then click Start >> Add or Remove Programs. Locate the entry labeled «NI Software», and select Uninstall.

uninstall_control_panel.webp

Selecione os componentes para desinstalar

Na caixa de dialógo que aparecer, selecione tudo. O meio mais fácil para fazer isso é desmarcar a caixa «Products Only» e selecionar a caixa a esquerda de «Name». Clique Remove. Espere a desinstalação e reinicie quando pronto.

Essas instruções assumem que nenhum outro software da NI está instalado. Se tiver é necessário desmarcar para que ele não seja desinstalado.

uninstall_select_components-1100.webp

Instalador LabVIEW

Localize e insira o LabVIEW USB Drive ou baixe o instalador do LabVIEW for FRC 2023 da NI. Certifique-se de selecionar a versão correta no menu suspenso.

offline-installer.webp

Se você quiser instalar em outras máquinas offline, não clique no botão de Download, clique em Individual Offline Instalers e então clique em Download para baixar o instalador completo.

Esse é um grande arquivo (~9GB). Por isso é recomendado utilizar uma rápida conexão com a internet e usar o instalador da NI para permitir que a instalação possa ser resumida caso seja interrompida.

Instalando o LabVIEW

NI LabVIEW precisa de uma licença. A licença de cada temporada permanece ativa até 31 de Janeiro do ano seguinte (exemplo, a licença de 2020 expira em 31 de Janeiro de 2021)

É permitiro que os times instalem o programa em quantos computadores precisarem, apenas sujeitos as restrições e aos termos de licença que da companhia que faz o programa, e desdque os membros ou os mentores da equipe o usem, e somente para FRC. LabVIEW é somente controlado pelos termos da licença que é mostrado durante a instalação.

Iniciando a instalação

Licença do Gerenciador de pacotes NI

ni-package-license1.webp

Se você ver essa tela, clique em Next.

Desative o inicio rápido do windows

labview_fast_startup1.webp

Se você ver essa tela, clique em Next.

Recapitulação - Gerenciador de pacotes NI

labview_package_manager_review1.webp

Se você ver essa tela, clique em Next.

Instalação do Gerenciador de pacotes NI

ni-package-install1.webp

O processo de instalação do NI Package Manager será mostrado nessa tela.

Lista de produtos

labview_product_list.webp

Clique em Next.

Pacotes adicionais

labview_additional_software.webp

Clique em Next.

Termos da licença

labview_license_1.webp

Cheque I accept... e clique em Next.

labview_license_2.webp

Cheque I accept... e clique em Next.

Informação do produto

labview_product_info.webp

Clique em Next.

Inicie a instalação

labview_start_install.webp

Clique em Next.

Progresso Geral

labview_install_progress.webp

O progresso geral da instalação será mostrado na tela.

Serviço de atualização NI

ni_update_enable.webp

Irá aparecer uma tela para habilitar o serviço de atualização da NI. Você pode escolher para não habilitar.

Não é recomendado instalar essas atualizações sem ser diretamente pela FRC, ou dos canais de comunicação (Blog da FRC, *Teams Updates*, *E-mail blasts*)

NI Activation Wizard

ni_activation_wizard.webp

Clique no botão Log in to Activate

ni_activation_login.webp

Entre na sua conta ni.com. Se você não tiver uma, selecione Crate account para criar uma conta de forma gratuita.

ni_activation_sn_selection.webp

Na caixa de seleção, selecione Enter a serial number

ni_activation_keys.webp

Coloque o número serial em todas as caixas. E depois clique em Activate.

ni_activation_success.webp

Se a ativação do seu produto deu certa, uma mensagem "Activation Successful" vai aparecer. Se o número serial estiver incorreto, irá aparecer uma caixa de texto e você poderá recolocar o número e selecionar Try Again. Os items mostrados acimas não são esperados para ativar. Se toda ativação ocorreu da forma certa, clique em Finish.

Reinicie

labview_restart.webp

Clique em Reboot Now depois de ter fechado qualquer programa aberto no seu computador.

Etapa 2: Instalando os programas

Instalando as FRC Game Tools

O FRC® Game Tools contém os seguintes programas:

Os componentes de LabVIEW operados em tempo real para a Driver Stations e Imaging Tool são incluídas neste pacote.

Nenhum componente do programa LabVIEW para pacote FRC é necessário para executar a *Driver Stations* ou *Imaging Tool*.

Requisitos

offline-installer (1).webp

Se você quiser instalar em outra máquina offline, clique em Individual Offline installers antes de clicar para baixar o instalador completo.

Desinstale as versões antigas (Recomendado)

Times que usam LabVIEW já completaram essas etapa, então não repita isso. Esses times podem pular para a seção de instalação.

Antes de instalar a nova versão da FRC Game Tools é recomendado remover as versões antigas. A nova versão vai coexistir com a antiga (nota que a DS vai sobrescrever a versão antiga), mas isso foi testado com as ferramentas FRC de 2022 apenas. Então click Start >> Add or Remove Programs. Encontre o software com o nome de “NI Software”, and select Uninstall.

É apenas necessário desinstalar as versões anteriores quando instalar uma versão de outro ano. Por exemplo, desinstalar a ferramenta de 2021 antes de instalar a de 2022. Mas não é necessário desinstalar uma ferramenta antes de *atualizar* para uma nova versão das ferramentas de 2022.


uninstall_control_panel.webp

Selecione os componentes para desinstalar

Na caixa de dialógo que aparecer, selecione todas entidades. O meio mais fácil de fazer isso é não selecionar a caixa individual do produto e selecionar a caixa a esquerda de Name. Então clique em Remove. Espere o desinstalador completar e então reinicie quando pedir.

uninstall_select_components-1100 (1).webp

Instalação

O instalador do Game Tools pode solicitar que o .NET Framework 4.6.2 precise ser atualizado ou instalado. Siga as instruções na tela para concluir a instalação, incluindo a reinicialização, se solicitado. Em seguida, retome a instalação do FRC Game Tools, reiniciando o instalador se necessário.

Extração

Licença do Gerenciador de pacotes NI

ni-package-license.webp

Se você ver essa tela, aceite os termos e clique Next. Essa tela confirma que você concorda com os termos do NI Package Manager

Desative o inicio rápido do windows

labview_fast_startup1.webp[![additional-software.webp]

É recomendado deixar essa tela do jeiro que está, o início rápido do windows pode ocasionar problemas com os drivers da NI necessários para configurar o roboRIO. Portanto, vá em frente e clique Next.

Recapitulação do Gerenciador de pacotes NI

labview_package_manager_review1.webp

Se você ver essa tela clique em Next.

Instalação do Gerenciador de pacotes NI

ni-package-install.webp

O progresso da instalação do NI Package Manager será mostrado nessa tela.

Programas adicionais

additional-software.webp

Se você ver essa tela, clique em Next.

Termos de licença

license-agreements.webp

Selecione I accept... e clique em Next.

labview_license_2 (1).webp

Selecione I accept... e clique em Next.

Sumário de recapitualação

review-summary.webp

Clique em Next

Progresso

detail-progress.webp

Essa tela mostra o processo de instalação, vá em frente e aperte em Next quando estiver finalizado*.

NI Activation Wizard

ni_activation_login (1).webp

Entre na sua conta ni.com (link). Se você não tiver uma, selecione Create account para criar uma conta de forma gratuita.

ni-activation-wizard-2.webp

Coloque o número serial e clique em Activate

Se este é o primeiro momento ativando o programa desse ano nessa conta, você vai ver uma mensagem, mostrada acima, sobre uma licença que não foi encontrada. Você pode ignorar isso.

ni-activation-wizard-3.webp

Se a ativação do seu produto foi bem sucedida, uma mensagem escrita "Activation Successful!" vai aparecer. Se o número serial estiver errada, irá aparecer uma caixa de texto e você poderá recolocar o número e selecionar Try Again.

ni-activation-wizard-4.webp

Clique em Close.

Serviço de atualização NI

ni_update_enable.webp

Vai aparecer uma caixa de dialógo perguntando se você quer ativar o NI update service. Você pode escolher não habilitar esse serviço.

Não é recomendado instalar essas atualizações sem ser diretamente pela FRC, ou dos canais de comunicação (Blog da FRC, *Teams Updates*, *E-mail blasts*)

Reinicie para completar a instalação

install-complete-reboot.webp

Selecione Reboot Now depois de fechar qualquer outro programa aberto no seu computador.

Etapa 2: Instalando os programas

Guia de instalação WPILib

Esse guia é para times que usam Java ou C++. Times que usam LabVIEW podem pular para Instalando LabVIEW para FRC (Apenas LabVIEW). Ademais, o seguinte tutorial foi feito em Windows 10, mas as etapas são idênticas para todos os sistemas operacionais. Nota-se que diferentes SO serão mostrados (não tenho certeza dessa parte).

Pré-requisitos

Sistemas Operacionais suportados:

Para 2024, macOS 12 ou maior será necessário para C++

Os seguintes sistemas operacionais não são mais suportados: macOS 10.15, Ubuntu 18.04 e 20.04, Windows 7, Windows 8.1, e qualquer 32-bit Windows.

WPILib é designada para ser instalada em diferentes pastas dependendo do ano, por isso não é necessário desinstalar uma versão anterior antes de instalar a desse ano.

Instalando

Para obter a versão mais recente da biblioteca WPI, utilize o botão abaixo:

Baixe WPI

Não esqueça de verificar as instruções de instalação na página de lançamentos do github!

Caso a versão for uma beta, apenas instale caso saiba o quê está fazendo


/br> Uma vez na página de lançamentos do GitHub, suba até a seção de lançamentos no topo da página.

github-release (1).webp

Então clique no arquivo correto para seu sistema operacional para começar a instalação.

github-assets.webp

Extraindo o instalador

Quando você baixar o instalador da WPILib, é distruibuído como um arquivo .iso para windows, .tar.gz para Linux e como um DMG para MacOS.

Executando o instalador

Abrindo o instalador, irá aparecer uma tela como a abaixo. Vá em frente e aperte Start.

installer-start.webp

installer-options.webp

Essa tela incluí uma lista de opções possíveis para a instalação da WPILib.

Você terá dois botões, Install for this User e Install for all Users. A opção de apenas um usuário instala apenas na conta atual, e não precisa de privilégio de administrador. Entretanto, instalar para todos os usuários, instala para todas as contas do sistema e irá solicitar privilégio de administrador. Instalar para todos os usuários não é uma opção para macOS e Linux.

Se você selecionar para instalar em todos usuários, o windows vai socilitar privilégio de administrador durante a instalação.

Selecione a opção que é mais apropriada para você, depois irá aparecer a seguinte tela.

This next screen involves downloading VS Code. Unfortunately, due to licensing reasons, VS Code can not be bundled with the installer.

installer-vscode-download.webp

Go ahead and select Download for this computer only. This will begin the download process and can take a bit depending on internet connectivity (it’s ~100MB). Once the download is done, select Next. You should be presented with a screen that looks similar to the one below. Vá em frente e selecione Download for this computer only. Isso vai começar o processo de instalação e pode demorar um pouco dependendo da conexão com a internet (~100MB). Uma vez que a instalação esteja concluída, selecione Next. Você deve ser apresentado a uma tela que parece similar a mostrada abaixo.

installer-installing.webp

Depois que a instalação for completa irá aparecer uma tela de encerramento.

installer-finish.webp

WPIlib instala uma versão separada do VS Code. Ele não usa uma versão já existente para instalação. Cada ano tem sua própria cópia das ferramentas daquele ano. IE: WPILib VS Code 2022. Por favor, inicie o WPILib VS Code e não uma cópia instalada no sistema!

Parabéns, o ambiente de desenvolvimento WPILib e ferramentas estão agora instalados no seu computador! Pressione Finish para sair do instalador.

O que esta instalado?

O instalador offline estabelece os seguintes componentes:

Desinstalação

WPILib é instalada em diferentes pastas em anos distintos, por isso não é necessário desinstalar a versão anterior antes de instalar a mais recente. Mas de toda forma, as instruções seguintes podem ser usadas para desinstalar a WPILib caso desejado.

Solução de problemas

No caso do instalador falhar, por vaor abra uma issue no repositório do instalador. O endereço está disponível aqui (link). O instalador deve fornecer uma mensagem informando a causa do erro, por favor, inclua isso na descrição da sua issue.

Etapa 2: Instalando os programas

Próximas etapas

Parabéns! Você completou a etapa 2 e deve ser capaz de ter um ambiente de desenvolvimento funcionando! A etapa 3 para esse tutorial aborda a atualização de hardare para que você possa programa-lo, enquanto a etapa 4 mostra a programação de um robô no VS Code IDE. Para mais informações, você pode ler a seção sobre VS Code para se familiarizar mais com a IDE.

Artigos específicos que a leitura é recomendada:

Adicionalmente, você pode ter que fazer configurações extras para o robô da sua equipe. Por favor, utilize a ferramenta de pesquisa para achar a documentação necessária.

É importante que os times usando controladores de motor CAN de terceiros leiam o artigo Instalando bibliotecas de terceiros, pois esses dispositivos precisam de etapas extras de configuração.

Etapa 3: Preparando seu robô

Etapa 3: Preparando seu robô

Preparando seu robô

Etapa 4: Programando seu robô

Etapa 4: Programando seu robô

Criando seu programa de teste para tração (LabVIEW)

Esse documento aborda como criar, construir e carregar uma programação básica de FRC® LabVIEW para uma tração no roboRIO. Antes de começar, tenha certeza que você instalou o LabVIEW para FR, as FRC Game Tools e que você configurou seu roboRIO como descrito no tutorial Do zero ao robô.

Criando um projeto

creating-a-project.webp

Inicie o LabVIEW e clique no FRC roboRIO Robot Project para abrir a caixa de dialógo Create New FRC Robot Project.

Configurando o projeto

configuring-project.webp

Preencha a caixa de dialógo Crate New FRC Robot Project

  1. Escolha um nome para seu projeto

  2. Selecione uma pasta para colocar o projeto

  3. Coloque o número do seu time

  4. Selecione um tipo de projeto. Se não tiver certeza, selecione Arcade Drive

  5. Clique em Finish

Executando o programa

running-the-program.webp

Nota-se que o programa executado dessa maneira não estara no roboRIO depois de um ciclo de ligação. Para implementar um programa para executar toda vez que o roboRIO inícia, siga a próxima etapa, implementando o programa.

  1. Na janela de explorador de projeto, clique duas vezes em Robot Main.vi para abrir o Robot Main.VI

  2. Clique no botão de Run (Flecha branca na aba superior) do Robot Main.VI para implementar o VI no roboRIO. LaVIEW implementa o VI, todos os items exigidos pelo VI, e as configurações alvo na memória do roboRIO. Se perguntar para salvar qualquer VIs, clique em Save on all prompts.

  3. Usando o programa da Driver Stations, coloque o robô no modo teleoperado. Para mais informações na configuração e utilização da Driver Station, veja o artigo FRC Driver Stations Software.

  4. Clique em Enable

  5. Mova o joystick e observe como o robô responde.

  6. Clique no Abort button do Robot Main.VI. Observe que o VI para. Quando você executa um programa utilizando o botão de Run, o programa opera no roboRIO, mas você consegue manipular os objetos no front panel pelo computador em que o programa esta sendo executado.

Implementando o programa

deploying-the-program.webp

Para operar na competição, você vai precisar implementar o robô no seu roboRIO. Isso permite que o programa sobreviva a resets do controlador, mas não permite as mesmas ferramentas de depuração (front panel, probes highlight execution) que estão operando no front panel. Para implementar seu programa:

  1. No explorador de projetos clique no + perto de Build Specifications para expandi-lo.

  2. Botão direito em FRC Robot Boot-up Deployment e selecione Build. Espere pela implementação para terminar.

  3. Botão direito novamente em FRC Robot Boot-Up Deployment e selecione Run as Startup. Se você receber um dialógo de conflito, cique em OK. Esse dialógo indica que o programa atual no roboRIO vai ser terminado/substituído.

  4. Either check the box to close the deployment window on successful completion ou clique no botão close quando a implementação for um sucesso.

  5. O roboRIO vai automáticamente começar operando o código implantado dentro de poucos segundos após a caixa de dialógo fechar.

Etapa 4: Programando seu robô

Criando seu programa de teste (C++/Java)

Assim que tudo estiver instalado, estamos prontos para criar um programa de robô. O WPILib vem com vários modelos para programas de robô. O uso desses modelos é altamente recomendado para novos usuários; no entanto, usuários avançados têm a liberdade de escrever seu próprio código de robô do zero. Este artigo guia você na criação de um projeto a partir de um dos exemplos fornecidos, que já possui algum código escrito para controlar um robô básico.

Este guia inclui exemplos de código que envolvem hardware do fornecedor para a conveniência do usuário. Neste documento, PWM refere-se ao controlador de motor incluído no KOP. A guia CTRE faz referência ao controlador de motor Talon FX (motor Falcon 500), mas o uso é semelhante para TalonSRX e VictorSPX. A guia REV faz referência ao CAN SPARK MAX controlando um motor sem escova, mas é semelhante para motor com escovas. Parte-se do pressuposto de que o usuário já instalou os vendordeps necessários e configurou o(s) dispositivo(s) (atualização de firmware, atribuição de IDs CAN, etc.) de acordo com a documentação do fabricante (CTRE REV).

Criando um novo projeto WPILib

Abra a paleta de comandos do Visual Studio Code com Ctrl+Shift+P. Em seguida, digite "WPILib" no prompt. Como todos os comandos do WPILib começam com "WPILib", isso mostrará a lista de comandos específicos do WPILib no VS Code. Agora, selecione o comando "Criar um novo projeto".

module

Isso abrirá a "Janela do Criador de Novo Projeto:".

module

Os elementos da "Janela do Criador de Novo Projeto" são explicados abaixo:

  1. Tipo de Projeto: O tipo de projeto que desejamos criar. Para este exemplo, selecione "Exemplo".

  2. Linguagem: Esta é a linguagem (C++ ou Java) que será usada para este projeto.

  3. Base do Projeto: Esta caixa é usada para selecionar a classe base ou exemplo a ser gerado para o projeto. Para este exemplo, selecione "Início Rápido" (Getting Started).

  4. Pasta Base: Isso determina a pasta na qual o projeto do robô será localizado.

  5. Nome do Projeto: O nome do projeto do robô. Isso também especifica o nome que será dado à pasta do projeto se a caixa "Criar Nova Pasta" estiver marcada.

  6. Criar Nova Pasta: Se esta opção estiver marcada, será criada uma nova pasta para armazenar o projeto dentro da pasta especificada anteriormente. Se não estiver marcada, o projeto será localizado diretamente na pasta especificada anteriormente. Um erro será gerado se a pasta não estiver vazia e esta opção não estiver marcada.

  7. Número da Equipe: O número da equipe para o projeto, que será usado para os nomes de pacotes dentro do projeto e para localizar o robô ao implantar o código.

  8. Habilitar Suporte de Desktop: Ativa os testes de unidade e a simulação. Embora o WPILib suporte isso, bibliotecas de software de terceiros podem não oferecer suporte a isso. Se as bibliotecas não suportarem desktop, seu código pode não compilar ou pode travar. Deve ser deixado desmarcado, a menos que os testes de unidade ou a simulação sejam necessários e todas as bibliotecas o suportem. Para este exemplo, não marque esta caixa.

Depois de configurar todos os itens acima, clique em "Gerar Projeto" e o projeto do robô será criado.

Quaisquer erros na geração do projeto aparecerão no canto inferior direito da tela.

Abrindo o novo projeto

module

Após criar com sucesso o seu projeto, o VS Code dará a opção de abrir o projeto, conforme mostrado acima. Podemos optar por fazer isso agora ou mais tarde, digitando Ctrl+K e, em seguida, Ctrl+O (ou apenas Command+O no macOS) e selecionar a pasta onde salvamos nosso projeto.

module

Clique em "Sim, confio nos autores".

Depois de abrir, veremos a hierarquia do projeto à esquerda. Clicar duas vezes no arquivo abrirá esse arquivo no editor.

module

Importações

PWM

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import edu.wpi.first.wpilibj.motorcontrol.PWMSparkMax;

CTRE

import edu.wpi.first.wpilibj.Joystick;
import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import com.ctre.phoenix.motorcontrol.can.WPI_TalonFX;

REV

import com.revrobotics.CANSparkMax;
import com.revrobotics.CANSparkMaxLowLevel.MotorType;

import edu.wpi.first.wpilibj.TimedRobot;
import edu.wpi.first.wpilibj.Timer;
import edu.wpi.first.wpilibj.XboxController;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;

Nosso código precisa fazer referência aos componentes do WPILib que estão sendo utilizados. Em Java, é feito com declarações import. O programa faz referência a classes como Joystick (para direção), PWMSparkMax / WPI_TalonFX / CANSparkMax (para controle de motores), TimedRobot (a classe base usada no exemplo), Timer (usado para o modo autônomo) e DifferentialDrive (para conectar o controle do joystick aos motores).

Definindo as variáveis para nosso robô de exemplo

PWM

public class Robot extends TimedRobot {
  private final PWMSparkMax m_leftDrive = new PWMSparkMax(0);
  private final PWMSparkMax m_rightDrive = new PWMSparkMax(1);
  private final DifferentialDrive m_robotDrive = new DifferentialDrive(m_leftDrive, m_rightDrive);
  private final XboxController m_controller = new XboxController(0);
  private final Timer m_timer = new Timer();

  /**
   * This function is run when the robot is first started up and should be used for any
   * initialization code.
   */
  @Override
  public void robotInit() {
    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_rightDrive.setInverted(true);
  }

CTRE

public class Robot extends TimedRobot {
   private final WPI_TalonFX m_leftDrive = new WPI_TalonFX(1);
   private final WPI_TalonFX m_rightDrive = new WPI_TalonFX(2);
   private final DifferentialDrive m_robotDrive = new DifferentialDrive(m_leftDrive, m_rightDrive);
   private final Joystick m_stick = new Joystick(0);
   private final Timer m_timer = new Timer();

REV

public class Robot extends TimedRobot {
  private final CANSparkMax m_leftDrive = new CANSparkMax(1, MotorType.kBrushless);
  private final CANSparkMax m_rightDrive = new CANSparkMax(2, MotorType.kBrushless);
  private final DifferentialDrive m_robotDrive = new DifferentialDrive(m_leftDrive, m_rightDrive);
  private final XboxController m_controller = new XboxController(0);
  private final Timer m_timer = new Timer();

O robô de exemplo em nossos exemplos terá um joystick na porta USB 0 para controle tipo arcade e dois motores nas portas PWM 0 e 1 (exemplos do fornecedor usam CAN com IDs 1 e 2). Aqui, criamos objetos do tipo DifferentialDrive (m_robotDrive), Joystick (m_stick) e Timer (m_timer). Esta seção do código faz três coisas:

  1. Define as variáveis como membros da nossa classe Robot.

  2. Inicializa as variáveis.

Inicialização do robô

@Override
public void robotInit() {}

O método RobotInit é executado quando o programa do robô está iniciando, mas após o construtor. O RobotInit para o nosso programa de exemplo não faz nada. Se quisermos executar algo aqui, podemos fornecer o código acima para substituir o padrão.

Autônomo simples de exemplo

  /** This function is run once each time the robot enters autonomous mode. */
  @Override
  public void autonomousInit() {
    m_timer.restart();
  }

  /** This function is called periodically during autonomous. */
  @Override
  public void autonomousPeriodic() {
    // Drive for 2 seconds
    if (m_timer.get() < 2.0) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.arcadeDrive(0.5, 0.0, false);
    } else {
      m_robotDrive.stopMotor(); // stop robot
    }
  }

O método AutonomousInit é executado uma vez cada vez que o robô faz a transição para o modo autônomo a partir de outro modo. Neste programa, reiniciamos o Timer neste método.

AutonomousPeriodic é executado uma vez a cada período enquanto o robô está no modo autônomo. Na classe TimedRobot, o período é um tempo fixo, que padrão é 20ms. Neste exemplo, o código periódico verifica se o temporizador é inferior a 2 segundos e, se for, avança a meio velocidade usando o método ArcadeDrive da classe DifferentialDrive. Se mais de 2 segundos tiverem decorrido, o código para o acionamento do robô.

Controle por analógico para teleoperado

  /** This function is called once each time the robot enters teleoperated mode. */
  @Override
  public void teleopInit() {}

  /** This function is called periodically during teleoperated mode. */
  @Override
  public void teleopPeriodic() {
    m_robotDrive.arcadeDrive(-m_controller.getLeftY(), -m_controller.getRightX());
  }

Assim como no modo Autônomo, o modo Teleop possui funções TeleopInit e TeleopPeriodic. Neste exemplo, não temos nada para fazer em TeleopInit; ele é fornecido apenas para fins ilustrativos. Em TeleopPeriodic, o código utiliza o método ArcadeDrive para mapear o eixo Y do Joystick para o movimento para frente/trás dos motores de acionamento e o eixo X para o movimento de virar.

Modo de teste

  /** This function is called once each time the robot enters test mode. */
  @Override
  public void testInit() {}

  /** This function is called periodically during test mode. */
  @Override
  public void testPeriodic() {}

O Modo de Teste é usado para testar a funcionalidade do robô. Semelhante ao TeleopInit, os métodos TestInit e TestPeriodic são fornecidos aqui apenas para fins ilustrativos.

Compilando o projeto no robô

Por favor, consulte as instruções aqui para implantar o programa em um robô.

Etapa 4: Programando seu robô

Programando seu robô (C++)

Essa página oferece para usuários de C++ um ensinamento básico de programação para FRC

Ainda que você não esteja usando Java, lembre-se de olhar a página anterior para criar seu projeto de robô

Configurações C++

Para projetos em C++, há mais uma etapa para configurar o IntelliSense. Sempre que abrimos um projeto, deveríamos receber um pop-up no canto inferior direito perguntando se desejamos atualizar as configurações do C++. Clique em "Sim" para configurar o IntelliSense.

module

Importações

PWM

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <frc/motorcontrol/PWMSparkMax.h>

CTRE

#include <frc/Joystick.h>
#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/drive/DifferentialDrive.h>
#include <ctre/phoenix/motorcontrol/can/WPI_TalonFX.h>

REV

#include <frc/TimedRobot.h>
#include <frc/Timer.h>
#include <frc/XboxController.h>
#include <frc/drive/DifferentialDrive.h>
#include <frc/motorcontrol/PWMSparkMax.h>

#include <rev/CANSparkMax.h>

Nosso código precisa fazer referência aos componentes do WPILib que estão sendo utilizados. Em C++, isso é feito usando declarações #include;. O programa faz referência a classes como Joystick (para direção), PWMSparkMax / WPI_TalonFX / CANSparkMax (para controle de motores), TimedRobot (a classe base usada no exemplo), Timer (usado para o modo autônomo) e DifferentialDrive (para conectar o controle do joystick aos motores).

Definindo as variáveis para nosso robô de exemplo

PWM

 public:
  Robot() {
    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    m_timer.Start();
  }

 private:
  // Robot drive system
  frc::PWMSparkMax m_left{0};
  frc::PWMSparkMax m_right{1};
  frc::DifferentialDrive m_robotDrive{m_left, m_right};

  frc::XboxController m_controller{0};
  frc::Timer m_timer;
};

CTRE

public:
 Robot() {
    m_right.SetInverted(true);
    m_robotDrive.SetExpiration(100_ms);
    // We need to invert one side of the drivetrain so that positive voltages
    // result in both sides moving forward. Depending on how your robot's
    // gearbox is constructed, you might have to invert the left side instead.
    m_timer.Start();
 }

private:
 // Robot drive system
 ctre::phoenix::motorcontrol::can::WPI_TalonFX m_left{1};
 ctre::phoenix::motorcontrol::can::WPI_TalonFX m_right{2};
 frc::DifferentialDrive m_robotDrive{m_left, m_right};

 frc::Joystick m_stick{0};
 frc::Timer m_timer;

REV

Robot() {
  // We need to invert one side of the drivetrain so that positive voltages
  // result in both sides moving forward. Depending on how your robot's
  // gearbox is constructed, you might have to invert the left side instead.
  m_right.SetInverted(true);
  m_robotDrive.SetExpiration(100_ms);
  m_timer.Start();
}

private:
 // Robot drive system
 rev::CANSparkMax m_left{1, rev::CANSparkMax::MotorType::kBrushless};
 rev::CANSparkMax m_right{2, rev::CANSparkMax::MotorType::kBrushless};
 frc::DifferentialDrive m_robotDrive{m_left, m_right};

 frc::XboxController m_controller{0};
 frc::Timer m_timer;

O robô de exemplo em nossos exemplos terá um joystick na porta USB 0 para direção arcade e dois motores nas portas PWM 0 e 1 (exemplos do fornecedor usam CAN com IDs 1 e 2). Aqui criamos objetos do tipo DifferentialDrive (m_robotDrive), Joystick (m_stick) e Timer (m_timer). Esta seção do código faz duas coisas:

  1. Define as variáveis como membros de nossa classe Robot.

  2. Inicializa as variáveis.

As inicializações de variáveis para C++ estão na seção privada na parte inferior do programa. Isso significa que elas são privadas para a classe (Robot). O código em C++ também define o tempo de expiração do Motor Safety para 0,1 segundos (o acionamento será desligado se não receber um comando a cada 0,1 segundos) e inicia o Timer usado para o modo autônomo.

Inicialização do robô

void RobotInit() {}

O método RobotInit é executado quando o programa do robô está inicializando, mas após o construtor. O RobotInit para o nosso programa de exemplo não faz nada. Se quisermos executar alguma coisa aqui, poderíamos fornecer o código acima para substituir o padrão.

Autônomo simples de exemplo

  void AutonomousInit() override { m_timer.Restart(); }

  void AutonomousPeriodic() override {
    // Drive for 2 seconds
    if (m_timer.Get() < 2_s) {
      // Drive forwards half speed, make sure to turn input squaring off
      m_robotDrive.ArcadeDrive(0.5, 0.0, false);
    } else {
      // Stop robot
      m_robotDrive.ArcadeDrive(0.0, 0.0, false);
    }
  }

O método AutonomousInit é executado uma vez cada vez que o robô faz a transição para o modo autônomo a partir de outro modo. Neste programa, reiniciamos o Timer neste método.

AutonomousPeriodic é executado uma vez a cada período enquanto o robô está no modo autônomo. Na classe TimedRobot, o período é um tempo fixo, que por padrão é de 20ms. Neste exemplo, o código periódico verifica se o temporizador é inferior a 2 segundos e, se for o caso, move-se para frente a meia velocidade usando o método ArcadeDrive da classe DifferentialDrive. Se mais de 2 segundos tiverem se passado, o código para o acionamento do robô.

Controle de analógico para teleoperado

  void TeleopInit() override {}

  void TeleopPeriodic() override {
    // Drive with arcade style (use right stick to steer)
    m_robotDrive.ArcadeDrive(-m_controller.GetLeftY(),
                             m_controller.GetRightX());
  }

Assim como no modo Autônomo, o modo Teleop possui funções TeleopInit e TeleopPeriodic. Neste exemplo, não temos nada a fazer em TeleopInit; ele é fornecido apenas para fins ilustrativos. Em TeleopPeriodic, o código utiliza o método ArcadeDrive para mapear o eixo Y do joystick no movimento para frente/trás dos motores de acionamento e o eixo X no movimento de viragem.

Modo de teste

  void TestInit() override {}

  void TestPeriodic() override {}

O Modo de Teste é utilizado para testar a funcionalidade do robô. Semelhante ao TeleopInit, os métodos TestInit e TestPeriodic são fornecidos aqui apenas para fins ilustrativos.

Compilando o projeto no robô

Por favor, consulte as instruções aqui para implantar o programa em um robô.

Etapa 4: Programando seu robô

Executando seu programa de teste

Visão geral

Você deve criar e instalar um programa de teste para sua linguagem escolhida, como visto nas seções anteriores.

Operação amarrada

Executar o seu programa de teste enquanto conectado à Estação do Condutor via cabo Ethernet ou USB confirmará que o programa foi implantado com sucesso e que a estação do condutor e o roboRIO estão configurados corretamente.

O roboRIO deve estar ligado e conectado ao PC através de Ethernet ou USB.

Iniciando a FRC Driver Station

module

Clique duas vezes no atalho para iniciar

Configurando a Driver Station

module

O DS deve ser configurado com o número da sua equipe para se conectar ao seu robô. Para fazer isso, clique na aba Configuração e insira o número da sua equipe na caixa de número da equipe. Pressione Enter ou clique fora da caixa para que a configuração tenha efeito.

Normalmente, os PCs já têm as configurações de rede corretas para que o DS se conecte ao robô, mas, se não, certifique-se de que seu adaptador de rede esteja configurado para DHCP.

Confirmação de conectividade

Cabo

module

Sem fio

module

Usando o software da Estação do Condutor, clique em Diagnóstico e confirme que as luzes de Enet Link (ou luz do Rádio do Robô, se estiver operando sem fio) e as luzes do Robô estejam verdes.

Operando o robô

module

Clique na aba Operação

  1. Confirme que a voltagem da bateria é exibida

  2. Os indicadores de Comunicação, Código do Robô e Joysticks estão verdes.

  3. Coloque o robô no Modo Teleop

  4. Clique em Habilitar. Mova os joysticks e observe como o robô responde.

  5. Clique em Desabilitar.

Operação sem fio

Antes de tentar a operação sem fio, a operação com cabo deve ter sido confirmada conforme descrito em Operação com Cabo. Executar o seu programa de teste enquanto conectado à Estação do Condutor via WiFi confirmará se o ponto de acesso está configurado corretamente.

Configurando o ponto de acesso

Consulte o artigo "Programando seu rádio" para obter detalhes sobre a configuração do rádio do robô para uso como ponto de acesso.

Após configurar o ponto de acesso, conecte a estação do condutor ao robô sem fio. O SSID será o número da sua equipe (conforme inserido no Utilitário de Configuração da Ponte). Se você definiu uma chave ao usar o Utilitário de Configuração da Ponte, precisará inseri-la para se conectar à rede. Certifique-se de que o adaptador de rede do computador esteja configurado para DHCP («Obter um endereço IP automaticamente»).

Agora você pode confirmar a operação sem fio usando as mesmas etapas em "Confirmar Conectividade e Operar o Robô" acima.