discussion04

Dicussion 04 C Intro with Piezo and UART

Ryan Robucci

Objectives

Review AVR I/O control and demo AVR C program on the AVR Butterfly

PORTx and DDRx Review

Summary of control signals for port pins

DDxn	PORTxn	PUD (in MCUCR)	I/O	Pull-Up	Comment
0	0	X	Input	No	Tri-state (Hi-Z)
0	1	0	Input	Yes	Pxn will source current if ext. pulled low.
0	1	1	Input	No	Tri-state (Hi-Z)
1	0	X	Output	No	Output Low (Sink)
1	1	X	Output	No	Output High (Source)

Micro-Controller Specific Constants/Defines

All programs will have a line of code to include various utility functions, as well as various value definitions and processor specific definitions
```
# include <avr/io.h>
```
which in turn includes <avr/iom169.h>
The files are located at "toolchain-directory/avr/include/avr"

Setting Up the Direction Bits

To set the direction of all 8 pins of port D, assign a 8-bit value to DDRD

DDRD = 0xFF;              // set all port D pins as outputs
DDRD = 0X00;              // set all port D pins as inputs
DDRD = 0b10101010;        // alternating pin directions

To just set pin 2 of port D to output, not touching the others

DDRD = DDRD | 0b00000100;

Or just

DDRD |= 0b00000100;        // recommended!

Outputting Values to PORTx

Do not set all 8 bits in register PORTD without regard for directions of each individual pin, i.e. all the bits stored in DDRD
Use bit operations when possible to suggest use of I/O bit assembly commands and to avoid unintentionally setting extra bit values

Set one pin:

PORTD |= (1<<3);

same as:

PORTD |= (1<<PD3);

Clear one pin:

PORTD &= ~((1<<3));

same as:

PORTD &= ~((1<<PD3));

Don't forget to set direction of pins first!
Remember if pins are configured as inputs (DDRD bit is 0) then the corresponding bit in PORTD (PORTDn) sets the pull-up status

Setting Multiple Pins

lets say we need 0, 2, 4, 6 pins to be as input and 1, 3, 5, 7 as output

DDRD = (1<<1)|(1<<3)|(1<<5)|(1<<7);     \\ set all port D pins as outputs

same as:

DDRD = (1<<7)|(0<<6)|(1<<5)|(0<<4)|(1<<3)|(0<<2)|(1<<1)|(0<<0);     \\ alternating pin directions

PD7 is defined as 7 in the device include file. Using PD7 instead of 7 is arguably more self-documenting:

DDRD = (1<<PD7)|(0<<PD6)|(1<<PD5)|(0<<PD4)|(1<<PD3)|(0<<PD2)|(1<<PD1)|(0<<PD0);

So we can output values to 1, 3, 5 and 7 pins:

PORTD |= (1<<1)|(1<<3)|(1<<5)|(1<<7);

Or clean them:

PORTD &= ~((1<<1)|(1<<3)|(1<<5)|(1<<7));

Checking Multiple Bits

flag = PIND & (0b00000001 | 0b01000000);

if (flag){
    // do something when flag either pin is high
}

The following modification changes nothing but expresses intent more explicitly

if (flag != 0){
    // do something when flag is non-zero
}

Special Functions

You may also use the _BV(x) macro defined in avr/sfr_defs.h which is included through avr/io.h as #define_BV(x)(1<<x)

#include <avr\io.h>

int main(void){
    DDRD &= ~_BV(0);    // set PORTD pin0 to zero as input
    PORTD |= _BV(0);    // enable pull up
    DDRD |= _BV(1);     // set PORTD pin1 to one as output
    PORTD |= _BV(1);    // LED ON
    while(1){
        if (bit_is_clear(PIND,0)){
            //if Button is presses
            while(1){
              PORTD &= ~_BV(1);    // LED OFF
              // LED OFF while Button is pressed
              loop_until_bit_is_det(PIND,0);
              PORTD |= _BV(1);     // LED ON

            }
        }
    }
}

Using Predefined Bits

Example to set bits TXEN0 and RXEN0 in UCSR0B

UCSR0B = _BV(TXEN0)|_BV(RXEN0);     //enable RX and TX

Both RXEN0 and TXEN0 is predefined in iom169p.h

Software Delay Functions

_delay_ms(double_ms)
- Requires #include <util/delay.h>
- F_CPU preprocessor symbol should be defined as MCPU frequency in Hz using #define or passed through the -D compiler option
  - in code:
```
#define F_CPU 8000000UL // 8MHz
```
  - Command line option: -D F_CPU=8000000UL
- Max delay is $4294967.295 * 10^6 / F\_CPU$ $4294967.295 * 1 0^{6} / F_CP U$ ms (Ex: 536871 ms for a 8MHz clock)
  - Assumes the avr-gcc toolchain being used has __builtin_avr_delay_cycles (unsigned long) support
  - Otherwise max delay is less and reduced precision is used for long delays (see documentation)
  - Use multiple delay commands if needed
- Conversion of delay to clock cycles will be rounded up to the next integer to ensure at least the specified delay
  - Alternatively, user can define __DELAY_ROUND_DOWN__ and __DELAY_ROUND_CLOSEST__ to round down and round to closest integer
_delay_us(double_us)
- Same as before but max delay is 1000 times less: $4294967.295*10^6 / F\_CPU$ us (Ex: 536871 us for a 8MHz clock)

AVR C Code

Piezo Buzzer is on Pin B5

#include <stdio.h>
#include <stdlib.h>

#include <avr/io.h>
# define F_CPU 8000000UL 
#include <util/delay.h>

