Desafio:
- Usando Round Robin sem interrupções implementar um sistema com um LED e um botão. O sistema deve piscar o LED a cada 2 segundos e ao botão ser pressionado envia uma mensagem pela serial.

(22/08/2018) – Interrupções

(27/08/2018) – Usando C++

Mudança de nível de abstração

Arduino Mega --> ATmega2560 (Ex.: I/O Ports)
Esquemático Arduino Mega
Esquemático Arduino Mega - CLONE

Fonte: https://www.arduino.cc/en/Hacking/PinMapping2560

ATmega2560: I/O Ports

Tabela verdade de configuração das portas:

Endereços registradores de I/O:

GCC, avr-libc

avr-libc
A simple Project
Eclipse IDE Neon.2 para Linux 64-bits (última atualização em 24/02/2017) - Mantido pelo Prof. Arliones.

Prática

Implemente um programa usando GCC e avr-libc para ligar um led quando um botão for pressionado (exemplo)
Operação de Bits em C/C++
Operações Booleanas em C/C++
Programming 101 - By Eric Weddington

Atividade

Re-implementar as seguintes atividades usando C++ e AVR-Libc:

Entregar:

Código fonte
Relatório apresentando principais registradores utilizados para cada atividade.

(29/08/2018) – Auxílio Atividade (Teste GPIO)

(03/09/2018) – Auxílio Atividade (Serial)

Análise dos registradores de controle
Funcionamento bloqueante da Serial

(05/09/2018) – Auxílio Atividade (Interrupção)

<avr/interrupt.h>: Interrupts

(09/09/2018) – Aula cancelada

Aula cancelada devido a troca pelo horário de sexta-feira

(12/09/2018) – Debug

Debug plataforma Atmega2560
Esquemático Arduino Mega - CLONE

Código C:

#include <avr/io.h>
#include <util/delay.h>

int main(){

	DDRB  = 0xFF;
	DDRE  = 0xFF;
	while(1){
		PORTB = 0x00;
		PORTE = 0x00;
		_delay_ms(1000);
		PORTB = 0xFF;
		PORTE = 0xFF;
		_delay_ms(1000);

	}

	return 1;
}

Código Arduino:

#define led1 1


void setup() {
  // put your setup code here, to run once:
  pinMode(led1, OUTPUT);
  
}

void loop() {
  // put your main code here, to run repeatedly:
 
  digitalWrite(led1, HIGH);
  delay(1000);
  digitalWrite(led1, LOW);
  delay(1000);
  
}

avr-objdump -h -S <PROJECT_NAME>.elf > <PROJECT_NAME>.lst

(17/09/2018) – Classe GPIO

Mapeamento de Pinos Arduino Mega

#include <avr/io.h>
#include <util/delay.h>
#include "GPIO.h"


//LEDS PLACA (acende com '0')
GPIO led0(0, GPIO::OUTPUT);		//PE0
GPIO led1(1, GPIO::OUTPUT);		//PE1

//LEDS PLACA (acende com '1')
GPIO led13(13, GPIO::OUTPUT);	//PB7

//Adicionar LED
GPIO led4(4, GPIO::OUTPUT);		//PG5
GPIO led6(6, GPIO::OUTPUT);		//PH0

int main(void){

	UCSR0B = 0;

	led0.set(1);
	led1.set(1);
	led6.clear();
	led4.clear();
	led13.clear();
	_delay_ms(1000);
	led0.clear();
	led1.clear();
	led6.set(1);
	led4.set(1);
	led13.set(1);
	_delay_ms(1000);

	while (1){
		led0.toggle();
		led1.toggle();
		led6.toggle();
		led4.toggle();
		led13.toggle();
		_delay_ms(1000);
	}

}

(19/09/2018) – Classe GPIO (cont.)

Continuando a implementação da classe.

(24/09/2018) – Classe GPIO (cont.)

Classe GPIO_Port
Análise conceitual das diferentes versões
Atividade 2:
- Análise prática das versões passadas em sala de aula (tamanho do construtor e do método set(val)).
- Completar a classe GPIO e GPIO_port para todos os pinos da plataforma Arduino, seguintes IDs:
  - Mapeamento de Pinos Arduino Mega
- Os arrays devem ser forçados para memória flash:
  - PROGMEM
- Entregar Código Fonte e Relatório contendo:
  - Análise prática e conceitual das versões
  - Discussão da implementação

(26/09/2018) – Classe UART Bloqueante

Dúvidas A2 (Classe GPIO)

Proposta e implementação da UART Bloqueante

Ler o capítulo 22 do datasheet (USART). Atenção especial as seguintes seções:
- "Clock Generation"
- "USART Initialization"
- "Sending Frames with 5 to 8 Data Bit"
- "Receiving Frames with 5 to 8 Data Bits"
- "Register Description"

Diagrama de Classe:

(01/10/2018) – Classe UART com Interrupção

Proposta e implementação da UART com interrupção:

Ler manuais da AVR-LIBC:
- https://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
- https://www.microchip.com/webdoc/AVRLibcReferenceManual/group__avr__interrupts.html

