В પ્રથમ ભાગ મેં શોખના ઈલેક્ટ્રોનિક્સ ઈજનેરોને કહેવાનો પ્રયાસ કર્યો કે જેઓ Arduino પેન્ટમાંથી ઉછર્યા છે તેઓએ કેવી રીતે અને શા માટે માઈક્રોકન્ટ્રોલર માટે ડેટાશીટ્સ અને અન્ય દસ્તાવેજો વાંચવા જોઈએ. ટેક્સ્ટ મોટો હોવાનું બહાર આવ્યું, તેથી મેં એક અલગ લેખમાં વ્યવહારુ ઉદાહરણો બતાવવાનું વચન આપ્યું. સારું, તે પોતાને દૂધ મશરૂમ કહે છે ...

આજે હું તમને બતાવીશ કે STM32 (Blue Pill) અને STM8 નિયંત્રકો પરના ઘણા પ્રોજેક્ટ્સ, કાર્યો માટે એકદમ સરળ, પરંતુ જરૂરી ઉકેલવા માટે ડેટાશીટ્સનો ઉપયોગ કેવી રીતે કરવો. બધા ડેમો પ્રોજેક્ટ્સ મારા મનપસંદ LED ને સમર્પિત છે, અમે તેમને મોટી માત્રામાં પ્રકાશિત કરીશું, જેના માટે અમારે તમામ પ્રકારના રસપ્રદ પેરિફેરલ્સનો ઉપયોગ કરવો પડશે.

ટેક્સ્ટ ફરીથી વિશાળ હોવાનું બહાર આવ્યું, તેથી અનુકૂળતા માટે હું સામગ્રી બનાવી રહ્યો છું:

STM32 બ્લુ પિલ: DM16 ડ્રાઇવર સાથે 634 LEDs
STM8: છ PWM પિન સેટ કરી રહ્યાં છે
STM8: ત્રણ પિન પર 8 RGB LED, વિક્ષેપ

અસ્વીકરણ: હું એન્જિનિયર નથી, હું ઈલેક્ટ્રોનિક્સમાં ઊંડું જ્ઞાન ધરાવતો હોવાનો ડોળ કરતો નથી, આ લેખ મારા જેવા એમેચ્યોર માટે બનાવાયેલ છે. વાસ્તવમાં, મેં મારી જાતને બે વર્ષ પહેલાં લક્ષ્ય પ્રેક્ષક તરીકે માન્યું હતું. જો કોઈએ મને કહ્યું હોત કે અજાણ્યા ચિપ પરની ડેટાશીટ્સ વાંચવામાં ડરામણી ન હતી, તો મેં ઇન્ટરનેટ પર કોડના કેટલાક ટુકડાઓ શોધવા અને કાતર અને એડહેસિવ ટેપ વડે ક્રૉચની શોધ કરવામાં ઘણો સમય વિતાવ્યો ન હોત.

આ લેખનો ફોકસ ડેટાશીટ્સ પર છે, પ્રોજેક્ટ્સ પર નહીં, તેથી કોડ ખૂબ સુઘડ અને ઘણી વાર ખેંચાયેલો ન હોઈ શકે. પ્રોજેક્ટ્સ પોતે ખૂબ જ સરળ છે, જોકે નવી ચિપ સાથે પ્રથમ પરિચય માટે યોગ્ય છે.

હું આશા રાખું છું કે મારો લેખ શોખમાં નિમજ્જનના સમાન તબક્કે કોઈને મદદ કરશે.

એસટીએમ 32

DM16 અને SPI સાથે 634 LEDs

બ્લુ પિલ (STM32F103C8T6) અને DM634 LED ડ્રાઇવરનો ઉપયોગ કરીને એક નાનો પ્રોજેક્ટ. ડેટાશીટ્સનો ઉપયોગ કરીને, અમે ડ્રાઇવર, STM IO પોર્ટ્સ શોધીશું અને SPI ને ગોઠવીશું.

DM634

16 16-બીટ PWM આઉટપુટ સાથે તાઇવાનની ચિપ, સાંકળોમાં જોડી શકાય છે. લો-એન્ડ 12-બીટ મોડલ ઘરેલું પ્રોજેક્ટમાંથી જાણીતું છે લાઇટપેક. એક સમયે, DM63x અને જાણીતા TLC5940 વચ્ચે પસંદગી કરતી વખતે, મેં ઘણા કારણોસર DM પસંદ કર્યું: 1) Aliexpress પર TLC ચોક્કસપણે નકલી છે, પરંતુ આ એક નથી; 2) ડીએમ પાસે તેના પોતાના ફ્રીક્વન્સી જનરેટર સાથે સ્વાયત્ત PWM છે; 3) અલી તરફથી પાર્સલની રાહ જોવાને બદલે તે મોસ્કોમાં સસ્તી રીતે ખરીદી શકાય છે. અને, અલબત્ત, તૈયાર પુસ્તકાલયનો ઉપયોગ કરવાને બદલે, ચિપને જાતે કેવી રીતે નિયંત્રિત કરવી તે શીખવું રસપ્રદ હતું. ચિપ્સ હવે મુખ્યત્વે SSOP24 પેકેજમાં રજૂ કરવામાં આવે છે; તેઓ એડેપ્ટર પર સોલ્ડર કરવા માટે સરળ છે.

ઉત્પાદક તાઇવાન હોવાથી, ડેટાશીટ ચિપ ચીની અંગ્રેજીમાં લખેલી છે, જેનો અર્થ છે કે તે મજા આવશે. પહેલા આપણે પિનઆઉટ જોઈએ છીએ (પિન કનેક્શન) કયા પગને શું જોડવું તે સમજવા માટે અને પિનનું વર્ણન (પિન વર્ણન). 16 પિન:

ડીસી સિંક સ્ત્રોતો (ઓપન ડ્રેઇન)

સિંક / ઓપન-ડ્રેન આઉટપુટ - ડ્રેઇન; વહેતા પ્રવાહનો સ્ત્રોત; આઉટપુટ સક્રિય સ્થિતિમાં જમીન સાથે જોડાયેલ છે - એલઇડી ડ્રાઇવર સાથે કેથોડ્સ દ્વારા જોડાયેલ છે. ઇલેક્ટ્રિકલી, આ, અલબત્ત, "ઓપન ડ્રેઇન" નથી (ખુલ્લી ગટર), પરંતુ ડેટાશીટ્સમાં ડ્રેઇન મોડમાં પિન માટે આ હોદ્દો ઘણીવાર જોવા મળે છે.

આઉટપુટ વર્તમાન મૂલ્ય સેટ કરવા માટે REXT અને GND વચ્ચેના બાહ્ય પ્રતિરોધકો

REXT પિન અને ગ્રાઉન્ડ વચ્ચે રેફરન્સ રેઝિસ્ટર ઇન્સ્ટોલ કરેલું છે, જે આઉટપુટના આંતરિક પ્રતિકારને નિયંત્રિત કરે છે, ડેટાશીટના પૃષ્ઠ 9 પરનો ગ્રાફ જુઓ. DM634 માં, આ પ્રતિકારને સોફ્ટવેર દ્વારા પણ નિયંત્રિત કરી શકાય છે, એકંદર તેજ (વૈશ્વિક તેજ); હું આ લેખમાં વિગતોમાં જઈશ નહીં, હું અહીં ફક્ત 2.2 - 3 kOhm રેઝિસ્ટર મૂકીશ.

ચિપને કેવી રીતે નિયંત્રિત કરવી તે સમજવા માટે, ચાલો ઉપકરણ ઇન્ટરફેસનું વર્ણન જોઈએ:

હા, અહીં તે છે, ચાઇનીઝ અંગ્રેજી તેની તમામ કીર્તિમાં. આનું ભાષાંતર કરવું સમસ્યારૂપ છે, જો તમે ઈચ્છો તો તમે તેને સમજી શકો છો, પરંતુ બીજી રીત છે - કાર્યાત્મક રીતે સમાન TLC5940 સાથે જોડાણ કેવી રીતે ડેટાશીટમાં વર્ણવેલ છે તે જુઓ:

... ઉપકરણમાં ડેટા દાખલ કરવા માટે માત્ર ત્રણ પિન જરૂરી છે. SCLK સિગ્નલની વધતી ધાર SIN પિનમાંથી ડેટાને આંતરિક રજિસ્ટરમાં શિફ્ટ કરે છે. તમામ ડેટા લોડ થઈ ગયા પછી, ટૂંકા ઉચ્ચ XLAT સિગ્નલ આંતરિક રજિસ્ટરમાં ક્રમિક રીતે સ્થાનાંતરિત ડેટાને લૅચ કરે છે. આંતરિક રજિસ્ટર એ XLAT સિગ્નલ સ્તર દ્વારા ટ્રિગર થયેલા દરવાજા છે. બધા ડેટા સૌથી મહત્વપૂર્ણ બીટ પ્રથમ પ્રસારિત થાય છે.

લોંચ - લેચ/લેચ/લોક.
વધતી ધાર - પલ્સની અગ્રણી ધાર
MSB પ્રથમ - સૌથી નોંધપાત્ર (ડાબેથી) બીટ આગળ.
ડેટા ઘડિયાળ માટે - ક્રમશઃ ડેટા ટ્રાન્સમિટ કરો (બીટ બાય બીટ).

શબ્દ કળણ ઘણીવાર ચિપ્સ માટેના દસ્તાવેજોમાં જોવા મળે છે અને તેનું વિવિધ રીતે ભાષાંતર કરવામાં આવે છે, તેથી સમજણ ખાતર હું મારી જાતને મંજૂરી આપીશ

એક નાનો શૈક્ષણિક કાર્યક્રમLED ડ્રાઇવર એ અનિવાર્યપણે એક શિફ્ટ રજીસ્ટર છે. "શિફ્ટ" (પાળી) નામમાં - ઉપકરણની અંદર ડેટાની બીટવાઇઝ હિલચાલ: અંદર ખસેડવામાં આવેલ દરેક નવો બીટ તેની સામે સમગ્ર સાંકળને આગળ ધકેલે છે. કોઈ પણ વ્યક્તિ શિફ્ટ દરમિયાન એલઈડીના અસ્તવ્યસ્ત ઝબકવાનું અવલોકન કરવા માંગતું નથી, તેથી પ્રક્રિયા બફર રજિસ્ટરમાં થાય છે જે ડેમ્પર દ્વારા કાર્યકારી રજિસ્ટરથી અલગ પડે છે (કળણ) એ એક પ્રકારનો વેઇટિંગ રૂમ છે જ્યાં બિટ્સને ઇચ્છિત ક્રમમાં ગોઠવવામાં આવે છે. જ્યારે બધું તૈયાર હોય, ત્યારે શટર ખુલે છે અને બિટ્સ કામ પર જાય છે, પાછલા બેચને બદલીને. શબ્દ કળણ માઇક્રોકિરકિટ્સ માટેના દસ્તાવેજોમાં લગભગ હંમેશા આવા ડેમ્પર સૂચવે છે, પછી ભલે તે કયા સંયોજનોમાં વપરાય છે.