int main(void){
    //DDRB=0xFF; overdone, change to DDRB|=_BV(PB5);
    
    // PORTB |=(1<<5);
    // PORTB &=~((1<<PB5));

    while(1) {
        _delay_us(200);
        PORTB |=((1<<PB5));
        _delay_us(200);
        PORTB &=~((1<<PB5));
    }
}

Uart Communications

Set your buad rate for 38400

uart.h

// File uart.h
// This is a guard condition so that contents of this file are not included
// more than once.  
#ifndef UART_H
#define	UART_H

#include <xc.h> // include processor files - each processor file is guarded.  
#include <avr/io.h>
#include <stdio.h>

#define BAUD_RATE   38400
/*

.equ	UBRRL	= UBRR0L	; For compatibility
.equ	UBRR	= UBRR0L	; For compatibility
.equ	UBRRH	= UBRR0H	; For compatibility
.equ	UCSRA	= UCSR0A	; For compatibility
.equ	UCSRB	= UCSR0B	; For compatibility
.equ	UDRE	= UDRE0	; For compatibility
.equ	UCSRC	= UCSR0C	; For compatibility
.equ	UCSZ1	= UCSZ01	; For compatibility
.equ	UDR	= UDR0	; For compatibility
.equ	UCSZ0	= UCSZ00	; For compatibility
.equ	RXC	= RXC0	; For compatibility
.equ	TXEN	= TXEN0	; For compatibility
.equ	RXEN	= RXEN0	; For compatibility
.equ	USBS	= USBS0	; For compatibility
*/

#define UBRRL UBRR0L
#define UBRR  UBRR0L
#define UBRRH UBRR0H
#define UCSRA UCSR0A
#define UCSRB UCSR0B
#define UDRE  UDRE0
#define UCSRC UCSR0C
#define	UCSZ1 UCSZ01
#define UDR UDR0
#define UCSZ0 UCSZ00
#define RXC RXC0
#define TXEN TXEN0
#define RXEN RXEN0
#define USBS USBS0

extern FILE uart_stream;

void UARTInit(void);
int SerialPutch(char ch);
int UARTPutch(char ch, FILE *stream);
int UARTGetch(FILE *stream);
int UARTIsByteAvailable(FILE *stream);

#endif

uart.c

/*
 * File:   uart.c
 * Author: robucci
 *
 * Created on March 1, 2022, 8:26 PM
 */


#ifndef F_CPU
#define F_CPU 8000000UL
#endif
#include "uart.h"

/* Assign I/O stream to UART */
FILE uart_stream = FDEV_SETUP_STREAM(UARTPutch, UARTGetch, _FDEV_SETUP_RW);

void UARTInit(void)
{

//BAUD RATE of 4800 for 8Mhz
//UBRRH = 0;
//UBRRL = 103;   
UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8;		// set baud rate
UBRRL = (((F_CPU/BAUD_RATE)/16)-1);


UCSRA = 0; //clearing all flags


UCSRB = (1<<RXEN0)|(1<<TXEN0);
  /* Enable Tx and Rx */
//  UCSRB = (1<<RXEN)|(1<<TXEN);


//UCSR0C =(1<<USBS0)|(3<<UCSZ00);
  /* Set Frame: Data 8 Bit, No Parity and 2 Stop Bit */
UCSRC = (1<<USBS0)|(3<<UCSZ00);

}

int SerialPutch(char ch)
{   
   while (!(UCSRA & (1<<UDRE))); //loop until bit is set
   UDR=ch;

   return 0;
}

int UARTPutch(char ch, FILE *stream)
{
   if (ch == '\n')
    UARTPutch('\r', stream);

   while (!(UCSRA & (1<<UDRE))); //loop until bit is set
   UDR=ch;

   return 0;
}

int UARTGetch(FILE *stream)
{
   unsigned char ch;

   while (!(UCSRA & (1<<RXC))); //loop until bit is set
   ch=UDR;  

   /* Echo the output back to the terminal */
   UARTPutch(ch,stream);      

   return ch;
}

int UARTIsByteAvailable(FILE *stream)
{
   return (UCSRA & (1<<RXC));
}

/*
 * File:   main.c
 * Author: robucci
 *
 * Created on March 1, 2022, 7:49 PM
 */


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>    
#include <string.h>    
#include <inttypes.h>    
#include <ctype.h>    
#include <unistd.h>

#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h"


#define MYDEBUG

#ifdef MYDEBUG
#define DEBUG_PRINTF(...) printf(__VA_ARGS__)
#define DEBUG_PRINTENTER(...) {printf("Entering Function ");int i=0;while(__func__[i]!='\0'){putchar(__func__[i]);i++;};putchar('\n');}
#define DEBUG_PRINTEXIT(...) {printf("Leaving Function ");int i=0;while(__func__[i]!='\0'){putchar(__func__[i]);i++;};putchar('\n');}
#else
#define DEBUG_PRINTF(...)
#define DEBUG_PRINTENTER(...)
#define DEBUG_PRINTEXIT(...)
#endif


#define LEN_USER_LINE 4

char userLine[LEN_USER_LINE];

void myFunc(const char str[]);

    
int main(void) {
    stderr = stdout = stdin = &uart_stream; /* Redirecting the standard I/O */
    UARTInit();
    
    DDRB |=  _BV(5);
    for (int i=0;i<100;i++){
        PORTB |=  (1<<5);
        _delay_ms(2);
        PORTB &= ~(1<<5);
        _delay_ms(2);
    }
    printf("*\b");
    if (fgets(userLine,LEN_USER_LINE,stdin)!=NULL) {
        if (strncmp(userLine,"yes",LEN_USER_LINE)==0){ //zero for match
            myFunc(userLine);
        }
    }
}

void myFunc(const char str[]){
    DEBUG_PRINTENTER();
    DEBUG_PRINTF("\tUser typed : \"%s\"\n",str);
    DEBUG_PRINTEXIT();
}