Scrum Framework - Agile

O Scrum é um framework para desenvolver, entregar e manter produtos complexos.

Esta definição consiste em papéis, eventos, artefatos e as regras do Scrum que unem os demais e os mantém integrados.

Definição do Scrum: 

O Scrum é um framework dentro do qual pessoas podem tratar e resolver problemas complexos e adaptativos, enquanto produtiva e criativamente entregam produtos com o mais alto valor possível.

O Scrum é fundamentado nas teorias empíricas de controle de processo, ou empirismo. 

O empirismo afirma que o conhecimento vem da experiência e de tomada de decisões baseadas no que é conhecido. 

O Scrum emprega uma abordagem iterativa e incremental para aperfeiçoar a previsibilidade e o controle de riscos.

Três pilares apoiam a implementação de controle de processo empírico: 

A Transparência

Aspectos significativos do processo devem estar visíveis aos responsáveis pelos resultados. A transparência requer que estes aspectos tenham uma definição padrão comum para que os observadores compartilharem um mesmo entendimento comum do que está sendo visto.

Aqueles que realizam o trabalho e aqueles que inspecionam o incremento resultado do trabalho devem compartilhar uma definição comum de “Pronto”

Inspeção

Os usuários Scrum devem, frequentemente, inspecionar os artefatos Scrum e o progresso em direção ao objetivo da Sprint para detectar variações indesejadas. 

Esta inspeção não deve ser tão frequente que atrapalhe o objetivo dos trabalhos. 

Adaptação

Se um inspetor determina que um ou mais aspectos de um processo desviou para fora dos limites aceitáveis, e que o resultado do produto será inaceitável, o processo ou o material sendo produzido deve ser ajustado. 

O ajuste deve ser realizado o mais breve possível para minimizar mais desvios.

O Scrum prescreve quatro Eventos formais para inspeção e adaptação.

1.        Planejamento da Sprint 

2.        Reunião diária 

3.        Revisão da Sprint 

4.        Retrospectiva da Sprint

Os valores do Scrum são incorporados e vividos pelo Time Scrum e tornam-se vivos e constroem a confiança para todos.

Os membros do Time Scrum aprendem e exploram estes valores à medida que trabalham com os eventos, papéis e artefatos do Scrum.

Os artefatos do Scrum representam o trabalho ou o valor para o fornecimento de transparência e oportunidades para inspeção e adaptação.

Os artefatos definidos para o Scrum são especificamente projetados para maximizar a transparência das informações chave de modo que todos tenham o mesmo entendimento dos artefatos.

O product owner é o ponto central com poderes de liderança sobre o produto ele é o único responsável por decidir quais recursos e funcionalidades serão construídos e qual a ordem que eles devem ser feito é, responsabilidade dele manter e comunicar a todos os outros  participantes uma visão clara do que a equipe Scrum está buscando alcançar no projeto é, ele quem prioriza os itens do próprio product backlog;

O Scrum  Master é o responsável por ajudar a todos os envolvidos a entender e abraçar os valores, princípios e, práticas do Scrum.

Ele tem que conhecer muito bem o Scrum, o papel dele é agir como um coaching executando a liderança do processo e ajudando a equipe a desenvolver sua própria abordagem do Scrum

O Scrum Master também tem um papel de facilitador ele não é chefe de ninguém 

O Dev-team são as pessoas que de fato vão construir um projeto no Scrum, quem decide como fazer as coisas é, o time e não o gerente ou qualquer outra pessoa, a idéia principal é que a equipe se auto organize para determinar a melhor maneira de realizar o trabalho para atingir a meta estabelecida pelo Product Owner 

Tudo deve começar com a visão do produto pelos Stekholders, o Product Owner é responsável por prover está visão como um macro planejamento, o importante é que descreva o que ele quer e qual a meta que ele quer atingir, em seguida deve se desmembrar essa visão em todas as funcionalidades que são necessárias e estabelecer uma lista de funcionalidades, que é chamada de product backlog