તેથી, DM634 પર ડેટા ટ્રાન્સફર આ રીતે કરવામાં આવે છે: DAI ઇનપુટને દૂરના એલઇડીના સૌથી નોંધપાત્ર બીટના મૂલ્ય પર સેટ કરો, DCK ને ઉપર અને નીચે ખેંચો; DAI ઇનપુટને આગલા બીટના મૂલ્ય પર સેટ કરો, DCK ખેંચો; અને તેથી જ્યાં સુધી તમામ બિટ્સ ટ્રાન્સમિટ ન થાય ત્યાં સુધી (ઘડિયાળમાં), જે પછી આપણે LAT ખેંચીએ છીએ. આ જાતે કરી શકાય છે (બીટ-બેંગ), પરંતુ આ માટે ખાસ તૈયાર કરેલ SPI ઇન્ટરફેસનો ઉપયોગ કરવો વધુ સારું છે, કારણ કે તે અમારા STM32 પર બે નકલોમાં પ્રસ્તુત છે.

બ્લુ પીલ STM32F103

પ્રારંભિક: STM32 નિયંત્રકો એટમેગા328 કરતાં વધુ જટિલ છે જે કદાચ ડરામણી લાગે છે. તદુપરાંત, ઊર્જા બચતના કારણોસર, લગભગ તમામ પેરિફેરલ્સ શરૂઆતમાં બંધ કરવામાં આવે છે, અને ઘડિયાળની આવર્તન આંતરિક સ્ત્રોતથી 8 મેગાહર્ટઝ છે. સદનસીબે, STM પ્રોગ્રામરોએ કોડ લખ્યો હતો જે ચિપને "ગણતરી કરેલ" 72 મેગાહર્ટઝ સુધી લાવે છે, અને હું જાણું છું તે તમામ IDE ના લેખકોએ તેને પ્રારંભિક પ્રક્રિયામાં સામેલ કર્યો છે, તેથી અમારે ઘડિયાળની જરૂર નથી (પરંતુ જો તમે ખરેખર ઇચ્છો તો તમે કરી શકો છો). પરંતુ તમારે પેરિફેરલ્સ ચાલુ કરવા પડશે.

દસ્તાવેજીકરણ: બ્લુ પિલ લોકપ્રિય STM32F103C8T6 ચિપથી સજ્જ છે, તેના માટે બે ઉપયોગી દસ્તાવેજો છે:

• ડેટા શીટ માઇક્રોકન્ટ્રોલર્સ STM32F103x8 અને STM32F103xB માટે;
• સંદર્ભ મેન્યુઅલ સમગ્ર STM32F103 લાઇન અને વધુ માટે.

ડેટાશીટમાં અમને રસ હોઈ શકે છે:

• પિનઆઉટ્સ - ચિપ પિનઆઉટ્સ - જો આપણે બોર્ડ જાતે બનાવવાનું નક્કી કરીએ;
• મેમરી મેપ - ચોક્કસ ચિપ માટે મેમરી મેપ. સંદર્ભ માર્ગદર્શિકામાં સમગ્ર લાઇન માટે નકશો છે, અને તે અમારી પાસે ન હોય તેવા રજિસ્ટરનો ઉલ્લેખ કરે છે.
• પિન વ્યાખ્યાઓ કોષ્ટક - પિનના મુખ્ય અને વૈકલ્પિક કાર્યોની સૂચિ; "વાદળી ગોળી" માટે તમે પિન અને તેમના કાર્યોની સૂચિ સાથે ઇન્ટરનેટ પર વધુ અનુકૂળ ચિત્રો શોધી શકો છો. તેથી, અમે તરત જ બ્લુ પિલ પિનઆઉટ ગૂગલ કરીએ છીએ અને આ ચિત્રને હાથમાં રાખીએ છીએ:

નોંધ: ઇન્ટરનેટ પરથી ચિત્રમાં એક ભૂલ હતી, જે ટિપ્પણીઓમાં નોંધવામાં આવી હતી, તેના માટે આભાર. ચિત્ર બદલવામાં આવ્યું છે, પરંતુ આ એક પાઠ છે - ડેટાશીટમાંથી નહીં પણ માહિતી તપાસવી વધુ સારું છે.

અમે ડેટાશીટ દૂર કરીએ છીએ, સંદર્ભ માર્ગદર્શિકા ખોલીએ છીએ, અને હવેથી અમે ફક્ત તેનો ઉપયોગ કરીએ છીએ.
પ્રક્રિયા: અમે પ્રમાણભૂત ઇનપુટ/આઉટપુટ સાથે વ્યવહાર કરીએ છીએ, SPI ગોઠવીએ છીએ, જરૂરી પેરિફેરલ્સ ચાલુ કરીએ છીએ.

ઇનપુટ આઉટપુટ

Atmega328 પર, I/O ને અત્યંત સરળ રીતે લાગુ કરવામાં આવે છે, તેથી જ STM32 વિકલ્પોની વિપુલતા મૂંઝવણમાં મૂકે છે. હવે આપણને ફક્ત નિષ્કર્ષની જરૂર છે, પરંતુ તેમાં પણ ચાર વિકલ્પો છે:

ઓપન ડ્રેઇન, પુશ-પુલ, વૈકલ્પિક પુશ-પુલ, વૈકલ્પિક ઓપન ડ્રેઇન

"પુલ-પુશ" (પુશ-પુલ) એ Arduino નું સામાન્ય આઉટપુટ છે, પિન ઉંચી અથવા નીચી કિંમત લઈ શકે છે. પરંતુ "ઓપન ડ્રેઇન" સાથે ત્યાં છે મુશ્કેલીઓ, જો કે હકીકતમાં અહીં બધું સરળ છે:

આઉટપુટ રૂપરેખાંકન / જ્યારે પોર્ટને આઉટપુટ સોંપવામાં આવે છે: / આઉટપુટ બફર સક્ષમ: / – ઓપન ડ્રેઇન મોડ: આઉટપુટ રજિસ્ટરમાં "0" N-MOSને સક્ષમ કરે છે, આઉટપુટ રજિસ્ટરમાં "1" પોર્ટને Hi-Z મોડમાં છોડી દે છે ( P-MOS સક્રિય થયેલ નથી ) / – પુશ-પુલ મોડ: આઉટપુટ રજિસ્ટરમાં “0” N-MOS ને સક્રિય કરે છે, આઉટપુટ રજિસ્ટરમાં “1” P-MOS ને સક્રિય કરે છે.

ખુલ્લા ગટર વચ્ચેનો તમામ તફાવત (ખુલ્લી ગટર) "પુશ-પુલ" માંથી (પુશ-પુલ) એ છે કે પ્રથમ પિનમાં ઉચ્ચ સ્થિતિ સ્વીકારી શકાતી નથી: જ્યારે આઉટપુટ રજિસ્ટરમાં એક લખવામાં આવે છે, ત્યારે તે ઉચ્ચ પ્રતિકાર મોડમાં જાય છે (ઉચ્ચ અવબાધ, હાય-ઝેડ). શૂન્ય લખતી વખતે, પીન તાર્કિક અને વિદ્યુત બંને સ્થિતિઓમાં સમાન વર્તે છે.

સામાન્ય આઉટપુટ મોડમાં, પિન ફક્ત આઉટપુટ રજિસ્ટરની સામગ્રીઓનું પ્રસારણ કરે છે. "વૈકલ્પિક" માં તે અનુરૂપ પેરિફેરલ્સ દ્વારા નિયંત્રિત થાય છે (જુઓ 9.1.4):

જો પોર્ટ બીટ વૈકલ્પિક કાર્ય પિન તરીકે ગોઠવેલ હોય, તો પિન રજિસ્ટર અક્ષમ થાય છે અને પિન પેરિફેરલ પિન સાથે જોડાયેલ હોય છે.

દરેક પિનની વૈકલ્પિક કાર્યક્ષમતા વર્ણવેલ છે પિન વ્યાખ્યાઓ ડેટાશીટ ડાઉનલોડ કરેલી ઈમેજ પર છે. જો પિનમાં અનેક વૈકલ્પિક કાર્યો હોય તો શું કરવું તે પ્રશ્નનો જવાબ ડેટાશીટમાં ફૂટનોટ દ્વારા આપવામાં આવે છે:

જો બહુવિધ પેરિફેરલ એક જ પિનનો ઉપયોગ કરે છે, તો વૈકલ્પિક કાર્યો વચ્ચેના સંઘર્ષને ટાળવા માટે, એક સમયે માત્ર એક પેરિફેરલનો ઉપયોગ થવો જોઈએ, પેરિફેરલ ક્લોક એનેબલ બીટ (યોગ્ય RCC રજિસ્ટરમાં)નો ઉપયોગ કરીને ટૉગલ કરીને.

છેલ્લે, આઉટપુટ મોડમાં પિનની પણ ઘડિયાળની ઝડપ હોય છે. આ બીજી ઊર્જા બચત સુવિધા છે; અમારા કિસ્સામાં, અમે તેને મહત્તમ પર સેટ કરીએ છીએ અને તેને ભૂલી જઈએ છીએ.

તેથી: અમે SPI નો ઉપયોગ કરી રહ્યા છીએ, જેનો અર્થ છે કે બે પિન (ડેટા સાથે અને ઘડિયાળ સિગ્નલ સાથે) "વૈકલ્પિક પુશ-પુલ ફંક્શન" હોવી જોઈએ, અને બીજી એક (LAT) "રેગ્યુલર પુશ-પુલ" હોવી જોઈએ. પરંતુ તેમને સોંપતા પહેલા, ચાલો SPI સાથે વ્યવહાર કરીએ.

SPI

બીજો નાનો શૈક્ષણિક કાર્યક્રમ

SPI અથવા સીરીયલ પેરીફેરલ ઈન્ટરફેસ (સીરીયલ પેરીફેરલ ઈન્ટરફેસ) એક MK ને અન્ય MK અને સામાન્ય રીતે બહારની દુનિયા સાથે જોડવા માટે એક સરળ અને ખૂબ જ અસરકારક ઈન્ટરફેસ છે. તેના ઓપરેશનના સિદ્ધાંત ઉપર પહેલેથી જ વર્ણવવામાં આવ્યું છે, જ્યાં ચાઇનીઝ એલઇડી ડ્રાઇવર વિશે (સંદર્ભ માર્ગદર્શિકામાં, વિભાગ 25 જુઓ). SPI માસ્ટર (“માસ્ટર”) અને સ્લેવ (“સ્લેવ”) મોડમાં કામ કરી શકે છે. SPI પાસે ચાર મૂળભૂત ચેનલો છે, જેમાંથી તમામનો ઉપયોગ કરી શકાતો નથી:

• MOSI, માસ્ટર આઉટપુટ / સ્લેવ ઇનપુટ: આ પિન માસ્ટર મોડમાં ડેટા ટ્રાન્સમિટ કરે છે, અને સ્લેવ મોડમાં ડેટા મેળવે છે;
• MISO, માસ્ટર ઇનપુટ / સ્લેવ આઉટપુટ: તેનાથી વિપરીત, તે માસ્ટરમાં મેળવે છે, અને સ્લેવમાં પ્રસારિત થાય છે;
• SCK, સીરીયલ ઘડિયાળ: માસ્ટરમાં ડેટા ટ્રાન્સમિશનની આવર્તન સેટ કરે છે અથવા સ્લેવમાં ઘડિયાળ સિગ્નલ મેળવે છે. અનિવાર્યપણે ધબકારા મારવા;
• એસએસ, સ્લેવ સિલેક્ટ: આ ચેનલની મદદથી, ગુલામ જાણે છે કે તેની પાસેથી કંઈક જોઈએ છે. STM32 પર તેને NSS કહેવામાં આવે છે, જ્યાં N = નેગેટિવ, એટલે કે. જો આ ચેનલમાં જમીન હોય તો નિયંત્રક ગુલામ બની જાય છે. તે ઓપન ડ્રેઇન આઉટપુટ મોડ સાથે સારી રીતે જોડાયેલું છે, પરંતુ તે બીજી વાર્તા છે.

બીજા બધાની જેમ, STM32 પર SPI કાર્યક્ષમતામાં સમૃદ્ધ છે, જે તેને સમજવામાં કંઈક અંશે મુશ્કેલ બનાવે છે. ઉદાહરણ તરીકે, તે ફક્ત SPI સાથે જ નહીં, પણ I2S ઇન્ટરફેસ સાથે પણ કામ કરી શકે છે, અને દસ્તાવેજીકરણમાં તેમના વર્ણનો મિશ્રિત છે, સમયસર રીતે વધારાનું કાપવું જરૂરી છે. અમારું કાર્ય અત્યંત સરળ છે: અમારે ફક્ત MOSI અને SCK નો ઉપયોગ કરીને ડેટા મોકલવાની જરૂર છે. અમે વિભાગ 25.3.4 (અર્ધ-ડુપ્લેક્સ કમ્યુનિકેશન, હાફ-ડુપ્લેક્સ કમ્યુનિકેશન) પર જઈએ છીએ, જ્યાં અમને મળે છે 1 ઘડિયાળ અને 1 દિશાહીન ડેટા વાયર (1 ઘડિયાળ સંકેત અને 1 દિશાહીન ડેટા સ્ટ્રીમ):

આ મોડમાં, એપ્લિકેશન કાં તો ટ્રાન્સમિટ-ઓન્લી અથવા રિસીવ-ઓન્લી મોડમાં SPI નો ઉપયોગ કરે છે. / ટ્રાન્સમિટ-ઓન્લી મોડ એ ડુપ્લેક્સ મોડ જેવો જ છે: ડેટા ટ્રાન્સમિટ પિન પર ટ્રાન્સમિટ થાય છે (માસ્ટર મોડમાં MOSI અથવા સ્લેવ મોડમાં MISO), અને રિસીવ પિન (અનુક્રમે MISO અથવા MOSI) નો ઉપયોગ નિયમિત I/O પિન તરીકે થઈ શકે છે. . આ કિસ્સામાં, એપ્લિકેશનને ફક્ત Rx બફરને અવગણવાની જરૂર છે (જો તે વાંચવામાં આવે, તો ત્યાં કોઈ સ્થાનાંતરિત ડેટા હશે નહીં).

સરસ, MISO પિન મફત છે, ચાલો LAT સિગ્નલને તેની સાથે જોડીએ. ચાલો સ્લેવ સિલેક્ટ જોઈએ, જે STM32 પર પ્રોગ્રામેટિકલી નિયંત્રિત કરી શકાય છે, જે અત્યંત અનુકૂળ છે. અમે વિભાગ 25.3.1 SPI સામાન્ય વર્ણનમાં સમાન નામનો ફકરો વાંચીએ છીએ:

સોફ્ટવેર નિયંત્રણ NSS (SSM = 1) / સ્લેવ પસંદગી માહિતી SPI_CR1 રજિસ્ટરના SSI બીટમાં સમાયેલ છે. બાહ્ય NSS પિન અન્ય એપ્લિકેશન જરૂરિયાતો માટે મફત રહે છે.

રજિસ્ટર પર લખવાનો સમય છે. મેં SPI2 નો ઉપયોગ કરવાનું નક્કી કર્યું, ડેટાશીટમાં તેનું આધાર સરનામું જુઓ - વિભાગ 3.3 મેમરી મેપમાં:

સારું, ચાલો શરૂ કરીએ:

#define _SPI2_(mem_offset) (*(volatile uint32_t *)(0x40003800 + (mem_offset)))

વિભાગ 25.3.3 ખોલો સ્વ-સ્પષ્ટીકરણ શીર્ષક સાથે "માસ્ટર મોડમાં SPI ની ગોઠવણી":

1. SPI_CR2 રજિસ્ટરમાં બીટ્સ BR[0:1] સાથે સીરીયલ ક્લોક ફ્રીક્વન્સી સેટ કરો.

રજિસ્ટર એ જ નામના સંદર્ભ મેન્યુઅલ વિભાગમાં એકત્રિત કરવામાં આવે છે. સરનામું શિફ્ટ (સરનામું ઑફસેટ) CR1 - 0x00 માટે, ડિફૉલ્ટ રૂપે તમામ બિટ્સ સાફ કરવામાં આવે છે (મૂલ્ય રીસેટ કરો 0x0000):

BR બિટ્સ નિયંત્રક ઘડિયાળ વિભાજકને સેટ કરે છે, આમ SPI કઈ આવર્તન પર કાર્ય કરશે તે નક્કી કરે છે. અમારી STM32 ફ્રિકવન્સી 72 MHz હશે, LED ડ્રાઇવર, તેની ડેટાશીટ મુજબ, 25 MHz સુધીની આવર્તન સાથે કાર્ય કરે છે, તેથી આપણે ચાર (BR[2:0] = 001) દ્વારા વિભાજીત કરવાની જરૂર છે.

#define _SPI_CR1 0x00

#define BR_0        0x0008
#define BR_1        0x0010
#define BR_2        0x0020

_SPI2_ (_SPI_CR1) |= BR_0;// pclk/4

2. ડેટા ટ્રાન્સફર અને સીરીયલ ઘડિયાળના સમય વચ્ચેના સંબંધને વ્યાખ્યાયિત કરવા માટે CPOL અને CPHA બિટ્સ સેટ કરો (પૃષ્ઠ 240 પર ડાયાગ્રામ જુઓ)

અમે અહીં ડેટાશીટ વાંચી રહ્યા હોવાથી અને સ્કીમેટિક્સને જોઈ રહ્યા નથી, ચાલો પૃષ્ઠ 704 (SPI સામાન્ય વર્ણન) પરના CPOL અને CPHA બિટ્સના ટેક્સ્ટ વર્ણન પર નજીકથી નજર કરીએ:

ઘડિયાળનો તબક્કો અને ધ્રુવીયતા
SPI_CR1 રજિસ્ટરના CPOL અને CPHA બિટ્સનો ઉપયોગ કરીને, તમે પ્રોગ્રામેટિકલી ચાર ટાઇમિંગ સંબંધો પસંદ કરી શકો છો. CPOL (ક્લોક પોલેરિટી) બીટ ઘડિયાળના સિગ્નલની સ્થિતિને નિયંત્રિત કરે છે જ્યારે કોઈ ડેટા ટ્રાન્સમિટ થતો નથી. આ બીટ માસ્ટર અને સ્લેવ મોડને નિયંત્રિત કરે છે. જો CPOL રીસેટ કરેલ હોય, તો SCK પિન રેસ્ટ મોડમાં ઓછી છે. જો CPOL બીટ સેટ કરેલ હોય, તો આરામ મોડ દરમિયાન SCK પિન ઊંચી હોય છે.
જ્યારે CPHA (ક્લોક ફેઝ) બીટ સેટ કરવામાં આવે છે, ત્યારે હાઈ બીટ ટ્રેપ સ્ટ્રોબ એ SCK સિગ્નલનો બીજો કિનારો છે (જો CPOL સ્પષ્ટ હોય તો ઘટે છે, જો CPOL સેટ હોય તો વધી જાય છે). ઘડિયાળના સિગ્નલમાં બીજા ફેરફાર દ્વારા ડેટા કેપ્ચર થાય છે. જો CPHA બીટ સ્પષ્ટ હોય, તો હાઈ બીટ ટ્રેપ સ્ટ્રોબ એ SCK સિગ્નલની વધતી ધાર છે (જો CPOL સેટ હોય તો ફોલિંગ એજ, જો CPOL સાફ હોય તો વધતી ધાર). ઘડિયાળના સંકેતમાં પ્રથમ ફેરફાર પર ડેટા કેપ્ચર થાય છે.

આ જ્ઞાનને ગ્રહણ કર્યા પછી, અમે નિષ્કર્ષ પર આવીએ છીએ કે બંને બિટ્સ શૂન્ય રહેવા જોઈએ, કારણ કે અમે ઇચ્છીએ છીએ કે SCK સિગ્નલ ઉપયોગમાં ન હોય ત્યારે નીચું રહે અને ડેટા પલ્સની વધતી ધાર પર પ્રસારિત થાય (ફિગ જુઓ. રાઇઝિંગ એજ DM634 ડેટાશીટમાં).

માર્ગ દ્વારા, અહીં આપણે સૌપ્રથમ ST ડેટાશીટ્સમાં શબ્દભંડોળની વિશેષતાનો સામનો કરવો પડ્યો: તેમાં "બીટને શૂન્ય પર ફરીથી સેટ કરો" વાક્ય લખાયેલું છે. થોડી રીસેટ કરવા માટે, અને નહીં થોડું સાફ કરવું, જેમ કે, ઉદાહરણ તરીકે, Atmega.

3. ડેટા બ્લોક 8-બીટ છે કે 16-બીટ ફોર્મેટ છે તે નક્કી કરવા માટે DFF બીટ સેટ કરો

મેં ખાસ કરીને 16-બીટ DM634 લીધું જેથી DM12 જેવા 633-બીટ PWM ડેટા ટ્રાન્સમિટ કરવામાં તકલીફ ન પડે. DFF ને એક પર સેટ કરવું અર્થપૂર્ણ છે:

#define DFF         0x0800

_SPI2_ (_SPI_CR1) |= DFF; // 16-bit mode

