Ler PWM, decodificar entrada do receptor RC e aplicar à prova de falhas

Sobre este projeto

• O fail-safe é ativado quando o receptor não tem sinal do transmissor. o canal do elevador está definido como cheio e o canal do aileron está definido como neutro
• A direção do servo azul é definida pela posição do acelerador
• A amplitude de movimento (taxas) do servo azul é definida pelo controle deslizante na lateral do transmissor
• A mixagem é ligada e desligada usando a chave de engrenagem no transmissor

Conteúdo

• Como os servos são controlados pelo PWM
• Exemplos de uso do Arduino em modelos / robôs RC
• Visão geral do código:decodifique o PWM do receptor RC com proteção contra falhas
• Como usar PWMread_RCfailsafe.ino
• Exibir a frequência e a taxa de quadros do receptor
• Exemplo de mistura de servo
• Justificativa para a abordagem adotada
• Limitações

Como os servos e controladores de velocidade são controlados pelo PWM?

• O IDE Arduino
• Variáveis ​​float, booleana e int
• If loops
• For loops
• Matrizes
• Biblioteca servo

Exemplos de uso do Arduino em modelos / robôs RC

• Aplicar a mistura servo, ligar / desligar as luzes, controlar bombas / válvulas, definir sequências sob medida ...
• Crie um controlador (ou seja, estabilização de vôo / piloto automático, sustentação de rumo, sustentação de altitude / profundidade, nivelador automático, detecte e evite, volte para casa ...)
• Faça com que seu modelo RC responda a uma perda de sinal ou baixa voltagem da bateria ...
• Use o mesmo transmissor para vários modelos / projetos sem ter que alterar nenhuma configuração ou usar um recurso de memória de modelo.

Visão geral do código:decodifique o PWM do receptor RC com proteção contra falhas

• Os pinos de entrada são identificados em uma matriz. Esta matriz pode ter qualquer comprimento.
• Uma função de configuração permite interrupções de mudança de pino, definindo os registros apropriados para cada pino listado na matriz de pinos.
• Uma mudança de tensão em qualquer um dos pinos selecionados irá disparar uma das três Rotas de Serviço de Interrupção (ISR) dependendo de qual registro de porta o pino pertence a ISR (PCINT0_vect) -> Porta B, ISR (PCINT1_vect) -> Porta C ou ISR (PCINT2_vect) -> Porta D.
• Dentro de cada ISR, um loop FOR e instruções IF são usados ​​para determinar qual pino foi alterado e a qual canal RC ele pertence. O tempo da interrupção é anotado por meio do uso de micros () antes de retornar ao loop principal ().
• Os intervalos de tempo entre as mudanças dos pinos são usados ​​para calcular a largura do pulso e o período de repetição.
• Sinalizadores são definidos em cada ISR para indicar quando novos pulsos foram recebidos
• Os sinalizadores são então usados ​​pelas funções restantes para extrair e processar os dados coletados pelos ISRs

Como usar PWMread_RCfailsafe.ino

• Ligue o receptor usando os pinos 5v e GND
• Conecte os pinos de sinal do receptor aos pinos 2 a 7 no Arduino usando fios de jumper fêmea para macho. (Se você tiver um receptor de 2 canais, conecte-se apenas aos pinos 2 e 3)
• Para o exemplo do servo mixer, conecte um fio de sinal do servo ao pino 9 e o outro ao pino 10.

Exibir a taxa de quadros e frequência do receptor

  now =millis (); if (RC_avail () || now - rc_update> 21) rc_update =now; // atualize os dados de entrada RC usando RC_decode () // execute um controlador PID // aplique a mistura de servo // posicione os servos}  

Exemplo de mistura de servo

Justificativa para a abordagem adotada

Limitações

Código

• PWMread_RCfailsafe
• RC_Read_Example
• RC_FrameRate
• RC_ServoMixer_Example

