ProHoster > Blog > Administración > Como conectar HX711 ADC a NRF52832

Como conectar HX711 ADC a NRF52832

1. Introdución

Na axenda estaba a tarefa de desenvolver un protocolo de comunicación para o microcontrolador nrf52832 con dous extensómetros chineses de media ponte.

A tarefa resultou non ser doada, xa que estaba ante a falta de información intelixible. É máis probable que a "raíz do mal" estea no SDK do propio Nordic Semiconductor: actualizacións constantes da versión, certa redundancia e funcionalidades confusas. Tiven que escribir todo dende cero.

Creo que este tema é bastante relevante baseándose no feito de que este chip ten unha pila BLE e todo un conxunto de "goodies" para o modo de aforro de enerxía. Pero non vou afondar demasiado na parte técnica, xa que se escribiron moitos artigos sobre este tema.

2. Descrición do proxecto

Como conectar HX711 ADC a NRF52832

Ferro:

  • Adafruit Feather nRF52 Bluefruit LE (o que estaba a man)
  • ADC HX711
  • Extensómetros chinos 2 unidades. (50 x 2 kg)
  • Programador ST-LINK V2

Suave:

  • IDE VSCODE
  • NRF SDK 16
  • OpenOCD
  • Programador ST-LINK V2

Todo está nun proxecto, só tes que axustar o Makefile (especifica a localización do teu SDK).

3. Descrición do código

Utilizaremos o módulo GPIOTE para traballar con periféricos baseados na vinculación de tarefas e eventos, así como o módulo PPI para transferir datos dun periférico a outro sen a participación dun procesador.

ret_code_t err_code;
   err_code = nrf_drv_gpiote_out_init(PD_SCK, &config);//настраеваем на выход
   nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(false);//будем передергивать пин для импульса
   err_code = nrf_drv_gpiote_out_init(PD_SCK, &config);//настраеваем на выход

Configuramos a liña de sincronización PD_SCL á saída para xerar pulsos cunha duración de 10 μs.

   nrf_drv_gpiote_in_config_t  gpiote_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(false);// переход уровня с высокого на низкий
   nrf_gpio_cfg_input(DOUT, NRF_GPIO_PIN_NOPULL);// на вход без подтяжки
   err_code = nrf_drv_gpiote_in_init(DOUT, &gpiote_config, gpiote_evt_handler); 

static void gpiote_evt_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
    nrf_drv_gpiote_in_event_disable(DOUT);//отключаем прерывание
    nrf_drv_timer_enable(&m_timer0);//включаем таймер
}

Configuramos a liña de datos DOUT para ler o estado de preparación do HX711; se hai un nivel baixo, desenvólvese un controlador no que desactivamos a interrupción e iniciamos un temporizador para xerar pulsos de reloxo na saída PD_SCL.

 err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel1);
   APP_ERROR_CHECK(err_code);
   err_code = nrf_drv_ppi_channel_assign(m_ppi_channel1,                                         nrf_drv_timer_event_address_get(&m_timer0, NRF_TIMER_EVENT_COMPARE0),                                           nrf_drv_gpiote_out_task_addr_get(PD_SCK));// подключаем таймер к выходу
   APP_ERROR_CHECK(err_code);
   err_code = nrf_drv_ppi_channel_enable(m_ppi_channel1);// включаем канал
   APP_ERROR_CHECK(err_code);
   nrf_drv_gpiote_out_task_enable(PD_SCK);

// activar gpiote

Despois diso, inicializamos o módulo PPI e conectamos o noso temporizador á saída PD_SCL para xerar pulsos cunha duración de 10 μs cando se produce un evento de comparación, e tamén activamos o módulo GPIOTE.


nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;// по умолчанию
   timer_cfg.frequency = NRF_TIMER_FREQ_1MHz;// тактируем на частоте 1Мгц
   ret_code_t err_code = nrf_drv_timer_init(&m_timer0, &timer_cfg, timer0_event_handler);
   APP_ERROR_CHECK(err_code);
   nrf_drv_timer_extended_compare(&m_timer0,
                                  NRF_TIMER_CC_CHANNEL0,
                                  nrf_drv_timer_us_to_ticks(&m_timer0,
                                                            10),
                                  NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                  true);// срабатывает по сравнению

Inicializamos o temporizador cero e o seu controlador. 

  if(m_counter%2 != 0 && m_counter<=48){
       buffer <<= 1;// переменная считанных даных
        c_counter++;// счетчик положительных  импульсов
           if(nrf_gpio_pin_read(DOUT))buffer++;//считываем состояние входа
   }

O máis interesante ocorre no controlador do temporizador. O período do pulso é de 20 μs. Interésanos os pulsos impares (ao longo do bordo ascendente) e sempre que o seu número non sexa superior a 24 e haxa 48 eventos. Para cada evento impar, lese DOUT

Da folla de datos despréndese que o número de pulsos debe ser polo menos 25, o que corresponde a unha ganancia de 128 (no código usei 25 pulsos), isto é equivalente a 50 eventos de temporizador, o que indica o final do marco de datos. 

 ++m_counter;// счетчик событий
if(m_counter==50){
      nrf_drv_timer_disable(&m_timer0);// отключаем таймер
       m_simple_timer_state = SIMPLE_TIMER_STATE_STOPPED;//
       buffer = buffer ^ 0x800000;
       hx711_stop();//jотключаем hx711
       }

Despois diso, apagamos o temporizador e procesamos os datos (segundo a folla de datos) e cambiamos o HX711 ao modo de baixo consumo de enerxía. 


static void repeated_timer_handler(void * p_context)
{
   nrf_drv_gpiote_out_toggle(LED_2);
   if(m_simple_timer_state == SIMPLE_TIMER_STATE_STOPPED){
      	hx711_start();// включаем hx711
       nrf_drv_gpiote_out_toggle(LED_1);
       m_simple_timer_state = SIMPLE_TIMER_STATE_STARTED;
   }
  
}
/**@brief Create timers.
*/
static void create_timers()
{
   ret_code_t err_code;
 
   // Create timers
   err_code = app_timer_create(&m_repeated_timer_id,
                               APP_TIMER_MODE_REPEATED,
                               repeated_timer_handler);
   APP_ERROR_CHECK(err_code);
}

Esperamos eventos do temporizador RTC cun intervalo de 10 s (isto é ao teu criterio) e lanzar o HX711 no controlador, provocando unha interrupción na liña DOUT.

Hai un punto máis, os rexistros saen a través de UART (velocidade en baudios 115200, TX - 6 pinos, RX - 8 pinos) todas as configuracións están en sdk_config.h

Como conectar HX711 ADC a NRF52832

Descubrimentos

Grazas a todos pola súa atención, espero que este artigo sexa útil e reduza o tempo valioso para que os desenvolvedores atopen unha solución. Quero dicir que o enfoque técnico que Nordic utiliza nas súas plataformas é bastante interesante dende o punto de vista da eficiencia enerxética.

PS

O proxecto aínda está en desenvolvemento, polo que se este tema é de interese, no seguinte artigo intentarei describir o algoritmo para calibrar sensores de peso, así como conectar a pila BLE.

Obras

Fonte: www.habr.com

Engadir un comentario