——DWIN ડેવલપર ફોરમ તરફથી
આ વખતે દરેક માટે ભલામણ કરાયેલ DWIN ડેવલપર ફોરમ ઓપન સોર્સ પ્રોજેક્ટ માનવ આંખોની હિલચાલનું અનુકરણ કરવા માટે ખૂબ જ રસપ્રદ રૂટિન છે.ઇજનેરે આંખની કીકીની હિલચાલ, આંખ મારવી, ચહેરાની ઓળખ અને અનુસરણ જેવા કાર્યોને સાકાર કરવા માટે માનવ આંખની કેટલીક ચિત્ર સામગ્રીનો ઉપયોગ કર્યો.
ઓપન સોર્સ સોલ્યુશન્સનો પરિચય:
1. UI છબી સામગ્રી
સંપાદકની નોંધ: DWIN સ્માર્ટ સ્ક્રીન UI ડેવલપમેન્ટ પૂર્ણ કરવા માટે ચિત્રો પર આધારિત છે, જે વિવિધ ડિસ્પ્લે અસરોને સરળતાથી અનુભવી શકે છે.
2. ઈન્ટરફેસ વિકાસ
DGUS સોફ્ટવેર દ્વારા ઈન્ટરફેસ વિકસાવવા માટે તે પ્રમાણમાં સરળ છે, અને માત્ર બે ગ્રાફિક નિયંત્રણોની જરૂર છે.આ રૂટિનમાં, એન્જિનિયરે 2.1-ઇંચની રાઉન્ડ સ્માર્ટ સ્ક્રીન પસંદ કરી.
3. બ્લિંક એનિમેશનનો અહેસાસ કરો
પોપચાના ચિત્રો સમયાંતરે પ્રદર્શિત થવા દો:
// બ્લિંક એનિમેશન
void blink_animat(void)
{
જો (ઝબૂકવું_ધ્વજ == 0)
{
blink_cnt++;
જો (blink_cnt >= 4)
{
blink_flag = 1;
}
}
બીજું
{
blink_cnt–;
જો (blink_cnt <= 0)
{
blink_flag = 0;
}
}
write_dgus_vp(0×3000, (u8 *)&blink_cnt, 2);
}
void blink_run()
{
સ્થિર u32 રન_ટાઇમર_cnt = 0;
run_timer_cnt++;
જો (રન_ટાઇમર_સીએનટી >= 2000000)
{
રન_ટાઇમર_સીએનટી = 0;
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
blink_animat();
વિલંબ_ms(30);
}
}
4. સમજો કે આંખની કીકી કુદરતી રીતે ડાબે અને જમણે દેખાય છે.
આ આંખ મારવા જેવું જ છે, પરંતુ આંખની ગતિને નિયંત્રિત કરવા માટે તેને ક્રિસ્ટલ ઓસિલેટરના સમયની તુલના કરવાની જરૂર છે.ઘણી વખત ડીબગીંગ કર્યા પછી, એન્જિનિયરે નીચેના કોડના સેટની રચના કરી.
// આંખની કીકી એનિમેશન
void eyeball_animat(void)
{
eyeball_timer_cnt++;
જો (આઇબોલ_ટાઈમર_સીએનટી < 50)
{
eyeball_cnt = 20;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 51)
{
eyeball_cnt = 50;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 52)
{
eyeball_cnt = 80;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 53)
{
eyeball_cnt = 94;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 103)
{
eyeball_cnt = 94;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 104)
{
eyeball_cnt = 80;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 105)
{
eyeball_cnt = 50;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 106)
{
eyeball_cnt = 20;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 107)
{
eyeball_cnt = -10;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 108)
{
eyeball_cnt = -40;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 158)
{
eyeball_cnt = -54;
}
બાકી જો (આંખની કીકી_ટાઈમર_સીએનટી < 159)
{
eyeball_cnt = -40;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 160)
{
eyeball_cnt = -10;
}
બાકી જો (આઇબોલ_ટાઈમર_સીએનટી < 161)
{
eyeball_cnt = 20;
eyeball_timer_cnt = 0;
}
//ડાબે અને જમણે ખસેડો
// જો (આંખની કીકી_ધ્વજ == 0)
// {
// આંખની કીકી_cnt++;
// જો (આઇબોલ_સીએનટી >= 94)
// {
// આંખની કીકી_ધ્વજ = 1;
// }
// }
// બીજું
// {
// eyeball_cnt–;
// જો(આઇબોલ_સીએનટી <= -54)
// {
// આંખની કીકી_ધ્વજ = 0;
// }
// }
જો (આઇબોલ_સીએનટી >= 0)
{
આંખની કીકી_પોઝ[0] = 0×00;
eyeball_pos[1] = eyeball_cnt;
}
બીજું
{
eyeball_pos[0] = 0xFF;
eyeball_pos[1] = (eyeball_cnt & 0xFF);
}
write_dgus_vp(0×3111, (u8 *)& eyeball_pos, 2);
}
void eyeball_run()
{
સ્થિર u32 રન_ટાઇમર_cnt = 0;
run_timer_cnt++;
જો (રન_ટાઇમર_સીએનટી >= 20000)
{
રન_ટાઇમર_સીએનટી = 0;
eyeball_animat();
}
}
5. ચહેરાને અનુસરીને આંખોની હિલચાલને સમજવા માટે ESP32 ચહેરાની ઓળખ ઉમેરો.
અહીં પ્રક્રિયા કરવાની પદ્ધતિ એ છે કે જ્યારે ચહેરો શોધી કાઢવામાં આવે છે, ત્યારે આંખો જાતે જ આગળ વધતી નથી, અને જ્યારે લૂપમાં વધારો થાય છે ત્યારે ચલને વ્યાખ્યાયિત કરવામાં આવે છે.જ્યારે ઇન્ક્રીમેન્ટ ચોક્કસ મૂલ્ય સુધી પહોંચે છે, ત્યારે આંખની કીકી જાતે જ આગળ વધશે.જ્યારે સીરીયલ પોર્ટ ડેટા મેળવે છે, ત્યારે આ વેરીએબલ સાફ થઈ જશે, અને પછી માત્ર ચહેરાની સ્થિતિ અનુસાર આંખોને ખસેડો.મુખ્ય કોડ નીચે મુજબ છે:
જો(rec_data_timer_cnt < 1000000)
{
rec_data_timer_cnt++;
}
બીજું
{
આંખની કીકી_રન();
}
બાહ્ય u32 rec_data_timer_cnt;
બાહ્ય u16 eyeball_timer_cnt;
void Communication_CMD(u8 st)
{
જો((uart[st].Rx_F==1 )&&(uart[st].Rx_T==0))
{
rec_data_timer_cnt = 0;
eyeball_timer_cnt = 0;
#if(Type_communication==1)
વર્ણન_8283(st);
#elif(Type_communication==2)
વર્ણન_મોડબસ(st);
#endif
uart[st].Rx_F=0;
uart[st].Rx_Num=0;
}
}
પોસ્ટ સમય: જૂન-26-2023