Menu de controle de velocidade de passo orientado para Arduino: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Esta biblioteca SpeedStepper é uma reescrita da biblioteca AccelStepper para permitir o controle de velocidade do motor de passo. A biblioteca SpeedStepper permite alterar a velocidade do motor definida e, em seguida, acelera / desacelera para a nova velocidade definida usando o mesmo algoritmo da biblioteca AccelStepper. A biblioteca SpeedStepper também permite definir os limites de mais e menos e uma posição 'inicial'. Existe um comando goHome para retornar à posição inicial.

Limitações: A biblioteca SpeedStepper direciona apenas saídas de direção e etapa e, portanto, precisa ser conectada a um driver de motor, como Easy Driver, para realmente acionar o motor de passo. A biblioteca AccelStepper oferece mais opções de direção que podem ser copiadas para esta biblioteca, se necessário.

Três esboços de exemplo são fornecidos, cada um dos quais pode ser executado sem um motor ou driver de motor. O esboço speedStepperPlot emite comandos de velocidade de exemplo e o comando goHome e gera um gráfico da velocidade e posição resultantes. O esboço speedStepperSetup fornece uma configuração orientada por menu para definir o início e os limites do motor e, em seguida, executar o motor e ajustar a velocidade para cima e para baixo e goHome para terminar. O esboço speedStepperProfile mostra um exemplo de configuração e execução de um perfil de velocidade.

Embora a biblioteca AccelStepper forneça um bom controle de posição, o controle de velocidade era necessário para o Protótipo de Sonda de Derretimento de Gelo para Coletar Amostras Biológicas na Europa. Aqui está um vídeo de uma versão anterior do protótipo, que usava peso em vez de um motor. A revisão 1.1 adicionou perfis de velocidade depois que um usuário solicitou um meio para controlar o perfil de velocidade de uma bomba.

Esta biblioteca roda em Arduino Uno e Mega2560, mas para o protótipo foi usado um processador de memória maior / mais rápido SparkFun Redboard Turbo.

Este instrutível também está disponível online em Stepper Speed Control Library for Arduino

Suprimentos

Para executar os esboços de exemplo, apenas um Arduino UNO ou Mega2560 e as bibliotecas de software são necessários

Para o teste de bancada da biblioteca, um SparkFun Redboard Turbo foi usado com um Easy Driver, um motor de passo de 200 etapas / rev, 12 V 350 mA e uma fonte de 12 CC 2A ou maior, por exemplo, https://www.sparkfun.com/products/14934. USB A para Micro cableUSB para TTL Serial CableArduino IDE V1.8.9 e um computador para executá-lo. Biblioteca pfodParser biblioteca para as classes nonBlockingInput e pfodBufferedStream biblioteca millisDelay para atrasos sem bloqueio

Etapa 1: funções da biblioteca

A biblioteca SpeedStepper executa o motor de passo limitado pelos limites definidos pela biblioteca. Consulte o arquivo SpeedStepper.h para os vários métodos de biblioteca disponíveis. Aqui está um esboço da lógica por trás deles.

A posição do stepper é rastreada pela contagem do número de etapas (pulsos). A biblioteca limita a posição entre as posições setPlusLimit (int32_t) e setMinusLimit (int32_t). O limite positivo é sempre> = 0 e o limite negativo é sempre <= 0. Na inicialização, a posição do motor é 0 (inicial) e os limites são definidos para números +/- muito grandes (cerca de +/- 1e9 etapas). setAcceleration (float) define a rapidez com que o motor mudará a velocidade para cima ou para baixo. Conforme o motor se aproxima do limite mais ou menos, ele desacelerará nessa taxa até que pare no limite. Na inicialização, a aceleração é definida para 1,0 passos / seg / seg. A configuração de aceleração é sempre um número + ve. O sinal da configuração setSpeed (float) define a direção em que o motor se moverá.