4. બ્લોક ફોર્મેટ નક્કી કરવા માટે SPI_CR1 રજિસ્ટરમાં LSBFIRST બીટને ગોઠવો

LSBFIRST, તેનું નામ સૂચવે છે તેમ, પ્રથમ ઓછામાં ઓછા નોંધપાત્ર બીટ સાથે ટ્રાન્સમિશનને ગોઠવે છે. પરંતુ DM634 સૌથી નોંધપાત્ર બીટથી શરૂ કરીને ડેટા પ્રાપ્ત કરવા માંગે છે. તેથી, અમે તેને ફરીથી સેટ કરીએ છીએ.

5. હાર્ડવેર મોડમાં, જો NSS પિનમાંથી ઇનપુટ જરૂરી હોય, તો સમગ્ર બાઈટ ટ્રાન્સફર સિક્વન્સ દરમિયાન NSS પિન પર ઉચ્ચ સિગ્નલ લાગુ કરો. NSS સોફ્ટવેર મોડમાં, SPI_CR1 રજિસ્ટરમાં SSM અને SSI બિટ્સ સેટ કરો. જો NSS પિનનો આઉટપુટ તરીકે ઉપયોગ કરવો હોય, તો માત્ર SSOE બીટ સેટ કરવાની જરૂર છે.

NSS હાર્ડવેર મોડ વિશે ભૂલી જવા માટે SSM અને SSI ઇન્સ્ટોલ કરો:

#define SSI         0x0100
#define SSM         0x0200

_SPI2_ (_SPI_CR1) |= SSM | SSI; //enable software control of SS, SS high

6. MSTR અને SPE બિટ્સ સેટ હોવા જ જોઈએ (જો NSS સિગ્નલ વધારે હોય તો જ તેઓ સેટ રહે છે)

ખરેખર, આ બિટ્સ સાથે અમે અમારા SPI ને માસ્ટર તરીકે નિયુક્ત કરીએ છીએ અને તેને ચાલુ કરીએ છીએ:

#define MSTR        0x0004
#define SPE         0x0040

_SPI2_ (_SPI_CR1) |= MSTR; //SPI master
//когда все готово, включаем SPI
_SPI2_ (_SPI_CR1) |= SPE;

SPI રૂપરેખાંકિત થયેલ છે, ચાલો તરત જ એવા કાર્યો લખીએ જે ડ્રાઇવરને બાઈટ મોકલે છે. 25.3.3 વાંચવાનું ચાલુ રાખો “માસ્ટર મોડમાં SPI ને ગોઠવી રહ્યું છે”:

ડેટા ટ્રાન્સફર ઓર્ડર
જ્યારે Tx બફર પર બાઈટ લખવામાં આવે ત્યારે ટ્રાન્સમિશન શરૂ થાય છે.
ડેટા બાઈટ પર શિફ્ટ રજીસ્ટરમાં લોડ થાય છે સમાંતર મોડ (આંતરિક બસમાંથી) પ્રથમ બીટના પ્રસારણ દરમિયાન, જેના પછી તે પ્રસારિત થાય છે ક્રમિક MOSI પિન મોડ, CPI_CR1 રજિસ્ટરમાં LSBFIRST બિટના સેટિંગના આધારે પ્રથમ અથવા છેલ્લો બીટ આગળ. ડેટા ટ્રાન્સમિશન પછી TXE ફ્લેગ સેટ કરવામાં આવે છે Tx બફરથી શિફ્ટ રજિસ્ટર સુધી, અને જો CPI_CR1 રજિસ્ટરમાં TXEIE બીટ સેટ કરેલ હોય તો વિક્ષેપ પણ જનરેટ કરે છે.

STM નિયંત્રકોમાં SPI અમલીકરણની એક વિશેષતા તરફ ધ્યાન દોરવા માટે મેં અનુવાદમાં થોડાક શબ્દો પ્રકાશિત કર્યા છે. એટમેગા પર TXE ધ્વજ (Tx ખાલી, Tx ખાલી છે અને ડેટા પ્રાપ્ત કરવા માટે તૈયાર છે) સંપૂર્ણ બાઈટ મોકલ્યા પછી જ સેટ કરવામાં આવે છે બાહ્ય. અને અહીં આ ધ્વજ આંતરિક શિફ્ટ રજિસ્ટરમાં બાઈટ દાખલ કર્યા પછી સેટ કરવામાં આવે છે. કારણ કે તે ત્યાં એક જ સમયે તમામ બિટ્સ સાથે દબાણ કરવામાં આવે છે (સમાંતરમાં), અને પછી ડેટા ક્રમિક રીતે સ્થાનાંતરિત થાય છે, બાઈટ સંપૂર્ણપણે મોકલવામાં આવે તે પહેલાં TXE સેટ કરવામાં આવે છે. આ મહત્વપૂર્ણ છે કારણ કે અમારા LED ડ્રાઇવરના કિસ્સામાં, અમને મોકલ્યા પછી LAT પિન ખેંચવાની જરૂર છે всех ડેટા, એટલે કે એકલા TXE ધ્વજ અમારા માટે પૂરતું નથી.

આનો અર્થ એ છે કે આપણને બીજા ધ્વજની જરૂર છે. ચાલો 25.3.7 - "સ્ટેટસ ફ્લેગ્સ" જોઈએ:

<…>

વ્યસ્ત ધ્વજ
BSY ધ્વજ હાર્ડવેર દ્વારા સેટ અને સાફ કરવામાં આવે છે (તેના પર લખવાની કોઈ અસર થતી નથી). BSY ધ્વજ SPI સંચાર સ્તરની સ્થિતિ દર્શાવે છે.
તે ફરીથી સેટ કરે છે:
જ્યારે ટ્રાન્સફર પૂર્ણ થાય છે (માસ્ટર મોડ સિવાય જો ટ્રાન્સફર સતત હોય તો)
જ્યારે SPI અક્ષમ હોય
જ્યારે માસ્ટર મોડમાં ભૂલ થાય છે (MODF=1)
જો ટ્રાન્સફર સતત ન હોય, તો દરેક ડેટા ટ્રાન્સફર વચ્ચે BSY ફ્લેગ સાફ કરવામાં આવે છે

ઠીક છે, આ કામમાં આવશે. ચાલો શોધી કાઢીએ કે Tx બફર ક્યાં સ્થિત છે. આ કરવા માટે, "SPI ડેટા રજીસ્ટર" વાંચો:

બિટ્સ 15:0 DR[15:0] ડેટા રજીસ્ટર
પ્રાપ્ત થયેલ ડેટા અથવા ડેટા ટ્રાન્સમિટ કરવાનો છે.
ડેટા રજિસ્ટરને બે બફરમાં વિભાજિત કરવામાં આવે છે - એક લખવા માટે (બફર ટ્રાન્સમિટ કરો) અને એક વાંચવા માટે (બફર પ્રાપ્ત કરો). ડેટા રજિસ્ટરમાં લખવું એ Tx બફરને લખે છે, અને ડેટા રજિસ્ટરમાંથી વાંચવાથી Rx બફરમાં સમાવિષ્ટ મૂલ્ય પરત થશે.

સારું, અને સ્ટેટસ રજિસ્ટર, જ્યાં TXE અને BSY ફ્લેગ જોવા મળે છે:

અમે લખીએ:

#define _SPI_DR  0x0C
#define _SPI_SR  0x08

#define BSY         0x0080
#define TXE         0x0002

void dm_shift16(uint16_t value)
{
    _SPI2_(_SPI_DR) = value; //send 2 bytes
    while (!(_SPI2_(_SPI_SR) & TXE)); //wait until they're sent
}

ઠીક છે, કારણ કે આપણે એલઇડી ડ્રાઇવર આઉટપુટની સંખ્યા અનુસાર 16 વખત બે બાઇટ્સ ટ્રાન્સમિટ કરવાની જરૂર છે, કંઈક આના જેવું:

void sendLEDdata()
{
    LAT_low();
    uint8_t k = 16;
    do
    {   k--;
        dm_shift16(leds[k]);
    } while (k);

    while (_SPI2_(_SPI_SR) & BSY); // finish transmission

    LAT_pulse();
}

પરંતુ અમને હજુ સુધી LAT પિન કેવી રીતે ખેંચી શકાય તે ખબર નથી, તેથી અમે I/O પર પાછા જઈશું.

પિન સોંપી રહ્યા છીએ

STM32F1 માં, પિનની સ્થિતિ માટે જવાબદાર રજિસ્ટર તદ્દન અસામાન્ય છે. તે સ્પષ્ટ છે કે તેમાં Atmega કરતાં વધુ છે, પરંતુ તે અન્ય STM ચિપ્સથી પણ અલગ છે. વિભાગ 9.1 GPIO નું સામાન્ય વર્ણન:

દરેક સામાન્ય હેતુના I/O પોર્ટ (GPIO) બે 32-બીટ રૂપરેખાંકન રજીસ્ટર (GPIOx_CRL અને GPIOx_CRH), બે 32-બીટ ડેટા રજીસ્ટર (GPIOx_IDR અને GPIOx_ODR), એક 32-બીટ સેટ/રીસેટ રજીસ્ટર (GPIOx_BSRR), 16-બીટ રીસેટ રજીસ્ટર (GPIOx_BSRR) અને GPIOx_32BR બીટ બ્લોકીંગ રજીસ્ટર (GPIOx_LCKR).

પ્રથમ બે રજિસ્ટર અસામાન્ય છે, અને તદ્દન અસુવિધાજનક પણ છે, કારણ કે 16 પોર્ટ પિન તેમની વચ્ચે “ભાઈ દીઠ ચાર બિટ્સ” ફોર્મેટમાં પથરાયેલા છે. તે. પિન શૂન્યથી સાત સીઆરએલમાં છે, અને બાકીના સીઆરએચમાં છે. તે જ સમયે, બાકીના રજિસ્ટરમાં પોર્ટના તમામ પિનના બિટ્સ સફળતાપૂર્વક સમાવિષ્ટ હોય છે - ઘણીવાર અડધા "આરક્ષિત" બાકી રહે છે.

સરળતા માટે, ચાલો સૂચિના અંતથી પ્રારંભ કરીએ.

અમને બ્લોકીંગ રજીસ્ટરની જરૂર નથી.

સેટ અને રીસેટ રજિસ્ટર ખૂબ જ રમુજી છે કારણ કે તેઓ આંશિક રીતે એકબીજાની નકલ કરે છે: તમે ફક્ત BSRR માં બધું જ લખી શકો છો, જ્યાં ઉચ્ચ 16 બિટ્સ પિનને શૂન્ય પર રીસેટ કરશે, અને નીચલા 1 પર સેટ કરવામાં આવશે, અથવા તમે પણ કરી શકો છો. BRR નો ઉપયોગ કરો, જેમાંથી નીચેના 16 બિટ્સ માત્ર પિન રીસેટ કરે છે. મને બીજો વિકલ્પ ગમે છે. આ રજિસ્ટર મહત્વપૂર્ણ છે કારણ કે તેઓ પિન પર અણુ ઍક્સેસ પ્રદાન કરે છે:

અણુ સેટ અથવા રીસેટ
બીટ લેવલ પર GPIOx_ODR પ્રોગ્રામિંગ કરતી વખતે વિક્ષેપોને નિષ્ક્રિય કરવાની કોઈ જરૂર નથી: એક અથવા વધુ બિટ્સ એક અણુ લખવાની ક્રિયા APB2 વડે બદલી શકાય છે. જે બીટ બદલવાની જરૂર છે તેના સેટ/રીસેટ રજીસ્ટર (GPIOx_BSRR અથવા, ફક્ત રીસેટ માટે, GPIOx_BRR) પર "1" લખીને આ પ્રાપ્ત થાય છે. અન્ય બિટ્સ યથાવત રહેશે.

ડેટા રજિસ્ટરમાં તદ્દન સ્વ-સ્પષ્ટિજનક નામો છે - IDR = ઇનપુટ દિશા રજીસ્ટર, ઇનપુટ રજીસ્ટર; ODR = આઉટપુટ દિશા રજીસ્ટર, આઉટપુટ રજીસ્ટર. વર્તમાન પ્રોજેક્ટમાં અમને તેમની જરૂર પડશે નહીં.

અને અંતે, નિયંત્રણ રજીસ્ટર. અમને બીજી SPI પિન એટલે કે PB13, PB14 અને PB15માં રસ હોવાથી, અમે તરત જ CRH પર ધ્યાન આપીએ છીએ:

અને આપણે જોઈએ છીએ કે આપણે 20 થી 31 ના બીટ્સમાં કંઈક લખવાની જરૂર પડશે.

પિનમાંથી આપણને શું જોઈએ છે તે ઉપર આપણે પહેલેથી જ શોધી કાઢ્યું છે, તેથી અહીં હું સ્ક્રીનશોટ વિના કરીશ, હું એટલું જ કહીશ કે MODE દિશા નિર્દિષ્ટ કરે છે (જો બંને બિટ્સ 0 પર સેટ હોય તો ઇનપુટ) અને પિન સ્પીડ (અમને 50MHzની જરૂર છે, એટલે કે. બંને પિન “1” પર), અને CNF મોડ સેટ કરે છે: નિયમિત “પુશ-પુલ” – 00, “વૈકલ્પિક” – 10. ડિફૉલ્ટ રૂપે, જેમ આપણે ઉપર જોઈએ છીએ, બધી પિનમાં નીચેથી ત્રીજો ભાગ હોય છે (CNF0), તે તેમને મોડ પર સેટ કરે છે ફ્લોટિંગ ઇનપુટ.

હું આ ચિપ સાથે બીજું કંઈક કરવાની યોજના ધરાવતો હોવાથી, સરળતા માટે મેં નીચલા અને ઉપલા નિયંત્રણ રજીસ્ટર બંને માટે તમામ સંભવિત MODE અને CNF મૂલ્યોને વ્યાખ્યાયિત કર્યા છે.

કોઈક આ રીતે

#define CNF0_0 0x00000004
#define CNF0_1 0x00000008
#define CNF1_0 0x00000040
#define CNF1_1 0x00000080
#define CNF2_0 0x00000400
#define CNF2_1 0x00000800
#define CNF3_0 0x00004000
#define CNF3_1 0x00008000
#define CNF4_0 0x00040000
#define CNF4_1 0x00080000
#define CNF5_0 0x00400000
#define CNF5_1 0x00800000
#define CNF6_0 0x04000000
#define CNF6_1 0x08000000
#define CNF7_0 0x40000000
#define CNF7_1 0x80000000
#define CNF8_0 0x00000004
#define CNF8_1 0x00000008
#define CNF9_0 0x00000040
#define CNF9_1 0x00000080
#define CNF10_0 0x00000400
#define CNF10_1 0x00000800
#define CNF11_0 0x00004000
#define CNF11_1 0x00008000
#define CNF12_0 0x00040000
#define CNF12_1 0x00080000
#define CNF13_0 0x00400000
#define CNF13_1 0x00800000
#define CNF14_0 0x04000000
#define CNF14_1 0x08000000
#define CNF15_0 0x40000000
#define CNF15_1 0x80000000

#define MODE0_0 0x00000001
#define MODE0_1 0x00000002
#define MODE1_0 0x00000010
#define MODE1_1 0x00000020
#define MODE2_0 0x00000100
#define MODE2_1 0x00000200
#define MODE3_0 0x00001000
#define MODE3_1 0x00002000
#define MODE4_0 0x00010000
#define MODE4_1 0x00020000
#define MODE5_0 0x00100000
#define MODE5_1 0x00200000
#define MODE6_0 0x01000000
#define MODE6_1 0x02000000
#define MODE7_0 0x10000000
#define MODE7_1 0x20000000
#define MODE8_0 0x00000001
#define MODE8_1 0x00000002
#define MODE9_0 0x00000010
#define MODE9_1 0x00000020
#define MODE10_0 0x00000100
#define MODE10_1 0x00000200
#define MODE11_0 0x00001000
#define MODE11_1 0x00002000
#define MODE12_0 0x00010000
#define MODE12_1 0x00020000
#define MODE13_0 0x00100000
#define MODE13_1 0x00200000
#define MODE14_0 0x01000000
#define MODE14_1 0x02000000
#define MODE15_0 0x10000000
#define MODE15_1 0x20000000

અમારી પિન પોર્ટ B (આધાર સરનામું - 0x40010C00), કોડ પર સ્થિત છે:

#define _PORTB_(mem_offset) (*(volatile uint32_t *)(0x40010C00 + (mem_offset)))

#define _BRR  0x14
#define _BSRR 0x10
#define _CRL  0x00
#define _CRH  0x04

//используем стандартный SPI2: MOSI на B15, CLK на B13
//LAT пусть будет на неиспользуемом MISO – B14

//очищаем дефолтный бит, он нам точно не нужен
_PORTB_ (_CRH) &= ~(CNF15_0 | CNF14_0 | CNF13_0 | CNF12_0);

//альтернативные функции для MOSI и SCK
_PORTB_ (_CRH) |= CNF15_1 | CNF13_1;

//50 МГц, MODE = 11
_PORTB_ (_CRH) |= MODE15_1 | MODE15_0 | MODE14_1 | MODE14_0 | MODE13_1 | MODE13_0;

અને, તે મુજબ, તમે LAT માટે વ્યાખ્યાઓ લખી શકો છો, જે BRR અને BSRR રજિસ્ટર દ્વારા ટ્વિચ કરવામાં આવશે:

/*** LAT pulse – high, then low */
#define LAT_pulse() _PORTB_(_BSRR) = (1<<14); _PORTB_(_BRR) = (1<<14)

#define LAT_low() _PORTB_(_BRR) = (1<<14)

(LAT_low માત્ર જડતા દ્વારા, તે હંમેશા એવું જ રહ્યું છે, તેને રહેવા દો)

હવે બધું સરસ છે, પરંતુ તે કામ કરતું નથી. કારણ કે આ STM32 છે, તે વીજળી બચાવે છે, જેનો અર્થ છે કે તમારે જરૂરી પેરિફેરલ્સની ઘડિયાળને સક્ષમ કરવાની જરૂર છે.

ઘડિયાળ ચાલુ કરો

ઘડિયાળ, જેને ઘડિયાળ તરીકે પણ ઓળખવામાં આવે છે, તે ઘડિયાળ માટે જવાબદાર છે. અને અમે પહેલાથી જ સંક્ષેપ RCC નોંધી શકીએ છીએ. અમે તેને દસ્તાવેજીકરણમાં શોધીએ છીએ: આ રીસેટ અને ઘડિયાળ નિયંત્રણ છે.

ઉપર કહ્યું તેમ, સદભાગ્યે, ઘડિયાળના વિષયનો સૌથી મુશ્કેલ ભાગ અમારા માટે STM ના લોકો દ્વારા કરવામાં આવ્યો હતો, જેના માટે અમે તેમનો ખૂબ આભાર માનીએ છીએ (ફરી એક વાર હું એક લિંક આપીશ ડી હોલ્ટની વેબસાઇટ, તે સ્પષ્ટ કરવા માટે કે તે કેટલું ગૂંચવણભર્યું છે). અમને ફક્ત પેરિફેરલ ક્લોકિંગ (પેરિફેરલ ક્લોક એનેબલ રજિસ્ટર) સક્ષમ કરવા માટે જવાબદાર રજિસ્ટર્સની જરૂર છે. પ્રથમ, ચાલો આરસીસીનું મૂળ સરનામું શોધીએ, તે "મેમરી મેપ" ની શરૂઆતમાં છે:

#define _RCC_(mem_offset) (*(volatile uint32_t *)(0x40021000 + (mem_offset)))

અને પછી ક્યાં તો તે લિંક પર ક્લિક કરો જ્યાં તમે પ્લેટમાં કંઈક શોધવાનો પ્રયાસ કરો છો, અથવા, વધુ સારું, તેના વિશેના વિભાગોમાંથી સક્ષમ રજિસ્ટરના વર્ણનો પર જાઓ. રજીસ્ટરો સક્ષમ કરો. જ્યાં અમને RCC_APB1ENR અને RCC_APB2ENR મળશે:

અને તેઓ, તે મુજબ, બીટ્સ ધરાવે છે જેમાં SPI2, IOPB (I/O પોર્ટ B) અને વૈકલ્પિક કાર્યો (AFIO) ના ક્લોકિંગનો સમાવેશ થાય છે.

#define _APB2ENR 0x18
#define _APB1ENR 0x1C

#define IOPBEN 0x0008
#define SPI2EN 0x4000
#define AFIOEN 0x0001

//включаем тактирование порта B и альт. функций
_RCC_(_APB2ENR) |= IOPBEN | AFIOEN;

//включаем  тактирование SPI2
_RCC_(_APB1ENR) |= SPI2EN;

અંતિમ કોડ શોધી શકાય છે અહીં.

જો તમારી પાસે પરીક્ષણ કરવાની તક અને ઇચ્છા હોય, તો પછી DM634 ને આ રીતે કનેક્ટ કરો: DAI થી PB15, DCK થી PB13, LAT થી PB14. અમે ડ્રાઇવરને 5 વોલ્ટથી પાવર કરીએ છીએ, ગ્રાઉન્ડ્સને કનેક્ટ કરવાનું ભૂલશો નહીં.

STM8 PWM

STM8 પર PWM

