collab/PineapplePad

git clone https://git.julia.blue/collab/PineapplePad

Joseph RyanAdd sfx0e8c935

master
7.8 KiB243 linesraw
1#include <stdint.h>
2#include "../inc/tm4c123gh6pm.h"
3#include "../inc/UART.h"
4
5#define PF1  (*((volatile uint32_t*)0x40025008))
6
7extern "C" void DisableInterrupts(void); // Disable interrupts
8extern "C" long StartCritical(void);     // previous I bit, disable interrupts
9extern "C" void EndCritical(long sr);    // restore I bit to previous value
10extern "C" void WaitForInterrupt(void);  // low power mode
11extern "C" void EnableInterrupts(void);
12
13#define NVIC_EN0_INT5    0x00000020  // Interrupt 5 enable
14extern "C" void UART0_Handler(void);
15#define TXFIFOSIZE 32 // must be a power of 2
16#define FIFOSIZE 32
17#define FIFOSUCCESS 1
18#define FIFOFAIL    0
19
20typedef char txDataType;
21uint32_t volatile TxPutI;// put next
22uint32_t volatile TxGetI;// get next
23txDataType static TxFifo[TXFIFOSIZE];
24
25// initialize index FIFO
26void TxFifo_Init(void) {
27    long sr;
28    sr = StartCritical(); // make atomic
29    TxPutI = TxGetI = 0;  // Empty
30    EndCritical(sr);
31}
32
33// add element to end of index FIFO
34// return TXFIFOSUCCESS if successful
35int TxFifo_Put(txDataType data) {
36    if (((TxPutI + 1) & (TXFIFOSIZE - 1)) == TxGetI) {
37        return(FIFOFAIL); // Failed, fifo full
38    }
39    TxFifo[TxPutI] = data; // put
40    TxPutI = (TxPutI + 1) & (TXFIFOSIZE - 1); // Success, update
41    return(FIFOSUCCESS);
42}
43
44// remove element from front of index FIFO
45// return TXFIFOSUCCESS if successful
46int TxFifo_Get(txDataType* datapt) {
47    if (TxPutI == TxGetI) {
48        return(FIFOFAIL); // Empty if TxPutI=TxGetI
49    }
50    *datapt = TxFifo[TxGetI];
51    TxGetI = (TxGetI + 1) & (TXFIFOSIZE - 1); // Success, update
52    return(FIFOSUCCESS);
53}
54
55// number of elements in index FIFO
56// 0 to TXFIFOSIZE-1
57uint32_t TxFifo_Size(void) {
58    return (TxPutI - TxGetI) & (TXFIFOSIZE - 1);
59}
60
61#define RXFIFOSIZE 32 // must be a power of 2
62typedef char rxDataType;
63uint32_t volatile RxPutI;// put next
64uint32_t volatile RxGetI;// get next
65rxDataType static RxFifo[RXFIFOSIZE];
66// initialize index FIFO
67void RxFifo_Init(void) {
68    long sr;
69    sr = StartCritical(); // make atomic
70    RxPutI = RxGetI = 0;  // Empty
71    EndCritical(sr);
72}
73
74// add element to end of index FIFO
75// return FIFOSUCCESS if successful
76int RxFifo_Put(rxDataType data) {
77    if (((RxPutI + 1) & (RXFIFOSIZE - 1)) == RxGetI) {
78        return(FIFOFAIL); // Failed, fifo full
79    }
80    RxFifo[RxPutI] = data; // put
81    RxPutI = (RxPutI + 1) & (RXFIFOSIZE - 1); // Success, update
82    return(FIFOSUCCESS);
83}
84
85// remove element from front of index FIFO
86// return FIFOSUCCESS if successful
87int RxFifo_Get(rxDataType* datapt) {
88    if (RxPutI == RxGetI) {
89        return(FIFOFAIL); // Empty if TxPutI=TxGetI
90    }
91    *datapt = RxFifo[RxGetI];
92    RxGetI = (RxGetI + 1) & (RXFIFOSIZE - 1); // Success, update
93    return(FIFOSUCCESS);
94}
95
96// number of elements in index FIFO
97// 0 to RXFIFOSIZE-1
98uint32_t RxFifo_Size(void) {
99    return (RxPutI - RxGetI) & (RXFIFOSIZE - 1);
100}
101
102// Initialize UART0
103// Baud rate is 115200 bits/sec
104void UART_Init(void) {
105    SYSCTL_RCGCUART_R |= 0x01;            // activate UART0
106    SYSCTL_RCGCGPIO_R |= 0x01;            // activate port A
107    RxFifo_Init();                        // initialize empty FIFOs
108    TxFifo_Init();
109    UART0_CTL_R &= ~UART_CTL_UARTEN;      // disable UART
110    UART0_IBRD_R =
111        43;                    // IBRD = int(80,000,000 / (16 * 115,200)) = int(43.403)
112    UART0_FBRD_R = 26;                    // FBRD = round(0.403 * 64 ) = 26
113    // 8 bit word length (no parity bits, one stop bit, FIFOs)
114    UART0_LCRH_R = (UART_LCRH_WLEN_8 | UART_LCRH_FEN);
115    UART0_IFLS_R &=
116        ~0x3F;                // clear TX and RX interrupt FIFO level fields
117    // configure interrupt for TX FIFO <= 1/8 full
118    // configure interrupt for RX FIFO >= 1/8 full
119    UART0_IFLS_R += (UART_IFLS_TX1_8 | UART_IFLS_RX1_8);
120    // enable TX and RX FIFO interrupts and RX time-out interrupt
121    UART0_IM_R |= (UART_IM_RXIM | UART_IM_TXIM | UART_IM_RTIM);
122    UART0_CTL_R |= 0x301;                 // enable UART
123    GPIO_PORTA_AFSEL_R |= 0x03;           // enable alt funct on PA1-0
124    GPIO_PORTA_DEN_R |= 0x03;             // enable digital I/O on PA1-0
125    // configure PA1-0 as UART
126    GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R & 0xFFFFFF00) + 0x00000011;
127    // UART0=priority 2
128    NVIC_PRI1_R = (NVIC_PRI1_R & 0xFFFF00FF) | 0x00004000; // bits 13-15
129    NVIC_EN0_R = NVIC_EN0_INT5;           // enable interrupt 5 in NVIC
130}
131
132// copy from hardware RX FIFO to software RX FIFO
133// stop when hardware RX FIFO is empty or software RX FIFO is full
134void static copyHardwareToSoftware(void) {
135    char letter;
136    while (((UART0_FR_R & UART_FR_RXFE) == 0) && (RxFifo_Size() < (FIFOSIZE - 1))) {
137        letter = UART0_DR_R;
138        RxFifo_Put(letter);
139    }
140}
141
142// copy from software TX FIFO to hardware TX FIFO
143// stop when software TX FIFO is empty or hardware TX FIFO is full
144void static copySoftwareToHardware(void) {
145    char letter;
146    while (((UART0_FR_R & UART_FR_TXFF) == 0) && (TxFifo_Size() > 0)) {
147        TxFifo_Get(&letter);
148        UART0_DR_R = letter;
149    }
150}
151
152// input ASCII character from UART
153// spin if RxFifo is empty
154char UART_InChar(void) {
155    char letter;
156    while (RxFifo_Get(&letter)) {
157    }
158    ;
159    return(letter);
160}
161
162bool UART_InStatus(void) {
163    // true if input data ready
164    return RxFifo_Size() > 0;
165}
166
167// output ASCII character to UART
168// spin if TxFifo is full
169void UART_OutChar(char data) {
170    while (TxFifo_Put(data) == FIFOFAIL) {
171    }
172    ;
173    UART0_IM_R &= ~UART_IM_TXIM;          // disable TX FIFO interrupt
174    copySoftwareToHardware();
175    UART0_IM_R |= UART_IM_TXIM;           // enable TX FIFO interrupt
176}
177
178// at least one of three things has happened:
179// hardware TX FIFO goes from 3 to 2 or less items
180// hardware RX FIFO goes from 1 to 2 or more items
181// UART receiver has timed out
182void UART0_Handler(void) {
183    if (UART0_RIS_R & UART_RIS_TXRIS) {    // hardware TX FIFO <= 2 items
184        UART0_ICR_R = UART_ICR_TXIC;        // acknowledge TX FIFO
185        // copy from software TX FIFO to hardware TX FIFO
186        copySoftwareToHardware();
187        if (TxFifo_Size() == 0) {            // software TX FIFO is empty
188            UART0_IM_R &= ~UART_IM_TXIM;      // disable TX FIFO interrupt
189        }
190    }
191    if (UART0_RIS_R & UART_RIS_RXRIS) {    // hardware RX FIFO >= 2 items
192        UART0_ICR_R = UART_ICR_RXIC;        // acknowledge RX FIFO
193        // copy from hardware RX FIFO to software RX FIFO
194        copyHardwareToSoftware();
195    }
196    if (UART0_RIS_R & UART_RIS_RTRIS) {    // receiver timed out
197        UART0_ICR_R = UART_ICR_RTIC;        // acknowledge receiver time out
198        // copy from hardware RX FIFO to software RX FIFO
199        copyHardwareToSoftware();
200    }
201}
202
203//------------UART_OutString------------
204// Output String (NULL termination)
205// Input: pointer to a NULL-terminated string to be transferred
206// Output: none
207void UART_OutString(char* pt) {
208    while (*pt) {
209        UART_OutChar(*pt);
210        pt++;
211    }
212}
213
214//-----------------------UART_OutUDec-----------------------
215// Output a 32-bit number in unsigned decimal format
216// Input: 32-bit number to be transferred
217// Output: none
218// Variable format 1-10 digits with no space before or after
219void UART_OutUDec(uint32_t n) {
220// This function uses recursion to convert decimal number
221//   of unspecified length as an ASCII string
222    if (n >= 10) {
223        UART_OutUDec(n / 10);
224        n = n % 10;
225    }
226    UART_OutChar(n + '0'); /* n is between 0 and 9 */
227}
228
229//------------UART_InMessage------------
230// Accepts ASCII characters from the serial port
231//    and adds them to a string until ETX is typed
232//    or until max length of the string is reached.
233// Input: pointer to empty buffer of 8 characters
234// Output: Null terminated string
235void UART_InMessage(char* bufPt) {
236    for (int i = 0; i < 8; ++i) {
237        char in = UART_InChar();
238        bufPt[i] = in;
239        if (in == ETX) {
240            break;
241        }
242    }
243}