setSpeed (float) define a velocidade para acelerar / desacelerar o motor a partir de sua velocidade atual. A velocidade que pode ser definida via setSpeed (float) é limitada, em valor absoluto, por configurações, setMaxSpeed (float), padrão 1000 passos / seg e setMinSpeed (float), padrão 0,003 passos / seg. Esses padrões também são os limites de velocidade codificados absolutos que a biblioteca aceitará para setMaxSpeed () e setMinSpeed (). Se você deseja definir uma velocidade máxima> 1000 passos / s, você precisará editar a primeira linha no arquivo SpeedStepper.cpp para alterar o maxMaxSpeed (1000) para a velocidade máxima desejada. Na prática, a velocidade máxima também é limitada pelo tempo entre as chamadas ao método run () da biblioteca. Para 1000 passos / s, o método run () deve ser chamado pelo menos a cada 1 ms. Veja a seção Latência abaixo.

Tentar definir uma velocidade menor que a velocidade mínima fará com que o motor pare. Cada um desses setters tem um getter correspondente, consulte o arquivo SpeedStepper.h. Para velocidade, getSetSpeed () retorna a velocidade definida por meio de setSpeed (), enquanto getSpeed () retorna a velocidade atual do motor, que varia conforme ele acelera / desacelera para a velocidade definida. Se o motor não estiver indo na direção que você pensa em + ve, você pode chamar invertDirectionLogic () para trocar a direção em que o motor se move para velocidades + ve.

getCurrentPosition () retorna a posição atual do motor em comparação com 'home' (0). Você pode substituir a posição atual do motor setCurrentPosition (int32_t). A nova posição está limitada aos limites de mais / menos definidos.

Inicialmente, o motor é parado na posição 0. Chamar setSpeed (50.0) fará com que ele comece a acelerar na direção + ve a uma velocidade máxima de 50 passos / min. Chamar hardStop () irá parar imediatamente o motor onde está. Por outro lado, chamar o método stop () definirá a velocidade para zero e desacelerará o motor até a parada. Chamar stopAndSetHome () irá parar o motor imediatamente e definir sua posição para 0. Os valores dos limites mais / menos não são alterados, mas agora são referidos a esta nova posição 0 (inicial). Chamar goHome () retornará o stepper para a posição 0 (inicial) e parará. Chamar setSpeed () cancelará a ida para casa.

A biblioteca SpeedStepper também fornece controle de perfil de velocidade por meio dos métodos setProfile (SpeedProfileStruct * profileArray, size_t arrayLen), startProfile (), stopProfile (), para interromper um perfil em execução e isProfileRunning (). Veja o esboço de exemplo speedStepperProfile.

Etapa 2: Executar o exemplo SpeedStepperPlot sem motor

Instale o Arduino IDE V1.8.9 Baixe e instale a biblioteca SpeedStepper Salve o SpeedStepper.zip e use o item de menu Arduino IDE Esboço → Incluir biblioteca → Adicionar biblioteca. ZIP para importar a biblioteca Baixe e instale também a biblioteca millisDelay

Abra Exemplos → SpeedStepper → esboço de exemplo speedStepperPlot (reinicie o IDE se necessário). Este esboço está configurado para funcionar com Serial, por exemplo, UNO e Mega etc. Para rodar no SparkFun Redboard Turbo veja abaixo.

Nenhuma placa de driver ou motor de passo é necessária para executar este exemplo. Esses exemplos usam D6 e D7 como saídas. Você pode alterar os pinos de saída para qualquer saída digital, alterando as configurações STEP_PIN e DIR_PIN perto do topo do esboço.

Faça upload do esboço para o tabuleiro e abra Ferramentas → Plotador serial a 115200 baud para mostrar o gráfico da velocidade (VERMELHO) e da posição (AZUL). no eixo x. O limite negativo é -510. A posição para em ~ -390 porque a velocidade foi exigida para 0,0. Em 380 pontos no eixo x, o goHome cmd é emitido, o que retorna o stepper para a posição zero.

Este esboço speedStepperPlot usa millisDelays para alternar entre várias velocidades e acelerações. Em muitos casos, usar um SpeedStepperProfile, como no próximo exemplo, é mais simples.

Etapa 3: executando o exemplo de SpeedStepperProfile sem um motor

Abra Exemplos → SpeedStepper → speedStepperPlot esboço de exemplo, este esboço produz o gráfico acima usando o Arduino Serial Plotter e é um exemplo de execução de um perfil de velocidade prescrita, por exemplo, se estiver executando uma bomba.

Perfis de velocidade de passo são compostos de uma matriz de SpeedProfileStruct, que é definida no arquivo SpeedStepper.h.

