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::DOUBLE_FALSE, 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; }

<\code>

(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 TimeoutManager na classe Timer:

Mudanças entre as edições de "STE29008-2018-2"

Edição das 08h55min de 22 de outubro de 2018

Í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