ProHoster > Blog > Verwaltung > So verbinden Sie den HX711 ADC mit NRF52832

So verbinden Sie den HX711 ADC mit NRF52832

1. Einleitung

Auf der Tagesordnung stand die Aufgabe, ein Kommunikationsprotokoll für den Mikrocontroller Nrf52832 mit zwei chinesischen Halbbrücken-Dehnmessstreifen zu entwickeln.

Die Aufgabe erwies sich als nicht einfach, da es mir an verständlichen Informationen mangelte. Es ist wahrscheinlicher, dass die „Wurzel des Übels“ im SDK von Nordic Semiconductor selbst liegt – ständige Versionsaktualisierungen, einige Redundanzen und verwirrende Funktionalität. Ich musste alles von Grund auf neu schreiben.

Ich denke, dieses Thema ist durchaus relevant, da dieser Chip über einen BLE-Stack und eine ganze Reihe von „Goodies“ für den Energiesparmodus verfügt. Ich werde jedoch nicht zu tief auf den technischen Teil eingehen, da bereits viele Artikel zu diesem Thema geschrieben wurden.

2. Projektbeschreibung

So verbinden Sie den HX711 ADC mit NRF52832

Eisen:

  • Adafruit Feather nRF52 Bluefruit LE (was gerade zur Hand war)
  • HX711 ADC
  • Chinesische Dehnungsmessstreifen 2 Stk. (50x2 kg)
  • Programmierer ST-LINK V2

Software:

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

Alles ist in einem Projekt, Sie müssen nur das Makefile optimieren (den Speicherort Ihres SDK angeben).

3. Beschreibung des Codes

Wir werden das GPIOTE-Modul verwenden, um mit Peripheriegeräten basierend auf der Bindung von Aufgaben und Ereignissen zu arbeiten, sowie das PPI-Modul, um Daten von einem Peripheriegerät zu einem anderen ohne Beteiligung eines Prozessors zu übertragen.

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);//настраеваем на выход

Wir konfigurieren die PD_SCL-Synchronisationsleitung zum Ausgang, um Impulse mit einer Dauer von 10 μs zu erzeugen.

   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);//включаем таймер
}

Wir konfigurieren die DOUT-Datenleitung so, dass sie den Bereitschaftszustand des HX711 ausliest; bei einem Low-Pegel wird ein Handler ausgelöst, in dem wir den Interrupt deaktivieren und einen Timer starten, um Taktimpulse am PD_SCL-Ausgang zu erzeugen.

 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);

// gpiote aktivieren

Danach initialisieren wir das PPI-Modul und verbinden unseren Timer mit dem PD_SCL-Ausgang, um bei Auftreten eines Vergleichsereignisses Impulse mit einer Dauer von 10 μs zu erzeugen, und schalten außerdem das GPIOTE-Modul ein.


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);// срабатывает по сравнению

Wir initialisieren den Null-Timer und seinen Handler. 

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

Das Interessanteste passiert im Timer-Handler. Die Pulsperiode beträgt 20 μs. Wir interessieren uns für ungerade Impulse (entlang der ansteigenden Flanke) und vorausgesetzt, dass ihre Anzahl nicht mehr als 24 beträgt und es 48 Ereignisse gibt. Für jedes ungerade Ereignis wird DOUT gelesen

Aus dem Datenblatt geht hervor, dass die Anzahl der Impulse mindestens 25 betragen muss, was einer Verstärkung von 128 entspricht (im Code habe ich 25 Impulse verwendet), dies entspricht 50 Timer-Ereignissen, was das Ende des Datenrahmens anzeigt. 

 ++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
       }

Danach schalten wir den Timer aus, verarbeiten die Daten (gemäß Datenblatt) und schalten den HX711 in den Energiesparmodus. 


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);
}

Wir erwarten Ereignisse vom RTC-Timer mit einem Intervall von 10 s (dies liegt in Ihrem Ermessen) und starten den HX711 im Handler, was einen Interrupt auf der DOUT-Leitung verursacht.

Es gibt noch einen weiteren Punkt: Die Protokolle werden über UART ausgegeben (Baudrate 115200, TX – 6 Pins, RX – 8 Pins). Alle Einstellungen befinden sich in sdk_config.h

So verbinden Sie den HX711 ADC mit NRF52832

Befund

Ich danke Ihnen allen für Ihre Aufmerksamkeit und hoffe, dass dieser Artikel nützlich ist und den Entwicklern wertvolle Zeit bei der Lösungsfindung verkürzt. Ich möchte sagen, dass der technische Ansatz, den Nordic in seinen Plattformen verwendet, unter dem Gesichtspunkt der Energieeffizienz recht interessant ist.

PS

Das Projekt befindet sich noch in der Entwicklung. Wenn dieses Thema für Sie von Interesse ist, werde ich im nächsten Artikel versuchen, den Algorithmus zur Kalibrierung von Gewichtssensoren sowie die Verbindung des BLE-Stacks zu beschreiben.

Material

Source: habr.com

Kommentar hinzufügen