Ler o capítulo 14 do datasheet (Interrupts).
Ler Seção "7.8 Reset and Interrupt Handling"
Ler o capítulo 22 do datasheet (USART). Atenção especial as seguintes seções:
- "Transmitter Flags and Interrupts"
- "Receive Compete Flag and Interrupt"
- "Register Description"
Atenção, a interrupção TXCIEn não deve ser usada - normalmente ela é utilizada apenas para implementar protocolos com reconhecimento/ack;
Diagrama de Classe:

(03/10/2018) – Classe Interrupção Externa

Proposta e implementação da classe de Interrupção Externa:

A classe deve funcionar para as 8 interrupções externas (INTn). Não confundir com a PCINTn.

Ler manuais da AVR-LIBC:
- https://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
- https://www.microchip.com/webdoc/AVRLibcReferenceManual/group__avr__interrupts.html

Ler o capítulo 14 do datasheet (Interrupts).
Ler Seção "7.8 Reset and Interrupt Handling"
Ler o capítulo 15 do datasheet (External Interrupts). Atenção especial as seguintes seções:
- "Register Description" (EICRA, EICRB, EIMSK e EIFR)

Diagrama de Classe:

#include <avr/interrupt.h>
#include "extint.h"
#include "uart.h"

using namespace EXT_INT;

UART uart(19200, UART::DATABITS_8, UART::NONE, UART::STOPBIT_1);

void int0_handler(void){
	uart.put('0');
	return;
}

void int1_handler(void){
	uart.put('1');
	return;
}

void int2_handler(void){
	uart.put('2');
	return;
}

void int3_handler(void){
	uart.put('3');
	return;
}

void int4_handler(void){
	uart.put('4');
	return;
}

void int5_handler(void){
	uart.put('5');
	return;
}

void int6_handler(void){
	uart.put('6');
	return;
}

void int7_handler(void){
	uart.put('7');
	return;
}

int main( void ){

	ExtInt int0_obj(ExtInt::INT_0, ExtInt::FALLING, &int0_handler);
	ExtInt int1_obj(ExtInt::INT_1, ExtInt::FALLING, &int1_handler);
	ExtInt int2_obj(ExtInt::INT_2, ExtInt::FALLING, &int2_handler);
	ExtInt int3_obj(ExtInt::INT_3, ExtInt::FALLING, &int3_handler);
	ExtInt int4_obj(ExtInt::INT_4, ExtInt::FALLING, &int4_handler);
	ExtInt int5_obj(ExtInt::INT_5, ExtInt::FALLING, &int5_handler);
	ExtInt int6_obj(ExtInt::INT_6, ExtInt::FALLING, &int6_handler);
	ExtInt int7_obj(ExtInt::INT_7, ExtInt::FALLING, &int7_handler);
	
	int0_obj.enable();
	int1_obj.enable();
	int2_obj.enable();
	int3_obj.enable();
	int4_obj.enable();
	int5_obj.enable();
	int6_obj.enable();
	int7_obj.enable();

	sei();
	while(1){                                   /* forever */
		if (uart.has_data()){
			uart.put(uart.get());                 /* echo the received character */
			uart.put((EICRA+0x30));
		}
	}

	return 0;
}

(08/10/2018) – Trabalhando Classe Serial e Interrupção externa

(10/10/2018) – Trabalhando Classe Serial e Interrupção externa (cont.)

(15/10/2018) – Trabalhando Classe Serial e Interrupção externa (cont.)

(17/10/2018) – Alunos encaminhados MCC

(22/10/2018) – Timer e Timeouts

Leitura capítulo 16 ("8-bit Timer/Counter0 with PWM").
Adaptar e testar a classe timer fornecida para o Atmega2560:
- Classe Timer

Implementar a classe Timeout e e inserir os métodos "TimeoutManager" e "addTimeout" na classe Timer:

(24/10/2018) – Timer e Timeouts (cont.)

(29/10/2018) – Atividade A3

Serial:
- Adicionar uma implementação de FIFO

Interrupção externa:
- Criar uma classe para tratar eventos não "prioritários" usando a PCINT
- Gerenciador de interrupções para adicionar no programa principal

Timeout:
- Implementar o suporte a pelo menos um Timer de 16 bits
- Permitir a escolha do Timer no construtor

Entrega:
- Implementar programas que testem as classes amplamente baseados nos requisitos
- Modelar a classe em UML
- Entregar todas as versões trabalhadas em sala de aula com programas testes
- Discutir a abordagem da extensão das classes
- Apresentar e defender individualmente as implementações

Data da Entrega: 12/11

(31/10/2018) – Atividade A3 (cont.)

STE29008-2018-2

Índice

Sistemas Embarcados

Aula 1 (30/07/2018) – Apresentação

Aula 2 (01/08/2018) – Introdução

Aula 3 (06/08/2018) – GPIO

Aula 4 (08/08/2018) – UART

Aula 5 (13/08/2018) – ADC

(15/08/2018) – ADC (cont.)

(20/08/2018) – PWM