Dasej Procesor Atmega4809  
Aktykuły które nie zmieściły się w żadnej kategorii

0102 /03
04Procesory Atmel megaAVR 0-series.

Algorytmy tu zaprezentowane były testowane na procesorach Atmega4809 lub Attiny1614 przy pomocy środowiska Atmel Studio 7.0. Opisuje konfigurację urządzeń peryferyjnych w tych procesorach.
06
070809

AnalizÄ™ kodu zacznijmy do main.

W pierwszej linii odblokowujemy dostęp do rejestru MCLKCTRLB tak byśmy mogli w nim dokonać zmian. Procesor domyśle startuje z wewnęntrzym zegarze 20MHz ale dzielonym przez 6 co daje 3.333MHz. Ustawiając ostatni bit rejestru na zero wyłączamy podział i od tej chwili nasz procesor pracuje na 20MHz.

PORTB.DIR ustalamy kierunki pracy poszczególnych pinów w bramie.

Następnie przechodzimy do inicjacji uarta-0.

Domyślnie USART0 jest podłączony do pinów PA0 i PA1

//uart0 na pinach podstawowych
//PORTA.DIRSET = PIN0_bm; // PA0(44)=0.TxD
//PORTA.DIRCLR = PIN1_bm; // PA1(45)=0.RxD

ale ja tutaj pokazuje jak przestawić USART0 na piny alternatywne PA4 i PA5.

// uart na pinach zapasowych
PORTMUX.USARTROUTEA = 0b00000001;
PORTA.DIRSET = PIN4_bm; // PA4(48)=0.TxD
PORTA.DIRCLR = PIN5_bm; // PA5( 1)=0.RxD

Należy zwrócić uwagę że trzeba odpowiednio ustalić kierunki pracy dla poszczególnych sygnałów.

