Սկիզբ » Ուսումնական նյութեր » Ծրագրավորում » Ծրագրավորման լեզուներ » C և C++ » Android + PC + Arduino: Տնային սարքերի կառավարում անդրոիդ օհ -ով սմարթ ֆոնից/պլանշետից: Մաս 7, Էլեկտրոնային համակարգերի ավտոմատ նախագծման PROTEUS համակարգ. Տվյալների փոխանցում UART/USART ինտերֆեյսի միջոցով:

Android + PC + Arduino: Տնային սարքերի կառավարում անդրոիդ օհ -ով սմարթ ֆոնից/պլանշետից: Մաս 7, Էլեկտրոնային համակարգերի ավտոմատ նախագծման PROTEUS համակարգ. Տվյալների փոխանցում UART/USART ինտերֆեյսի միջոցով:

| Հունվար 4, 2013 | Մեկնաբանված չէ |

Շարունակում ենք: Նախորդ մասում հավաքեցինք սարքի սեխման, բայց այն չի սիմուլացվի Proteus -ում այնքան ժամանակ քանի դեռ չենք գրել և տեղակայել միկրոկոնտրոլերի firmware -ը: Ինչը և կանենք հիմա: ՈՒրեմն քաշում ենք Code VIsionAvr -ծրագրիրը այստեղից  , տեղակայում և բացում ենք: Ստեղծում ենք նոր project: File -> New:

1.1

 