PWMread_RCfailsafe Arduino

 / * Kelvin Nelson 24/07/2019 * * Decodificação de modulação por largura de pulso (PWM) do receptor RC com proteção contra falhas * * Este código contém funções fáceis de usar para medir sinais de onda quadrada em qualquer arduiuno pro mini, nano ou uno pins, excluindo A6 e A7. * O código deve ser usado com receptores RC, mas também pode ser usado na maioria das outras aplicações de medição PWM como um substituto direto para pulseIn (PIN, HIGH). * (até o momento ele não foi testado em uma frequência maior que 1 khz ou em um megacontrole) * * Um pulso de sinal RC pode ser convertido de uma duração de largura de pulso (1000-2000uS) em cada pino de entrada em um - + 100 % (- + 1,0) saída para uso em um esboço. * A calibração para esta conversão mais uma configuração à prova de falhas pode ser definida para cada canal. (tolerâncias à prova de falhas de 10-330 Hz e 500-2500uS). * * Os dados brutos para cada pino também podem ser extraídos, ou seja, tempo de pulso, largura de pulso, comprimento do quadro, dever e frequência. * * A configuração é rápida, a organização deste arquivo é a seguinte:* * - Visão geral do código * - Lista de funções * - Como usar, incluindo esboços de exemplo * - Variáveis ​​definidas pelo usuário -> especificar pinos de entrada, transmissor calibração e à prova de falhas. * - Variáveis ​​globais e funções * * VISÃO GERAL DO CÓDIGO:* * O código ativa interrupções de mudança de pino nos pinos selecionados, definindo os registros apropriados. * * Uma mudança de tensão em qualquer um dos pinos selecionados acionará uma das três Rotinas de Serviço de Interrupção, dependendo de qual registro o pino pertence. * - ISR (PCINT0_vect), ISR (PCINT1_vect) ou ISR (PCINT2_vect) * * Dentro de cada ISR, o código determina qual pino foi alterado e faz uma anotação do tempo antes de retornar ao loop principal (). * * Os intervalos de tempo entre as mudanças de pino são usados ​​para calcular a largura de pulso e o comprimento do quadro. * * Os sinalizadores são definidos pelo ISR para indicar quando novos pulsos são recebidos. * * Os sinalizadores são então usados ​​para extrair e processar os dados coletados por cada ISR. * * Embora não seja exatamente o mesmo, este código segue princípios semelhantes aos explicados neste vídeo:https://youtu.be/bENjl1KQbvo * * /// LISTA DE FUNÇÕES:// TIPO DE SAÍDA NOME DE NOTAS DE FUNÇÃO // void setup_pwmRead () inicializa a medição PWM usando interrupções de mudança de pino // DECODIFICAÇÃO DO RECEPTOR RC // O booleano RC_avail () retorna um ALTO quando novos dados RC estão disponíveis // float RC_decode (número do canal) decodifica o canal RC selecionado no intervalo + -100 %, e aplica um failafe.// void print_RCpwm () Imprime os dados brutos do canal RC na porta serial (usada para calibração) .// GENERIC PWM MEASUREMENTS // boolean PWM_read (número do canal) retorna um HIGH quando um novo pulso foi detectado em um canal específico. // A função salva os dados do pulso em variáveis ​​fora das rotinas de interrupção // e deve ser chamada antes de usar o resto das funções PWM.// Unsigned long PWM_time () retorna o tempo no início do pulso // float PWM () retorna a largura do pulso // float PWM_period () retorna o tempo entre os pulsos // float PWM_freq () calcula a frequência // float PWM_duty () calcula o dever // NOTA:PWM_read (CH) e RC_decode (CH) usam os mesmos sinalizadores para detectar quando novos dados estão disponíveis, o que significa que os dados podem ser perdidos se ambos forem usados ​​no mesmo canal ao mesmo tempo.// SUGESTÃO:se você quiser usar PWM_read (CH) para encontrar a taxa de quadros de um canal RC, chame-o antes de RC_decode (CH). A saída de RC_decode (CH) será então padronizada para failafe.// COMO USAR, incluindo esboços de exemplo // sob o título "VARIÁVEIS DEFINIDAS PELO USUÁRIO" no código abaixo://// Etapa 1:insira os pinos de entrada em a matriz pwmPIN [] ={}. //// - Qualquer número de pinos pode ser inserido em pwmPIN [] (pinos disponíveis 0 - 13 e A0 - A5) // - Os pinos não precisam estar em ordem numérica, por exemplo pwmPIN [] ={A0, 5,6,10,8} para 5 canais, ou pwmPIN [] ={A0,5} para 2 canais // - O primeiro elemento na matriz é o número do pino para "canal 1" e o segundo é o pino número para "canal 2" ... etc.// - Todos os pinos conectados ao receptor RC precisam estar no início do array. ou seja, os primeiros 2 canais podem ser entradas RC e o terceiro canal pode ser conectado a outro dispositivo como o pino de eco de um sensor ultrassônico.//// Etapa 2:se um receptor RC estiver conectado a todas as entradas, defina RC_inputs para 0, se não, especifique o número de canais conectados ao receptor, ou seja, RC_inputs =2; //// Etapa 3:calibre seu transmissor enviando um esboço simples com este arquivo .ino incluído na pasta de esboço e imprima os valores PWM brutos para serial (como alternativa, copie e cole as funções necessárias no esboço) .// Usando as informações do monitor serial, atualize manualmente os valores nas matrizes RC_min [], RC_mid [], RC_max [] para se adequar ao seu transmissor (use taxas totais para obter a melhor resolução). // um esboço de exemplo para imprimir os dados PWM do canal RC em serial. / * void setup () {setup_pwmRead (); Serial.begin (9600); } void loop () {if (RC_avail ()) print_RCpwm (); } * /// Etapa 4:Escolha uma posição à prova de falhas para cada canal, no intervalo de -1,0 a +1,0, e insira-a na matriz RC_failsafe [] ={} // Observação:se você deseja que o arduino responda a perda de sinal do transmissor pode ser necessário desativar o recurso de proteção contra falhas em seu receptor (se houver) .// um esboço de exemplo para verificar a operação da proteção contra falhas e para imprimir os canais calibrados em serial:/ * unsigned long now; // variáveis ​​de tempo para atualizar os dados em um intervalo regular unsigned long rc_update; canais int constantes =6; // especifica o número de canais do receptor float RC_in [canais]; // um array para armazenar a entrada calibrada do receptor void setup () {setup_pwmRead (); Serial.begin (9600); } void loop () {agora =millis (); if (RC_avail () || now - rc_update> 25) {// se os dados RC estão disponíveis ou 25ms se passaram desde a última atualização (ajuste para se adequar à taxa de quadros do receptor) rc_update =now; // print_RCpwm (); // descomente a impressão de dados brutos do receptor para serial para (int i =0; i  =0 &&pwmPIN [i] <=7) pwmPIN_port [i] =2; // pino pertence a PCINT2_vect (PORT D) else if (pwmPIN [i]> =8 &&pwmPIN [i] <=13) pwmPIN_port [i] =0; // o pino pertence a PCINT0_vect (PORTA B) // converte o número do pino (ou seja, pino 11 ou pino A0) para a posição do pino no registro da porta. É mais provável que haja uma maneira melhor de fazer isso usando uma macro ... // (Ler o estado do pino diretamente dos registradores da porta acelera o código no ISR) if (pwmPIN [i] ==0 || pwmPIN [i ] ==A0 || pwmPIN [i] ==8) pwmPIN_reg [i] =0b00000001; else if (pwmPIN [i] ==1 || pwmPIN [i] ==A1 || pwmPIN [i] ==9) pwmPIN_reg [i] =0b00000010; else if (pwmPIN [i] ==2 || pwmPIN [i] ==A2 || pwmPIN [i] ==10) pwmPIN_reg [i] =0b00000100; else if (pwmPIN [i] ==3 || pwmPIN [i] ==A3 || pwmPIN [i] ==11) pwmPIN_reg [i] =0b00001000; else if (pwmPIN [i] ==4 || pwmPIN [i] ==A4 || pwmPIN [i] ==12) pwmPIN_reg [i] =0b00010000; else if (pwmPIN [i] ==5 || pwmPIN [i] ==A5 || pwmPIN [i] ==13) pwmPIN_reg [i] =0b00100000; else if (pwmPIN [i] ==6) pwmPIN_reg [i] =0b01000000; else if (pwmPIN [i] ==7) pwmPIN_reg [i] =0b10000000; }} // CONFIGURAÇÃO DE INTERRUPTS DE MUDANÇA DE PIN evite setup_pwmRead () {for (int i =0; i  num_ch) RC_inputs =num_ch; // define o número de pinos conectados a um receptor RC. } // INTERRUPT SERVICE ROUTINES (ISR) USADO PARA LER PWM INPUT // o PCINT0_vect (registro da porta B) reage a qualquer mudança nos pinos D8-13.// o PCINT1_vect (registro da porta C) "" "" A0-A5. // os registros de porta PCINT2_vect (registrador de porta D) "" "" D0-7.// são usados ​​para acelerar instruções if no código ISR:// https://www.arduino.cc/en/Reference/PortManipulation http ://tronixstuff.com/2011/10/22/tutorial-arduino-port-manipulation/// http://harperjiangnew.blogspot.co.uk/2013/05/arduino-port-manipulation-on-mega-2560 .html // LER INTERRUPÇÕES NOS PINOS D8-D13:A rotina ISR detecta qual pino foi alterado e retorna a largura de pulso PWM e o período de repetição de pulso. ISR (PCINT0_vect) {// esta função será executada se uma mudança de pino for detectada na porta B pciTime =micros (); // Record the time of the PIN change in microseconds for (int i =0; i  RC_inputs) return 0; // if channel number is out of bounds return zero. int i =CH - 1; // determine the pulse width calibration for the RC channel. The default is 1000, 1500 and 2000us. int Min; if(CH <=size_RC_min) Min =RC_min[CH-1]; else Min =1000; int Mid; if(CH <=size_RC_mid) Mid =RC_mid[CH-1]; else Mid =1500; int Max; if(CH <=size_RC_max) Max =RC_max[CH-1]; else Max =2000; float CH_output; if(FAILSAFE(CH) ==HIGH){ // If the RC channel is outside of failsafe tolerances (10-330hz and 500-2500uS) if(CH> size_RC_failsafe) CH_output =0; // and if no failsafe position has been defined, set output to neutral else CH_output =RC_failsafe[i]; // or if defined set the failsafe position } else{ // If the RC signal is valid CH_output =calibrate(PW[i],Min,Mid,Max); // calibrate the pulse width to the range -1 to 1. } return CH_output; // The signal is mapped from a pulsewidth into the range of -1 to +1, using the user defined calibrate() function in this code. // 0 represents neutral or center stick on the transmitter // 1 is full displacement of a control input is one direction (i.e full left rudder) // -1 is full displacement of the control input in the other direction (i.e. full right rudder)}/* * Receiver Calibration */ // NEED TO SPEED UPfloat calibrate(float Rx, int Min, int Mid, int Max){ float calibrated; if (Rx>=Mid) { calibrated =map(Rx, Mid, Max, 0, 1000); // map from 0% to 100% in one direction } else if (Rx ==0) { calibrated =0; // neutral } else { calibrated =map(Rx, Min, Mid, -1000, 0); // map from 0% to -100% in the other direction } return calibrated * 0.001;}// Basic Receiver FAIL SAFE// check for 500-2500us and 10-330Hz (same limits as pololu)boolean FAILSAFE(int CH){ int i =CH-1; boolean failsafe_flag =LOW; if(pwmFlag[i] ==1) // if a new pulse has been measured. { pwmFlag[i] =0; // set flag to zero if(pwmPeriod[i]> 100000) // if time between pulses indicates a pulse rate of less than 10Hz { failsafe_flag =HIGH; } else if(pwmPeriod[i] <3000) // or if time between pulses indicates a pulse rate greater than 330Hz { failsafe_flag =HIGH; } if(PW[i] <500 || PW[i]> 2500) // if pulswidth is outside of the range 500-2500ms { failsafe_flag =HIGH; } } else if (micros() - pwmTimer[i]> 100000) // if there is no new pulswidth measurement within 100ms (10hz) { failsafe_flag =HIGH; } return failsafe_flag; }/* * Quick print function of Rx channel input */void print_RCpwm(){ // display the raw RC Channel PWM Inputs for (int i =0; i =0) Serial.print(" "); if (abs(pc) <100) Serial.print(" "); if (abs(pc) <10) Serial.print(" "); Serial.print(" ");Serial.print(pc);Serial.print("% ");}/* * GENERIC PWM FUNCTIONS */unsigned long pin_time;float pin_pwm;float pin_period;boolean PWM_read(int CH){ if(CH <1 &&CH> num_ch) return false; int i =CH-1; boolean avail =pwmFlag[i]; if (avail ==HIGH){ pwmFlag[i] =LOW; noInterrupts(); pin_time =pwmTimer[i]; pin_pwm =PW[i]; pin_period =pwmPeriod[i]; interrupções (); } return avail;}unsigned long PWM_time(){return pin_time;}float PWM_period(){return pin_period;}float PWM(){return pin_pwm;}float PWM_freq(){ float freq; return freq =1000000 / pin_period; // frequency Hz}float PWM_duty(){ float duty; duty =pin_pwm/pin_period; return duty;}

