HX711 ADC-യെ NRF52832-ലേക്ക് എങ്ങനെ ബന്ധിപ്പിക്കാം

1. ആമുഖം

രണ്ട് ഹാഫ് ബ്രിഡ്ജ് ചൈനീസ് സ്‌ട്രെയിൻ ഗേജുകളുള്ള nrf52832 മൈക്രോകൺട്രോളറിനായി ഒരു കമ്മ്യൂണിക്കേഷൻ പ്രോട്ടോക്കോൾ വികസിപ്പിക്കുക എന്നതായിരുന്നു അജണ്ടയിൽ.

ബുദ്ധിപരമായ വിവരങ്ങളുടെ അഭാവം നേരിട്ടതിനാൽ, ചുമതല എളുപ്പമായിരുന്നില്ല. നോർഡിക് അർദ്ധചാലകത്തിൽ നിന്ന് തന്നെ "തിന്മയുടെ റൂട്ട്" SDK-യിൽ ആയിരിക്കാൻ സാധ്യതയുണ്ട് - നിരന്തരമായ പതിപ്പ് അപ്ഡേറ്റുകൾ, ചില ആവർത്തനങ്ങൾ, ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന പ്രവർത്തനം. എനിക്ക് ആദ്യം മുതൽ എല്ലാം എഴുതേണ്ടി വന്നു.

ഈ ചിപ്പിന് ഒരു BLE സ്റ്റാക്കും ഊർജ്ജ സംരക്ഷണ മോഡിനായി "ഗുഡീസ്" ഒരു മുഴുവൻ സെറ്റും ഉണ്ടെന്ന വസ്തുതയെ അടിസ്ഥാനമാക്കി ഈ വിഷയം വളരെ പ്രസക്തമാണെന്ന് ഞാൻ കരുതുന്നു. എന്നാൽ ഈ വിഷയത്തിൽ നിരവധി ലേഖനങ്ങൾ എഴുതിയതിനാൽ ഞാൻ സാങ്കേതിക ഭാഗത്തേക്ക് കൂടുതൽ ആഴത്തിൽ പോകില്ല.

2. പദ്ധതിയുടെ വിവരണം

ഇരുമ്പ്:

• അഡാഫ്രൂട്ട് ഫെതർ nRF52 ബ്ലൂഫ്രൂട്ട് LE (കൈയിൽ എന്താണ് സംഭവിച്ചത്)
• ADC HX711
• ചൈനീസ് സ്‌ട്രെയിൻ ഗേജുകൾ 2 പീസുകൾ. (50x2 കി.ഗ്രാം)
• പ്രോഗ്രാമർ ST-LINK V2

സോഫ്റ്റ്വെയർ:

• IDE VSCODE
• NRF SDK 16
• ഓപ്പൺ ഒസിഡി
• പ്രോഗ്രാമർ ST-LINK V2

എല്ലാം ഒരു പ്രോജക്റ്റിലാണ്, നിങ്ങൾ Makefile മാറ്റേണ്ടതുണ്ട് (നിങ്ങളുടെ SDK-യുടെ സ്ഥാനം വ്യക്തമാക്കുക).

3. കോഡിന്റെ വിവരണം

ടാസ്‌ക്കുകളുടെയും ഇവന്റുകളുടെയും ബൈൻഡിംഗിനെ അടിസ്ഥാനമാക്കി പെരിഫറലുകളുമായി പ്രവർത്തിക്കാൻ ഞങ്ങൾ GPIOTE മൊഡ്യൂളും ഒരു പ്രോസസറിന്റെ പങ്കാളിത്തമില്ലാതെ ഒരു പെരിഫറലിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഡാറ്റ കൈമാറാൻ PPI മൊഡ്യൂളും ഉപയോഗിക്കും.

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

10 μs ദൈർഘ്യമുള്ള പൾസുകൾ ജനറേറ്റുചെയ്യുന്നതിന് ഞങ്ങൾ PD_SCL സിൻക്രൊണൈസേഷൻ ലൈൻ ഔട്ട്‌പുട്ടിലേക്ക് കോൺഫിഗർ ചെയ്യുന്നു.

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

HX711-ന്റെ തയ്യാറെടുപ്പ് നില വായിക്കാൻ ഞങ്ങൾ DOUT ഡാറ്റാ ലൈൻ കോൺഫിഗർ ചെയ്യുന്നു; താഴ്ന്ന നിലയുണ്ടെങ്കിൽ, ഒരു ഹാൻഡ്‌ലർ പ്രവർത്തനക്ഷമമാകും, അതിൽ ഞങ്ങൾ ഇന്ററപ്റ്റ് പ്രവർത്തനരഹിതമാക്കുകയും 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); 

// gpiote പ്രവർത്തനക്ഷമമാക്കുക

