Arduino માં શબ્દમાળાઓ સાથે કામ કરતી વખતે, તેમની સરખામણી કરવાની ઘણી રીતો છે. સૌથી ઉપયોગી કાર્યો પૈકી એક છે strcmp(), જે C સ્ટાન્ડર્ડ લાઇબ્રેરીની છે, cstring
. આ ફંક્શન તમને બે કેરેક્ટર સ્ટ્રીંગ્સ (સ્ટ્રિંગ્સ) ને સીધી રીતે સરખાવવા માટે પરવાનગી આપે છે, એક મૂલ્ય પરત કરે છે જે અમને જણાવે છે કે શું શબ્દમાળાઓ સમાન છે અથવા તેમની વચ્ચે કોઈ તફાવત છે.
Arduino માં, અક્ષર શબ્દમાળાઓ સામાન્ય રીતે વર્ગની વસ્તુઓ દ્વારા નિયંત્રિત થાય છે String
, જો કે તેની સાથે કામ કરવાનો વિકલ્પ પણ છે અક્ષર એરે, ખાસ કરીને જો આપણે સંસાધનોને ઑપ્ટિમાઇઝ કરવા અથવા લો-મેમરી કોડ સાથે કામ કરવા માગીએ છીએ. ચાલો આ સુવિધાનો યોગ્ય રીતે ઉપયોગ કેવી રીતે કરવો તે વિશે જાણીએ strcmp() અને અન્ય વિકલ્પો કે જે આ વાતાવરણમાં પણ ઉપયોગી છે.
શું છે strcmp()
અને તે Arduino પર કેવી રીતે કામ કરે છે?
કાર્ય strcmp()
તે ખૂબ જ સરળ વર્તન ધરાવે છે: તે અક્ષરોની બે સ્ટ્રીંગ લે છે, તેમને પાત્ર દ્વારા પાત્રની તુલના કરે છે અને તે સરખામણીના આધારે મૂલ્ય પરત કરે છે. પદ્ધતિ મૂલ્યાંકન કરે છે ASCII મૂલ્યો અક્ષરોની, જે ધ્યાનમાં રાખવી મહત્વપૂર્ણ છે. આ સરખામણીના સંભવિત પરિણામો નીચે મુજબ છે.
- જો સાંકળો સમાન હોય,
strcmp()
પાછુ લઇ આવો 0. - જો પ્રથમ અક્ષર જે અલગ છે તેની પ્રથમ સ્ટ્રિંગમાં ASCII મૂલ્ય ઓછું હોય, તો ફંક્શન પરત આવશે નકારાત્મક સંખ્યા.
- જો પ્રથમ સ્ટ્રિંગનું મેળ ન ખાતું અક્ષર વધારે હોય, તો તે પરત આવશે હકારાત્મક સંખ્યા.
ફંક્શનનો ઉપયોગ કરવાનું એક વ્યવહારુ ઉદાહરણ strcmp()
બે શબ્દમાળાઓની સરખામણી કરવી કે જે આપણે અન્ય કાર્યોનો ઉપયોગ કરીને રજૂ કરીએ છીએ અથવા જનરેટ કરીએ છીએ. ઉદાહરણ તરીકે, અમે એક પ્રોગ્રામ બનાવી શકીએ છીએ જે વપરાશકર્તા ડેટા એકત્રિત કરે છે અને, સંગ્રહિત સ્ટ્રિંગ સાથે સરખામણી કરીને, માહિતી સાચી છે કે કેમ તે માન્ય કરે છે.
વચ્ચે મહત્વપૂર્ણ તફાવતો strcmp()
અને અન્ય કાર્યો
Arduino માં શબ્દમાળાઓ સાથે કામ કરતી વખતે, ત્યાં અન્ય વિકલ્પો છે strcmp()
જે તમારી જરૂરિયાતોને શ્રેષ્ઠ રીતે બંધબેસશે. તેમાંથી એક છે memcmp()
, જે મેમરી-સ્તરની સરખામણી કરે છે, જ્યારે અમે અમારી સ્ટ્રીંગ્સમાં નલ ટર્મિનેટર પર આધાર રાખવા માંગતા નથી ત્યારે તે ઉપયોગી છે. વિપરીત strcmp()
, જે નલ-ટર્મિનેટેડ સ્ટ્રિંગ્સ સાથે કામ કરવા માટે રચાયેલ છે, memcmp()
તે ફક્ત ચોક્કસ સંખ્યાની બાઇટ્સની તુલના કરે છે.
ચાલો તેના મૂળભૂત વાક્યરચના જોઈએ:
if (memcmp(payload, "cadena", longitud) == 0) { // Ejecuta la acción}
તેની લવચીકતાને જોતાં, તે ખૂબ જ ઉપયોગી વિકલ્પ છે જો તમે ડેટાના ટુકડાઓ અથવા નિશ્ચિત-લંબાઈના સંદેશાઓ સાથે કામ કરો છો જેની સરખામણી બાઈટ બાય બાઈટ સાથે થવી જોઈએ.
કોંક્રિટ ઉપયોગના કેસ: રીઅલ-ટાઇમ સ્ટ્રિંગ મોનિટરિંગ અને સરખામણી
કલ્પના કરો કે તમે એવા પ્રોજેક્ટ પર કામ કરી રહ્યા છો જ્યાં તમને વાસ્તવિક સમયમાં માહિતી પ્રાપ્ત થાય છે અને તમારે ચોક્કસ મૂલ્ય સાથે તેની સરખામણી કરવાની જરૂર છે. કાર્ય strcmp() આ પ્રકારની પરિસ્થિતિમાં તે મુખ્ય સાધન છે. ઉદાહરણ તરીકે, જો તમે સેન્સરમાંથી મેળવેલા ડેટાની સરખામણી કરી રહ્યાં છો અને તે પૂર્વવ્યાખ્યાયિત મૂલ્ય સાથે મેળ ખાય છે કે કેમ તે માન્ય કરવા માગો છો, strcmp() તમને આ કાર્યક્ષમ રીતે કરવા દેશે.
આ કોડ સ્નિપેટમાં, અમે સરખામણી કરીએ છીએ કે શું pH સેન્સરમાંથી પ્રાપ્ત મૂલ્ય ચોક્કસ માપાંકિત મૂલ્યો સાથે મેળ ખાય છે કે કેમ:
if (strcmp(inputString, "CAL,4") == 0) { // Acción cuando se recibe el valor de calibración}
આ પ્રકારની સરખામણી એપ્લીકેશનમાં નિર્ણાયક છે જ્યાં ડેટા બદલાઈ શકે છે અને અમારે રીડિંગ્સના પરિણામોના આધારે નિર્ણયો લેવા જોઈએ.
શબ્દમાળાઓ સાથે કામ કરવાની અન્ય પદ્ધતિઓ
સિવાય strcmp()
, તમે Arduino ઇકોસિસ્ટમમાં અન્ય કાર્યોનો પણ ઉપયોગ કરી શકો છો. કાર્ય compareTo
, ઉદાહરણ તરીકે, વર્ગનો ભાગ છે String
અને તે વર્ગની વસ્તુઓની સરખામણી કરવાનું સરળ બનાવે છે. જોકે strcmp()
તે નિમ્ન-સ્તરના અમલીકરણમાં અથવા અક્ષર એરે સાથે વધુ સામાન્ય છે, compareTo
જો તમે પહેલાથી જ વસ્તુઓ સાથે કામ કરી રહ્યા હોવ તો ઉપયોગી String
.
અહીં કેટલીક વધારાની પદ્ધતિઓ છે જેનો તમે ઉપયોગ કરી શકો છો:
- સરખામણી કરો(): બે વસ્તુઓની સરખામણી કરો
String
અને માં તરીકે સરખામણી મૂલ્ય પરત કરે છેstrcmp()
. - બરાબર (): તપાસે છે કે શું બે સ્ટ્રિંગ ઑબ્જેક્ટ બરાબર સમાન છે, સાચું કે ખોટું પરત કરે છે.
સામાન્ય સમસ્યાઓ અને તેને કેવી રીતે ઠીક કરવી
ઉપયોગ કરતી વખતે સૌથી સામાન્ય ભૂલોમાંની એક strcmp()
Arduino પર એ સુનિશ્ચિત કરતું નથી કે a સાથે શબ્દમાળાઓ યોગ્ય રીતે સમાપ્ત થાય છે \0
(નલ અક્ષર). જો શબ્દમાળા યોગ્ય રીતે સમાપ્ત ન થઈ હોય, તો ફંક્શન મેમરીમાં તમારી અપેક્ષા કરતાં વધુ સરખામણી કરવાનું ચાલુ રાખશે, જે અનપેક્ષિત ભૂલો અથવા અનિયમિત વર્તન તરફ દોરી શકે છે.
જો તમને શંકા હોય કે તમારી તાર યોગ્ય રીતે સમાપ્ત થઈ નથી, તો તમે ઉકેલોનો આશરો લઈ શકો છો જેમ કે memcmp()
, જે સ્ટ્રિંગને સીમાંકિત કરવા માટે નલ પર આધાર રાખતું નથી, અને તમને સરખામણી કરવા માટે ચોક્કસ સંખ્યાના બાઈટનો ઉલ્લેખ કરવાની મંજૂરી આપે છે.
બીજી સમસ્યા જે તમે અનુભવી શકો છો તે એ છે કે તમે સીરીયલ ઇનપુટ દ્વારા પ્રાપ્ત કરેલ શબ્દમાળાઓની સરખામણી કરો. કોઈપણ સરખામણી કરવાનો પ્રયાસ કરતા પહેલા તમારે હંમેશા સ્ટ્રીંગ્સને સાફ અને ફોર્મેટ કરવાની ખાતરી કરવી જોઈએ.
સંપૂર્ણ અમલીકરણનું ઉદાહરણ
આ ટૂલ્સ વાસ્તવિક પ્રોજેક્ટમાં કેવી રીતે કાર્ય કરે છે તે સમજાવવા માટે, અહીં એક ઉદાહરણ છે જે ફંક્શન સાથે સ્ટ્રિંગ સરખામણીને જોડે છે. Serial.println()
Arduino સીરીયલ મોનિટર પર પરિણામો પ્રદર્શિત કરવા માટે:
#include <string.h> void setup() { Serial.begin(9600); char str1[] = "Hola"; char str2[] = "Hola"; int result = strcmp(str1, str2); if (result == 0) { Serial.println("Las cadenas son iguales"); } else if (result > 0) { Serial.println("La primera cadena es mayor"); } else { Serial.println("La segunda cadena es mayor"); } } void loop() { }
આ કોડ બે શબ્દમાળાઓની તુલના કરે છે અને મોનિટર પર પરિણામો દર્શાવે છે. ના વ્યવહારિક ઉપયોગનું તે એક સારું ઉદાહરણ છે strcmp()
વાસ્તવિક Arduino એપ્લિકેશન્સમાં ટેક્સ્ટ સ્ટ્રીંગ્સને અસરકારક રીતે સરખાવવા માટે.
સરખામણી ઉપરાંત, તમે ના આઉટપુટનો ઉપયોગ કરી શકો છો strcmp()
શરતી માળખામાં જેમ કે if
જ્યારે શબ્દમાળાઓ મેળ ખાતી હોય કે ન હોય ત્યારે ચોક્કસ ક્રિયાઓ કરવા.
મર્યાદિત સંસાધનો સાથેના પ્રોજેક્ટ્સમાં ઑપ્ટિમાઇઝેશન
જેમ તમે પહેલાથી જ નોંધ્યું હશે, નો ઉપયોગ strcmp()
અને સમાન કાર્યો એ ખૂબ જ કાર્યક્ષમ વિકલ્પ છે જ્યારે અમારી પાસે મેમરી મર્યાદાઓ સાથેના પ્રોજેક્ટ્સ હોય છે, જે Arduino પ્રોજેક્ટ્સમાં એકદમ સામાન્ય છે. ઑબ્જેક્ટને બદલે અક્ષર એરેનો ઉપયોગ કરતી વખતે String
, અમે મેમરી વપરાશને ઑપ્ટિમાઇઝ કરીએ છીએ, જે ઓછી સ્ટોરેજ ક્ષમતાવાળા માઇક્રોકન્ટ્રોલર પર કામ કરતી વખતે જરૂરી છે.
છેલ્લે, એ હાઇલાઇટ કરવું અગત્યનું છે કે તમે સેન્સર, ઇન્ટરફેસ અથવા કોમ્યુનિકેશન મોડ્યુલ સાથે કામ કરો છો તેવા પ્રોજેક્ટ્સમાં, અમલીકરણમાં ભૂલો અથવા અનિચ્છનીય વર્તણૂકને ટાળવા માટે પ્રાપ્ત દરેક ડેટાને માન્ય કરવું આવશ્યક છે.
ઉપરોક્ત તમામ, strcmp()
તે ખૂબ જ સર્વતોમુખી સાધન છે જે બહુવિધ દૃશ્યોને અનુકૂલિત કરે છે, સરળથી વધુ જટિલ એપ્લિકેશનો જ્યાં તેને સંસાધનોને ઑપ્ટિમાઇઝ કરવા અને સાંકળની તુલનાના આધારે નિર્ણયો લેવા માટે જરૂરી છે.