RC_Read_ExampleArduino

unsigned long now; // timing variables to update data at a regular interval unsigned long rc_update;const int channels =6; // specify the number of receiver channelsfloat RC_in[channels]; // an array to store the calibrated input from receiver void setup() { setup_pwmRead(); Serial.begin(9600);}void loop() { now =millis(); if(RC_avail() || now - rc_update> 25){ // if RC data is available or 25ms has passed since last update (adjust to be equal or greater than the frame rate of receiver) rc_update =now; print_RCpwm(); // uncommment to print raw data from receiver to serial for (int i =0; i 
RC_FrameRateArduino 
 Example sketch that prints the frame rate and frequency of an RC Receiver. The PWMread_RCfailsafe.ino file should be copied into the same folder in order for the functions to be available.
void setup() { setup_pwmRead(); Serial.begin(9600);}void loop() { // Print RC receiver frame length and frame rate if (PWM_read(1)){ // if a new pulse is detected on channel 1 Serial.print(PWM_period(),0);Serial.print("uS "); Serial.print(PWM_freq());Serial.println("Hz"); }} 
 
RC_ServoMixer_ExampleArduino 
 An servo mixing example. Two channels from a 6 channel are receiver are mixed and sent to two servos controlled using the servo library. The PWMread_RCfailsafe.ino file should be copied into the same folder in order for the functions to be available.
// servo variables#include  // include the servo library to control the servosServo servo1; // name each servo output for use with the servo library Servo servo2; // Each servo must be attached to a pin that has a PWM output// on the arduino uno, nano and pro mini these pins are 3, 5, 6, 9, 10 and 11const int servo1_pin =9; // identify the pins that each servo signal wire is connected toconst int servo2_pin =10;// Select Servo Direction, Rates and Sub-trim (the size of each array must match the number of servos)boolean servo_dir[] ={0,1}; // Direction:0 is normal, 1 is reversefloat servo_rates[] ={1,0.5}; // Rates:range 0 to 2 (1 =+-500us (NORMAL), 2 =+-1000us (MAX)):The amount of servo deflection in both directionsfloat servo_subtrim[] ={0.0,0.0}; // Subtrimrange -1 to +1 (-1 =1000us, 0 =1500us, 1 =2000us):The neutral position of the servoboolean servo_mix_on =true;unsigned long now; // timing variables to update data at a regular interval unsigned long rc_update;// Receiver variablesconst int channels =6; // specify the number of receiver channelsfloat RC_in[channels]; // an array to store the calibrated input from receiver void setup() { servo1.attach(servo1_pin, 500, 2500); // attach the servo library to each servo pin, and define min and max uS values servo2.attach(servo2_pin, 500, 2500); setup_pwmRead(); Serial.begin(9600);}void loop() { now =millis(); if(RC_avail() || now - rc_update> 25){ // if RC data is available or 25ms has passed since last update (adjust to> frame rate of receiver) rc_update =now; print_RCpwm(); // uncommment to print raw data from receiver to serial for (int i =0; i 1) mix1 =1; // limit mixer output to +-1 else if(mix1 <-1) mix1 =-1; if(mix2> 1) mix2 =1; // limit mixer output to +-1 else if(mix2 <-1) mix2 =-1; // Calculate the pulse widths for the servos servo1_uS =calc_uS(mix1, 1); // apply the servo rates, direction and sub_trim for servo 1, and convert to a RC pulsewidth (microseconds, uS) servo2_uS =calc_uS(mix2, 2); // apply the servo rates, direction and sub_trim for servo 2, and convert to a RC pulsewidth (microseconds, uS) } else{ // MIXING OFF servo1_uS =calc_uS(RC_in[1],1); // apply the servo rates, direction and sub_trim for servo 1, and convert to a RC pulsewidth (microseconds, uS) servo2_uS =calc_uS(RC_in[2],2); // apply the servo rates, direction and sub_trim for servo 1, and convert to a RC pulsewidth (microseconds, uS) } servo1.writeMicroseconds(servo1_uS); // write the pulsewidth to the servo. servo2.writeMicroseconds(servo2_uS); // write the pulsewidth to the servo. }}int calc_uS(float cmd, int servo){ // cmd =commanded position +-100% // servo =servo num (to apply correct direction, rates and trim) int i =servo-1; float dir; if(servo_dir[i] ==0) dir =-1; else dir =1; // set the direction of servo travel cmd =1500 + (cmd*servo_rates[i]*dir + servo_subtrim[i])*500; // apply servo rates and sub trim, then convert to a uS value if(cmd> 2500) cmd =2500; // limit pulsewidth to the range 500 to 2500us else if(cmd <500) cmd =500; return cmd;}
 

Esquemas