Para entender como funciona o framework temos esse fluxo que é bem conhecida.

Tudo começa com a visão o esboço inicial visualizado pelos Stakeholder.

Atravez do Product Owner isso se desdobra em product backlog.

 Esse product backlog sofre grooming.

Onde é priorizado por maior valor ou grau de importância.

Depois durante o planejamento da sprint cria-se um sprint backlog.

Que é alista de histórias ou funcionalidades que serão criadas durante o Sprint.

O sprint com duração entre duas e quatro semanas.

Todos os dias no mesmo lugar e horário o daily scrum acontece com as suas três famosas perguntas.

O que eu fiz ontem que ajudou o time a atingir a meta do Sprint;

O que eu vou fazer hoje para ajudar o time a atingir a meta do Sprint;

Existe algum impedimento que não permita a mim o time atingir a meta do Sprint;

E ao final do sprint tem o produto funcionalidade concluída;

Também ocorre outros dois eventos.

O Sprint Review ou

Revisão da Sprint é realizada no final da Sprint para inspecionar o incremento e adaptar o Backlog do Produto se necessário.

ocorre também

Sprint Retropesctive ou

Retrospectiva da Sprint é uma oportunidade para o Time Scrum inspecionar a si próprio e criar um plano para melhorias a serem aplicadas na próxima Sprint.

Sensor de distância Ultrasonico com o Atmega328 – Arduino.

Segue código que utilizei no projeto.

// O código original é o que está no link abaixo, fiz algumas adaptações para poder visualizar no display de sete seguimentos.

// http://arduino.cc/en/Tutorial/ShftOut23

// Segue o código que adaptei. Janeiro de 2013

// Por: Marcelo Victorio.

//Pin connected to ST_CP of 74HC595

int latchPin = 8;

//Pin connected to SH_CP of 74HC595

int clockPin = 10;

////Pin connected to DS of 74HC595

int dataPin = 9;

////Pin Sensor Ultrasonic

#define trigPin 12

#define echoPin 13

//holders for infromation you're going to pass to shifting function

byte dataDISPA;

byte dataDISPB;

byte dataArrayDISPA[10];

byte dataArrayDISPB[10];

void setup() {

  //set pins to output because they are addressed in the main loop

  pinMode(latchPin, OUTPUT);

  Serial.begin(9600);

  pinMode(trigPin, OUTPUT);

  pinMode(echoPin, INPUT);

//Marcelo - 26/08/2012

  dataArrayDISPA[0] = 0x3F; //00111111

  dataArrayDISPA[1] = 0x06; //00000110

  dataArrayDISPA[2] = 0x5B; //01011011

  dataArrayDISPA[3] = 0x4F; //01001111

  dataArrayDISPA[4] = 0x66; //01100110

  dataArrayDISPA[5] = 0x6D; //01101101

  dataArrayDISPA[6] = 0x7D; //01111101

  dataArrayDISPA[7] = 0x07; //00000111

  dataArrayDISPA[8] = 0x7F; //01111111

  dataArrayDISPA[9] = 0x67; //01100111

  dataArrayDISPB[0] = 0x3F; //00111111

  dataArrayDISPB[1] = 0x06; //00000110

  dataArrayDISPB[2] = 0x5B; //01011011

  dataArrayDISPB[3] = 0x4F; //01001111

  dataArrayDISPB[4] = 0x66; //01100110

  dataArrayDISPB[5] = 0x6D; //01101101

  dataArrayDISPB[6] = 0x7D; //01111101

  dataArrayDISPB[7] = 0x07; //00000111

  dataArrayDISPB[8] = 0x7F; //01111111

  dataArrayDISPB[9] = 0x67; //01100111

  //function that blinks all the LEDs

  //gets passed the number of blinks and the pause time

  blinkAll_2Bytes(2,500); 

}