જ્યારે હું હમણાં જ આ લેખનું આયોજન કરી રહ્યો હતો, ત્યારે મેં, ઉદાહરણ તરીકે, ફક્ત ડેટાશીટનો ઉપયોગ કરીને અજાણ્યા ચિપની કેટલીક કાર્યક્ષમતાને માસ્ટર કરવાનો પ્રયાસ કરવાનું નક્કી કર્યું, જેથી હું બૂટ વગરના જૂતા સાથે સમાપ્ત ન થઈ શકું. STM8 આ ભૂમિકા માટે આદર્શ હતો: પ્રથમ, મારી પાસે STM8S103 સાથેના થોડા ચાઇનીઝ બોર્ડ હતા, અને બીજું, તે ખૂબ લોકપ્રિય નથી, અને તેથી ઇન્ટરનેટ પર વાંચવાની અને ઉકેલ શોધવાની લાલચ આ ખૂબ જ ઉકેલોના અભાવ પર આધારિત છે.

ચિપ પણ છે ડેટાશીટ и સંદર્ભ માર્ગદર્શિકા RM0016, પ્રથમમાં પિનઆઉટ અને રજીસ્ટર સરનામાં છે, બીજામાં - બીજું બધું. STM8 એ ભયંકર IDE માં C માં પ્રોગ્રામ કરેલ છે ST વિઝ્યુઅલ ડેવલપ.

ઘડિયાળ અને I/O

મૂળભૂત રીતે, STM8 2 MHz ની આવર્તન પર કાર્ય કરે છે, આને તરત જ સુધારવું આવશ્યક છે.

HSI (હાઈ સ્પીડ ઈન્ટરનલ) ઘડિયાળ
HSI ઘડિયાળ સિગ્નલ પ્રોગ્રામેબલ વિભાજક (16 થી 1) સાથે આંતરિક 8 MHz RC ઓસિલેટરમાંથી મેળવવામાં આવે છે. તે ઘડિયાળ વિભાજક રજીસ્ટર (CLK_CKDIVR) માં સેટ કરેલ છે.
નોંધ: શરૂઆતમાં, 8 ના વિભાજક સાથેનું HSI RC ઓસિલેટર ઘડિયાળ સિગ્નલના અગ્રણી સ્ત્રોત તરીકે પસંદ થયેલ છે.

અમને ડેટાશીટમાં રજિસ્ટર સરનામું, રેફમેનમાં વર્ણન મળે છે અને જુઓ કે રજિસ્ટરને સાફ કરવાની જરૂર છે:

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

આપણે PWM ચલાવવા જઈ રહ્યા છીએ અને LED ને કનેક્ટ કરીશું, ચાલો પિનઆઉટ જોઈએ:

ચિપ નાની છે, ઘણા કાર્યો સમાન પિન પર સસ્પેન્ડ કરવામાં આવે છે. ચોરસ કૌંસમાં જે છે તે "વૈકલ્પિક કાર્યક્ષમતા" છે, તે "વિકલ્પ બાઇટ્સ" દ્વારા સ્વિચ કરવામાં આવે છે (વિકલ્પ બાઇટ્સ) – એટમેગા ફ્યુઝ જેવું કંઈક. તમે તેમના મૂલ્યોને પ્રોગ્રામેટિકલી બદલી શકો છો, પરંતુ તે જરૂરી નથી, કારણ કે નવી કાર્યક્ષમતા રીબૂટ કર્યા પછી જ સક્રિય થાય છે. ST વિઝ્યુઅલ પ્રોગ્રામર (વિઝ્યુઅલ ડેવલપ સાથે ડાઉનલોડ કરેલ) નો ઉપયોગ કરવો વધુ સરળ છે, જે આ બાઇટ્સ બદલી શકે છે. પિનઆઉટ દર્શાવે છે કે પ્રથમ ટાઈમરના CH1 અને CH2 પિન ચોરસ કૌંસમાં છુપાયેલા છે; STVP માં AFR1 અને AFR0 બિટ્સ સેટ કરવા જરૂરી છે, અને બીજો પણ બીજા ટાઈમરના CH1 આઉટપુટને PD4 થી PC5 માં સ્થાનાંતરિત કરશે.

આમ, 6 પિન LED ને નિયંત્રિત કરશે: પ્રથમ ટાઈમર માટે PC6, PC7 અને PC3, બીજા માટે PC5, PD3 અને PA3.

STM8 પર I/O પિન જાતે સેટ કરવું STM32 કરતાં વધુ સરળ અને વધુ તાર્કિક છે:

• Atmega DDR ડેટા ડિરેક્શન રજિસ્ટરથી પરિચિત (ડેટા ડાયરેક્શન રજિસ્ટર): 1 = આઉટપુટ;
• પ્રથમ નિયંત્રણ રજીસ્ટર CR1, જ્યારે આઉટપુટ, પુશ-પુલ મોડ (1) અથવા ઓપન ડ્રેઇન (0) સેટ કરે છે; હું એલઇડીને કેથોડ્સ સાથે ચિપ સાથે કનેક્ટ કરું છું, તેથી હું અહીં શૂન્ય છોડું છું;
• બીજું કંટ્રોલ રજિસ્ટર CR2, જ્યારે આઉટપુટ, ઘડિયાળની ઝડપ સેટ કરે છે: 1 = 10 MHz

#define PA_DDR     *(volatile uint8_t *)0x005002
#define PA_CR2     *(volatile uint8_t *)0x005004
#define PD_DDR     *(volatile uint8_t *)0x005011
#define PD_CR2     *(volatile uint8_t *)0x005013
#define PC_DDR     *(volatile uint8_t *)0x00500C
#define PC_CR2     *(volatile uint8_t *)0x00500E

PA_DDR = (1<<3); //output
PA_CR2 |= (1<<3); //fast
PD_DDR = (1<<3); //output
PD_CR2 |= (1<<3); //fast
PC_DDR = ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //output
PC_CR2 |= ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //fast

PWM સેટિંગ

પ્રથમ, ચાલો શરતો વ્યાખ્યાયિત કરીએ:

• પીડબ્લ્યુએમ આવર્તન - આવર્તન જેની સાથે ટાઈમર ટિક કરે છે;
• સ્વતઃ-રીલોડ, AR - ઑટોલોડેબલ મૂલ્ય કે જેમાં ટાઈમર ગણતરી કરશે (પલ્સ અવધિ);
• અપડેટ ઇવેન્ટ, UEV - જ્યારે ટાઈમર એઆરમાં ગણાય ત્યારે બનેલી ઘટના;
• PWM ડ્યુટી સાયકલ - PWM ડ્યુટી સાયકલ, જેને ઘણીવાર "ડ્યુટી ફેક્ટર" કહેવાય છે;
• કેપ્ચર/મૂલ્ય સરખામણી કરો - કેપ્ચર/સરખામણી માટેનું મૂલ્ય, જેમાં ટાઈમરે ગણતરી કરી છે કંઈક કરશે (PWM ના કિસ્સામાં, તે આઉટપુટ સિગ્નલને ઉલટાવે છે);
• પ્રીલોડ મૂલ્ય - પ્રીલોડેડ મૂલ્ય. મૂલ્યની સરખામણી કરો જ્યારે ટાઈમર ટિક કરી રહ્યું હોય ત્યારે બદલી શકાતું નથી, અન્યથા PWM ચક્ર તૂટી જશે. તેથી, નવા પ્રસારિત મૂલ્યો બફરમાં મૂકવામાં આવે છે અને જ્યારે ટાઈમર તેના કાઉન્ટડાઉનના અંતે પહોંચે છે અને રીસેટ થાય છે ત્યારે તેને ખેંચી લેવામાં આવે છે;
• ધાર-સંરેખિત и મધ્ય-સંરેખિત મોડ્સ - સરહદ સાથે અને કેન્દ્રમાં ગોઠવણી, એટમેલની જેમ જ ફાસ્ટ પીડબ્લ્યુએમ и તબક્કો-સાચો PWM.
• OCiREF, આઉટપુટ સરખામણી સંદર્ભ સિગ્નલ - સંદર્ભ આઉટપુટ સિગ્નલ, હકીકતમાં, PWM મોડમાં અનુરૂપ પિન પર શું દેખાય છે.

પિનઆઉટ પરથી પહેલેથી જ સ્પષ્ટ છે તેમ, બે ટાઈમરમાં PWM ક્ષમતાઓ છે - પ્રથમ અને બીજું. બંને 16-બીટ છે, પ્રથમમાં ઘણી બધી વધારાની સુવિધાઓ છે (ખાસ કરીને, તે ઉપર અને નીચે બંનેની ગણતરી કરી શકે છે). અમારે બંનેને સમાન રીતે કામ કરવાની જરૂર છે, તેથી મેં દેખીતી રીતે ગરીબ બીજાથી પ્રારંભ કરવાનું નક્કી કર્યું, જેથી ત્યાં ન હોય તેવી વસ્તુનો આકસ્મિક ઉપયોગ ન થાય. કેટલીક સમસ્યા એ છે કે સંદર્ભ મેન્યુઅલમાં તમામ ટાઈમરની PWM કાર્યક્ષમતાનું વર્ણન પ્રથમ ટાઈમર (17.5.7 PWM મોડ) વિશેના પ્રકરણમાં છે, તેથી તમારે આખા દસ્તાવેજમાં હંમેશા આગળ-પાછળ જવું પડશે.

STM8 પર PWM નો Atmega પર PWM કરતાં મહત્વપૂર્ણ ફાયદો છે:

સીમા સંરેખિત PWM
એકાઉન્ટ કન્ફિગરેશન નીચેથી ઉપર સુધી
જો TIM_CR1 રજિસ્ટરમાં DIR બીટ સાફ કરવામાં આવે તો બોટમ-અપ કાઉન્ટિંગ સક્રિય છે
ઉદાહરણ:
ઉદાહરણ પ્રથમ PWM મોડનો ઉપયોગ કરે છે. PWM સંદર્ભ સંકેત OCiREF TIM1_CNT < TIM1_CCRi સુધી ઊંચું રાખવામાં આવે છે. નહિંતર તે નીચું સ્તર લે છે. જો TIM1_CCRi રજિસ્ટરમાં સરખામણી મૂલ્ય ઑટોલોડ મૂલ્ય (TIM1_ARR રજિસ્ટર) કરતાં વધુ હોય, તો OCiREF સિગ્નલ 1 પર રાખવામાં આવે છે. જો સરખામણી મૂલ્ય 0 હોય, તો OCiREF શૂન્ય પર રાખવામાં આવે છે....

દરમિયાન STM8 ટાઈમર અપડેટ ઇવેન્ટ પહેલા તપાસ કરે છે મૂલ્યની તુલના કરો, અને માત્ર ત્યારે જ સંદર્ભ સંકેત ઉત્પન્ન કરે છે. એટમેગાનું ટાઈમર પ્રથમ સ્ક્રૂ કરે છે અને પછી સરખામણી કરે છે, પરિણામે compare value == 0 આઉટપુટ એ સોય છે, જેની સાથે કોઈક રીતે વ્યવહાર થવો જોઈએ (ઉદાહરણ તરીકે, પ્રોગ્રામેટિકલી તર્કને ઉલટાવીને).