struct SpeedProfileStruct {

velocidade de flutuação; // a velocidade alvo no final desta etapa unsigned long deltaTms; // o tempo para acelerar da velocidade atual (no início desta etapa) para a velocidade alvo};

Defina uma matriz de SpeedProfileStruct contendo a velocidade alvo para cada etapa e o tempo, deltaTms, em mS, para atingir essa velocidade alvo a partir da velocidade alvo anterior. Se o deltaTms for zero ou muito pequeno, a velocidade irá pular imediatamente para a nova velocidade alvo. Caso contrário, a aceleração necessária será calculada setAcceleration () será chamado seguido por uma chamada para setSpeed () para a nova velocidade alvo. Em todos os casos, o perfil será limitado pelos limites de posição mais e menos existentes e pelas configurações de velocidade máx. / Mín. Se você quiser manter uma velocidade, basta repetir a velocidade anterior com o tempo que você deseja manter. Uma vez que a nova velocidade alvo é igual à velocidade atual, a aceleração calculada será zero e, nenhuma mudança ocorre na velocidade.

Esta matriz SpeedProfileStruct produziu o gráfico acima

const SpeedProfileStruct profile = {{0, 0}, // pare imediatamente se ainda não tiver parado {0, 1000}, // mantenha zero por 1seg {-50, 0}, // pule para -50 {-200, 2000}, // desacelerar para -200 {-200, 6000}, // manter em -200 por 6 segundos {-50, 2000}, // desacelerar para -50 {0, 0}, // // parar imediatamente {0, 1500}, // mantenha zero por 1,5 segundos {50, 0}, // pule para 50 {200, 2000}, // acelere para 200 {200, 6000}, // mantenha 200 por 6 segundos {50, 2000}, // sobe para 50 {0, 0}, // // pare imediatamente {0, 1000} // mantenha zero // para plotagem de saída}; const size_t PROFILE_LEN = sizeof (perfil) / sizeof (SpeedProfileStruct); // calcula o tamanho da matriz de perfil

O perfil é definido chamando setProfile (SpeedProfileStruct * profileArray, size_t arrayLen). stepper.setProfile (perfil, PROFILE_LEN);

Uma vez que o perfil tenha sido definido, chame startProfile () para começar a executá-lo a partir da velocidade atual do motor (normalmente você iniciará de parado). No final do perfil, o motor continuará a funcionar na última velocidade alvo. O método isProfileRunning () pode ser chamado para ver se o perfil ainda está em execução. Se você quiser interromper o perfil mais cedo, pode chamar stopProfile (), que abandonará o perfil e parará o motor.

Etapa 4: executando o exemplo SpeedStepperSetup sem um motor

O esboço de exemplo é projetado como uma base para sua própria aplicação de motor de passo. Ele fornece uma interface orientada por menu que permite que você mova o motor para sua posição inicial, se ainda não estiver lá e, em seguida, opcionalmente, redefina os limites de mais e menos e, em seguida, opere o motor dentro dessa faixa. O menu 'executar' permite aumentar e diminuir a velocidade, congelar na velocidade atual, parar e também voltar para casa.

Este esboço ilustra uma série de recursos de software que mantêm o loop () responsivo para que você possa adicionar suas próprias entradas de sensor para controlar o stepper. É difícil evitar atrasos que possam interferir no controle de velocidade. (Veja Delays are Evil)

Instale as bibliotecas usadas para executar o SpeedStepperPlot, acima, e depois instale também a biblioteca pfodParser. A biblioteca pfodParser fornece as classes NonBlockingInput e pfodBufferedStream que são usadas para manipular a entrada do usuário e a saída do menu com o bloqueio da execução de loop ().

Abra o exemplo Exemplos → SpeedStepper → speedSpeedSetup. Este esboço está configurado para funcionar com Serial, por exemplo, UNO e Mega etc. Para rodar no SparkFun Redboard Turbo veja abaixo.

Nenhuma placa de driver ou motor de passo é necessária para executar este exemplo. Esses exemplos usam D6 e D7 como saídas. Você pode alterar os pinos de saída para qualquer saída digital, alterando as configurações STEP_PIN e DIR_PIN perto do topo do esboço. Carregue o esboço para o quadro e abra Ferramentas → Monitor serial em 115200 para ver o menu CONFIGURAÇÃO.

POS SETUP: 0 sp: 0.00 + Lim: 500000 -Lim: -500 LATENCY: stepper: 492uS loop: 0uS p - definir Home l - definir limites h - goHome r - run>

Quando o esboço é executado, a posição atual do stepper é considerada sua posição 'inicial' (0). Se você precisar reposicionar o stepper para sua verdadeira posição 'inicial', digite o comando p para exibir o menu SET HOME

POS SET HOME: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATÊNCIA: stepper: 752uS loop: 3852uS x - setHome aqui e sair + - Forward - - Reverse s - swap Forward / Reverse - hardStop >

Como você pode ver, os limites codificados no esboço foram removidos para que você possa reposicionar o stepper em qualquer lugar. Você precisa tomar cuidado para não ultrapassar os limites físicos ou você pode quebrar alguma coisa.

Use o + cmd para começar a mover o stepper para frente, se você achar que ele está se movendo na direção errada, insira um não-comando ou apenas uma linha vazia para pará-lo e então use o scommand para trocar a direção de Forward. Você deve atualizar o esboço para incluir uma chamada para invertDirectionLogic () na configuração para corrigir isso na próxima execução.

Use os cmds + / - para posicionar o stepper na posição zero correta. O motor começa a funcionar devagar e depois aumenta a velocidade à medida que avança, basta usar uma linha vazia para pará-lo. A velocidade máxima para isso e o menu de limites é definido pelo MAX_SETUP_SPEED no topo do setupMenus.cpp.

Uma vez que o motor tenha sido posicionado em sua posição 'inicial', use x cmd para redefinir a posição atual como 0 e retornar ao menu CONFIGURAÇÃO.

Se você precisar definir os limites, geralmente apenas na configuração inicial, use l cmd para entrar no menu DEFINIR LIMITES

AJUSTAR LIMITES pos: 0 sp: 0,00 + Lim: 1073741808 -Lim: -1073741808 LATÊNCIA: passo a passo: 944uS loop: 5796uS l - setLimit aqui + - Avançar - - Reverter h - goHome x - sair - hardStop>

Use + cmd para avançar para o limite positivo e, em seguida, use l cmd para defini-lo como o limite positivo. O comando h pode então ser usado para retornar a 0 e o - cmd usado para mover se reverte para a posição do motor no limite negativo. Novamente use l cmd para definir o limite negativo. Observe as posições dos limites de mais e menos e atualize as instruções setPlusLimit e setMinusLimit do método setup () com esses valores.

Quando os limites são definidos, use x cmd para retornar ao menu CONFIGURAÇÃO e então você pode usar r cmd para abrir o menu RUN

RUN MENU pos: 0 sp: 3,31 + Lim: 500000 -Lim: -500 LATÊNCIA: stepper: 944uS loop: 5796uS + - Acelerar - - Acelerar h - goHome. - hardStop - congelar Speed> + pos: 4 sp: 9,49 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 42 sp: 29,15 + Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 120 sp: 49,09 + Lim: 500000 -Lim: -500 LATÊNCIA: stepper: 792uS loop: 5664uS pos: 238 sp: 69,06 + Lim: 500000 -Lim: -500 LATÊNCIA: stepper: 792uS loop: 5664uS

O + cmd começa a acelerar na direção para frente e imprime a posição e a velocidade a cada 2 segundos. Quando o motor atinge a velocidade desejada, você pode parar a aceleração com qualquer outra tecla (ou uma entrada vazia). Você pode reduzir a velocidade usando - cmd down para parar. Se parado, o - cmd irá acelerar em sentido inverso.

Este menu RUN fornece controle manual do seu projeto. Para o controle automático, você precisará adicionar alguns outros sensores.

Etapa 5: Latência

O controle do motor de passo depende do software que comanda cada etapa. Para manter a velocidade definida, seu esboço precisa chamar o método stepper.run () com freqüência suficiente para disparar a próxima etapa no momento certo para a velocidade atual. Para o controle por meio de sensores, você precisa ser capaz de processar prontamente novas medições. A impressão da posição / velocidade inclui duas medidas LATENCY para permitir que você verifique se o seu esboço é rápido o suficiente.

Latência de passo (pfodBufferedStream)

A latência do stepper mede o atraso máximo entre chamadas sucessivas para o método stepper.run (). Para operar o motor de passo a 1000 passos por segundo, a latência do passo precisa ser inferior a 1000 µS (1 ms). A primeira versão deste esboço teve uma latência de muitos milissegundos. Para superar essas chamadas extras, o método runStepper () (que chama stepper.run ()) foi adicionado por meio do código. Isso não resolveu completamente o problema porque o menu e as instruções de impressão de saída bloqueavam o esboço quando o pequeno buffer Serial Tx estava cheio. Para evitar esse bloqueio, o pfodBufferedStream da biblioteca pfodParser foi usado para adicionar um buffer de impressão de saída de 360 bytes no qual as instruções de impressão pudessem gravar rapidamente. Em seguida, pfodBufferedStream libera os bytes na taxa de transmissão especificada 115200 neste caso. pfodBufferedStream tem a opção de bloquear quando o buffer está cheio ou apenas descartar os caracteres de estouro. Aqui, ele é definido para descartar quaisquer caracteres extras quando o buffer estiver cheio para que o esboço não seja bloqueado esperando que Serial envie os caracteres.

Latência de loop (NonBlockingInput)

A latência do loop mede o atraso máximo entre chamadas sucessivas para o método loop (). Isso define a rapidez com que você pode processar novas medições do sensor e ajustar a velocidade definida do motor. O quão rápido precisa ser depende do que você está tentando controlar.

Os atrasos devido às instruções de impressão foram removidos usando pfodBufferedStream acima, mas para processar a entrada do usuário você precisa pegar o primeiro caractere da entrada e ignorar o resto da linha. A classe NonBlockingInput na biblioteca pfodParer é usada para retornar um caractere diferente de zero quando há entrada, usando readInput () e para limpar e descartar os seguintes caracteres, usando clearInput (), até que nenhum caractere seja recebido por 10 ms sem bloquear o loop ()

É claro que a latência do loop será aumentada pelo código extra que você adiciona para ler os sensores e calcular a nova velocidade definida. Muitas bibliotecas de sensores optam por usar apenas o atraso (..) entre o início de uma medição e a recuperação do resultado. Você precisará reescrever essas bibliotecas para usar o millisDelay, para pegar a medição após um atraso sem bloqueio adequado.

Etapa 6: executando SpeedStepperSetup com um motor de passo e SparkFun Redboard Turbo

Para executar o esboço SpeedStepperSetup de verdade, você precisará de um motor de passo, driver e fonte de alimentação e, neste exemplo, SparkFun Redboard Turbo.

O diagrama de fiação acima (versão pdf) mostra as conexões. No esboço SpeedStepperSetup, altere a definição de SERIAL para #define SERIAL Serial1

Motor de passo, fonte de alimentação, driver e proteção

Existem muitos tipos e tamanhos de motores de passo. Aqui, um motor de passo de 12 V 350 mA com duas bobinas é usado para o teste. Para alimentar este stepper, você precisa de uma fonte de alimentação de 12 V ou mais e superior a 350 mA.

Esta biblioteca fornece apenas uma saída de direção e etapa, portanto, você precisa de um driver para fazer a interface com o motor de passo. O Easy Driver e o Big Easy Driver controlam a corrente para as bobinas do motor para que você possa usar uma fonte de alimentação de uma tensão mais alta com segurança, por exemplo, usando uma fonte de 6V para um motor de 3,3V. O Easy Driver pode fornecer entre 150mA / bobina e 700mA / bobina. Para correntes mais altas, o Big Easy Driver pode fornecer até 2A por bobina. Leia as perguntas frequentes na parte inferior da página Easy Drive.

Esses exemplos usam D6 e D7 como saídas de etapa e direção. Você pode alterar os pinos de saída para qualquer saída digital, alterando as configurações STEP_PIN e DIR_PIN perto do topo do esboço.

Programando o Sparkfun Redboard Turbo

Programar o Redboard Turbo é problemático. Se a programação falhar, primeiro pressione o botão de reinicialização uma vez e selecione novamente a porta COM no menu Arduino Tools e tente novamente. Se isso não funcionar, pressione duas vezes o botão de reinicialização e tente novamente.

Conectando o Easy Driver

Dois motores de passo de bobina têm 4 fios. Use um multímetro para encontrar os pares que se conectam a cada bobina e, em seguida, conecte uma bobina aos terminais A do Easy Driver e a outra bobina ao terminal B. Não importa a direção em que você os conecta, porque você pode usar o s cmd no menu de configuração para trocar a direção do movimento.

A alimentação do motor é conectada ao M + e GNDSet o nível lógico da placa com o link 3 / 5V. Encurte o link para saídas de microprocessador de 3,3 V, como o SparkFun Redboard Turbo (se você deixá-lo aberto, é adequado para sinais digitais de 5 V, por exemplo, UNO, Mega) Conecte os pinos GND, STEP, DIR ao microprocessador GND e o passo e pinos de saída dir. Nenhuma outra conexão é necessária para acionar o motor.

USB para cabo serial TTL

Ao mover o esboço SpeedStepperSetup do Uno / Mega para o Redboard Turbo, você pode ingenuamente apenas substituir #define SERIAL Serial por #define SERIAL SerialUSB para se adequar à conexão serial USB Redboard Turbo, no entanto, você descobriria que a latência de passo resultante é de cerca de 10 ms. Isso é 10x mais lento do que o UNO. Isso ocorre devido à forma como a CPU do Redboard lida com a conexão USB. Para superar isso, conecte um cabo serial USB para TTL a D0 / D1 e defina # define SERIAL Serial1 para usar a conexão serial do hardware para controlar o motor de passo. Usar Serial1 dá LATÊNCIA: stepper: 345uS loop: 2016uS que é 3 vezes mais rápido que o UNO para stepper e latência de loop

Programa Terminal

O Arduino Serial Monitor é um pouco mais difícil de usar para controlar o motor de passo, pois você precisa inserir o char na linha cmd e pressionar Enter para enviá-lo. Um meio mais rápido e responsivo é abrir uma janela de terminal, TeraTerm para PC (ou CoolTerm Mac), conectada à porta COM do cabo USB para TTL. Então, nessa janela, pressionar uma tecla cmd o envia imediatamente. Pressionar Enter apenas enviará uma linha vazia.

Configurando a faixa de velocidade do motor

Como conectado acima, o Easy Drive é configurado para 1/8 de passo, então 1000 passo / seg irá girar o motor a 1000/8/200 passo / revolução = 0,625 revs por segundo ou 37,5 rpm no máximo. Alterando as entradas para MS1 / MS2, você pode alternar entre 1/8, ¼, ½ e etapas completas. Para as etapas completas, conecte MS1 e MS2 ao GND. Isso permitirá velocidades de até 300 rpm. A escolha das configurações MS1 / MS2 adequadas permite que você ajuste a relação de engrenagem instalada entre o motor e a parte acionada.

Proteção de Hardware

Enquanto a biblioteca SpeedStepper permite definir limites de posição no movimento do motor, o alinhamento da posição é feito contando as etapas geradas pelo software. Se o motor parar, ou seja, o torque é insuficiente para acionar o motor na próxima etapa, a posição do software estará fora de sincronia com a posição do motor. Então, quando você usa o comando 'goHome', o motor ultrapassa a posição inicial. Para evitar danos ao hardware, você deve instalar interruptores de limite nos limites rígidos para desconectar a fonte de alimentação do motor

Configurando o limite de corrente do motor

Primeiro, defina-o para a configuração mais baixa do potenciômetro. ou seja, a tensão em TP1 é mínima. O potenciômetro é delicado, então não force o potenciômetro além das paradas mecânicas. Defina a direção do motor em uma velocidade lenta constante um lento e, em seguida, gire lentamente o potenciômetro até que o motor não pule ou salte entre as etapas.

Conclusão

Este projeto mostra como usar a biblioteca SpeedStepper em uma aplicação prática. Embora a biblioteca AccelStepper forneça um bom controle de posição, o controle de velocidade foi necessário para o Prototype Ice-Melting Probe para Coletar Amostras Biológicas na Europa, então a biblioteca AccelStepper foi reescrita para fornecer controle de velocidade com limites finais e uma função goHome.