Kolejnym urządzeniem które uruchamiam to jest jedn z timerów, a konkretnie TCA0.
Timer jest tak ustawiony by dawał przerwanie co około 1 sekundy. Przerwanie dla timera zapisujemy w następujący sposób ISR(TCA0_OVF_vect). Istotna różnica między zwykłymi AVR jest to że trzeba kasować flagę przerwania informując procesor że zostało obsłużone. TCA0.SINGLE.INTFLAGS = ( TCA_SINGLE_OVF_bm); Jak tego nie dokonamy w obsłudze przerwania to procesor uparcie będzie je wykonywał w kółko. Dotyczy to również innych przerwań.

  1. /*
  2.  *       Created: 2019-07-30 22:35:28
  3.  *       Author : Dasej
  4.  */ 
  6. #define F_CPU 20000000
  8. #include <avr/io.h>
  9. #include <util/delay.h>
  10. #include <avr/interrupt.h>
  11. #include <string.h>
  12. #include <stdlib.h>  // ltoa  konwersja liczb
  14. uint16_t sekunda = 0;
  16. #define USART0_BAUD_RATE(BAUD_RATE) ((float)(F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
  18. void USART0_init(void)
  19. {   
  20.   // inicjacja i obsÅ‚uga uarta0
  21.   // 115200 8 N 1
  22.   //uart0 na pinach podstawowych  
  23.   //PORTA.DIRSET = PIN0_bm; // PA0(44)=0.TxD
  24.   //PORTA.DIRCLR = PIN1_bm; // PA1(45)=0.RxD
  26.   // uart na pinach zapasowych
  27.   PORTMUX.USARTROUTEA = 0b00000001;
  28.   PORTA.DIRSET = PIN4_bm; // PA4(48)=0.TxD
  29.   PORTA.DIRCLR = PIN5_bm; // PA5( 1)=0.RxD
  31.   USART0.BAUD = (uint16_t)USART0_BAUD_RATE(115200);
  32.   USART0.CTRLB |= USART_TXEN_bm;
  33. }
  35. void USART0_sendChar(char c)
  36. {
  37.   while (!(USART0.STATUS & USART_DREIF_bm)) {;}
  38.   USART0.TXDATAL = c;
  39. }
  41. void USART0_sendString(char *str)
  42. {
  43.   for(size_t i = 0; i < strlen(str); i++)
  44.     { USART0_sendChar(str[i]); }
  45. }
  48. void rsInt0( long num ) // wysÅ‚anie liczby caÅ‚kowitej
  49. {
  50.    char buffer[81];
  51.    ltoa( num , buffer, 10);
  52.    USART0_sendString ( buffer );
  53. }
  55. ISR(TCA0_OVF_vect)
  56. {
  57.   // kasowanie znacznika przerwania jak nie zostanie 
  58.   // zkasowany to przerwanie bÄ™dzie stale siÄ™ wywoÅ‚yÅ‚aÅ‚o 
  59.   TCA0.SINGLE.INTFLAGS = ( TCA_SINGLE_OVF_bm);
  60.   // informacja Å¼e przerwanie zostaÅ‚o wykonane 
  61.   PORTB.OUTTGL =  PIN4_bm | PIN0_bm;
  62.   USART0_sendString("T.");
  63. }
  66. void initTimer(void)
  67. {
  68.   TCA0.SINGLE.CTRLA =  0b00001111; // prescaler 1024 i b0 = enable wÅ‚Ä…cz timer
  69.   TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;
  70.   // TCA0.SINGLE.PER = (20 000 000 / prescaler 1024) co daje
  71.   TCA0.SINGLE.PER = 0x4C4B; //  przerwanie co 1 sekundÄ™ 
  72. }
  74. ISR(RTC_CNT_vect)
  75. {
  76.   RTC.INTFLAGS = RTC_OVF_bm;
  77.   sekunda++;
  78. }
  80. void initRTC(void)
  81. {
  82.   RTC.CLKSEL = RTC_CLKSEL_INT32K_gc;
  83.   while (RTC.STATUS>0); // czekaj na ustabilizowanie zagara
  84.   RTC.CTRLA = RTC_PRESCALER_DIV32_gc | RTC_RTCEN_bm | RTC_RUNSTDBY_bm;
  85.   RTC.PER = 1024; // zegar ( 32768 / 32 ) / 1024 = 1 sekunda  
  86.   RTC.INTCTRL |= RTC_OVF_bm;
  87. }
  89. int main(void)
  90. {
  91.   CPU_CCP = CCP_IOREG_gc;  // odblokowanie zapisu do rejestru MCLKCTRLB
  92.   CLKCTRL.MCLKCTRLB = 0x10; // wyÅ‚acz podziaÅ‚ CLKCTRL_PEN_bp 
  94.   PORTB.DIR = PIN4_bm | PIN0_bm;
  96.   USART0_init();
  97.   initTimer();
  98.   USART0_sendString("Start uart\r\n");
  99.   initRTC();
  100.   sei();
  102.   while (1)
  103.     {
  104.       USART0_sendString("Hello World! : sekunda= ");
  105.       rsInt0(sekunda);
  106.       USART0_sendString("\n\r");
  107.       _delay_ms(1000);
  108.     }    
  109. }

W plikach nagłówkowych procesorów Atmel dodał litery za nazwami rejestrów lub opisu poszczególnych bitów rejestru. Litery których znaczenie widać w poniższym oknie kodu.

  1. ..._gm 0x03   - maska
  2. ..._gp 0      - pozycja
  3. ..._bm (1<<0) - bit maski
  4. ..._bp 0      - bit pozycja
  6. // fragment kodu z pliku iom4809.h
  7. // CRCSCAN.CTRLB  bit masks and bit positions
  8. #define CRCSCAN_SRC_gm  0x03  // CRC Source group mask. 
  9. #define CRCSCAN_SRC_gp  0  // CRC Source group position.
  10. #define CRCSCAN_SRC0_bm  (1<<0)  // CRC Source bit 0 mask. 
  11. #define CRCSCAN_SRC0_bp  0  // CRC Source bit 0 position. 
  12. #define CRCSCAN_SRC1_bm  (1<<1)  // CRC Source bit 1 mask.
  13. #define CRCSCAN_SRC1_bp  1  // CRC Source bit 1 position.
  14. #define CRCSCAN_MODE_gm  0x30  // CRC Flash Access Mode group mask.
  15. #define CRCSCAN_MODE_gp  4  // CRC Flash Access Mode group position.
  16. #define CRCSCAN_MODE0_bm  (1<<4)  // CRC Flash Access Mode bit 0 mask.
  17. #define CRCSCAN_MODE0_bp  4  // CRC Flash Access Mode bit 0 position.
  18. #define CRCSCAN_MODE1_bm  (1<<5)  // CRC Flash Access Mode bit 1 mask.
  19. #define CRCSCAN_MODE1_bp  5  // CRC Flash Access Mode bit 1 position.