તો આપણે શું કરવા માંગીએ છીએ: 8-બીટ PWM (AR == 255), નીચેથી ઉપર સુધી ગણતરી, સરહદ સાથે સંરેખણ. લાઇટ બલ્બ કેથોડ્સ દ્વારા ચિપ સાથે જોડાયેલા હોવાથી, PWM એ ત્યાં સુધી આઉટપુટ 0 (LED ચાલુ) કરવું જોઈએ. મૂલ્યની તુલના કરો અને 1 પછી.

અમે પહેલાથી જ કેટલાક વિશે વાંચ્યું છે PWM મોડ, તેથી અમે આ શબ્દસમૂહ (18.6.8 - TIMx_CCMR1) માટે સંદર્ભ માર્ગદર્શિકામાં શોધ કરીને બીજા ટાઈમરનું જરૂરી રજિસ્ટર શોધીએ છીએ:

110: પ્રથમ PWM મોડ - જ્યારે નીચેથી ઉપર સુધી ગણતરી કરવામાં આવે છે, ત્યારે પ્રથમ ચેનલ સક્રિય હોય છે જ્યારે TIMx_CNT < TIMx_CCR1. નહિંતર, પ્રથમ ચેનલ નિષ્ક્રિય છે. [વધુમાં દસ્તાવેજમાં ટાઈમર 1 માંથી એક ભૂલભરેલી કોપી-પેસ્ટ છે] 111: બીજો PWM મોડ - જ્યારે નીચેથી ઉપર સુધી ગણતરી કરવામાં આવે છે, ત્યારે પ્રથમ ચેનલ નિષ્ક્રિય હોય છે જ્યારે TIMx_CNT < TIMx_CCR1. નહિંતર, પ્રથમ ચેનલ સક્રિય છે.

LEDs MK સાથે કેથોડ્સ દ્વારા જોડાયેલા હોવાથી, બીજો મોડ અમને અનુકૂળ આવે છે (પહેલો પણ, પરંતુ અમે હજુ સુધી તે જાણતા નથી).

બીટ 3 OC1PE: પિન 1 પ્રીલોડ સક્ષમ કરો
0: TIMx_CCR1 પર પ્રીલોડ રજિસ્ટર અક્ષમ છે. તમે કોઈપણ સમયે TIMx_CCR1 પર લખી શકો છો. નવું મૂલ્ય તરત જ કામ કરે છે.
1: TIMx_CCR1 પર પ્રીલોડ રજિસ્ટર સક્ષમ છે. પ્રીલોડ રજિસ્ટરને વાંચવા/લેખવાની કામગીરી ઍક્સેસ કરો. પ્રીલોડેડ મૂલ્ય TIMx_CCR1 દરેક અપડેટ ઇવેન્ટ દરમિયાન શેડો રજિસ્ટરમાં લોડ થાય છે.
*નોંધ: PWM મોડ યોગ્ય રીતે કાર્ય કરવા માટે, પ્રીલોડ રજિસ્ટર સક્ષમ હોવા આવશ્યક છે. સિંગલ સિગ્નલ મોડમાં આ જરૂરી નથી (OPM બીટ TIMx_CR1 રજિસ્ટરમાં સેટ કરેલ છે).

ઠીક છે, ચાલો બીજા ટાઈમરની ત્રણ ચેનલો માટે જરૂરી બધું ચાલુ કરીએ:

#define TIM2_CCMR1 *(volatile uint8_t *)0x005307
#define TIM2_CCMR2 *(volatile uint8_t *)0x005308
#define TIM2_CCMR3 *(volatile uint8_t *)0x005309

#define PWM_MODE2   0x70 //PWM mode 2, 0b01110000
#define OCxPE       0x08 //preload enable

TIM2_CCMR1 = (PWM_MODE2 | OCxPE);
TIM2_CCMR2 = (PWM_MODE2 | OCxPE);
TIM2_CCMR3 = (PWM_MODE2 | OCxPE);

AR બે આઠ-બીટ રજિસ્ટર ધરાવે છે, બધું સરળ છે:

#define TIM2_ARRH  *(volatile uint8_t *)0x00530F
#define TIM2_ARRL  *(volatile uint8_t *)0x005310

TIM2_ARRH = 0;
TIM2_ARRL = 255;

બીજું ટાઈમર ફક્ત નીચેથી ઉપર સુધી ગણતરી કરી શકે છે, સરહદ સાથે ગોઠવણી, કંઈપણ બદલવાની જરૂર નથી. ચાલો આવર્તન વિભાજક સેટ કરીએ, ઉદાહરણ તરીકે, 256. બીજા ટાઈમર માટે, વિભાજક TIM2_PSCR રજિસ્ટરમાં સેટ છે અને તેની શક્તિ બે છે:

#define TIM2_PSCR  *(volatile uint8_t *)0x00530E

TIM2_PSCR = 8;

જે બાકી છે તે તારણો અને બીજું ટાઈમર પોતે જ ચાલુ કરવાનું છે. પ્રથમ સમસ્યા રજીસ્ટર દ્વારા ઉકેલવામાં આવે છે કેપ્ચર/સરખામણી કરો સક્ષમ કરો: ત્યાં બે, ત્રણ ચેનલો અસમપ્રમાણ રીતે ફેલાયેલી છે. અહીં આપણે એ પણ શીખી શકીએ છીએ કે સિગ્નલની ધ્રુવીયતાને બદલવી શક્ય છે, એટલે કે. સૈદ્ધાંતિક રીતે, PWM મોડ 1 નો ઉપયોગ કરવો શક્ય હતું. અમે લખીએ છીએ:

#define TIM2_CCER1 *(volatile uint8_t *)0x00530A
#define TIM2_CCER2 *(volatile uint8_t *)0x00530B

#define CC1E  (1<<0) // CCER1
#define CC2E  (1<<4) // CCER1
#define CC3E  (1<<0) // CCER2

TIM2_CCER1 = (CC1E | CC2E);
TIM2_CCER2 = CC3E;

અને અંતે, અમે TIMx_CR1 રજિસ્ટરમાં ટાઈમર શરૂ કરીએ છીએ:

#define TIM2_CR1   *(volatile uint8_t *)0x005300

TIM2_CR1 |= 1;

ચાલો એનાલોગરાઈટ() નું એક સરળ એનાલોગ લખીએ, જે સરખામણી માટે વાસ્તવિક મૂલ્યોને ટાઈમરમાં સ્થાનાંતરિત કરશે. રજિસ્ટરમાં અનુમાન મુજબ નામ આપવામાં આવ્યું છે નોંધણીઓ કેપ્ચર/સરખાવો, દરેક ચેનલ માટે તેમાંના બે છે: TIM8_CCRxL માં લો-ઓર્ડર 2 બિટ્સ અને TIM2_CCRxH માં ઉચ્ચ-ઓર્ડરવાળા. અમે 8-બીટ PWM બનાવ્યું હોવાથી, તે ફક્ત ઓછામાં ઓછા નોંધપાત્ર બિટ્સ લખવા માટે પૂરતું છે:

#define TIM2_CCR1L *(volatile uint8_t *)0x005312
#define TIM2_CCR2L *(volatile uint8_t *)0x005314
#define TIM2_CCR3L *(volatile uint8_t *)0x005316

void setRGBled(uint8_t r, uint8_t g, uint8_t b)
{
    TIM2_CCR1L = r;
    TIM2_CCR2L = g;
    TIM2_CCR3L = b;
}

સચેત વાચક જોશે કે અમારી પાસે થોડી ખામીયુક્ત PWM છે, જે 100% ફિલ ઉત્પન્ન કરવામાં અસમર્થ છે (255 ના મહત્તમ મૂલ્ય પર, સિગ્નલ એક ટાઈમર ચક્ર માટે ઊંધુ છે). એલઇડી માટે આ કોઈ વાંધો નથી, અને સચેત રીડર પહેલેથી જ અનુમાન કરી શકે છે કે તેને કેવી રીતે ઠીક કરવું.

બીજા ટાઈમર પર PWM કામ કરે છે, ચાલો પહેલા તરફ આગળ વધીએ.

પ્રથમ ટાઈમર સમાન રજિસ્ટરમાં બરાબર સમાન બિટ્સ ધરાવે છે (તે માત્ર એટલું જ છે કે તે બિટ્સ જે બીજા ટાઈમરમાં "આરક્ષિત" રહી ગયા હતા તે તમામ પ્રકારની અદ્યતન વસ્તુઓ માટે પ્રથમમાં સક્રિયપણે ઉપયોગમાં લેવાય છે). તેથી, ડેટાશીટમાં સમાન રજિસ્ટર્સનાં સરનામાં શોધવા અને કોડની નકલ કરવા માટે તે પૂરતું છે. સારું, ફ્રીક્વન્સી વિભાજકનું મૂલ્ય બદલો, કારણ કે... પ્રથમ ટાઈમર બે પાવર નહીં, પરંતુ બે રજિસ્ટરમાં ચોક્કસ 16-બીટ મૂલ્ય પ્રાપ્ત કરવા માંગે છે Prescaler ઉચ્ચ и નીચા. અમે બધું કરીએ છીએ અને... પ્રથમ ટાઈમર કામ કરતું નથી. શું બાબત છે?

ટાઈમર 1 ના કંટ્રોલ રજિસ્ટર્સ વિશેના સમગ્ર વિભાગને જોઈને જ સમસ્યાનું નિરાકરણ લાવી શકાય છે, જ્યાં આપણે બીજા ટાઈમર પાસે ન હોય તેવા એકને શોધીએ છીએ. ત્યાં હશે 17.7.30 બ્રેક રજિસ્ટર (TIM1_BKR), જ્યાં આ બીટ છે:

મુખ્ય આઉટપુટ સક્ષમ કરો

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

તે હવે ખાતરી માટે છે, કોડ ત્યાં.

STM8 મલ્ટિપ્લેક્સ

STM8 પર મલ્ટિપ્લેક્સિંગ

ત્રીજો મિની-પ્રોજેક્ટ આઠ RGB LEDs ને PWM મોડમાં બીજા ટાઈમર સાથે જોડવાનો છે અને તેમને વિવિધ રંગો બતાવવાનો છે. તે એલઇડી મલ્ટિપ્લેક્સીંગની વિભાવના પર આધારિત છે, જે એ છે કે જો તમે એલઇડી ખૂબ જ ઝડપથી ચાલુ અને બંધ કરો છો, તો તે અમને લાગે છે કે તે સતત ચાલુ છે (દ્રષ્ટિની સાતત્ય, દ્રશ્ય દ્રષ્ટિની જડતા). મેં એકવાર કર્યું Arduino પર આવું કંઈક.

