Mudanças entre as edições de "STE29008-2018-2"
Ir para navegação
Ir para pesquisar
Linha 549: | Linha 549: | ||
* Apresentar: | * Apresentar: | ||
** Diagrama de Classes | ** Diagrama de Classes | ||
− | ** Diagrama de sequência ou máquina de estado do sistema | + | ** Diagrama de sequência ou máquina de estado do sistema ou fluxograma |
** Diagrama de blocos da solução do hardware | ** Diagrama de blocos da solução do hardware | ||
Edição das 07h39min de 26 de novembro de 2018
Sistemas Embarcados
- Professor: Roberto de Matos
- Encontros: segundas e quartas às 7:30h no Laboratório de Programação.
Aula 1 (30/07/2018) – Apresentação
- Apresentação do professor.
- Apresentação da disciplina.
- 2017 Embedded Markets Study
Aula 2 (01/08/2018) – Introdução
- Notas de Aula:
Aula 3 (06/08/2018) – GPIO
- Notas de Aula:
- Experimentos:
Aula 4 (08/08/2018) – UART
- Experimentos:
- Finalizar GPIO
- Lab 02: UART - Serial Communication
- Lab 03: UART - Master/Slave
Aula 5 (13/08/2018) – ADC
- Notas de Aula:
- Experimentos:
(15/08/2018) – ADC (cont.)
- Experimento:
(20/08/2018) – PWM
- 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:
- Lab 01: GPIO - Hello LED
- Lab 02: UART - Serial Communication
- Lab 04: UART - ADC e Sensor Reading
- Lab 07: GPIO and External Interrupts - part 1
- Lab 08: GPIO and External Interrupts - part 2
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)
(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
#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:
- Os arrays devem ser forçados para memória flash:
- Entregar Código Fonte e Relatório contendo:
- Análise prática e conceitual das versões
- Discussão da implementação
- Essas perguntas não precisam ser respondidas como questionário e não devem limitar suas análises.
- 1- Por que salvar o _bit como (1 << BIT_PORTA)? É melhor do que usar diretamente (1 << BIT_PORTA)?
- 2- Qual tamanho do clear? Por que ele é maior e mais lento que o set? Como resolver?
- 3- Por que utilizar grandes vetores na memória Flash? O que isso impacta no acesso a constante?
- 4- Comente sobre a versão 1.2 e 1.3. Qual é menor e por quê? Quais as vantagens da v1.3?
- 5- Comente sobre a estratégia usada na implementação v2?
- 6- Qual o tamanho total dos recursos ocupados pelo atributo do objeto "GPIO" nas vesões sugeridas?
- 7- Qual a diferença de expandir as versões passads para todos os pinos do hardware do arduino? Como isso impactaria no "construtor" e no "set"?
(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:
- 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:
- 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));
}
}
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:
- 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
Definição A3
- Serial:
- Adicionar uma implementação de FIFO
- Adicionar a configuração double speed no construtor
- Adicionar o puts (envio de strings)
- 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
Ponto de Checagem
- Análise do andamento das atividades realizadas em sala de aula desde o dia 26/08.
- Vinicius
- Seriais: OK
- ExtInt: NÃO
- timeout: OK
- Nelson
- Seriais: OK
- ExtInt: OK
- timeout: NÃO
- Gustavo
- Seriais: OK
- ExtInt: OK
- timeout: NÃO
- Letícia:
- Seriais: OK
- ExtInt: NÃO
- timeout: NÃO
- Bruno:
- Seriais: OK
- ExtInt: OK
- timeout: NÃO
- Luisa:
- Seriais: OK
- ExtInt: NÃO
- timeout: NÃO
- Mario Allan:
- Seriais: OK
- ExtInt: NÃO
- timeout: NÃO
- Mario Andre:
- Seriais: OK
- ExtInt: NÃO
- timeout: NÃO
- Schaiana:
- Seriais: Só bloqueante
- ExtInt: NÃO
- timeout: NÃO
- Layssa:
- Seriais: NÃO
- ExtInt: NÃO
- timeout: NÃO
- Lucas:
- Seriais: NÃO
- ExtInt: NÃO
- timeout: NÃO
(31/10/2018) – Atividade A3 (cont.)
(05/11/2018) – Aula Cancelada (Problemas Saúde)
(07/11/2018) – Atividade A3 (cont.)
(12/11/2018) – Atividade A3 (cont.)
https://sites.google.com/site/qeewiki/books/avr-guide/external-interrupts-on-the-atmega328
(14/11/2018) – Atividade A3 (cont.)
(19/11/2018) – Apresentação A3
(21/11/2018) – Apresentação A3
(26/11/2018) – Projeto Final
- Simular uma FXO para testar projetos de centrais telefônicas (FXS)
- Permitir o envio de uma sequência programável (via serial) de tons DTMF
- Três botões: 1) Start, 2) Program e 3) Cancel (Teste ou Programação)
- Ter uma sequência predefinida para teste sem programação, por exemplo, “tira do gancho”, 0, 1, 2, 3, 4, ..., *, #, “volta gancho”
- Mensagens durante o teste e programação devem ser enviadas via serial
- O sistema tem que se conectar de fato a uma FXS (provida pelo professor) e funcionar
- Três abordagens possíveis:
- Implementar a geração do DTMF no AVR (Precisa fazer o circuito de conexão, por exemplo)
- Usar um CI MT8880C para gerar o DTMF (Precisa fazer o circuito de conexão, por exemplo)
- Hackear um telefone. Por exemplo, Telefone Premium da Intelbras: Apostila Telefonia - Capítulo 4 e CI HM91710
- Cronograma:
- 03/12/2018: Entrega dos diagramas preliminares
- 12/12/2018: Última aula de dúvidas
- 14/12/2018: Prazo final para apresentação/teste do projeto (agendar com o professor) e entrega dos códigos e diagramas finais (pelo SIGAA)
- 17/12/2018: Recuperação
- Nota final:
- 60% Média das Atividades (A1, A2 e A3)
- 40% Nota do projeto final
(28/11/2018) – Projeto Final
- Não haverá Aula. Convocação "Critical Design Review" do FloripaSat.
(03/12/2018) – Projeto Final
(05/12/2018) – Projeto Final
- Apresentar:
- Diagrama de Classes
- Diagrama de sequência ou máquina de estado do sistema ou fluxograma
- Diagrama de blocos da solução do hardware