Licznik TCB jest prostszą wersją licznika TCA. Licznika TCB0 z uruchomionym przerwaniem. Wywołujący przerwanie na zasadzie porównania rejestru TCB0.CNT ( licznika ) z rejestrem TCB0.CCMP W odniesieniu do zwykłych liczników w AVR-erach można użyć określenia ( przerwanie wywołanie przepełnieniem licznika ).

  2. ISR(TCB0_INT_vect)
  3. {
  4. TCB0.INTFLAGS = TCB_CAPT_bm; // kasowanie flagi, wymagane
  5. razy++;
  6. }
  8. void start(void)
  9. {
  10. razy =0; // ile przerwaÅ„ 
  11. TCB0.INTCTRL =1; // uruchom przerwanie
  12. TCB0.CCMP = 0xFFFF; // porównie do 
  13. TCB0.CNT = 0;  // licznik 
  14. TCB0.CTRLA = 1; // wÅ‚Ä…cz timer / taktowanie procesora
  15. }
  17. void stop(void)
  18. {
  19. TCB0.CTRLA = 0; // wyÅ‚Ä…cz timer
  20. }

Kilka informacji o konfigurowaniu PORT-ów.

  1.     PORTC.DIR = 0b00001111   // ustawienie caÅ‚ego portu jednoczesnie
  2.     PORTC.DIRSET = 0xF0; // ustaw tylko bity 7,6,5,4
  3.     PORTC.DIRCLR = 0x60; // skazuj tylko bity 6,5
  4.     PORTC.DIRTGL = 0x06; // odwróc znacznie tylko bitów 2,1 
  6.     PORTC.DIR = 0xFF   // ustawienie caÅ‚ego portu jednoczesnie
  7.     PORTC.OUT = 0b01010101;  
  8.     PORTC.OUTSET = 0b10;
  9.     PORTC.OUTSET = (1<<3)|(1<<7); // zamiennie PORTC.OUT |= (1<<3)|(1<<7); 
  10.     PORTC.OUTSET = PIN5_bm; // zamienna operacji PORTC.OUT |= (1<<5); 
  12.     PORTC.OUT = 0;  
  13.     PORTC.OUT |= 5; 
  14.     PORTC.OUT = 0;  
  15.     PORTC.OUTSET = PIN5_bp; // zamienna operacji PORTC.OUT |= 5; 
  17.     PORTC.DIR = 0b11011111   
  18. //    PORTC.OUTTGL;
  19. //    PORTC.IN;  
  20. //    PORTC.INTFLAGS; 
  21. //    PORTC.PORTCTRL; 
  23. /* PINxCTRL 
  24.     bit 7 = inwerter pinu w bramie
  25.     bit 3 = podciÄ…gnij pin do zasilanie przez rezystor
  26.     bit 2,1,0 = przerwania
  28.     0x0 INTDISABLE     Przerwanie wyÅ‚Ä…czone, ale bufor wejÅ›ciowy wÅ‚Ä…czony
  29.     0x1 BOTHEDGES      Przerwanie wÅ‚Ä…czone z wyczuciem w obu krawÄ™dziach
  30.     0x2 RISING         Przerwanie wÅ‚Ä…czone z wyczuciem na zbocze narastajÄ…ce
  31.     0x3 FALLING        Przerwanie wÅ‚Ä…czone z wyczuciem na zbocze opadajÄ…ce
  32.     0x4 INPUT_DISABLE  Przerwanie i bufor wejÅ›cia cyfrowego wyÅ‚Ä…czony
  33.     0x5 POZIOM POZIOMU wÅ‚Ä…czony z wyczuciem na niskim poziomie
  35.     PORTD interrupt vectors 
  36.     #define PORTD_PORT_vect_num  20
  37.     #define PORTD_PORT_vect      _VECTOR(20)  a
  39. */
  40.     PORTC.PIN0CTRL; 
  41.     PORTC.PIN1CTRL; 
  42.     PORTC.PIN2CTRL; 
  43.     PORTC.PIN3CTRL; 
  44.     PORTC.PIN4CTRL; 
  45.     PORTC.PIN5CTRL = 2; // zbocze narastajÄ…ce
  46.     PORTC.PIN6CTRL; 
  47.     PORTC.PIN7CTRL; 