કાર્ય અલ્ગોરિધમ આના જેવો દેખાય છે:

• પ્રથમ આરજીબી એલઇડીના એનોડને કનેક્ટ કર્યું;
• તેને પ્રગટાવો, કેથોડ્સને જરૂરી સંકેતો મોકલીને;
• PWM ચક્રના અંત સુધી રાહ જોવી;
• બીજા આરજીબી એલઇડીના એનોડને કનેક્ટ કર્યું;
• તેને પ્રગટાવ્યો...

સારું, વગેરે. અલબત્ત, સુંદર કામગીરી માટે તે જરૂરી છે કે એનોડ જોડાયેલ હોય અને LED તે જ સમયે "સળગાવેલ" હોય. સારું, અથવા લગભગ. કોઈ પણ સંજોગોમાં, અમારે એક કોડ લખવાની જરૂર છે જે બીજા ટાઈમરની ત્રણ ચેનલોમાં મૂલ્યોનું આઉટપુટ કરશે, જ્યારે UEV પહોંચી જાય ત્યારે તેમને બદલશે, અને તે જ સમયે હાલમાં સક્રિય RGB LED ને બદલશે.

LED સ્વિચિંગ ઓટોમેટિક હોવાથી, અમારે "વીડિયો મેમરી" બનાવવાની જરૂર છે જેમાંથી ઇન્ટરપ્ટ હેન્ડલર ડેટા પ્રાપ્ત કરશે. આ એક સરળ એરે છે:

uint8_t colors[8][3];

ચોક્કસ એલઇડીનો રંગ બદલવા માટે, આ એરેમાં જરૂરી મૂલ્યો લખવા માટે તે પૂરતું હશે. અને ચલ સક્રિય એલઇડીની સંખ્યા માટે જવાબદાર રહેશે

uint8_t cnt;

ડેમક્સ

યોગ્ય મલ્ટિપ્લેક્સિંગ માટે, અમને, વિચિત્ર રીતે, CD74HC238 ડિમલ્ટિપ્લેક્સરની જરૂર છે. ડિમલ્ટિપ્લેક્સર - એક ચિપ જે ઑપરેટરને હાર્ડવેરમાં લાગુ કરે છે <<. ત્રણ ઇનપુટ પિન (બિટ્સ 0, 1 અને 2) દ્વારા અમે તેને ત્રણ-બીટ નંબર X ફીડ કરીએ છીએ, અને તેના જવાબમાં તે આઉટપુટ નંબરને સક્રિય કરે છે (1<<X). ચિપના બાકીના ઇનપુટ્સનો ઉપયોગ સમગ્ર ડિઝાઇનને માપવા માટે થાય છે. અમને આ ચિપની જરૂર છે માત્ર માઇક્રોકન્ટ્રોલરની કબજે કરેલી પિનની સંખ્યા ઘટાડવા માટે, પણ સલામતી માટે પણ - જેથી આકસ્મિક રીતે શક્ય કરતાં વધુ એલઇડી ચાલુ ન થાય અને MK બર્ન ન થાય. ચિપની કિંમત એક પૈસો છે અને તેને હંમેશા તમારી હોમ મેડિસિન કેબિનેટમાં રાખવી જોઈએ.

અમારું CD74HC238 ઇચ્છિત LED ના એનોડને વોલ્ટેજ સપ્લાય કરવા માટે જવાબદાર રહેશે. સંપૂર્ણ સુવિધાયુક્ત મલ્ટિપ્લેક્સમાં, તે P-MOSFET દ્વારા કૉલમમાં વોલ્ટેજ સપ્લાય કરશે, પરંતુ આ ડેમોમાં તે સીધું જ શક્ય છે, કારણ કે તે અનુસાર 20 mA ખેંચે છે સંપૂર્ણ મહત્તમ રેટિંગ્સ ડેટાશીટમાં. થી ડેટાશીટ CD74HC238 અમને પિનઆઉટ્સ અને આ ચીટ શીટની જરૂર છે:

H = ઉચ્ચ વોલ્ટેજ સ્તર, L = નીચા વોલ્ટેજ સ્તર, X - કાળજી નથી

અમે E2 અને E1 ને ગ્રાઉન્ડ સાથે, E3, A0, A1 અને A3 ને PD5, PC3, PC4 અને PC5 ને STM8 સાથે જોડીએ છીએ. ઉપરના કોષ્ટકમાં નીચા અને ઉચ્ચ બંને સ્તરો હોવાથી, અમે આ પિનને પુશ-પુલ પિન તરીકે ગોઠવીએ છીએ.

PWM

બીજા ટાઈમર પર PWM એ અગાઉની વાર્તાની જેમ બે તફાવતો સાથે ગોઠવેલ છે:

પ્રથમ, આપણે વિક્ષેપ ચાલુ કરવાની જરૂર છે ઇવેન્ટ અપડેટ કરો (UEV) જે એક ફંક્શનને કૉલ કરશે જે સક્રિય LED ને ટૉગલ કરે છે. આ બીટ બદલીને કરવામાં આવે છે અપડેટ વિક્ષેપ સક્ષમ કરો કહેવાના નામ સાથે રજિસ્ટરમાં

વિક્ષેપ સક્ષમ રજીસ્ટર

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

બીજો તફાવત મલ્ટિપ્લેક્સીંગની ઘટના સાથે સંબંધિત છે, જેમ કે ભૂતિયા - ડાયોડની પરોપજીવી ગ્લો. અમારા કિસ્સામાં, તે એ હકીકતને કારણે દેખાઈ શકે છે કે ટાઈમર, યુઇવી પર વિક્ષેપ લાવ્યા પછી, ટિક કરવાનું ચાલુ રાખે છે, અને ટાઈમર પિન પર કંઈક લખવાનું શરૂ કરે તે પહેલાં વિક્ષેપિત હેન્ડલર પાસે એલઇડી સ્વિચ કરવાનો સમય નથી. આનો સામનો કરવા માટે, તમારે તર્કને ઉલટાવવો પડશે (0 = મહત્તમ તેજ, ​​255 = કંઈપણ પ્રકાશિત નથી) અને અત્યંત ફરજ ચક્ર મૂલ્યોને ટાળવા પડશે. તે. ખાતરી કરો કે UEV પછી LEDs એક PWM ચક્ર માટે સંપૂર્ણપણે બહાર જાય છે.

બદલાતી ધ્રુવીયતા:

//set polarity 
    TIM2_CCER1 |= (CC1P | CC2P);
    TIM2_CCER2 |= CC3P;

r, g અને b ને 255 પર સેટ કરવાનું ટાળો અને તેનો ઉપયોગ કરતી વખતે તેમને ઉલટાવાનું યાદ રાખો.

વિક્ષેપ પાડે છે

વિક્ષેપનો સાર એ છે કે ચોક્કસ સંજોગોમાં ચિપ મુખ્ય પ્રોગ્રામને એક્ઝિક્યુટ કરવાનું બંધ કરે છે અને કેટલાક બાહ્ય કાર્યને કૉલ કરે છે. ટાઈમર સહિત બાહ્ય અથવા આંતરિક પ્રભાવોને કારણે વિક્ષેપો થાય છે.

જ્યારે અમે સૌપ્રથમ એસટી વિઝ્યુઅલ ડેવલપમાં પ્રોજેક્ટ બનાવ્યો હતો, ઉપરાંત main.c અમને એક રહસ્યમય ફાઇલવાળી વિન્ડો મળી છે stm8_interrupt_vector.c, આપમેળે પ્રોજેક્ટમાં સમાવવામાં આવેલ છે. આ ફાઇલમાં, દરેક વિક્ષેપને કાર્ય સોંપેલ છે NonHandledInterrupt. આપણે આપણા કાર્યને ઇચ્છિત વિક્ષેપ સાથે જોડવાની જરૂર છે.

ડેટાશીટમાં વિક્ષેપ વેક્ટરનું કોષ્ટક છે, જ્યાં અમને જરૂર હોય તે શોધીએ છીએ:

13 TIM2 અપડેટ/ઓવરફ્લો
14 TIM2 કેપ્ચર/સરખામણી

અમારે UEV પર LED બદલવાની જરૂર છે, તેથી અમને ઇન્ટરપ્ટ #13ની જરૂર છે.

તદનુસાર, પ્રથમ, ફાઇલમાં stm8_interrupt_vector.c ઇન્ટરપ્ટ નંબર 13 (IRQ13) માટે જવાબદાર ફંક્શનનું ડિફોલ્ટ નામ તમારા પોતાનામાં બદલો:

{0x82, TIM2_Overflow}, /* irq13 */

બીજું, આપણે એક ફાઇલ બનાવવી પડશે main.h નીચેની સામગ્રી સાથે:

#ifndef __MAIN_H
#define __MAIN_H

@far @interrupt void TIM2_Overflow (void);
#endif

અને છેલ્લે, આ ફંક્શનને તમારામાં લખો main.c:

@far @interrupt void TIM2_Overflow (void)
{
    PD_ODR &= ~(1<<5); // вырубаем демультиплексор
    PC_ODR = (cnt<<3); // записываем в демультиплексор новое значение
    PD_ODR |= (1<<5); // включаем демультиплексор

    TIM2_SR1 = 0; // сбрасываем флаг Update Interrupt Pending

    cnt++; 
    cnt &= 7; // двигаем счетчик LED

    TIM2_CCR1L = ~colors[cnt][0]; // передаем в буфер инвертированные значения
    TIM2_CCR2L = ~colors[cnt][1]; // для следующего цикла ШИМ
    TIM2_CCR3L = ~colors[cnt][2]; // 

    return;
}

જે બાકી છે તે વિક્ષેપોને સક્ષમ કરવાનું છે. આ એસેમ્બલર આદેશનો ઉપયોગ કરીને કરવામાં આવે છે rim - તમારે તેને શોધવાનું રહેશે પ્રોગ્રામિંગ મેન્યુઅલ:

//enable interrupts
_asm("rim");

અન્ય એસેમ્બલર આદેશ છે sim - વિક્ષેપો બંધ કરે છે. જ્યારે "વિડિયો મેમરી" પર નવા મૂલ્યો લખવામાં આવી રહ્યા હોય ત્યારે તેઓ બંધ હોવા જોઈએ, જેથી ખોટી ક્ષણે ઉદ્ભવતા વિક્ષેપ એરેને બગાડે નહીં.

બધા કોડ - GitHub પર.

જો ઓછામાં ઓછું કોઈને આ લેખ ઉપયોગી લાગે, તો મેં તે નિરર્થક નથી લખ્યું. મને ટિપ્પણીઓ અને ટિપ્પણીઓ પ્રાપ્ત કરવામાં આનંદ થશે, હું દરેક વસ્તુનો જવાબ આપવાનો પ્રયત્ન કરીશ.

સોર્સ: www.habr.com