void loop() {

  int duration, distance;

  digitalWrite(trigPin, LOW); 

  delayMicroseconds(2); 

  digitalWrite(trigPin, HIGH); 

  delayMicroseconds(10); 

  digitalWrite(trigPin, LOW); 

  duration = pulseIn(echoPin, HIGH); 

  distance = (duration/2) / 29.1;

  if (distance >= 200 || distance <= 0){

     distance = 0; 

  }

   

  //load the light sequence you want from array

  int jj = distance;

  int x = jj%10;

  int y = jj/10;

      dataDISPB = dataArrayDISPB[y];

      dataDISPA = dataArrayDISPA[x];

  

      //ground latchPin and hold low for as long as you are transmitting

      digitalWrite(latchPin, 0);

      //move 'em out

      shiftOut(dataPin, clockPin, dataDISPB);   

      shiftOut(dataPin, clockPin, dataDISPA);

      //return the latch pin high to signal chip that it 

      //no longer needs to listen for information

      digitalWrite(latchPin, 1);

    delay(800);

}

// the heart of the program

void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {

  // This shifts 8 bits out MSB first, 

  //on the rising edge of the clock,

  //clock idles low

  //internal function setup

  int i=0;

  int pinState;

  pinMode(myClockPin, OUTPUT);

  pinMode(myDataPin, OUTPUT);

  //clear everything out just in case to

  //prepare shift register for bit shifting

  digitalWrite(myDataPin, 0);

  digitalWrite(myClockPin, 0);

  //for each bit in the byte myDataOut

  //NOTICE THAT WE ARE COUNTING DOWN in our for loop

  //This means that 000001 or "1" will go through such

  //that it will be pin Q0 that lights. 

  for (i=7; i>=0; i--)  {

    digitalWrite(myClockPin, 0);

    //if the value passed to myDataOut and a bitmask result 

    // true then... so if we are at i=6 and our value is

    // %11010100 it would the code compares it to %01000000 

    // and proceeds to set pinState to 1.

    if ( myDataOut & (1<<i) ) {

      pinState= 1;

    }

    else {

      pinState= 0;

    }

    //Sets the pin to HIGH or LOW depending on pinState

    digitalWrite(myDataPin, pinState);

    //register shifts bits on upstroke of clock pin  

    digitalWrite(myClockPin, 1);

    //zero the data pin after shift to prevent bleed through

    digitalWrite(myDataPin, 0);

  }

  //stop shifting

  digitalWrite(myClockPin, 0);

}

//blinks the whole register based on the number of times you want to 

//blink "n" and the pause between them "d"

//starts with a moment of darkness to make sure the first blink

//has its full visual effect.

void blinkAll_2Bytes(int n, int d) {

  digitalWrite(latchPin, 0);

  shiftOut(dataPin, clockPin, 0);

  shiftOut(dataPin, clockPin, 0);

  digitalWrite(latchPin, 1);

  delay(200);

  for (int x = 0; x < n; x++) {

    digitalWrite(latchPin, 0);

    shiftOut(dataPin, clockPin, 255);

    shiftOut(dataPin, clockPin, 255);

    digitalWrite(latchPin, 1);

    delay(d);

    digitalWrite(latchPin, 0);

    shiftOut(dataPin, clockPin, 0);

    shiftOut(dataPin, clockPin, 0);

    digitalWrite(latchPin, 1);

    delay(d);

  }

}

O que é Arduino...

Scrolling Text + Arduino Tutorial

Como fazer o seu cubo de leds 5x5x5

Já faz algum tempo que venho planejando construir um cubo de leds e mesmo com diversos projetos na internet não encontrei nenhum bem detalhado e com componentes fáceis de encontrar. Tive a ideia de utilizar o shift register 74HCC595 que é exemplo no tutorial do Arduino.cc.   http://www.arduino.cc/en/Tutorial/ShiftOut

O chip 74HC595 recebe do microcontrolador através de comandos ShiftOut um número decimal que é convertido em binário, este número binário representa os pinos que devem ser ligados e desligados para acender ou apagar os leds que formam os desenhos no cubo de leds.

O  Cube de Leds é um cubo composto por LEDs interligados capaz de proporcionar imagens holográficas, em movimento.