0102 /03
04Obsługa przerwania od PORT-u. Należy zwrócić uwagę że obsługa przewanie jest wywoływane dla całego portu a nie wybranego pinu w porcie. Pierwsze co musimy zrobić to sprawdzić który pin zgłosił przerwanie. Chyba że mamy ustawiony tylko jeden pin w porcie który będzie zgłaszał przerwanie. 06
070809
  1. ISR(PORTC_PORT_vect)
  2. {
  3.     if(PORTC.INTFLAGS & PIN5_bm) // sprawdzenie czy 5 bit wywoÅ‚aÅ‚ przerwanie
  4.       { 
  5.          PORTC.OUTSET = PIN7_bm;
  6.       }
  7.     PORTC.INTFLAGS |=  PIN5_bm;   // kasowanie flagi przerwania, wymagane
  8. }



Kilka procedur do wysyłania danych przez USART.
  3. void initUsart0(float bspeed)
  4. {
  5.     // 115200 reszt 8 N 1 danych jest ustawiona domyslnie danych jest
  6.     //uart0 na pinach podstawowych
  7.     PORTB.DIRSET = PIN2_bm; // PA0(44)=0.TxD
  8.     PORTB.DIRCLR = PIN3_bm; // PA1(45)=0.RxD
  10.     // uart na pinach zapasowych
  11.     //PORTMUX.USARTROUTEA = 0b00000001;
  12.     //PORTA.DIRSET = PIN4_bm; // PA4(48)=0.TxD
  13.     //PORTA.DIRCLR = PIN5_bm; // PA5( 1)=0.RxD
  14.    
  15.     USART0.BAUD = (uint16_t)USART0_BAUD_RATE(bspeed);
  16.     USART0.CTRLB |= USART_TXEN_bm;
  17. }
  19. void rsChar(uint8_t channel ,  char c)
  20. {
  21.     switch (channel)
  22.       {
  23.         case 0 : { while (!(USART0.STATUS & USART_DREIF_bm)); 
  24.                    // bufor USART0.TXDATAL jest pusty
  25.                    USART0.STATUS |= USART_TXCIF_bm;           
  26.                    // flaga informujÄ…ca o braku danych do wysÅ‚ania
  27.                    USART0.TXDATAL = c;                        
  28.                    // zaÅ‚adowane nowej danej
  29.                    break; }
  30.         case 1 : { while (!(USART1.STATUS & USART_DREIF_bm));
  31.                    USART1.STATUS |= USART_TXCIF_bm;        
  32.                    USART1.TXDATAL = c; 
  33.                    break; }
  34.         case 2 : { while (!(USART2.STATUS & USART_DREIF_bm));
  35.                    USART2.STATUS |= USART_TXCIF_bm;        
  36.                    USART2.TXDATAL = c; 
  37.                    break; }
  38.         case 3 : { while (!(USART3.STATUS & USART_DREIF_bm));
  39.                    USART3.STATUS |= USART_TXCIF_bm;        
  40.                    USART3.TXDATAL = c; 
  41.                    break }
  42.       }
  43. }
  45. void rsString(uint8_t channel, char *str)
  46. {
  47.     uint8_t i;
  48.     for( i = 0; i < strlen(str); i++)
  49.       { 
  50.         rsChar( channel, str[i]);
  51.       }
  52. }
  55. void rsInt(uint8_t channel, long num ) // wysÅ‚anie liczby caÅ‚kowitej
  56. {
  57.     char buffer[20];
  58.     ltoa( num , buffer, 10);
  59.     rsString(channel, buffer );
  60. }
