1. పరిచయం
ఎజెండాలో రెండు హాఫ్-బ్రిడ్జ్ చైనీస్ స్ట్రెయిన్ గేజ్‌లతో nrf52832 మైక్రోకంట్రోలర్ కోసం కమ్యూనికేషన్ ప్రోటోకాల్‌ను అభివృద్ధి చేసే పని ఉంది.
నాకు అర్థమయ్యే సమాచారం లేకపోవడంతో పని సులభం కాదని తేలింది. నార్డిక్ సెమీకండక్టర్ నుండి "చెడు యొక్క మూలం" SDKలో ఉండే అవకాశం ఉంది - స్థిరమైన సంస్కరణ నవీకరణలు, కొంత రిడెండెన్సీ మరియు గందరగోళ కార్యాచరణ. నేను మొదటి నుండి ప్రతిదీ వ్రాయవలసి వచ్చింది.
ఈ చిప్‌లో BLE స్టాక్ మరియు శక్తి పొదుపు మోడ్ కోసం "గూడీస్" మొత్తం సెట్ ఉన్నందున ఈ అంశం చాలా సందర్భోచితంగా ఉంటుందని నేను భావిస్తున్నాను. కానీ నేను సాంకేతిక భాగంలోకి చాలా లోతుగా వెళ్లను, ఎందుకంటే ఈ అంశంపై చాలా కథనాలు వ్రాయబడ్డాయి.
2. ప్రాజెక్ట్ యొక్క వివరణ
ఇనుము:
- అడాఫ్రూట్ ఫెదర్ nRF52 బ్లూఫ్రూట్ LE (చేతిలో ఏమి జరిగింది)
- HX711 ADC
- చైనీస్ స్ట్రెయిన్ గేజ్‌లు 2 pcs. (50x2 కేజీ)
- ప్రోగ్రామర్ ST-LINK V2
సాఫ్ట్‌వేర్:
- IDE VSCODE
- NRF SDK 16
- OpenOCD
- ప్రోగ్రామర్ 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 సెకన్ల విరామంతో ఈవెంట్‌లను ఆశిస్తున్నాము (ఇది మీ అభీష్టానుసారం) మరియు హ్యాండ్లర్‌లో HX711ని ప్రారంభించడం వలన DOUT లైన్‌లో అంతరాయం ఏర్పడుతుంది.
మరో పాయింట్ ఉంది, లాగ్‌లు UART ద్వారా అవుట్‌పుట్ చేయబడతాయి (బాడ్ రేట్ 115200, TX - 6 పిన్స్, RX - 8 పిన్స్) అన్ని సెట్టింగ్‌లు sdk_config.hలో ఉన్నాయి
కనుగొన్న
మీ దృష్టికి ధన్యవాదాలు, ఈ వ్యాసం ఉపయోగకరంగా ఉంటుందని మరియు డెవలపర్‌లకు పరిష్కారాన్ని కనుగొనడానికి విలువైన సమయాన్ని తగ్గిస్తుందని నేను ఆశిస్తున్నాను. నార్డిక్ దాని ప్లాట్‌ఫారమ్‌లలో ఉపయోగించే సాంకేతిక విధానం శక్తి సామర్థ్యం యొక్క కోణం నుండి చాలా ఆసక్తికరంగా ఉందని నేను చెప్పాలనుకుంటున్నాను.
PS
ప్రాజెక్ట్ ఇంకా అభివృద్ధిలో ఉంది, కాబట్టి ఈ అంశం ఆసక్తిగా ఉంటే, తదుపరి వ్యాసంలో నేను బరువు సెన్సార్లను క్రమాంకనం చేయడానికి, అలాగే BLE స్టాక్‌ను కనెక్ట్ చేయడానికి అల్గోరిథంను వివరించడానికి ప్రయత్నిస్తాను.
Материалы
మూలం: www.habr.com