A ideia foi de um estudante norueguês, que queria expressar a arte visual de uma forma bem diferente, através do conjunto de LEDs interligados, de forma a criar um cubo.

O cubo está ligado a um conjunto de registradores que são controlados por um microcontrolador com instruções que controlam cada um dos LEDs que  deve acender e apagar

Apesar de ainda não ser um holograma perfeito em alta definição consegue apresentar a ideia que imaginamos. Esta forma envolve uma tecnologia bem avançada e criativa pela sua engenhosa construção. O efeito final é a ilusão de imagens 3D em movimento, dentro dos limites do Cube de Leds.  

O projeto foi montado, experimentalmente, em duas  Protoboards de 850 pontos, utilizei alguns jumpers para as ligações entre os componentes eletrônicos, 4 registradores 74HC595, um Atmega328 com Bootloader Arduino Duemilanove, resistores, 125 leds e outros componentes, a lista completa de todo o material será exibida mais a frente. O Acesso ao computador foi feito com um conversor USB-TTL.

Diagrama do 74hc595 Registrador de deslocamento Binário (shift register)

Em breve publicarei todo o circuito eletrônico e código fonte que desenvolvi.

Cubo de leds 5x5x5 - Arduino

Comunicação entre dois Arduinos com auxílio do PC, através de Rádio Frequência, utilizando os módulos de RF 433Mhz

Há algum tempo venho pensando em desenvolver um link de comunicação serial entre o PC e o arduino com um display digital. Algo onde fosse possível escrever no PC e transmitir para o LCD. Conversando com meu filho sobre esse assunto tivemos a idéia de desenvolver um módulo transmissor e um receptor sem fio, onde fosse possível escrever uma mensagem na tela do PC e esta mesnagem ser transmitida para o LCD remotamente. Pensamos em algumas possibilidade e após verificar o que tinhamos disponível em nossa bancada resolvemos utilizar os Módulo RF Transmissor+receptor 433mhz, um LCD de fundo azul e letras brancas, uma placa protoshield, baterias para o módulo remoto, fios e conectores.

Começamos pela montagem da base do LCD que deve ser compacta e por este motivo optamos por montar em uma ProtoShield que são placas de circuito impresso normalmente projetadas para acoplar em cima do Arduino.e utilizar as mesmas conexões.

A ligação do LCD ao arduino é muito simples, utilizamos os pinos digitais 2, 3, 4, 5, 6, 7 que estão livres e não são utilizados internamente pela VirtualWire, que falaremos mais adiante.

Na ProtoShield soldamos os pinos refrente as conexões do Arduino para que a placa se encaixe perfeitamente. Também soldamos as barras de conexão que serão usadas para encaixar os pinos de 1 a 16 do LCD e todas as ligações referente aos pinos de contraste, backlight e alimentação do módulo.

Em seguida construímos os conectores que ligam os componentes de RF a placa do Arduino. São necessários apenas quatro fios para ligar, que podem ser da seguinte forma: Um fio vermelho para os 5  ou 3,3 Volts dependendo do módulo transmissor. Um fio preto para o GND (negativo), um fio branco para a comunicação de dados e outro para a antena que deve ter 30 centímetros.

No módulo receptor é comum ter mais do que quatro terminais, mas alguns são interligados internamente, você deve consultar o Datasheet do fabricante para ter certesa de como fazer as ligações.

No Arduíno que será usado como transmissor utilizamos o pino digital 12 para a transmissão de dados, que é o default no VirtualWire.h. Os fios positivo e GND foram ligados nos pinos 3V3 e GND.

No módulo receptor, utilizamos o pino digital 13 para a transmissão de dados, que é o default no VirtualWire.h. Os fios positivo e GND foram ligados nos pinos 5V e GND.

A pós a montagem da ProtoShield, soldagem da barra de terminais no módulo LCD e os conectores dos módulos RF, encaixamos todos os módulos e concluímos a parte referente ao hardware do nosso projeto.