Բացվում է փոքրիկ դիալոգային պատուհան` Create New FIle, որտեղից նշում ենք Project.

2

Հաջորդ քայլին սեղմում ենք Ok.

Արդյունքում բացվում է կոդի ավտոմատ գեներացիայի և նախնական կարգաբերումների պատուհանը, որտեղ մենք կարող ենք ինիցիալիզացնել թայմերները, պորտերը, միացնել կամ անջատել ընդհատումները, տալ տակտային ռեզոնատորի հաճախությունը, կարգաբերել ֆյուսները և այլն: Մի խոսքով այս պատուհանում կարելի է ինիցիալիզացնել միկրոկոնտրոլերի շատ պարամետրեր:

4

Բացված պատուհանում ընտրում ենք մեր կոնտրոլերի տիպը Chip դաշտից, որը տվյալ դեպքում Atmega8 է, իսկ Program Type նույնպես լռությամբ դրված է Application, եթե ինչ-ինչ պատճառով այդպես չէ, ապա դնում ենք Application -ի վրա: Գնում ենք USART  tab -ի վրա.

1

Այդտեղից նշում ենք միայն Reciver  և Transsmiter դաշտերը: Այստեղ Baude rate դաշտում նշված է տվյալների փոխանակման արագությունը: Այս պարամետրը շատ հաճախ խնդիրների պատճառ է դառնում և պրոյեկտի ընթացքում ենթարկվում է կարգաբերումների: Մենք այն կթողնենք 9600 -ի վրա: Տվյալնրի փոխանակումը այս ինտերֆեյսով մեր դեպքում կկատարվի ասինխրոն ռեժիմում՝ 8 ինֆորմատիվ բիթ և դրան գումարած մեկ stop բիթ: Սրանց հետ միասին կարմիրով գրված է նաև usart ինտերֆոյսով տվյալների փոխանցաման դեպքում սխալի տոկոսը, որը կազմում է մեր դեպքում Baud Rate Error: -7.5%: Դա կախված է միկրոկոնտրոլերի աշխատանքային հաճախությունից: Usart ինտերֆեյսով ստաբիլ տվյլաների փոխանաիկման համար անհրաժեշտ է ոչ պակաս քան 18-20 mghz հաճախություն, որը ներքին գեներատորը չի կարող ապահովել: Այդ հաճախության ապահովման համար օգտագործում են արտաքին կցվող քվարցային ռեզոնատոր: Բայց մեր դեպքում փոխանցվող ինֆորմացիան մեծ չէ, ուստի ինտերֆեյսը նորմալ կաշխատի: Նախնական կոդի գեներացիայի պատուհանում թերևս կարող էինք նաև տալ պորտերի նախնական կարգաբերումները, որոնք օգտագործելու ենք, բայց դա մենք կանենք արդեն ամջիջապես կոդի մեջից: Ոչ մի բան այլևս չենք փոխում: Այժմ սեղմում ենք Generate Save and Exit.

5

 

Մեր միկրոկոնտրոլերի աշխատանքը տակտավորվելու է ներքին գեներատորից և ինչպես տեսնում ենք կոդի գեներացիայի պատուհանում լռությամբ տակտային հաճախությունը դրված է 1 mghz

Արդյունքում  երեք անգամ հաջորդաբար կբացի save -ի նույն դիալոգային պատուհանը՝ համապատասխանաբար <<.c>> ,  <<.prj>> և <<.cwp>> ձևաչափով ֆայլերի save -ի համար. կարող ենք բոլոր երեք դեպքերում էլ տալ նույն անունը, օրինակ՝ temp,  որի արդյունքում կստեղծվի երեք ֆայլ՝  temp.c, temp. prj, temp.cwp, որտեղ temp.c ծրագրի (firmware) -ի կոդն է C լեզվով, temp.prj պրոյեկտի ֆայլն է (պրոյեկտի ֆայլը դա այն ֆայլն է, որը բացելով բացվում է ամբողջ պրոյեկտը), temp.cwp կոնտրոլերի պարամետրերի կարգաբերումները պարունակող ֆայլն է (այս ֆայլի հետ մենք անմիջական գործ չունենք տվյալ պրոյեկտում):

6

Բացվում է հետևյալ դաշտը, որտեղ կարող ենք գրել մեր կոդը.

7

Կոդի նախնական գեներացիայի արդյունքում ունենք մեծ քանակությամբ գեներացված կոդ: Կոդի նախնական գեներացիան ինիցիալիզացնում է պորտերը, այսինքն տալիս է յուրաքանչյուր պորտի ուղղությունը (input  կամ output), պորտի լարման տրամաբանկան մակարդակը, միացնում/անջատում է պորտին կցված ներքին դիմադրությանները և այլն, ինիցիալիզացնում/միացնում/անջատում է թայմերները, ընդհատումները, անալոգային կոմպարատորը, անալոգաթվային կերպափոխիչը (ինձ որ մնար կասեյի անալոգաթվային ձևափոխիչ, քանի որ ի վերջո ազդանշանի տեսքն ու պարամետրերը ձևափոխվում են, բայց քանի որ մեր հարազատ պոլիտեխում :D, մեզ սովորեցրել են <<անալոգաթվային կերպափոխիչ>> արտահայտությամբ, այդպս էլ գրում եմ ավտոմատ): Մեր պրոյեկտում մենք չենք օգտգործում ոչ՛ անալոգաթվային կերպափոխիչ, ոչ՛ անալոգային կոմպարատոր, ոչ՛ ընդհատումներ հետևաբար կոդի այդ հատվածը կթողնենք այնպես, ինչպես կա (իսկ լռությամբ դրանք բոլորը անջատված են): Մենք օգտագործում ենք միայն USART ինտերֆեյսը համակարգչի հետ տվյալների փոխանակման համար: Պորտերի ինիցիալիզցիայի հատվածում մենք կփոխենք միայն D արժեքը, ստորև բերված նկարում ընդգծված հատվածում հետևյալ կոդով

PORTD=0x00;
DDRD=0b00001110

 

PORTD = 0x00; տողով մենք PORTD ռեգիստորի բոլոր բիթերի (պորտերի) վրա լարման տրամաբանական մակարդակը լռությամբ դնում ենք 0, դա նշանակում է, որ եթե հետո PORTD  ռեգիստորի արժեքը չփոխվի, ապա PD0, PD1, PD2, PD3, PD4 պորտերի վրա ելքային լարումը կլինի տրամաբանական 0, որը մեզ ձեռք չի տալիս, այսինքն մեր դեպքում անհրաժեշտ է, որ գոնե մեկ պորտի արժեքը կոնտրոլերի աշխատանքի ժամանակ 0-ից տարբեր արժեքներ ընդունի (ավելի կոնկրետ PORTD0 բիթը (պորտը)):

DDRD=0b00001110 արտահայտությամբ, մենք տալիս են PORTD -ի բոլոր պորտերի ուղղությունը (ելքային/մուտքային) : Այսպիսով (նկատենք, որ 16-ական համակարգով գրված 0x0E թիվը նույն է, ինչ-որ 2-ական համակարգով գրված 00001110 -ը), սա նշանակում է, որ աջից ձախ ուղղությամբ պորտերը կինիցիալիզացվեն հետևյալ կերպ՝ PD0- ն 0, PD1 -ը, PD2 -ը և PD3 -ը կդրվեն 1, իսկ մնացած  չորս բիթերը կմնան 0DDRD ռեգիստորում կոդում նշված բիթերի արժեքը դնում ենք 1, դա նշանակում է, որ դրանք ելքային բիթեր են (պորտեր են):

Հիմա USART-ի մասին մանրամասն.

ՈՒնիվերսալ ասինխրոն ընդունիչ-հաղորդիչ (Universal Asynchronous Receiver-Transmitter (UART)), ինտերֆեյս է, որը թույլ է տալիս տվյալներ փոխանակել այլ թվային սարքերի (թվային համկարգերի) հետ: Այն ձևափոխում է տրված տվյալների հավաքածուն հաջորդական տեսքի , այնպես, որ հնարավոր լինի հաղորդել այն նմանատիպ այլ սարքին միալարային թվային գծի միջոցով: Ընդ որում երկու և ավելի տվյալների բլոկների  հաջորդական փոխանցաման ժամանակային միջակայքերը կարող են և միմյանցից տարբերվել: Մեթոդը բավական երկար ժամանակ է, ինչ գոյություն ունի, ստանդարտացված է (ստեղ հիշեցի մեր ստանդարտացման և սերտիֆիկացման դասախոս պարոն Բեգլարյանին :D) և լայնորեն կիրառվում է:  Կա նաև USART ինտերֆեյսը, որը նշանակում է ունիվերսալ սինխրոն-ասինխրոն ընդունիչ-հաղորդիչ, այն կարող է աշխատել ինչպես սինխրոն, այնպես էլ ասինխրոն ռեժիմներում: Չհաշված մի քանի ռեգիստորների, USART և UART ինտերֆեյնսները նույնն են, դրա համար կարճության այսուհետ կասենք uart: UART-ը ունի աշխատանքի կարգաբերման համար նախատեսված  մի քանի ռեգիստրներ, որոնցից մենք կանդրադառնանք անմիջականորեն նրանցից մի քանիսին, որոնց միջոցով հնարավոր է կարգաբերել տվյալների փոխանակման  պրոցեսը:

Ամենալավ introduction-ը դա տվյալ արտադրանքի (կլինի դա ծրագրային ապահովում, էլեկտրոնային սարք և այլն) տեխնիկական փաստաթուղթն է, որի միջոցով տրված են դրա բոլոր աշխատանքային, թույլատրելի և կրիտիկական պարամետրերն ու վիճակները: Պետք է ձգտել ինֆորմացիա ստանալ հենց առաջնային աղբյուրներից: Ընդանհրապես կյանքում գնահատվում է և որպես տվյալ ոլորտի հեղինակություն ընկալվում է նա, ով ուրիշների կողմից օգնություն խնդրելու հնարավորությունը ամենավերջում է օգտագործում, ձգտում է թեկուզ մեծ դժվարությամբ, բայց ինքնուրույն լուծել դրված խնդիրը: Իսկ էդ գործում հենց լավ օգնության միջոց են հանդիսանում ինֆորմացիայի բաց աղբյուրները, իսկ տվյալ դեպքում տեխնիկական փաստաթուղթը, իսկ մեր դեպքում միկրոկոնտրոլերի datasheet -ը :): ՈՒրեմն UART -ի կարգաբերման ռեգիստորներն են UCSRA, UCSRB, UCSRC, UBRR, UDR: Կան նաև այլ ռեգիստրներ, բայց մենք կօգտագործենք սրանք: Բացում ենք atmega8datasheet -ը և նայում

USART Control and Status Register A – UCSRA.

uart2

Bit 7 – RXC: USART Receive Complete – Այս ֆլագը դրվում է , երբ կա դեռևս չընթերցված տվյալ UDR ռեգիստրում: Այն կարող է լինել ընդհատման պատճառ, եթե ընդհատումները թույլատրված են:

Bit 6 – TXC: USART Transmit Complete – Այս ֆլագը դրվում է բայթի հաղորդման վերջում՝ վերջին ստոպ բիթը հաղորդելուց հետո: Այն կարող է լինել ընդհատման պատճառ, եթե ընդհատումները թույլատրված են

Bit 5 – UDRE: USART Data Register Empty – տվյալների ռեգիստրի դատարկման ֆլագ, որը ցույց է տալիս, եթ հաջորդ բայթի ընդունման/հաղորդմանը միկրոկոնտրոլերը, երբ է պատրաստ, եթե այս բիթը դրված է 1 ,ապա միկրոկոնտրոլերը կարող է հաղորդել/ընդունել տվյալներ:

• Bit 4 – FE: Frame Error

• Bit 3 – DOR: Data OverRun

• Bit 2 – PE: Parity Error

• Bit 1 – U2X: Double the USART Transmission Speed

• Bit 0 – MPCM: Multi-processor Communication Mode.

Այս ռեգիստրում մնացած բիթերը մենք չենք օգտագործի, իսկ հետքքրքրվողները կարող են դրանց մասին տեղեկանալ atmega8 -ի datasheet -ից:

USART Control and Status Register B – UCSRB

 uart3

• Bit 7 – RXCIE: RX Complete Interrupt Enable – Ընդունման վերջում ընդհատման թույլատրում,

• Bit 6 – TXCIE: TX Complete Interrupt Enable – Հաղորդման վերջում ընդհատման թույլատրում,

• Bit 5 – UDRIE: USART Data Register Empty Interrupt Enable– USART -ի տվյալների ռեգիստրի դատարկման դեպքում ընդհատման թույլատրում,

• Bit 4 – RXEN: Receiver Enable – Ընդունիչի աշխատանքի թույլատրում (ընդունիչի միացում),

• Bit 3 – TXEN: Transmitter Enable – Հաղորդիչի աշխատանքի թույլատրում (հաղորդիչի միացում),

• Bit 2 – UCSZ2: Character Size,

• Bit 1 – RXB8: Receive Data Bit 8:

 

USART Control and Status Register C – UCSRC.

uart4

• Bit 7 – URSEL: Register Select – Ռեգիստրի ընտրության բիթ: Եթե էս ֆլագը դրված է1 ,ապա տվյալներy գրվում են UCSRC -ի, իսկ եթե ոչ, ապա  UBRRH մեջ,

• Bit 6 – UMSEL: USART Mode Select – մոդուլի աշխատանքային ռեժիմի ընտրության ֆլագ, եթե 1 -է սինխրոն ռեժիմ է, եթե 0, ապա ասինխրոն,

• Bit 5:4 – UPM1:0: Parity Mode – Այս բիթերը որոշում են ընդունված տվյալենրի հողորդագրության զույգության ստուգման ռեժիմը:

• Bit 3 – USBS: Stop Bit Select – ստոպ բիթերի քանակի որոշման բիթ, եթե 0-է, ապա կա 1 ստոպ բիթ, եթե 1 է, ապա 2 հատ ստոպ բիթ է,

• Bit 2:1 – UCSZ1:0: Character Size – Այս բիթերը որոշում են ընդունվող սիմվոլի չափը,

• Bit 0 – MPCM: Multi-processor Communication Mode, չի օգտագործվում:

UDR (UART Data Register) -ը այն ռեգիստրն է, որտեղ փոխանցվում և են տվյալները: Տվյալների ընդունման ժամանակ, երբ UDR ռեգիստրի արժեքը ընթերցվում է, գեներացվում է ապարատային ընդհատում և միկրոկոնտրոլերի ընդունիչը սպասում է նոր տվյալների ընդուման, իսկ փոխանցման ժամանակ, երբ UDR -ի մեջ տվյալ է լցվում, գեներացվում է ապարատային ընդհատում և տեղի է ունենում տվյալների փոխանցում:

Հիմա մեր կոդում մենք կանենք UART -ի հետևյալ կարգաբերումները

UCSRA=0x00; // սկզբում չընթերցված տվյալներ և stop բիթեր չունենք հետևաբար RXC և TXC բիթերը 0 -են. 0-են նաև մնացածը,
UCSRB=0x18; // միացնում ենք միկրոկոնտրոլերի ընդունիչը և հաղորդիչը, 0x18-ը 2-ական համակարգով 00011000 -է, 1 էն դրված RXEN և TXEN բիթերը (նայում ենք աջից ձախ),
UCSRC=0x86; // 0x86 կամ 10000110, այստեղ (նայում ենք աջից ձախ), երբ UCSZ0 և UCSZ1 միաժամանակ 1 -են ապա տվյալի մեկ բջիջը կազմում է 8 բիթ (նորից տեղեկանում ենք atmega 8-ի datasheet-ից, էջ 157 -ի աղյուսակ 58-ը)  
UBRRH=0x00;
UBRRL=0x06;

Հիմա UBRR (Usart Boud Rate Register) ռեգիստորի մասին խոսենք առանձին: Այն իրենից ներկայացնում է uart ինտերֆեյսով տվյալների փոխանցման արագության կարգաբերման ռեգիստր:Հետևաբար տվյալների փոխանցման արագություն կարգաբերման համար պետք է համապատասխան թիվ գրել այս ռեգիստրում
Հաշվարկը կատարվում է հետևյալ բանաձևով

UBBR = (F/(B*16) - 1), որտեղ F-ը միկրոկոնտրոլերի աշխատանքային հաճախությունն է (մեր դեպքում 1 mghz, ինչպես և դրել էինք), B -ն տվյալների փոխանակման ցանկալի արագությունը, հետևաբար կլինի՝
UBBR = (1000000/(9600*16) - 1) = 6, իսկ քանի որ UBBR ռեգիստրը ունի
UBBRL (UBBR low) և UBBRH(UBBR hight)մասեր, կունենանք
UBBRH= 00000000 (կամ 16-ականով 0x00</strong>) և
UBBRL=00000110(կամ 16-ականով0x06):

uartՀիմա բերենք ամբողջական կոդը՝

/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.9 Standard
Automatic Program Generator
© Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : 
Version : 
Date    : 12/31/2012
Author  : F4CG                            
Company : F4CG                            
Comments: 

Chip type           : ATmega8
Program type        : Application
Clock frequency     : 1.000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size     : 256
*****************************************************/
#define UDRE 5  
#define RXEN 4
#define TXEN 3

#include <mega8.h>   
#include <delay.h>  

// Standard Input/Output functions
#include <stdio.h>

// Declare your global variables here
unsigned char r;

void main(void)
{
// Declare your local variables here

// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTB=0x00;
DDRB=0x00;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTD=0x00;
DDRD=0b00001110;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
TCCR0=0x00;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud Rate: 9600
UCSRA=0x00;
UCSRB=0x18;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x06;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;

while (1)
      {
      // Place your code here   
      while(UCSRA.7==1)
      {
        r = UDR;
        if(r == '1') 
        {
                PORTD = 0b00001110;
        }
        if(r == 'b')
                PORTD = 0x00;      
      }    
      };
}

While ցիկլի մեջ սպասում ենք մինչև տվյալների ընդունման բուֆերը ազատվի այնուհետև r փոփոխականի մեջ ստանում ենք եկած տվյալները, որոնք պահվում ենք UDR ռեգիստրում ու հարսնում ենք, եթե եկել է ‘1‘ թիվը
PORTD -ի պորտերի վրա դնում ենք 0b00001110 մակարդակը, իսկ եթե եկած սիմվոլը ‘b‘ է անջատում եքն PORTD -ի բոլոր պորտերը: Այժմ բացում ենք Proteus -ը տալիս ենք Open Design, ընտրում ենք
մեր նախորդ հոդվածում պատրաստած *.DSN ձևաչափով ֆայլը և տալիս ենք open: proteus + uart file

Program FIle: դաշտից ընտրում ենք մեր մեր CvAvr ծրագրով սարքած ֆայլը .cof  ձևաչափով և տալիս ենք open: Այժմ արդեն կարող ենք համակարգը սիմուլացնել, դրա համար սեղմում ենք Proteus  -պատուհանի ձախ ներքի անկյունում Run the simulation կոչակի վրա: Ամեն ինչ պետք է հարթ անցնի: Կարող ենք միացնել virtual terminalcompim էլեմենտի txd ոտքին և ազդանշաններ ուղղարկել: Այդ դեպքում ուշադրություն դարձրեք միկրոկոնտրոլերի ոտքերին. ակտիվացած ոտքերի գույնը կարմիր է: Որպեսզի այսպես ասած highlighting -ը միացնենք գնում ենք System -> Set Animation Options …  և Animation Options դաշտում դնում ենք բոլոր չորս նշիչները: Հաջորդ հոդվածում sprint layout  ծրագրով կգծենք պլատան, որը պետք է պատրաստենք: CvAvr– ի ինչպես Proteus -ի բոլոր ֆայլերը կցված են հոդվածին:

 

Android + PC + Arduino: Տնային սարքերի կառավարում անդրոիդ օհ -ով սմարթ ֆոնից/պլանշետից: Մաս 7, Էլեկտրոնային համակարգերի ավտոմատ նախագծման PROTEUS համակարգ. Տվյալների փոխանցում UART/USART ինտերֆեյսի միջոցով:, 10.0 out of 10 based on 21 ratings

Նշագրեր: , , ,

Բաժին: C և C++, Ժեշտ, Ծրագրավորում

Կիսվել , տարածել , պահպանել

VN:F [1.9.20_1166]
Rating: 10.0/10 (21 votes cast)

Մեկնաբանեք

Կհաստատվեն միայն մեսրոպատառ հայերենով գրած մեկնաբանությունները

287