അതിനുശേഷം, ഞങ്ങൾ PPI മൊഡ്യൂൾ സമാരംഭിക്കുകയും ഒരു താരതമ്യ ഇവന്റ് സംഭവിക്കുമ്പോൾ 10 μs ദൈർഘ്യമുള്ള പൾസുകൾ സൃഷ്ടിക്കുന്നതിന് PD_SCL ഔട്ട്‌പുട്ടിലേക്ക് ഞങ്ങളുടെ ടൈമർ ബന്ധിപ്പിക്കുകയും 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);// срабатывает по сравнению

സീറോ ടൈമറും അതിന്റെ ഹാൻഡ്‌ലറും ഞങ്ങൾ സമാരംഭിക്കുന്നു.

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

ഏറ്റവും രസകരമായ കാര്യം ടൈമർ ഹാൻഡ്‌ലറിൽ സംഭവിക്കുന്നു. പൾസ് കാലയളവ് 20 μs ആണ്. വിചിത്രമായ പൾസുകളിൽ (ഉയരുന്ന അരികിൽ) ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്, കൂടാതെ അവയുടെ എണ്ണം 24-ൽ കൂടരുത്, കൂടാതെ 48 ഇവന്റുകൾ ഉണ്ട്. ഓരോ ഒറ്റ സംഭവത്തിനും, DOUT വായിക്കുന്നു

ഡാറ്റാഷീറ്റിൽ നിന്ന്, പൾസുകളുടെ എണ്ണം കുറഞ്ഞത് 25 ആയിരിക്കണം, അത് 128 ന്റെ നേട്ടവുമായി പൊരുത്തപ്പെടുന്നു (ഞാൻ 25 പൾസുകൾ ഉപയോഗിച്ച കോഡിൽ), ഇത് 50 ടൈമർ ഇവന്റുകൾക്ക് തുല്യമാണ്, ഇത് ഡാറ്റ ഫ്രെയിമിന്റെ അവസാനത്തെ സൂചിപ്പിക്കുന്നു.

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

ഇതിനുശേഷം, ഞങ്ങൾ ടൈമർ ഓഫ് ചെയ്യുകയും ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയും (ഡാറ്റാഷീറ്റ് അനുസരിച്ച്) HX711 കുറഞ്ഞ പവർ ഉപഭോഗ മോഡിലേക്ക് മാറുകയും ചെയ്യുന്നു.

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

RTC ടൈമറിൽ നിന്ന് 10 സെക്കന്റ് ഇടവേളയുള്ള ഇവന്റുകൾ ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു (ഇത് നിങ്ങളുടെ വിവേചനാധികാരത്തിലാണ്) കൂടാതെ DOUT ലൈനിൽ തടസ്സമുണ്ടാക്കുന്ന ഹാൻഡ്‌ലറിൽ HX711 ലോഞ്ച് ചെയ്യുന്നു.

ഒരു പോയിന്റ് കൂടിയുണ്ട്, ലോഗുകൾ UART വഴി ഔട്ട്‌പുട്ട് ചെയ്യുന്നു (ബോഡ് നിരക്ക് 115200, TX - 6 പിൻസ്, RX - 8 പിൻസ്) എല്ലാ ക്രമീകരണങ്ങളും sdk_config.h-ലാണ്.

കണ്ടെത്തലുകൾ

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് എല്ലാവർക്കും നന്ദി, ഈ ലേഖനം ഉപയോഗപ്രദമാകുമെന്നും ഡെവലപ്പർമാർക്ക് പരിഹാരം കണ്ടെത്തുന്നതിനുള്ള വിലപ്പെട്ട സമയം കുറയ്ക്കുമെന്നും ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഊർജ്ജ കാര്യക്ഷമതയുടെ വീക്ഷണകോണിൽ നിന്ന് നോർഡിക് അതിന്റെ പ്ലാറ്റ്ഫോമുകളിൽ ഉപയോഗിക്കുന്ന സാങ്കേതിക സമീപനം വളരെ രസകരമാണെന്ന് ഞാൻ പറയാൻ ആഗ്രഹിക്കുന്നു.

പി.എസ്

പ്രോജക്റ്റ് ഇപ്പോഴും വികസനത്തിലാണ്, അതിനാൽ ഈ വിഷയം താൽപ്പര്യമുണ്ടെങ്കിൽ, അടുത്ത ലേഖനത്തിൽ ഭാരം സെൻസറുകൾ കാലിബ്രേറ്റ് ചെയ്യുന്നതിനും BLE സ്റ്റാക്ക് ബന്ധിപ്പിക്കുന്നതിനുമുള്ള അൽഗോരിതം വിവരിക്കാൻ ഞാൻ ശ്രമിക്കും.

വസ്തുക്കൾ

• പ്രോജക്റ്റ് കോഡ്
• ഇംഗ്ലീഷിലുള്ള HX711-നുള്ള ഡാറ്റാഷീറ്റ്
• സ്ട്രെയിൻ ഗേജുകളുടെ പ്രവർത്തനത്തിന്റെ വിവരണം

അവലംബം: www.habr.com