O VirtualWire é uma biblioteca que fornece recursos para enviar mensagens curtas. Pode ser utilizado com diversos modelos de transmissores e receptores de rádio de baixo custo. Tem tudo o que é necessário para transmitir e receber dados através dos módulos Arduíno. Pode ser baixado de vários sites conhecidos que falam sobre Arduino.

O código fonte foi retirado de alguns exemplos e adaptado para exibir mensagens em uma tela de LCD.

O  “VirtualWirw.h”  deve ser descompactado para dentro da pasta  “/libraries”

//TRANSMISSOR

#include <VirtualWire.h> // you must download and install the VirtualWire.h to your hardware/libraries folder

char myCmd[16];

int inputSize=0;

void setup()

{

Serial.begin(9600);

// Initialise the IO and ISR

vw_set_ptt_inverted(true); // Required for RF Link module

vw_setup(2000); // Bits per sec

vw_set_tx_pin(12); // Set the digital IO pin to use for transmit data. Defaults to 12.

}

void loop()

{

   inputSize=0;

   if (Serial.available() > 0) {

   delay(300);

   inputSize = Serial.available();

   Serial.print("inputSize=");

   Serial.println(inputSize);

   for (int i = 0; i < inputSize; i++){

     myCmd[i] = Serial.read();

   }

  

   // say what you got:

   Serial.print("I received: ");

   Serial.println(myCmd);

} 

 

vw_send((uint8_t *)myCmd, strlen(myCmd));

vw_wait_tx(); // Wait for message to finish

delay(200);

}

//RECEPTOR LCD

#include <VirtualWire.h>

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

int i;

int cont;

int message_ok;

void setup()

{

    Serial.begin(9600); // Debugging only

    Serial.println("setup");

    // set up the LCD's number of columns and rows:

    lcd.begin(16, 2);

    // Print a message to the LCD.

    lcd.print("Setup LCD");

    // Initialise the IO and ISR

    vw_set_ptt_inverted(true); // Required for DR3100

    vw_setup(2000);     // Bits per sec

    vw_rx_start();       // Start the receiver PLL running

    lcd.clear();

    lcd.print("VirtualWire     ");

}

void loop()

{

    // set the cursor to column 0, line 1 (note: line 1 is the second row, since counting begins with 0)

    lcd.setCursor(0, 1);

 

    uint8_t buf[VW_MAX_MESSAGE_LEN];

    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    //reception to stabilize

    message_ok = 0;

    cont = 0;

    for (cont = 0; cont < 12 ; cont++)

    {

      delay(50);          // wait for reception to stabilize

    

      message_ok = vw_get_message(buf, &buflen);  // check the reception

      if (message_ok > 0){cont = 12;} //force the output

             

     

      Serial.print(message_ok);

      Serial.print(" ");

    }

   

    //if (vw_get_message(buf, &buflen)) // Non-blocking

    if (message_ok > 0)

    {

        digitalWrite(13, true); // Flash a light to show received good message

      // Message with a good checksum received, dump it.

      Serial.print("Got: ");

     

      for (i = 0; i < buflen; i++)

      {

          Serial.print(buf[i], HEX);

          Serial.print(" ");

            lcd.print(buf[i]);

      }

      Serial.println("");

        digitalWrite(13, false);

    }else

    { lcd.print("No message.....");}

     

}

[]'s Marcelo Victorio de A. Costa.

Robótica

Robô é um termo com o qual quase todos nós estamos bastante familiarizados. Mas a maioria de nós, não têm conhecimento técnicos sobre essas maravilhas do mundo eletrônico.
Atualmente existem vários usos para essa tecnologia, como automação de vitrines, sistemas de segurança, casa inteligente, computador de bordo, animatrônicos (boneco-robôs usados para dar maior realismo a filmes) e muitas outras aplicações.

 

Um robô é definido como "reprogramável, manipulador multifuncional", projetado para mover materiais, peças, ferramentas ou dispositivos especializados através de vários movimentos programados para o desempenho de uma variedade de tarefas.

 

Abs, Marcelo Victorio de A. Costa.