Procedury i funkcje do obsługi TWI.
  1. /*
  2.  *  twi.c
  3.  *  Created: 2019-08-20
  4.  *  Author: Dasej
  5.  */ 
  7. #include <avr/io.h>
  8. #define TWI0_BAUD(F_SCL)  ((((float)F_CPU / (float)F_SCL)) - 10 )
  10. void initTwi(float ispeed)
  11. {
  12.    TWI0.MBAUD = (uint8_t)TWI0_BAUD(ispeed);  
  13.    TWI0.MCTRLB |= TWI_FLUSH_bm;
  14.    TWI0.MSTATUS |= (TWI_RIF_bm | TWI_WIF_bm);
  15.    TWI0.MCTRLA = 1<<TWI_SMEN_bp | 1 << TWI_ENABLE_bp;
  16.    TWI0.MSTATUS |= TWI_BUSSTATE_IDLE_gc;
  17. }
  19. void twi_start(char addr)
  20. {
  21.    TWI0.MCTRLB &= ~(1<<TWI_ACKACT_bp);
  22.    TWI0.MADDR = addr;
  23.    if (addr & 1) { while (!(TWI0_MSTATUS & TWI_RIF_bm)); }
  24.             else { while (!(TWI0_MSTATUS & TWI_WIF_bm)); }
  25. }
  27. char twi_read( char ack)
  28. {
  29.    while (!(TWI0.MSTATUS & TWI_RIF_bm));
  30.    if (ack) { TWI0.MCTRLB &= ~(1<<TWI_ACKACT_bp); } //Send ACK
  31.        else { TWI0.MCTRLB |= 1<<TWI_ACKACT_bp;  }  //Send NACK
  32.    return TWI0.MDATA;
  33. }
  35. void twi_write(char data)
  36. {
  37.    while (!((TWI0.MSTATUS & TWI_WIF_bm) | (TWI0_MSTATUS & TWI_RXACK_bm)));
  38.    TWI0.MDATA = data;
  39. }
  41. void twi_stop()
  42. {
  43.    TWI0.MCTRLB |= TWI_MCMD_STOP_gc;
  44. }
Przykład użycia procedur i funkcje do obsługi TWI.
  1.     initTwi(100000);
  3.     // zapis danych do rejestru 
  4.     twi_start(0x90);       // adres urzÄ…dznie
  5.     twi_write(0x01);       // adres rejestru
  6.     twi_write(0b11100001); // wartość
  7.     twi_stop();
  9.     // odczyt dwóch bajtów 
  10.     twi_start(0x90);  // adres urzÄ…dznie
  11.     twi_write(0x00);  // adres rejestru do odczytu
  12.     twi_start(0x91);  // adres urzÄ…dzenia, odczytujemy  
  13.     d1=twi_read(1);   // czytaj dalej 
  14.     d2=twi_read(0);   // zakoÅ„cz czytanie
  15.     twi_stop();
Odczyt danych z przetwornika ADC0.
  1. /*
  2.  *  ADC.c
  3.  *  Created: 2019-08-17 08:37:35
  4.  *  Author: Dasej
  6.      VREF_ADC0REFSEL_0V55_gc = (0x00<<4),  // Voltage reference at 0.55V
  7.      VREF_ADC0REFSEL_1V1_gc  = (0x01<<4),  // Voltage reference at 1.1V 
  8.      VREF_ADC0REFSEL_2V5_gc  = (0x02<<4),  // Voltage reference at 2.5V 
  9.      VREF_ADC0REFSEL_4V34_gc = (0x03<<4),  // Voltage reference at 4.34V 
  10.      VREF_ADC0REFSEL_1V5_gc  = (0x04<<4),  // Voltage reference at 1.5V 
  11.  
  12.  */ 
  14. #include <avr/io.h>
  16. void initADC(void)
  17. {
  18.     VREF.CTRLA |=( VREF_ADC0REFSEL_2V5_gc);
  19.     ADC0.CTRLA |= ADC_RESSEL_10BIT_gc;
  21.     ADC0.CTRLC |= ADC_PRESC_DIV4_gc;
  22.     ADC0.CTRLC |= ADC_REFSEL_VREFA_gc;
  23.     ADC0.CTRLC |= ADC_SAMPCAP_bm;
  25. }
  27. uint16_t inADC(uint8_t channel)
  28. {
  29.     ADC0_MUXPOS = channel;
  30.     ADC0.CTRLC = ADC_SAMPCAP_bm | ADC_PRESC_DIV64_gc | ADC_REFSEL_INTREF_gc 
  31.     ADC0.CTRLA = ADC_ENABLE_bm;
  33.     ADC0.COMMAND = ADC_STCONV_bm 
  34.     while(!(ADC0.INTFLAGS & ADC_RESRDY_bm)) {;}
  36.     return ADC0.RES;
  37. }



Warning: Uninitialized string offset 0 in /usr/home/dasej/domains/dasej.pl/public_html/autoCreate.php on line 223
Fatal error: Uncaught mysqli_sql_exception: Table 'm1592_php.tab' doesn't exist in /usr/home/dasej/domains/dasej.pl/public_html/autoCreate.php:309 Stack trace: #0 /usr/home/dasej/domains/dasej.pl/public_html/autoCreate.php(309): mysqli_query(Object(mysqli), 'select txt from...') #1 {main} thrown in /usr/home/dasej/domains/dasej.pl/public_html/autoCreate.php on line 309