O ESP8266+Arduino Mega como WebServer

Depois de testar o modulo com vários comandos AT (vale a pena dar uma sapeada no arquivo anexo, bem legal!), parti para fazer o modulo funcionar como Web Server. Partido que tinha aprendido, principalmante com um tutorial do blog FILIPEFLOP:

http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

O Circuito:

 

Webservercircuit

 

O código:

/*************************************************************************

* Web Server with ESP8266

* Based on: FILIPEFLOP http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

* Adapted by Marcelo Jose Rovai

**************************************************************************/

#define esp8266 Serial2

#define CH_PD 4

#define speed8266 115200 // This is the speed that worked with my ESP8266

#define DEBUG true

void setup()

{

  esp8266.begin (speed8266);

  Serial.begin(9600);

  reset8266(); // Pin CH_PD needs a reset before start communication

  sendData(“AT+RST\r\n”, 2000, DEBUG); // reset

  sendData(“AT+CWJAP=\”ROVAI TIMECAP\”,\”mjr747@1\”\r\n”, 2000, DEBUG); //Connect network

  delay(3000);

  sendData(“AT+CWMODE=1\r\n”, 1000, DEBUG);

  sendData(“AT+CIFSR\r\n”, 1000, DEBUG); // Show IP Adress

  sendData(“AT+CIPMUX=1\r\n”, 1000, DEBUG); // Multiple conexions

  sendData(“AT+CIPSERVER=1,80\r\n”, 1000, DEBUG); // start comm port 80

}

void loop()

{

  if (esp8266.available()) // check if 8266 is sending data

  {

    if (esp8266.find(“+IPD,”))

    {

      delay(300);

      int connectionId = esp8266.read() – 48;

      String webpage = “<head><meta http-equiv=””refresh”” content=””3″”>”;

      webpage += “</head><h1><u>MJRoBot ==> WebServer (ESP8266) </u></h1><h2>Arduino Pin: “;

      webpage += “D8 status ==> “;

      int a = digitalRead(8);

      webpage += a;

      webpage += “<h2>Arduino Pin: D9 status ==> “;

      int b = digitalRead(9);

      webpage += b;

      webpage += “<h2>Arduino Pin: A0 data ===> “;

      int c = analogRead(0);

      webpage += c;

      webpage += “</h2>”;

      String cipSend = “AT+CIPSEND=”;

      cipSend += connectionId;

      cipSend += “,”;

      cipSend += webpage.length();

      cipSend += “\r\n”;

      sendData(cipSend, 1000, DEBUG);

      sendData(webpage, 1000, DEBUG);

      String closeCommand = “AT+CIPCLOSE=”;

      closeCommand += connectionId; // append connection id

      closeCommand += “\r\n”;

      sendData(closeCommand, 3000, DEBUG);

    }

  }

}

/*************************************************/

 // Send AT commands to module

String sendData(String command, const int timeout, boolean debug)

{

  String response = “”;

  esp8266.print(command);

  long int time = millis();

  while ( (time + timeout) > millis())

  {

    while (esp8266.available())

    {

      // The esp has data so display its output to the serial window

      char c = esp8266.read(); // read the next character.

      response += c;

    }

  }

  if (debug)

  {

    Serial.print(response);

  }

  return response;

}

/*************************************************/

// Reset funtion to accept communication

void reset8266 ()

{

  pinMode(CH_PD, OUTPUT);

  digitalWrite(CH_PD, LOW);

  delay(300);

  digitalWrite(CH_PD, HIGH);

}

A web Page:

Note que o endereço da pagina é o segundo IP que aparece no Serial monitor com o comando AT+CIFSR na fase de Set-up (veja a copia do Serial monitor abaixo): 

+CIFSR:STAIP,”10.0.1.2″

Webserverpage

A saída no Serial Monitor:

1. A conexão com o modulo esp8266

 

SerialConxion

2. A comunicação:

SerialOngoingcomm

Eu fiz um pequeno vídeo para dar uma visão do WebServer funcionando:

ESP8266 como webserver

Documento legal com dicas de comandos AT para configurar o esp8266:

ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Fonte:  http://labdegaragem.com/profiles/blogs/o-esp8266-como-webserver-usando-o-mega?xg_source=msg_mes_network

Como Configurar Xbee Explorer

Quem se interessa por redes wireless em automação já deve ter ouvido falar de um módulo muito popular chamado Xbee, uma placa que se comunica via radiofrequência utilizando o padrão Zigbeede comunicação de rede sem fio e permite a interligação de vários módulos.

Com o Xbee você pode construir uma rede wireless extremamente robusta, confiável e de certa forma econômica, pois o módulo Xbee possuem um modo “sleep” que economiza energia quando não estão executando nenhuma ação. Isso permite que os módulos funcionem por muito tempo apenas utilizando baterias.

O Xbee é muito usado em ambientes industriais, onde o fator velocidade não é um ponto crítico, como por exemplo um equipamento que precise enviar dados da produção para um computador central. Isso não impede que o Xbee seja usado com sucesso em aplicações de automação residencial, como alarmes, iluminação, coleta de dados e outras aplicações.

A programação do Xbee exige atenção e por esse motivo vamos dividir esse assunto em 2 tutoriais. Hoje vamos falar do Xbee Explorer USB, que é a placa utilizada para programar o Módulo Xbee :

XBee_USB_Explorer_Adapter22

Com o Xbee Explorer USB, você consegue não só programar e configurar o seu Xbee, como também atualizar o seu dispositivo e realizar uma série de outras tarefas.

INSTALAÇÃO XBEE EXPLORER USB:

Antes de efetuarmos as ligações do Xbee, vamos instalar o software de programação, que iremos utilizar em conjunto com o Xbee Explorer. Esse software é o XCTU, disponível nesse link.

Ao acessar o link, você será direcionado à página do software XCTU. Clique em Diagnostics, Utilities and MIBS :

Tela-1-Link-XCTU

Na próxima tela que abrir, clique em XCTU Next Gen Installer, Windows x32/x64 ou na versão de acordo com o seu sistema operacional:

Tela-2-Link-XCTU-Opcoes-de-download

Baixe o arquivo, que tem o tamanho aproximado de 130 Mb e execute o instalador. Na tela de boas vindas, simplesmente clique em NEXT :

Tela-4-XCTU-Install-Tela-Inicial

Leia atentamente o contrato de licença e clique novamente em NEXT :

Tela-5-XCTU-Install-Tela-Licenca

A tela seguinte apresenta um aviso de que o usuário do Windows Vista e 7 deve ter direitos de administrador para evitar problemas na cópia de arquivos. Clique em NEXT :

Tela-6-XCTU-Install-Tela-Path-info

Escolha a pasta de destino de instalação do software e clique em NEXT :

Tela-7-XCTU-Install-Tela-Path

Revise a escolhas e clique em Install para que tenha início o processo de cópia dos arquivos :

Tela-8-XCTU-Install-Confirmacao

Aguarde o final da instalação :

Tela-8-XCTU-Install-Confirmacao Tela-9-XCTU-Install

CONFIGURANDO O MÓDULO XBEE:

O próximo passo é encaixar o Módulo Xbee no Xbee Explorer USB e ligar ao computador usando o cabo usb que acompanha o produto. O módulo que estamos utilizando é o Módulo Xbee Serie 2:

XBee_USB_Explorer_Adapter22

Ao conectar o Xbee Explorer USB ao computador, terá início o processo de instalação dos drivers. No Windows 7 / 64 bits, os drivers foram instalados automaticamente pelo Windows Update, e o dispositivo foi detectado na porta serial Com20 :

Tela-3-Instalacao-drivers

Vamos agora executar o XCTU e procurar pelo módulo Xbee conectado ao USB Explorer. Na tela inicial do programa, clique em Discover Devices :

Tela-10-XCTU-Tela-inicial

Selecione a porta serial detectada na instalação do Xbee Explorer USB. No nosso caso, COM20. Depois, clique em next :

Tela-11-XCTU-Dispositivo-Scan

 

Deixe os parâmetros da porta nos valores padrão e clique em Finish para iniciar a varredura :

Tela-12-XCTU-Dispositivo-parametros

 

Na próxima tela, clique em Add Selected Devices para adicionar os dispositivos detectados

Tela-13-XCTU-Dispositivo-detectado

 

De volta à tela inicial do XCTU, clique no dispositivo, agora listado no lado esquerdo :

Tela-14-XCTU-Lista-Dispositivo

No lado direito da tela serão carregados os parâmetros previamente gravados no módulo Xbee, como nome do módulo, versão de firmware, configuração de portas, entre outros :

Tela-15-XCTU-Dispositivo-parametros-carregados

Isso encerra a parte básica de instalação e configuração do Xbee Explorer USB. Em um próximo artigo iremos mostrar como configurar dois módulos Xbee Serie 2 e enviar informações para o Arduino usando o Arduino Xbee Shield.

Arduino_Xbee_Shield12

http://blog.filipeflop.com/wireless/como-configurar-xbee-explorer-usb.html

A aristocracia operária

” A aristocracia operária significa o surgimento de um setor da classe operária que passa a ser mais maleável as pressões do capital e que mais facilmente é  cooptado por ele. Todavia, este surgimento não decorre de uma alteração das relações de produção e, portanto, não significa o surgimento de uma nova classe, nem implica na que a determinação essencial da classe operária tenha sido alterada.

Pyramid_of_Capitalist_System

A aristocracia operária é  parte da classe operária, e não uma nova classe. A crítica de Mandel (1964) a Baratt Brown, neste particular, é  precisa: a aristocracia operária faz parte do movimento operário, e nele se distingue politicamente do restante da classe. As implicações ontológicas e políticas aqui são vastas…Um corpo desorganizado não tem porta-voz autorizado nem um programa definido; suas reclamações e exigências são frequentemente vagas e impalpaveis: é  mais possível que seja arrastada por um impulso irracional; que se mova no momento errado e na direção errada.”
(Jones, 1971:317, nota 8)

Publicado do WordPress para Android

Construindo um classificador de texto no Spark Shell do Mahout

Construindo um classificador de texto no Spark Shell do Mahout

Este tutorial o guiará pelas etapas usadas para treinar um modelo Naive Bayes Multinomial e criar um classificador de texto baseado nesse modelo usando o mahout spark-shell.

Pré-requisitos

Este tutorial pressupõe que você tenha suas variáveis ​​de ambiente do Spark configuradas para a mahout spark-shellvisualização: Reprodução com o Shell do Mahout . Além disso, assumimos que o Mahout está sendo executado no modo de cluster (ou seja, com a MAHOUT_LOCALvariável de ambiente não definida ), conforme estaremos lendo e gravando no HDFS.

Download e vetorização do conjunto de dados da Wikipedia

A partir de Mahout v. 0.10.0, ainda estamos dependentes das versões MapReduce de mahout seqwikimahout seq2sparsepara extrair e vetorizar nosso texto. Uma implementação Spark do seq2sparse está em andamento para o Mahout v. 0.11. No entanto, para baixar o conjunto de dados da Wikipedia, extrair os corpos da documentação, rotular cada documento e vetorizar o texto em vetores TF-IDF, podemos executar o exemplo de wikipedia-classifier.sh de forma simples .

Please select a number to choose the corresponding task to run
1. CBayes (may require increased heap space on yarn)
2. BinaryCBayes
3. clean -- cleans up the work area in /tmp/mahout-work-wiki
Enter your choice :

Digite (2). Isso fará o download de um grande dump XML recente do banco de dados da Wikipedia, em um /tmp/mahout-work-wikidiretório, descompactá-lo e colocá-lo no HDFS. Ele executará um trabalho MapReduce para analisar o conjunto da wikipedia , extraindo e rotulando apenas páginas com tags de categoria para [Estados Unidos] e [Reino Unido] (documentos ~ 11600). Em seguida, ele será executado mahout seq2sparsepara converter os documentos em vetores TF-IDF. O script também irá compilar e testar um modelo Naive Bayes usando o MapReduce . Quando estiver concluído, você verá uma matriz de confusão na tela. Para este tutorial, vamos ignorar o modelo MapReduce e construir um novo modelo usando o Spark baseado na saída de texto vetorizado por seq2sparse.

Começando

Inicie o mahout spark-shell. Há um script de exemplo: spark-document-classifier.mscala(.mscala denota um script Mahout-Scala que pode ser executado de forma semelhante a um script R). Nós estaremos percorrendo este script para este tutorial, mas se você quisesse simplesmente executar o script, você poderia simplesmente emitir o comando:

mahout> :load /path/to/mahout/examples/bin/spark-document-classifier.mscala

Por enquanto, vamos desmontar o roteiro, peça por peça. Você pode recortar e colar os seguintes blocos de código no mahout spark-shell.

Importações

Nossas importações de Mahout Naive Bayes:

import org.apache.mahout.classifier.naivebayes._
import org.apache.mahout.classifier.stats._
import org.apache.mahout.nlp.tfidf._

Importações Hadoop necessárias para ler o nosso dicionário:

import org.apache.hadoop.io.Text
import org.apache.hadoop.io.IntWritable
import org.apache.hadoop.io.LongWritable

Leia em nosso conjunto completo do HDFS como vetorizado por seq2sparse em classify-wikipedia.sh

val pathToData = "/tmp/mahout-work-wiki/"
val fullData = drmDfsRead(pathToData + "wikipediaVecs/tfidf-vectors")

Extrair a categoria de cada observação e agregar essas observações por categoria

val (labelIndex, aggregatedObservations) = SparkNaiveBayes.extractLabelsAndAggregateObservations(
                                                             fullData)

Construa um modelo Muitinomial Naive Bayes e autoteste no conjunto de treinamento

val model = SparkNaiveBayes.train(aggregatedObservations, labelIndex, false)
val resAnalyzer = SparkNaiveBayes.test(model, fullData, false)
println(resAnalyzer)

imprimir o ResultAnalyzermostrará a matriz de confusão.

Leia no dicionário e conte a frequência de documentos do HDFS

val dictionary = sdc.sequenceFile(pathToData + "wikipediaVecs/dictionary.file-0",
                                  classOf[Text],
                                  classOf[IntWritable])
val documentFrequencyCount = sdc.sequenceFile(pathToData + "wikipediaVecs/df-count",
                                              classOf[IntWritable],
                                              classOf[LongWritable])

// setup the dictionary and document frequency count as maps
val dictionaryRDD = dictionary.map { 
                                case (wKey, wVal) => wKey.asInstanceOf[Text]
                                                         .toString() -> wVal.get() 
                                   }
                                   
val documentFrequencyCountRDD = documentFrequencyCount.map {
                                        case (wKey, wVal) => wKey.asInstanceOf[IntWritable]
                                                                 .get() -> wVal.get() 
                                                           }

val dictionaryMap = dictionaryRDD.collect.map(x => x._1.toString -> x._2.toInt).toMap
val dfCountMap = documentFrequencyCountRDD.collect.map(x => x._1.toInt -> x._2.toLong).toMap

Definir uma função para tokenize e vectorize o novo texto usando nosso dicionário atual

Para este exemplo simples, nossa função vectorizeDocument(...)irá converter um novo documento em unigramas usando métodos nativos de String Java e vetorizar usando nossas frequências de dicionário e documento. Você também pode usar um analisador Lucene para bigramas, trigramas, etc. e integrar o Apache Tika para extrair texto de diferentes tipos de documentos (PDF, PPT, XLS, etc.). Aqui, no entanto, vamos mantê-lo simples, separando e tokenizing nosso texto usando regexs e métodos nativos de String.

def vectorizeDocument(document: String,
                        dictionaryMap: Map[String,Int],
                        dfMap: Map[Int,Long]): Vector = {
    val wordCounts = document.replaceAll("[^\\p{L}\\p{Nd}]+", " ")
                                .toLowerCase
                                .split(" ")
                                .groupBy(identity)
                                .mapValues(_.length)         
    val vec = new RandomAccessSparseVector(dictionaryMap.size)
    val totalDFSize = dfMap(-1)
    val docSize = wordCounts.size
    for (word <- wordCounts) {
        val term = word._1
        if (dictionaryMap.contains(term)) {
            val tfidf: TermWeight = new TFIDF()
            val termFreq = word._2
            val dictIndex = dictionaryMap(term)
            val docFreq = dfCountMap(dictIndex)
            val currentTfIdf = tfidf.calculate(termFreq,
                                               docFreq.toInt,
                                               docSize,
                                               totalDFSize.toInt)
            vec.setQuick(dictIndex, currentTfIdf)
        }
    }
    vec
}

Configure nosso classificador

val labelMap = model.labelIndex
val numLabels = model.numLabels
val reverseLabelMap = labelMap.map(x => x._2 -> x._1)

// instantiate the correct type of classifier
val classifier = model.isComplementary match {
    case true => new ComplementaryNBClassifier(model)
    case _ => new StandardNBClassifier(model)
}

Definir uma função argmax

O rótulo com a pontuação mais alta ganha a classificação de um determinado documento.

def argmax(v: Vector): (Int, Double) = {
    var bestIdx: Int = Integer.MIN_VALUE
    var bestScore: Double = Integer.MIN_VALUE.asInstanceOf[Int].toDouble
    for(i <- 0 until v.size) {
        if(v(i) > bestScore){
            bestScore = v(i)
            bestIdx = i
        }
    }
    (bestIdx, bestScore)
}

Defina nosso classificador de vetores TF (-IDF)

def classifyDocument(clvec: Vector) : String = {
    val cvec = classifier.classifyFull(clvec)
    val (bestIdx, bestScore) = argmax(cvec)
    reverseLabelMap(bestIdx)
}

Dois exemplos de artigos de notícias: Futebol dos Estados Unidos e Futebol do Reino Unido

// A random United States football article
// http://www.reuters.com/article/2015/01/28/us-nfl-superbowl-security-idUSKBN0L12JR20150128
val UStextToClassify = new String("(Reuters) - Super Bowl security officials acknowledge" +
    " the NFL championship game represents a high profile target on a world stage but are" +
    " unaware of any specific credible threats against Sunday's showcase. In advance of" +
    " one of the world's biggest single day sporting events, Homeland Security Secretary" +
    " Jeh Johnson was in Glendale on Wednesday to review security preparations and tour" +
    " University of Phoenix Stadium where the Seattle Seahawks and New England Patriots" +
    " will battle. Deadly shootings in Paris and arrest of suspects in Belgium, Greece and" +
    " Germany heightened fears of more attacks around the world and social media accounts" +
    " linked to Middle East militant groups have carried a number of threats to attack" +
    " high-profile U.S. events. There is no specific credible threat, said Johnson, who" + 
    " has appointed a federal coordination team to work with local, state and federal" +
    " agencies to ensure safety of fans, players and other workers associated with the" + 
    " Super Bowl. I'm confident we will have a safe and secure and successful event." +
    " Sunday's game has been given a Special Event Assessment Rating (SEAR) 1 rating, the" +
    " same as in previous years, except for the year after the Sept. 11, 2001 attacks, when" +
    " a higher level was declared. But security will be tight and visible around Super" +
    " Bowl-related events as well as during the game itself. All fans will pass through" +
    " metal detectors and pat downs. Over 4,000 private security personnel will be deployed" +
    " and the almost 3,000 member Phoenix police force will be on Super Bowl duty. Nuclear" +
    " device sniffing teams will be deployed and a network of Bio-Watch detectors will be" +
    " set up to provide a warning in the event of a biological attack. The Department of" +
    " Homeland Security (DHS) said in a press release it had held special cyber-security" +
    " and anti-sniper training sessions. A U.S. official said the Transportation Security" +
    " Administration, which is responsible for screening airline passengers, will add" +
    " screeners and checkpoint lanes at airports. Federal air marshals, behavior detection" +
    " officers and dog teams will help to secure transportation systems in the area. We" +
    " will be ramping it (security) up on Sunday, there is no doubt about that, said Federal"+
    " Coordinator Matthew Allen, the DHS point of contact for planning and support. I have" +
    " every confidence the public safety agencies that represented in the planning process" +
    " are going to have their best and brightest out there this weekend and we will have" +
    " a very safe Super Bowl.")

// A random United Kingdom football article
// http://www.reuters.com/article/2015/01/26/manchester-united-swissquote-idUSL6N0V52RZ20150126
val UKtextToClassify = new String("(Reuters) - Manchester United have signed a sponsorship" +
    " deal with online financial trading company Swissquote, expanding the commercial" +
    " partnerships that have helped to make the English club one of the richest teams in" +
    " world soccer. United did not give a value for the deal, the club's first in the sector," +
    " but said on Monday it was a multi-year agreement. The Premier League club, 20 times" +
    " English champions, claim to have 659 million followers around the globe, making the" +
    " United name attractive to major brands like Chevrolet cars and sportswear group Adidas." +
    " Swissquote said the global deal would allow it to use United's popularity in Asia to" +
    " help it meet its targets for expansion in China. Among benefits from the deal," +
    " Swissquote's clients will have a chance to meet United players and get behind the scenes" +
    " at the Old Trafford stadium. Swissquote is a Geneva-based online trading company that" +
    " allows retail investors to buy and sell foreign exchange, equities, bonds and other asset" +
    " classes. Like other retail FX brokers, Swissquote was left nursing losses on the Swiss" +
    " franc after Switzerland's central bank stunned markets this month by abandoning its cap" +
    " on the currency. The fallout from the abrupt move put rival and West Ham United shirt" +
    " sponsor Alpari UK into administration. Swissquote itself was forced to book a 25 million" +
    " Swiss francs ($28 million) provision for its clients who were left out of pocket" +
    " following the franc's surge. United's ability to grow revenues off the pitch has made" +
    " them the second richest club in the world behind Spain's Real Madrid, despite a" +
    " downturn in their playing fortunes. United Managing Director Richard Arnold said" +
    " there was still lots of scope for United to develop sponsorships in other areas of" +
    " business. The last quoted statistics that we had showed that of the top 25 sponsorship" +
    " categories, we were only active in 15 of those, Arnold told Reuters. I think there is a" +
    " huge potential still for the club, and the other thing we have seen is there is very" +
    " significant growth even within categories. United have endured a tricky transition" +
    " following the retirement of manager Alex Ferguson in 2013, finishing seventh in the" +
    " Premier League last season and missing out on a place in the lucrative Champions League." +
    " ($1 = 0.8910 Swiss francs) (Writing by Neil Maidment, additional reporting by Jemima" + 
    " Kelly; editing by Keith Weir)")

Vetorize e classifique nossos documentos

val usVec = vectorizeDocument(UStextToClassify, dictionaryMap, dfCountMap)
val ukVec = vectorizeDocument(UKtextToClassify, dictionaryMap, dfCountMap)

println("Classifying the news article about superbowl security (united states)")
classifyDocument(usVec)

println("Classifying the news article about Manchester United (united kingdom)")
classifyDocument(ukVec)

Amarre tudo em um novo método para classificar o texto

def classifyText(txt: String): String = {
    val v = vectorizeDocument(txt, dictionaryMap, dfCountMap)
    classifyDocument(v)
}

Agora podemos simplesmente chamar nosso método classifyText (…) em qualquer String

classifyText("Hello world from Queens")
classifyText("Hello world from London")

Persistência do modelo

Você pode salvar o modelo no HDFS:

model.dfsWrite("/path/to/model")

E recupere-o com:

val model =  NBModel.dfsRead("/path/to/model")

O modelo treinado agora pode ser incorporado em um aplicativo externo.

 

Fonte:  http://mahout.apache.org/docs/latest/tutorials/samsara/classify-a-doc-from-the-shell.html

Construindo uma aplicação Ionic CRUD com Firestore

O Firestore é o novo banco de dados do Firebase. É um banco de dados orientado a documentos NoSQL para desenvolvimento móvel e web.

Ele é projetado para armazenar e sincronizar dados de aplicativos em escala global com facilidade. Algumas de suas principais características incluem:

  • Documentos e Coleções com consultas poderosas.
  • Acesso off-line ao WEB SDK.
  • Sincronização de dados em tempo real.

Hoje vamos aprender a integrar o Firestore com o Ionic para criar um fluxo de trabalho CRUD. Este aplicativo de amostra mostrará a você como:

  • Mostrando uma lista de itens do seu banco de dados ( que no Firestore é chamado exibindo uma coleção de documentos ).
  • Criando um novo item e adicionando-o à lista.
  • Navegar para a página de detalhes desse item.
  • Excluindo um item da nossa lista.

captura de tela mostrando as diferentes visualizações para o firestore CRUD

Vamos dividir este processo em X passos:

  • Etapa 1: crie e inicialize nosso aplicativo Ionic.
  • Etapa 2: adicione itens à lista.
  • Passo # 3: Mostre a lista de itens.
  • Passo # 4: Navegue até a página de detalhes de um item.
  • Etapa 5: excluir um item da lista.

Agora que sabemos o que vamos fazer, vamos pular para o modo de codificação.

Etapa 1: criar e inicializar seu aplicativo

O objetivo desta etapa é criar seu novo aplicativo iônico, instalar os pacotes necessários ( somente Firebase e AngularFire2 ) e inicializar nosso aplicativo do Firebase.

Com isso em mente, vamos criar nosso aplicativo primeiro, abrir seu terminal e navegar até a pasta que você usa para codificação ( ou em qualquer lugar que você quiser, para mim, essa é a pasta Desenvolvimento ) e criar seu aplicativo:

cd Development/
ionic start firestore-example blank
cd firestore-example 

Depois que criarmos o aplicativo, precisaremos instalar o Firebase. Para isso, abra o terminal novamente e ( enquanto estiver na raiz do projeto ), digite:

npm install angularfire2 firebase

Esse comando instalará as versões estáveis ​​mais recentes do AngularFire2 e do Firebase Web SDK.

Agora que instalamos tudo, vamos conectar o Ionic ao nosso aplicativo do Firebase.

A primeira coisa que precisamos é obter as credenciais do nosso aplicativo, fazer login no Firebase Console e navegar até o aplicativo do Firebase ( ou criar um novo caso você ainda não tenha o aplicativo ).

Na guia Visão geral do projeto, você verá a tela “Primeiros passos”, com opções para adicionar o Firebase a diferentes tipos de aplicativos, e selecione “Adicionar o Firebase ao seu aplicativo da web”.

De todo o código que aparece nessa janela pop-up, concentre-se nesse bit:

var config = {
  apiKey: "Your credentials here",
  authDomain: "Your credentials here",
  databaseURL: "Your credentials here",
  projectId: "Your credentials here",
  storageBucket: "Your credentials here",
  messagingSenderId: "Your credentials here",
};

Esse é o seu objeto de configuração do Firebase, ele tem todas as informações necessárias para acessar as diferentes APIs do Firebase, e precisaremos disso para conectar nosso aplicativo iônico ao nosso aplicativo do Firebase.

Vá para a sua src/apppasta e crie um arquivo chamado credentials.tsa idéia deste arquivo é manter todas as nossas credenciais em um só lugar, este arquivo não deve estar no controle de origem para adicioná-lo ao seu .gitignorearquivo.

Copie seu objeto de configuração para essa página. Vou mudar o nome para algo que faça mais sentido para mim:

export var firebasConfig = {
  apiKey: "AIzaSyBJT6tfre8uh3LGBm5CTiO5DUZ4",
  authDomain: "javebratt-playground.firebaseapp.com",
  databaseURL: "https://javebratt-playground.firebaseio.com",
  projectId: "javebratt-playground",
  storageBucket: "javebratt-playground.appspot.com",
  messagingSenderId: "3676553551"
};

Estamos exportando para que possamos importá-lo para outros arquivos onde precisarmos.

Agora é hora da parte final desta etapa, precisamos inicializar o Firebase, para isso, vamos entrar app.module.tse, primeiro, vamos importar os pacotes AngularFire2 que precisaremos e nosso objeto de credencial:

import { AngularFireModule } from 'angularfire2';
import { AngularFirestoreModule } from 'angularfire2/firestore';
import { firebaseConfig } from './credentials';

Como vamos usar apenas o banco de dados Firestore, importamos o módulo de base AF2 ( vou me referir a AngularFire2 como AF2 de agora em diante ) e o módulo Firestore. Se você também precisasse de autenticação ou armazenamento, você precisaria adicionar esses módulos aqui.

Dentro de sua @NgModule()aparência para sua importsmatriz e adicione o módulo AF2 e o módulo Firestore:

imports: [
  BrowserModule,
  IonicModule.forRoot(MyApp),
  AngularFireModule.initializeApp(firebaseConfig),
  AngularFirestoreModule,
],

Estamos chamando o .initializeApp(firebaseConfig)método e passando nosso objeto de credencial para que nosso aplicativo saiba como se conectar ao Firebase.

E é isso, pode não parecer muito ainda , mas nossos aplicativos Firebase e Ionic agora podem conversar entre si.

Etapa 2: adicione itens à lista.

É hora de começar a trabalhar com nossos dados, vamos construir um aplicativo CRUD, usaremos uma lista de músicas como um exemplo, mas os mesmos princípios se aplicam a qualquer fluxo de trabalho Mestre / Detalhe que você queira construir.

A primeira coisa que precisamos é entender como nossos dados são armazenados, o Firestore é um banco de dados NoSQL orientado a documentos, que é um pouco diferente do RTDB ( banco de dados em tempo real ).

Isso significa que temos dois tipos de dados em nosso banco de dados, documentos, que são objetos com os quais podemos trabalhar, e coleções que são os contêineres que agrupam esses objetos.

Por exemplo, se estivermos criando um banco de dados de músicas, nossa coleção seria chamada songs, ou songList, que conteria todos os objetos de música individuais e cada objeto teria suas propriedades, como o nome da música, o artista etc.

Em nosso exemplo, o objeto song terá cinco propriedades, um id, o álbum, o artista, uma descrição e o nome da música. No espírito de aproveitar os recursos de verificação de tipos do TypeScript, vamos criar uma interface que funcione como modelo para todas as nossas músicas.

Vá até a srcpasta e crie uma pasta chamada models, adicione um arquivo chamado song.interface.tse preencha-o com os seguintes dados:

export interface Song {
  id: string;
  albumName: string;
  artistName: string;
  songDescription: string;
  sonName: string;
}

Essa é a interface da música e garante que, sempre que estivermos trabalhando com um objeto de música, ele tenha todos os dados necessários.

Para começar a criar novas músicas e adicioná-las à nossa lista, precisamos ter uma página que contenha um formulário para inserir os dados da música, criar essa página com o Ionic CLI, abrir o terminal e digitar:

ionic generate page Create

Na verdade, enquanto estamos nisso, vamos dedicar alguns minutos para criar a página de detalhes, uma visualização detalhada de uma música específica e o provedor de Firestore, ele cuidará de todas as interações do banco de dados para que possamos gerenciar tudo desse arquivo.

ionic generate page Detail
ionic generate provider Firestore

Agora precisamos de uma maneira de ir da home page para o CreatePage, para que abrir home.htmle alterar seu cabeçalho para ficar assim:

<ion-header>
  <ion-navbar color="primary">
    <ion-title>
      Song List
    </ion-title>
    <ion-buttons end>
      <button ion-button icon-only (click)="goToCreatePage()">
        <ion-icon name="add"></ion-icon>
      </button>
    </ion-buttons>
  </ion-navbar>
</ion-header>

Estamos adicionando um botão ao cabeçalho que aciona a goToCreatePage()função, para que funcione, vamos abrir o home.tsarquivo e escrever essa função:

import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';

@Component({
  selector: 'page-home',
  templateUrl: 'home.html',
})
export class HomePage {
  constructor(public navCtrl: NavController) {}

  goToCreatePage(): void {
    this.navCtrl.push('CreatePage');
  }
}

A única coisa que esta função está fazendo é levá-lo para o CreatePage, agora que podemos chegar a essa página, é hora de construir sua funcionalidade. A funcionalidade consistirá em 3 coisas:

  • A exibição de HTML que mostra o formulário.
  • A classe TypeScript que coleta os dados do formulário e os envia ao provedor.
  • A função no provedor que cria a música e a adiciona à lista de músicas.

Vamos começar com o HTML, abrir o create.htmlarquivo e dentro das <ion-content></ion-content>tags criar o formulário:

<ion-content>
  <form [formGroup]="createSongForm" (submit)="createSong()" novalidate>
    <ion-item>
      <ion-label stacked>Song Name</ion-label>
      <ion-input formControlName="songName" type="text" 
        placeholder="What's this song called?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Artist Name</ion-label>
      <ion-input formControlName="artistName" type="text" 
        placeholder="Who sings this song?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Album Name</ion-label>
      <ion-input formControlName="albumName" type="text" 
        placeholder="What's the album's name?">
      </ion-input>
    </ion-item>

    <ion-item>
      <ion-label stacked>Song Description</ion-label>
      <ion-textarea formControlName="songDescription" type="text" 
        placeholder="What's this song about?">
      </ion-textarea>
    </ion-item>


    <button ion-button block type="submit" [disabled]="!createSongForm.valid">
      Add Song
    </button>
  </form>

</ion-content>

Se você é novo em formas angulares, então aqui está o que está acontecendo:

  • [formGroup]="createSongForm" => Este é o nome do formulário que estamos criando.
  • (submit)="createSong()"=> Isso indica o formulário que, ao enviar, deve chamar a createSong()função.
  • formControlName => Este é o nome do campo.
  • [disabled]="!createSongForm.valid" => Isso define o botão a ser desativado até que o formulário seja válido.

Agora vamos para o create.tsarquivo, aqui coletamos os dados do nosso formulário e passamos para o nosso provedor. Primeiro, vamos importar tudo o que precisaremos:

import { Component } from '@angular/core';
import {
  IonicPage,
  NavController,
  Loading,
  LoadingController,
  AlertController,
  Alert,
} from 'ionic-angular';
import { FormGroup, FormBuilder, Validators } from '@angular/forms';
import { FirestoreProvider } from '../../providers/firestore/firestore';

Estamos importando:

  • Formulário métodos auxiliares de @angular/forms.
  • Carregando controlador para mostrar um widget de carregamento para nossos usuários enquanto o formulário processa os dados.
  • Alertar o controlador para exibir um alerta para o nosso usuário, se houver algum erro.
  • E o provedor Firestore para chamar a função que adicionará a música ao banco de dados.

Agora precisamos injetar todos esses provedores no construtor e inicializar nosso formulário:

public createSongForm: FormGroup; // This is the form we're creating.

constructor(
  public navCtrl: NavController,
  public loadingCtrl: LoadingController,
  public alertCtrl: AlertController,
  public firestoreProvider: FirestoreProvider,
  formBuilder: FormBuilder
) {
  this.createSongForm = formBuilder.group({
    albumName: ['', Validators.required],
    artistName: ['', Validators.required],
    songDescription: ['', Validators.required],
    songName: ['', Validators.required],
  });
}

E agora tudo que precisamos é a função que coleta os dados e os envia para o provedor, se você se lembrar da parte HTML, nós a chamamos createSong()

createSong(): void { }

A primeira coisa que queremos fazer dentro dessa função é acionar um componente de carregamento que permitirá ao usuário saber que os dados estão sendo processados ​​e, depois disso, extrairemos todos os dados de campo do formulário.

createSong(): void {
  const loading: Loading = this.loadingCtrl.create();
  loading.present();

  const albumName = this.createSongForm.value.albumName;
  const artistName = this.createSongForm.value.artistName;
  const songDescription = this.createSongForm.value.songDescription;
  const songName = this.createSongForm.value.songName;
}

E, por último, enviaremos os dados para o provedor, assim que a música for criada com sucesso, o usuário deverá navegar de volta para a página anterior, e se houver algo errado ao criá-lo, exibiremos um alerta com a mensagem de erro.

createSong(): void {
  const loading: Loading = this.loadingCtrl.create();
  loading.present();

  const albumName = this.createSongForm.value.albumName;
  const artistName = this.createSongForm.value.artistName;
  const songDescription = this.createSongForm.value.songDescription;
  const songName = this.createSongForm.value.songName;

  this.firestoreProvider
    .createSong(albumName, artistName, songDescription, songName)
    .then(
      () => {
        loading.dismiss().then(() => {
          this.navCtrl.pop();
        });
      },
      error => {
        loading.dismiss().then(() => {
          const alert: Alert = this.alertCtrl.create({
            message: error.message,
            buttons: [{ text: 'Ok', role: 'cancel' }],
          });
          alert.present();
        });
      }
    );
}

OBSERVAÇÃO: Como uma boa prática, manipule esses erros você mesmo, em vez de mostrar a mensagem de erro padrão para os usuários, certifique-se de fazer algo mais fácil de usar e usar suas mensagens personalizadas, somos técnicos, sabemos o que o erro significa, do tempo que nossos usuários não vão.

Nós quase terminamos essa parte, tudo que precisamos agora é criar a função dentro do provedor que recebe todos os dados do formulário que estamos enviando e usa para criar uma música em nosso banco de dados.

Abra providers/firestore/firestore.tse vamos fazer algumas coisas, precisamos:

  • Importar Firestore.
  • Importe nossa interface de música.
  • Injetar firestore no construtor.
  • E escreva a createSong()função que leva todos os parâmetros que enviamos do nosso formulário.
import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> { }
}

A função está tomando todos os parâmetros que estamos enviando. Agora vamos fazer algo que possa parecer incomum . Nós vamos usar a createId()função firestore para gerar um id para a nossa nova música.

import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> {
    const id = this.firestore.createId();
  }
}

O Firestore gera automaticamente IDs para nós quando enviamos itens para uma lista, mas eu gosto de criar primeiro o ID e depois armazená-lo dentro do item. Dessa forma, se eu puxar um item, posso obter sua ID e não tem que fazer quaisquer outras operações para obtê-lo.

Agora que criamos o id, vamos criar uma referência para essa música e definir todas as propriedades que temos, incluindo o id.

import { Injectable } from '@angular/core';
import { AngularFirestore } from 'angularfire2/firestore';
import { Song } from '../../models/song.interface';

@Injectable()
export class FirestoreProvider {
  constructor(public firestore: AngularFirestore) {}

  createSong(
    albumName: string,
    artistName: string,
    songDescription: string,
    songName: string
  ): Promise<void> {
    const id = this.firestore.createId();

    return this.firestore.doc(`songList/${id}`).set({
      id,
      albumName,
      artistName,
      songDescription,
      songName,
    });
  }
}

Essa última parte do código está criando uma referência ao documento identificado com esse ID em nossa songListcoleção e, depois de criar a referência, ele adiciona todas as informações que enviamos como parâmetros.

E é isso. Agora você pode adicionar músicas à nossa lista. E uma vez que cada música é criada, o usuário irá navegar de volta para a página inicial, onde vamos mostrar a lista de músicas armazenadas no banco de dados.

Passo # 3: Mostre a lista de itens.

Para mostrar a lista de músicas, seguiremos a mesma abordagem que usamos para nossa última funcionalidade, criaremos a exibição HTML, a classe TypeScript e a função dentro do provedor que se comunica com o Firebase.

Já que temos o provedor aberto a partir da funcionalidade anterior vamos começar por aí, queremos criar uma função chamada de getSongList()função que deva retornar uma coleção de músicas:

getSongList(): AngularFirestoreCollection<Song> {
  return this.firestore.collection(`songList`);
}

Note que para isso funcionar você precisa importar AngularFirestoreCollectiondo angularfire2/firestorepacote ( ou remover a verificação de tipo se você não se importa com isso ).

Agora, vamos para a página inicial e importamos tudo o que precisaremos:

import { Song } from '../../models/song.interface';
import { FirestoreProvider } from '../../providers/firestore/firestore';
import { Observable } from 'rxjs/Observable';

Queremos a Songinterface para uma verificação de tipo restrita, FirestoreProviderpara se comunicar com o banco de dados e Observabletambém para verificação de tipo, nosso provedor retornará um AngularFirestoreCollection que transformaremos em um observável para exibir em nossa visualização.

Então, dentro de nossa classe, queremos criar a songListpropriedade, vamos usá-la para exibir as músicas no HTML e injetar o provedor firestore no construtor.

public songList: Observable<Song[]>;
constructor(
  public navCtrl: NavController,
  public firestoreProvider: FirestoreProvider
) {}

E, por último, queremos esperar até que a página carregue e buscar a lista do nosso provedor:

ionViewDidLoad() {
  this.songList = this.firestoreProvider.getSongList().valueChanges();
}

.valueChanges()método pega o AngularFirestoreCollection e o transforma em um tipo Observable of Songs.

Agora podemos ir para home.htmldentro e dentro da <ion-content>nossa lista de músicas para exibir todas as músicas no banco de dados.

<ion-content>
  <ion-card *ngFor="let song of songList | async" 
    (click)="goToDetailPage(song)">
    <ion-card-header>
      {{ song.songName }}
    </ion-card-header>
    <ion-card-content>
      Artist Name: {{ song.artistName }}
    </ion-card-content>
  </ion-card>
</ion-content>

Estamos apenas mostrando o nome da música e o nome do artista, e estamos adicionando um evento de clique ao nosso cartão, uma vez que o usuário clica no cartão, ele deve acionar a goToDetailPage()função e passar todo o objeto da música como um parâmetro.

Nós não criamos essa função, então vamos criar um momento para criá-la em nossa homepage:

goToDetailPage(song: Song): void {
  this.navCtrl.push('DetailPage', { song: song });
}

A função navega o usuário até a página Detail e passa todo o objeto da música como um parâmetro de navegação. Na próxima seção, usaremos esse parâmetro de navegação para exibir os dados da música inteira na página de detalhes.

Por enquanto, pegue um biscoito ou algo assim, você já leu muito, e seus níveis de açúcar podem precisar de um impulso. Vejo vocês em alguns minutos na próxima seção🙂

Passo # 4: Navegue até a página de detalhes de um item.

Na etapa anterior, criamos uma função que nos leva à página de detalhes com as informações da música e, agora, vamos usar essas informações e exibi-las para o usuário ver.

Em vez de falar com o provedor para obter o registro da música, estamos passando a música inteira como um parâmetro de navegação, portanto, não precisamos importar nosso provedor do firestore agora.

A primeira coisa que faremos é detail.htmlcriar uma visualização básica que exiba todos os dados que temos para nossa música:

<ion-header>
  <ion-navbar color="primary">
    <ion-title>
      {{ song.songName }}
    </ion-title>
  </ion-navbar>
</ion-header>

<ion-content padding>
  <h3> Artist </h3>
  <p>
    The song {{ song.songName }} was released by {{ song.artistName }}.
  </p>

  <h3> Album </h3>
  <p>
    It was part of the {{ song.albumName }} album.
  </p>

  <h3> Description </h3>
  <p>
    {{ song.songDescription }}
  </p>
</ion-content>

Estamos mostrando o nome da música na barra de navegação e adicionamos o restante dos dados ao conteúdo da página.

Agora vamos pular detail.tspara que possamos fazer o songcontrário, isso irá cometer erros.

Tudo que você precisa fazer é criar uma propriedade songdo tipo Song, para isso precisamos importar a Songinterface.

Então, você deseja obter o parâmetro de navegação que enviamos para a página e atribuir seu valor à songpropriedade que você criou.

import { Component } from '@angular/core';
import { IonicPage, NavController, NavParams } from 'ionic-angular';
import { Song } from '../../models/song.interface';

@IonicPage()
@Component({
  selector: 'page-detail',
  templateUrl: 'detail.html',
})
export class DetailPage {
  public song: Song;
  constructor(public navCtrl: NavController, public navParams: NavParams) {
    this.song = this.navParams.get('song');
  }
}

Você deve fazer um teste agora mesmo, pois ionic serveseu aplicativo deve estar funcionando, e você deve ser capaz de criar novas músicas, mostrar a lista de músicas e entrar na página de detalhes de uma música.

Etapa 5: excluir um item da lista.

Na última parte do tutorial vamos adicionar um botão dentro da DetailPage, esse botão dará ao usuário a capacidade de remover músicas da lista.

Primeiro, abra detail.htmle crie o botão, nada muito chique, um botão regular que chame a função remove fará, configure-o imediatamente antes da tag de conteúdo iônico de fechamento.

<button ion-button block (click)="deleteSong(song.id, song.songName)">
    DELETE SONG
  </button>
</ion-content>

Agora vá para o detail.tse crie a deleteSong()função, ele deve levar 2 parâmetros, o ID da música e o nome da música:

deleteSong(songId: string, songName: string): void {}

A função deve acionar um alerta que solicita ao usuário uma confirmação e, se o usuário aceitar a confirmação, deverá chamar a função de exclusão do provedor e retornar à página anterior ( Nossa home page ou página de listagem ).

deleteSong(songId: string, songName: string): void {
    const alert: Alert = this.alertCtrl.create({
      message: `Are you sure you want to delete ${songName} from your list?`,
      buttons: [
        {
          text: 'Cancel',
          handler: () => {
            console.log('Clicked Cancel');
          },
        },
        {
          text: 'OK',
          handler: () => {
            this.firestoreProvider.deleteSong(songId).then(() => {
              this.navCtrl.pop();
            });
          },
        },
      ],
    });
    alert.present();
  }

NOTA: Certifique-se de importar Alert, AlertController e nosso FirestoreProvider para que isso funcione.

Agora, tudo o que precisamos fazer é ir ao nosso provedor e criar a função de exclusão:

deleteSong(songId: string): Promise<void> {
  return this.firestore.doc(`songList/${songId}`).delete();
}

A função usa o ID da música como um parâmetro e, em seguida, usa-a para criar uma referência a esse documento específico no banco de dados. Por último, chama o .delete()método nesse documento.

E é isso. Você deve ter uma funcionalidade Mestre / Detalhe totalmente funcional na qual possa listar objetos, criar novos objetos e excluir objetos do banco de dados.🙂

Próximos passos

Parabéns, esse foi longo, mas estou certo de que você agora entende mais sobre o Firestore e como usá-lo com o Firebase.

Se você quiser saber mais sobre o Firestore e começar a criar aplicativos Ionic mais completos, criei um Crash Course que aborda a teoria por trás do que vimos aqui e também inclui os disparadores do Cloud Functions para as regras de segurança do Firestore e do Firestore.

VOCÊ PODE RECEBER GRATUITAMENTE AQUI .

FONTE: https://javebratt.com/crud-ionic-firestore/

Conhecendo o MQTT

Por que o MQTT é um dos melhores protocolos de rede para a Internet das Coisas?

Para os dispositivos de Internet das Coisas (IoT), a conexão com a Internet é um requisito. A conexão com a Internet permite que os dispositivos trabalhem entre si e com serviços de backend. O protocolo de rede subjacente da Internet é o TCP/IP. Desenvolvido com base na pilha TCP/IP, o MQTT (Message Queue Telemetry Transport) tornou-se o padrão para comunicações de IoT.

O MQTT foi inventado e desenvolvido inicialmente pela IBM no final dos anos 90. Sua aplicação original era vincular sensores em pipelines de petróleo a satélites. Como seu nome sugere, ele é um protocolo de mensagem com suporte para a comunicação assíncrona entre as partes. Um protocolo de sistema de mensagens assíncrono desacopla o emissor e o receptor da mensagem tanto no espaço quanto no tempo e, portanto, é escalável em ambientes de rede que não são confiáveis. Apesar de seu nome, ele não tem nada a ver com filas de mensagens, na verdade, ele usa um modelo de publicação e assinatura. No final de 2014, ele se tornou oficialmente um padrão aberto OASIS, com suporte nas linguagens de programação populares, usando diversas implementações de software livre.

Por que o MQTT

O MQTT é um protocolo de rede leve e flexível que oferece o equilíbrio ideal para os desenvolvedores de IoT:

  • O protocolo leve permite a implementação em hardware de dispositivo altamente restringido e em redes de largura da banda limitada e de alta latência.
  • Sua flexibilidade possibilita o suporte a diversos cenários de aplicativo para dispositivos e serviços de IoT.

Para entender por que o MQTT é tão adequado para desenvolvedores de IoT, vamos analisar por que outros protocolos de rede populares falharam em IoT.

Por que não usar algum dos outros inúmeros protocolos de rede

A maioria dos desenvolvedores já se acostumou aos serviços da Web HTTP. Então, por que não conectar os dispositivos de IoT aos serviços da web? O dispositivo poderia enviar seus dados como uma solicitação de HTTP e receber atualizações do sistema como uma resposta de HTTP. Esse padrão de solicitação e resposta tem algumas limitações graves:

  • O HTTP é um protocolo síncrono. O cliente espera que o servidor responda. Os navegadores da web têm esse requisito, mas o custo é a baixa escalabilidade. No mundo da IoT, a comunicação síncrona tem sido um problema devido ao grande número de dispositivos e à rede, muitas vezes não confiável e de alta latência. Um protocolo de mensagem assíncrono é muito mais adequado para aplicativos de IoT. Os sensores podem enviar leituras e permitir que a rede descubra o caminho e a sincronização ideais para entregar aos dispositivos e serviços de destino.
  • HTTP é unidirecional. O cliente precisa iniciar a conexão. Em um aplicativo de IoT, os dispositivos e sensores geralmente são clientes, o que significa que eles não podem receber comandos da rede passivamente.
  • HTTP é um protocolo de um para um. O cliente faz uma solicitação e o servidor responde. É difícil e caro transmitir uma mensagem a todos os dispositivos na rede, o que é um caso de uso comum em aplicativos de IoT.
  • HTTP é um protocolo pesado com muitos cabeçalhos e regras. Ele não é adequado para redes restringidas.

Pelos motivos citados acima, a maioria dos sistemas escaláveis de alto desempenho usam um barramento do sistema de mensagens assíncrono, em vez de serviços da web, para trocas de dados internas. Na verdade, o protocolo de sistema de mensagens mais popular que é usado em sistemas de middleware corporativos é chamado AMQP (Advanced Message Queuing Protocol). No entanto, no ambiente de alto desempenho, a capacidade de computação e a latência da rede geralmente não são uma preocupação. O AMQP foi criado para assegurar a confiabilidade e a interoperabilidade em aplicativos corporativos. Ele possui um rico conjunto de recursos, mas não é adequado para aplicativos de IoT com restrição de recursos.

Além do AMQP, existem outros protocolos populares de sistema de mensagens. Por exemplo, o XMPP (Extensible Messaging and Presence Protocol) é um protocolo de mensagem instantânea (IM) ponto a ponto. Ele é pesado em recursos com suporte para casos de uso de IM, como presença e anexos de mídia. Em comparação com o MQTT, ele requer muito mais recursos no dispositivo e na rede.

Então, como o MQTT consegue ser tão leve e flexível? Um importante recurso do protocolo MQTT é o modelo de publicação e assinatura. Como em todos os protocolos de sistema de mensagens, ele desacopla o publicador e o consumidor de dados.

O modelo de publicação e assinatura

O protocolo MQTT define dois tipos de entidades na rede: um message broker e inúmeros clientes. O broker é um servidor que recebe todas as mensagens dos clientes e, em seguida, roteia essas mensagens para os clientes de destino relevantes. Um cliente é qualquer coisa que possa interagir com o broker e receber mensagens. Um cliente pode ser um sensor de IoT em campo ou um aplicativo em um data center que processa dados de IoT.

  1. O cliente conecta-se ao broker. Ele pode assinar qualquer “tópico” de mensagem no broker. Essa conexão pode ser uma conexão TCP/IP simples ou uma conexão TLS criptografada para mensagens sensíveis.
  2. O cliente publica as mensagens em um tópico, enviando a mensagem e o tópico ao broker.
  3. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Como as mensagens do MQTT são organizadas por tópicos, o desenvolvedor de aplicativos tem a flexibilidade de especificar que determinados clientes somente podem interagir com determinadas mensagens. Por exemplo, os sensores publicarão suas leituras no tópico “sensor_data” e assinarão o tópico “config_change”. Os aplicativos de processamento de dados que salvam os dados do sensor em um banco de dados de backend assinarão o tópico “sensor_data”. Um aplicativo de console administrativo poderia receber comandos do administrador do sistema para ajustar as configurações dos sensores, como a sensibilidade e a frequência de amostragem, e publicar essas mudanças no tópico “config_change”. (Consulte Figura 1.)

Figura 1. O modelo de publicação e assinatura do MQTT para sensores de IoT

Ao mesmo tempo, o MQTT é leve. Ele tem um cabeçalho simples para especificar o tipo de mensagem, um tópico baseado em texto e, em seguida, uma carga útil binária arbitrária. O aplicativo pode usar qualquer formato de dados para a carga útil como JSON, XML, binário criptografado ou Base64, desde que os clientes de destino possam analisar a carga útil.

Introdução ao desenvolvimento com MQTT

A ferramenta mais fácil para começar o desenvolvimento com MQTT é o módulo Python mosquitto, que faz parte do projeto Eclipse Paho e fornece SDKs e bibliotecas do MQTT em várias linguagens de programação. Ele contém um broker do MQTT que pode ser executado no computador local e ferramentas de linha de comandos que podem interagir com o broker usando mensagens. É possível fazer download e instalar o módulo mosquitto no website do mosquitto.

O comando mosquitto executa o broker do MQTT no computador local. Opcionalmente, é possível usar a opção -d para executá-lo em segundo plano.

$ mosquitto -d

Em seguida, em outra janela do terminal, é possível usar o comando mosquitto_sub para conectar-se ao broker local e assinar um tópico. Após a execução do comando, ele vai esperar e imprimir todas as mensagens que receber da assinatura, à medida que elas forem chegando.

$ mosquitto_sub -t "dw/demo"

Em uma outra janela do terminal, é possível usar o comando mosquitto_pub para conectar-se ao broker local e, em seguida, publicar uma mensagem em um tópico.

$ mosquitto_pub -t "dw/demo" -m "hello world!"

Agora, o terminal que executa o mosquitto_sub deverá exibir “hello world!” na tela. Você acabou de enviar e receber uma mensagem usando um broker do MQTT!

É claro que em um sistema de produção, não é possível usar um computador local como o broker. Nesse caso, é possível usar o Serviço da plataforma Internet das Coisas do IBM Bluemix, que é um serviço sob demanda e confiável que funciona como um broker do MQTT. (Leia mais sobre como esse serviço do Bluemix se integra e usa o MQTT como seu protocolo para comunicar-se com dispositivos e aplicativos na documentação do serviço.)

O nó Serviço da plataforma Internet das Coisas do IBM Bluemix funciona da seguinte forma.

  • No console do Bluemix, é possível criar uma instância do serviço da plataforma Internet das Coisas sob demanda.
  • Em seguida, é possível incluir dispositivos que possam conectar a instância de serviço usando o MQTT. Cada dispositivo terá um ID e um nome. Somente os dispositivos listados podem acessar o serviço, e o painel da plataforma Watson IoT relatará informações sobre tráfego e uso desses serviços, nos respectivos dispositivos.
  • Para cada cliente do dispositivo, o Bluemix designará um nome do host, um nome de usuário e uma senha para a conexão com a instância de serviço (o broker do MQTT). (No Bluemix, o nome de usuário sempre é use-token-auth e a senha é o token que é mostrado na Figura 2 para cada dispositivo conectado.)
Figura 2. Criando uma instância de serviço da plataforma Internet das Coisas no IBM Bluemix

Ao usar um broker remoto do MQTT, será necessário passar pela aprovação das credenciais de autenticação e de nome do host do broker para os comandos mosquitto_sub e mosquitto_pub. Por exemplo, o comando a seguir assina o tópico de demonstração no nosso serviço da plataforma Internet das Coisas com o nome de usuário e senha fornecidos pelo Bluemix:

$ mosquitto_sub -t "demo" -h host.iotp.mqtt.bluemix.com -u username -P password

Para conhecer mais opções de como usar as ferramentas do mosquitto e também de como usar a API do mosquitto para criar seus próprios aplicativos clientes do MQTT, consulte a documentação no website do mosquitto.

Agora que você já tem as ferramentas necessárias, vamos nos aprofundar no protocolo MQTT.

Entendendo o protocolo MQTT

O MQTT é um protocolo de ligação que especifica como os bytes de dados são organizados e transmitidos pela rede TCP/IP. Mas por motivos práticos, os desenvolvedores não precisam entender o protocolo de ligação. Basta saber que cada mensagem tem uma carga útil de comando e dados. O comando define o tipo de mensagem (por exemplo, uma mensagem CONNECT ou uma mensagem SUBSCRIBE). Todas as bibliotecas e ferramentas do MQTT oferecem maneiras simples de manipular essas mensagens diretamente e podem preencher automaticamente alguns campos necessários, como os IDs da mensagem e do cliente.

Primeiro, o cliente conecta-se ao broker enviando uma mensagem CONNECT. A mensagem CONNECT pede para estabelecer uma conexão do cliente com o broker. A mensagem CONNECT tem os parâmetros de conteúdo a seguir.

Tablela 1. Parâmetros da mensagem CONNECT
Parâmetro Descrição
cleanSession Esta sinalização especifica se a conexão é persistente ou não. Uma sessão persistente armazena todas as assinaturas e as mensagens possivelmente perdidas (dependendo do QoS) no broker. (Consulte Tablela 3 para obter uma descrição do QoS).
username As credenciais de autenticação e autorização do broker.
password As credenciais de autenticação e autorização do broker.
lastWillTopic Quando a conexão for encerrada inesperadamente, o broker publicará automaticamente uma mensagem de “último desejo” em um tópico.
lastWillQos O QoS da mensagem de “último desejo”. (Consulte Tablela 3 para obter uma descrição do QoS).
lastWillMessage A própria mensagem de “último desejo”.
keepAlive Este é o intervalo de tempo em que o cliente precisa efetuar ping no broker para manter a conexão ativa.

O cliente receberá uma mensagem CONNACK do broker. A mensagem CONNACK tem os parâmetros de conteúdo a seguir.

Tablela 2. Parâmetros da mensagem CONNACK
Parâmetro Descrição
sessionPresent Indica se a conexão já tem uma sessão persistente. Ou seja, a conexão já tem tópicos assinados e receberá a entrega de mensagens ausentes.
returnCode 0 indica sucesso. Outros valores identificam a causa da falha.

Depois que uma conexão for estabelecida, o cliente poderá enviar uma ou mais mensagens SUBSCRIBE ao broker para indicar que ele receberá mensagens do broker de determinados tópicos. A mensagem pode ter uma ou várias repetições dos parâmetros a seguir.

Tablela 3. Parâmetros da mensagem SUBSCRIBE
Parâmetro Descrição
qos A sinalização qos (qualidade de serviço ou QoS) indica com que consistência as mensagens neste tópico precisam ser entregues aos clientes.

  • Valor 0: não confiável, a mensagem é entregue no máximo uma única vez, se o cliente estiver indisponível no momento, ele perderá a mensagem.
  • Valor 1: a mensagem deve ser entregue pelo menos uma vez.
  • Valor 2: a mensagem deve ser entregue exatamente uma vez.
tópico Um tópico para assinar. Um tópico pode ter vários níveis separados pelo caractere barra. Por exemplo, “dw/demo” e “ibm/bluemix/mqtt” são tópicos válidos.

Depois que o cliente tiver assinado um tópico com sucesso, o broker retornará uma mensagem SUBACK com um ou mais parâmetros returnCode.

Tablela 4. Parâmetros da mensagem SUBACK
Parâmetro Descrição
returnCode Existe um código de retorno para cada um dos tópicos no comando SUBSCRIBE. Os valores de retorno são os seguintes.

  • Valores 0 a 2: sucesso como nível de QoS correspondente. (Consulte Tablela 3 para saber mais sobre QoS.)
  • Valor 128: falha.

Correspondendo à mensagem SUBSCRIBE, o cliente também poderá UNSUBSCRIBE (cancelar a assinatura) de um tópico ou de vários tópicos.

Tablela 5. Parâmetros da mensagem UNSUBSCRIBE
Parâmetro Descrição
tópico Este parâmetro pode se repetir para vários tópicos.

O cliente pode enviar mensagens PUBLISH ao broker. A mensagem contém um tópico e uma carga útil de dados. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Tablela 6. Parâmetros da mensagem PUBLISH
Parâmetro Descrição
topicName O tópico no qual a mensagem é publicada.
qos O nível de qualidade de serviço da entrega da mensagem. (Consulte Tablela 3 para obter uma descrição do QoS).
retainFlag Esta sinalização indica se o broker reterá a mensagem como a última mensagem conhecida deste tópica.
carga útil Os dados reais na mensagem. Pode ser uma sequência de texto ou um blob binário de dados.

Dicas e soluções alternativas

O poder do MQTT é a simplicidade. Não há restrições quanto ao tipo de tópico ou de carga útil de mensagem que se pode usar. Isso permite alguns casos de uso interessantes. Por exemplo, considere estas questões:

Como executar mensagens de um para um com o MQTT? Ambas as partes podem concordar em usar um tópico que seja exclusivo para elas. Por exemplo, o nome do tópico pode conter os IDs dos dois clientes para garantir sua exclusividade.

Como um cliente transmite seu status de presença? O sistema pode concordar com uma convenção de nomenclatura para tópicos de “presença”. Por exemplo, o tópico “presence/client-id” pode conter as informações de presença do cliente. O cliente define a mensagem como true quando se conecta e false quando se desconecta. O cliente também pode configurar uma mensagem de last will como false para ser definida quando a conexão for encerrada. A mensagem pode ser retida pelo broker para que novos clientes possam ler o tópico e descobrir o status de presença.

Como proteger as comunicações? A conexão do cliente com o broker pode ser uma conexão TLS criptografada para proteger os dados em trânsito. Além disso, como o protocolo MQTT não impõe restrições quanto ao formato de dados da carga útil, o sistema pode concordar com um método de criptografia e um mecanismo de atualização de chave. Depois disso, todo o conteúdo na carga útil pode ser dados binários criptografados das mensagens JSON ou XML reais.

Conclusão

Neste artigo eu ofereci uma introdução técnica ao protocolo MQTT. Você aprendeu o que é o MQTT, por que ele é adequado para aplicativos de IoT e como começar a desenvolver aplicativos que usam o MQTT.

Em um de meus próximos artigos, vou mostrar como desenvolver uma solução de sensor de IoT completa com serviços de MQTT de backend e usando uma placa NodeMCU.

Recursos

Recursos para download

Temas relacionados

Fonte:  https://www.ibm.com/developerworks/br/library/iot-mqtt-why-good-for-iot/index.html

Mosquitto Eclipse – Um Broker MQTT de Software Livre

O Eclipse Mosquitto é um intermediário de mensagens de código-fonte aberto (licenciado por EPL / EDL) que implementa as versões 3.1 e 3.1.1 do protocolo MQTT. O Mosquitto é leve e adequado para uso em todos os dispositivos, desde computadores de mesa única de baixa potência até servidores completos.

O protocolo MQTT fornece um método leve de executar mensagens usando um modelo de publicação / assinatura. Isso o torna adequado para mensagens da Internet das Coisas, como sensores de baixa potência ou dispositivos móveis, como telefones, computadores embutidos ou microcontroladores.

O projeto Mosquitto também fornece uma biblioteca C para implementar clientes MQTT, e os populares clientes MQTT da linha de comando mosquitto_pub e mosquitto_sub.

O Mosquitto faz parte da Eclipse Foundation e é um projeto do iot.eclipse.org

Baixar

O Mosquitto é altamente portátil e está disponível para uma ampla gama de plataformas. Vá para a página de download dedicada para encontrar a origem ou os binários para sua plataforma.

Leia o log de alterações para saber mais sobre os lançamentos recentes.

Teste

Você pode ter sua própria instância do Mosquitto em execução em minutos, mas para tornar o teste ainda mais fácil, o Projeto Mosquitto executa um servidor de teste em test.mosquitto.org onde você pode testar seus clientes de várias maneiras: MQTT simples, MQTT sobre TLS , MQTT sobre TLS (com certificado de cliente , MQTT sobre WebSockets e MQTT sobre WebSockets com TLS.

plataformas.

Comunidade

Segurança

Use a página de segurança para descobrir como denunciar vulnerabilidades ou respostas a problemas de segurança anteriores.

Fonte

Downloads mais antigos estão disponíveis em http://mosquitto.org/files/

Instalação Binária

janelas

Veja o arquivo readme-windows.txt depois de instalar os detalhes e dependências específicos do Windows.

Mac

Mosquitto pode ser instalado a partir do projeto homebrew. Veja brew.sh e depois usebrew install mosquitto

Arch Linux

  • Mosquitto pode ser encontrado no repositório da comunidade.

CentOS

Baixe o arquivo de configuração do repositório para sua versão do CentOS a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. CentOS 7CentOS 6

Debian

  • O Mosquitto agora está no Debian. Haverá um pequeno atraso entre uma nova versão e ela aparecerá no Debian como parte dos procedimentos normais da Debian.
  • Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository>

Fedora

O Mosquitto está agora disponível diretamente no Fedora. Use yum install mosquittoou pesquise “mosquito” para encontrar os pacotes relacionados.

FreeBSD

Mosquitto está disponível para o FreeBSD: http://www.freshports.org/net/mosquitto/

Gentoo

Usar emerge mosquitto

openSUSE

Faça o download do arquivo de configuração do repositório para a sua versão do openSUSE abaixo e copie-o para /etc/zypp/repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

As embalagens disponíveis são: mosquitto, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto.

OpenWrt

Se você estiver usando um instantâneo de tronco, use opkg update; opkg install mosquitto

Karl Palsson mantém um conjunto de feeds que podem ser mais atualizados do que a versão atual do OpenWrt:

Raspberry Pi

Mosquitto está disponível através do repositório principal.

Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository/

Redhat Enterprise Linux

Faça o download do arquivo de configuração do repositório para sua versão do RHEL a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquitto atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. RHEL 7RHEL 6

SUSE Linux Enterprise Server

Adicione o repositório apropriado à sua configuração de pacote na lista abaixo e instale o mosquitto a partir de suas ferramentas normais de gerenciamento de pacotes.

Ubuntu

O Mosquitto está disponível nos repositórios do Ubuntu para que você possa instalar como em qualquer outro pacote. Se você estiver em uma versão anterior do Ubuntu ou quiser uma versão mais recente do mosquitto, adicione o PPA mosquitto-dev à sua lista de repositórios – veja o link para detalhes. O mosquito pode então ser instalado a partir do gerenciador de pacotes.

  • sudo apt-add-repository ppa:mosquitto-dev/mosquitto-ppa
  • sudo apt-get update

Se o comando apt-add-repositorynão for reconhecido, ele poderá ser instalado com:

  • sudo apt-get install python-software-properties

Iphone

Você pode usar o libmosquitto (incluído no download da fonte) no iPhone para criar aplicativos MQTT. Ele compila como objective-c, ou você pode usar o projeto marquette que é um wrapper object-c e aplicativo de exemplo.

Fonte: https://mosquitto.org/download/

 .

Mosquitto e paho-mqtt-python

Mosquitto e paho-mqtt-python

Melhore a segurança do mosquito no Ubuntu 16.04 LTS

Instalar mosquito
> sudo apt-adicionar-repositório ppa: mosquitto-dev / mosquitto-ppa
> sudo apt-get atualizar
> sudo apt-get instalar mosquitto mosquitto-clients

Instalar o paho-mqtt-python
> pip install paho-mqtt

Configurar mosquito
> sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistência true 
persistence_location / var / lib / mosquitto / 
allow_anonymous falso 
arquivo log_dest /var/log/mosquitto/mosquitto.log 
include_dir /etc/mosquitto/conf.d

Adicione a confoguração do mosquito
> sudo vi /etc/mosquitto/conf.d/default.conf

password_file / etc / mosquitto / passwd
ouvinte 1883 localhost
listener 8883 
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem 
cafile /etc/letsencrypt/live/[hostname]/chain.pem 
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem

Adicionar nome de usuário e senha do
mosquitto> mosquitto_passwd -c / etc / mosquitto / passwd [nome de usuário]
Senha: [senha]
Redigite a senha: [senha]

Teste com o assinante do mosquitto
> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -q [qos] -c -i [clientid] -u [username] -P [senha]

Teste com o editor de mosquitos
> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [senha]

assinante paho-mqtt

 

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

 

Configurar mosquito

>sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistence true
persistence_location /var/lib/mosquitto/
allow_anonymous false
log_dest file /var/log/mosquitto/mosquitto.log
include_dir /etc/mosquitto/conf.d

Adicione a configuração do mosquito

password_file /etc/mosquitto/passwd
listener 1883 localhost
listener 8883
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem
cafile /etc/letsencrypt/live/[hostname]/chain.pem
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem
include_dir /etc/mosquitto/conf.d

Adicionar nome de usuário e senha do

> mosquitto_passwd -c /etc/mosquitto/passwd [username]
Password: [password]
Reenter password: [password]

 

Teste com o assinante do mosquitto

> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -q [qos] -c -i [clientid] -u [username] -P [password]

 

Teste com o editor de mosquitos

> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [password]

Assinante paho-mqtt

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

Editor paho-mqtt

import ssl
import sys

import paho.mqtt.client
import paho.mqtt.publish

def on_connect(client, userdata, flags, rc):
	print('connected')

def main():
	paho.mqtt.publish.single(
		topic='[topic]',
		payload='[message]',
		qos=2,
		hostname='[hostname]',
		port=8883,
		client_id='[clientid]',
		auth={
			'username': '[username]',
			'password': '[password]'
		},
		tls={
			'ca_certs': '/etc/ssl/certs/DST_Root_CA_X3.pem',
			'tls_version': ssl.PROTOCOL_TLSv1_2
		}
	)

if __name__ == '__main__':
	main()
	sys.exit(0)

 

erinus diz:

Se o seu assinante quiser receber todas as mensagens não lidas em um tópico após o início, você deverá concluir estas etapas:

Use o mesmo ID de cliente quando você inicia o assinante.
Use clean_session = False quando você inicia o assinante.
Use qos> 0 quando você assina um tópico.
Use qos> 0 quando você publicar uma mensagem.

Para tornar suas comunicações mais seguras, você deve concluir estas etapas:

Usar TLS 1.2
Set allow_anonymous = False
Habilitar autenticação com nome de usuário e senha

Se você quer mais métodos de autenticação, tente este plugin mosquitto:

https://github.com/jpmens/mosquitto-auth-plug

 

Fonte:  https://medium.com/@erinus/mosquitto-paho-mqtt-python-29cadb6f8f5c

 

 

 

 

Princípios Básicos da API SOAP do PayPal

A API do PayPal SOAP é baseada em padrões abertos conhecidos coletivamente como serviços da Web, que incluem o SOAP (Simple Object Access Protocol), o WSDL (Web Services Definition Language) e o XSD (XML Schema Definition language). Uma ampla variedade de ferramentas de desenvolvimento em diversas plataformas oferece suporte a serviços da Web.

Como muitos serviços da Web, o PayPal SOAP é uma combinação de esquemas do lado do cliente e do lado do servidor, servidores de hardware e software e serviços principais.

Diagrama de alto nível do PayPal SOAP

Em um modelo de processamento orientado a objetos, a interface para solicitações / respostas SOAP é um objeto na linguagem de programação nativa do seu aplicativo. Seu cliente SOAP de terceiros gera interfaces de objeto de negócios e stubs de rede dos arquivos WSDL e XSD fornecidos pelo PayPal que especificam a estrutura de mensagens do PayPal SOAP, seu conteúdo e as ligações de serviço da API do PayPal. Um aplicativo de negócios trabalha com dados na forma de propriedades do objeto para enviar e receber dados chamando métodos de objeto. O cliente SOAP manipula os detalhes da criação da solicitação SOAP, enviando-a ao serviço do PayPal e convertendo a resposta de volta para um objeto.

Definições de esquema do PayPal WSDL / XSD

O esquema de Serviços da Web do PayPal e seus componentes básicos e base do eBay Business Language (eBL) são necessários para o desenvolvimento de aplicativos com a API de serviços da Web do PayPal. A seguir estão os locais dos arquivos WSDL e XSD.

Localização dos arquivos PayPal WSDL e XSD
Desenvolvimento e teste com a sandbox do PayPal
Esquema do PayPal https://www.sandbox.paypal.com/wsdl/PayPalSvc.wsdl
Componentes básicos e componentes do eBL https://www.sandbox.paypal.com/wsdl/eBLBaseComponents.xsd 
https://www.sandbox.paypal.com/wsdl/CoreComponentTypes.xsd
Produção com a API do PayPal ao vivo
Esquema do PayPal https://www.paypal.com/wsdl/PayPalSvc.wsdl
Componentes básicos e componentes do eBL https://www.paypal.com/wsdl/eBLBaseComponents.xsd 
https://www.paypal.com/wsdl/CoreComponentTypes.xsd

Definições da API do SOAP do PayPal

A API do PayPal para SOAP inclui definições de API individuais para funções comerciais específicas. Como base, a API depende dos componentes básicos e básicos da eBay Business Language (eBL). As principais estruturas do eBL AbstractRequestTypeAbstractResponseTypesão a base da solicitação e resposta do SOAP de cada API do PayPal. AbstractResponseTypetambém é a estrutura para mensagens de erro comuns em todas as APIs do PayPal.

O PayPal tomou algumas decisões de design de esquema que podem afetar como os negócios projetam seus próprios aplicativos.

  • Enumerações – Enumerações são definidas diretamente no esquema da API do PayPal.
  • Informações de solução de problemas – A API do PayPal retorna informações sobre elementos que acionam erros.
  • Compatibilidade retroativa – A API do PayPal é versionada para que os aplicativos de negócios sejam compatíveis com versões anteriores quando novos elementos são introduzidos no esquema do lado do servidor.

Nota: O eBL define muitas estruturas específicas para leilões de processamento. O esquema SOAP do PayPal inclui essas definições para manter a compatibilidade com o SOAP do eBay. O material se concentra apenas nas definições de SOAP pertinentes ao uso da API do PayPal SOAP.

Segurança

O serviço da API SOAP do PayPal é protegido para garantir que apenas membros autorizados do PayPal o usem. Existem quatro níveis de segurança:

  1. Uma API Usernamee uma API obrigatórias Password.
  2. Um terceiro mecanismo de autenticação obrigatório, que é um dos seguintes:
    • Assinatura de solicitação do lado do cliente usando um certificado de API emitido pelo PayPal
    • Solicitar autenticação usando uma assinatura de API incluída na solicitação
  3. Se você estiver chamando a API em nome de um comerciante de terceiros, deverá especificar o endereço de e-mail registrado no PayPal do comerciante de terceiros ou o ID da conta do comerciante (às vezes chamado de ID do pagador) no Subjectcampo.

    Nota: Terceiros podem obter seu ID de comerciante entrando no paypal.com , clicando no ícone do perfil ( Menu Perfil) no canto superior direito da página e selecionando Perfil e configurações no menu Perfil de negócios . (Se o ícone do perfil na parte superior da página não estiver visível, clique em Perfil , que aparece no menu superior quando a guia Minha conta estiver selecionada.) Clique em Informações da minha empresa à esquerda e o ID da conta do comerciante é exibido no lista de itens de perfil à direita.

    Normalmente, um comerciante concede permissões de terceiros a um carrinho de compras, portanto, o carrinho de compras pode chamar a API em nome do comerciante. O comerciante deve ter concedido anteriormente permissão para executar a operação da API.

  4. Transporte de dados TLS (Transport Layer Security). Consulte as diretrizes de segurança das informações do desenvolvedor do PayPal para obter mais informações sobre o TLS.

Uma falha na segurança autenticada em qualquer um desses níveis nega acesso ao serviço da API do PayPal SOAP.

RequesterCredentials SOAP: nome de usuário, senha, assinatura e assunto

Para a segurança de seus negócios, o PayPal deve verificar se os comerciantes ou desenvolvedores de terceiros têm permissão para iniciar uma transação antes de fazer uma. O PayPal autentica cada solicitação. Se a solicitação não puder ser autenticada, uma falha de segurança SOAP será retornada.

No cabeçalho da solicitação SOAP, seu cliente SOAP deve definir os elementos UsernamePasswordpara passar uma combinação de nome de usuário / senha da API. Além disso, você pode definir o Signaturepara especificar sua string de assinatura de API. Se você estiver chamando a API em nome de um comerciante de terceiros, deverá definir o Subjectelemento para especificar o endereço de e-mail de terceiros ou o ID da conta do comerciante (às vezes chamado de ID do pagador).

Nota: Terceiros podem obter seu ID de comerciante entrando no paypal.com , clicando no ícone do perfil ( Menu Perfil) no canto superior direito da página e selecionando Perfil e configurações no menu Perfil de negócios . (Se o ícone do perfil na parte superior da página não estiver visível, clique em Perfil , que aparece no menu superior quando a guia Minha conta estiver selecionada.) Clique em Informações da minha empresa à esquerda e o ID da conta do comerciante é exibido no lista de itens de perfil à direita.

Normalmente, um comerciante concede permissões de terceiros a um carrinho de compras, portanto, o carrinho de compras pode chamar a API em nome do comerciante. O comerciante deve ter concedido anteriormente permissão para executar a operação da API.

O exemplo a seguir mostra parte dos RequesterCredentialselementos.

A maioria desses elementos é necessária para todas as solicitações SOAP.

<SOAP-ENV:Header>
  <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI" xsi:type="ebl:CustomSecurityHeaderType">
  <Credentials xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:UserIdPasswordType">
    <Username>API-Username</Username>
    <Password>API-Password</Password>
    <Signature>API-Signature</Signature>
    <Subject>Authorizing-Merchant-Email -or- Authorizing-Merchant-Account-ID</Subject>
  </Credentials>
  </RequesterCredentials>
</SOAP-ENV:Header>
Elementos de autenticação RequesterCredentials no cabeçalho SOAP
Elemento Valor Descrição
Username API-Username Seu nome de usuário da API, que é gerado automaticamente pelo PayPal quando vocêsolicita credenciais de API de certificado ou assinatura para usar a API do PayPal SOAP. Você pode ver esse valor em https://www.paypal.com/ em seu perfil em Acesso à API> Credenciais da API.
Password API-Password Sua senha da API, que você especifica quandosolicita credenciais de API de certificado ou assinatura para usar a API do PayPal SOAP.
Signature API-Signature Sua assinatura de API , se você usar uma em vez de um certificado de API.
Subject Authorizing-Merchant-Email

ou

Authorizing-Merchant-Account-ID

O endereço de e-mail ou ID da conta do comerciante (às vezes chamado de ID do pagador) de um terceiro para quem você está enviando solicitações para a API do PayPal para SOAP. Seu nome de usuário da API deve terrecebido permissão desse terceiro para fazer uma solicitação da API do PayPal em seu nome.

Pontos de extremidade do serviço SOAP

O terminal em serviço que processa suas solicitações SOAP depende do tipo de credenciais da API.

Pontos de extremidade do serviço SOAP
Tipo de credenciais da API Ponto de extremidade de produção ao vivo Ponto de extremidade de teste (sandbox)
Certificado de API https://api.paypal.com/2.0/ https://api.sandbox.paypal.com/2.0/
Assinatura API https://api-3t.paypal.com/2.0/ https://api-3t.sandbox.paypal.com/2.0/

Envelope de pedido SOAP

O diagrama a seguir ilustra o conteúdo de um envelope de solicitação do PayPal SOAP.

Todas as APIs do PayPal são baseadas em duas estruturas principais: AbstractRequestTypeAbstractResponseType.

Diagrama do envelope de solicitação SOAP

Solicitar estrutura

A descrição anotada a seguir da estrutura de solicitação SOAP mostra os elementos requeridos pela API do PayPal SOAP.

Estrutura geral da solicitação SOAP da API do PayPal

1.  <?xml version="1.0" encoding="UTF-8"?>
2.  <SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
3.    <SOAP-ENV:Header>
4.      <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI">
5.        <Credentials xmlns="urn:ebay:apis:eBLBaseComponents">
6.          <Username>API-Username</Username>
7.          <Password>API-Password</Password>
8.          <Signature/>
9.          <Subject/>
10.       </Credentials>
11.     </RequesterCredentials>
12.   </SOAP-ENV:Header>
13.   <SOAP-ENV:Body>
14.     <Specific-API-Name-Req xmlns="urn:ebay:api:PayPalAPI">
15.       <Specific-API-Name-Request>
16.         <Version xmlns="urn:ebay:apis:eBLBaseComponents">API-Version</Version>
17.         <Required-Or-Optional-Fields xs:type="Type">Data</Required-Or-Optional-Fields>
18.       </Specific-API-Name-Request>
19.     </Specific-API-Name-Req>
20.   </SOAP-ENV:Body>
21. </SOAP-ENV:Envelope>
Anotação de solicitação SOAP genérica
Linhas Comente
6, 7 Os campos UsernamePasswordsão parte do RequesterCredentialsmecanismo de autenticação de segurança da API SOAP do PayPal que você deve construir para cada cabeçalho de solicitação SOAP. Veja RequesterCredentials para mais informações.
8 Signatureelemento deve incluir sua assinatura de API se esse for o tipo de credencial de API que você está usando.
9 Subjectelemento deve ser incluído ao usar permissões de terceiros (realizando transações em nome de outro comerciante que tenha autorizado você a fazer isso). Passe o ID da conta do comerciante de terceiros autorizador (às vezes chamado de ID do pagador) ou endereço de e-mail.
13 a 20 A solicitação SOAP para cada API do PayPal segue esse padrão de nomenclatura de elemento. O nome específico da API é anexado com Reqe, nesse elemento, o nomeSpecific-API-Name-Reqé aninhado. Cada Specific-API-Name-Requestum tem um correspondente Specific-API-Name-RequestType.
16 O número da versão da API do PayPal SOAP é necessário em cada solicitação SOAP. Este número de versão é o valor de ns:versionem https://www.paypal.com/wsdl/PayPalSvc.wsdl .
17 Para detalhes sobre elementos obrigatórios e opcionais e valores para solicitações específicas, consulte as referências da API .

Estilo da Mensagem SOAP: doc-literal

PayPal usa doc-literalmensagens SOAP, não rpc-encoding. Com doc-literal, uma única chamada de interface de serviço passa um documento XML na solicitação para o servidor da API do PayPal, que responde com uma instância do documento XML.

Estrutura de Resposta

A seguir, uma descrição anotada da estrutura de uma resposta SOAP bem-sucedida da API do PayPal, em que Ack=Success:

1.  <?xml version="1.0"?>
2.  <SOAP-ENV:Envelope
    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:cc="urn:ebay:apis:CoreComponentTypes"
    xmlns:wsu="http://schemas.xmlsoap.org/ws/2002/07/utility"
    xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion"
    xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
    xmlns:wsse="http://schemas.xmlsoap.org/ws/2002/12/secext"
    xmlns:ebl="urn:ebay:apis:eBLBaseComponents"
    xmlns:ns="urn:ebay:api:PayPalAPI">
3.    <SOAP-ENV:Header>
4.      <Security xmlns="http://schemas.xmlsoap.org/ws/2002/12/secext"xsi:type="wsse:SecurityType"/>
5.      <RequesterCredentials xmlns="urn:ebay:api:PayPalAPI" xsi:type="ebl:CustomSecurityHeaderType">
6.        <Credentials xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:UserIdPasswordType"/>
7.      </RequesterCredentials>
8.    </SOAP-ENV:Header>
9.    <SOAP-ENV:Body id="_0">
10.     <Specific-API-Operation-Name>-Response xmlns="urn:ebay:api:PayPalAPI">
11.       <Timestamp xmlns="urn:ebay:api:PayPalAPI">DateTime-In-UTC/GMT-Format</TIMESTAMP>
12.       <Ack xmlns="urn:ebay:apis:eBLBaseComponents">Success</Ack>
13.       <Version xmlns="urn:ebay:apis:eBLBaseComponents">API-Version</Version>
14.       <CorrelationId xmlns="urn:ebay:apis:eBLBaseComponents">Correlation-ID</CorrelationID>
15.       <Build xmlns="urn:ebay:apis:eBLBaseComponents">API-Build-Number</Build>
16.       <Elements-For-Specific-API-Response></Elements-For-Specific-API-Response>
17.     </Specific-API-Operation-Name-Response>
18.   </SOAP-ENV:Body>
19. </SOAP-ENV:Envelope>
Anotação de Resposta SOAP Genérica
Linhas Comente
10 a 17 Os elementos de início e fim. Um exemplo de uma operação da API é . Consulte a referência da API NVP / SOAP para obter uma lista completa.Specific-API-Operation-Name-ResponseSetExpressCheckout
11 Cada resposta da API contém uma Timestampdata e hora no formato UTC / GMT.
12 Ackelemento acknowledgement ( ) contém a string Successindicando que a solicitação correspondente foi processada com sucesso. Quando há um erro, ele Acké definido como um valor diferente de Successe o corpo da resposta contém um Errorselemento com informações para ajudá-lo a solucionar a causa do erro. Veja Respostas de erros para mais informações.
14 CorrelationIDelemento contém informações sobre o aplicativo do PayPal que processou a solicitação. Use o valor desse elemento se você precisar solucionar um problema com uma das suas solicitações.
16 As diferentes APIs do PayPal retornam elementos diferentes, dependendo de suas definições de resposta. Para informações detalhadas, consulte as descrições na referência da API .

Nota: Como um campo é definido na estrutura formal de uma resposta da API, isso não significa que o campo seja necessariamente retornado. Os dados são retornados em uma resposta somente se o PayPal registrou dados que correspondem ao campo.

Respostas de erro

Se o Ackvalor não for Success, o pagamento ou ação desejada pode não passar.

Os valores possíveis do Ackcampo de resposta são os seguintes:

  • Success – O pedido foi bem sucedido.
  • SuccessWithWarning – A solicitação foi bem-sucedida, mas um código de erro de aviso também foi retornado.
  • Failure– A solicitação da API falhou. Veja mensagens de erro para detalhes.
  • FailureWithWarning – A solicitação da API falhou e mensagens de aviso adicionais foram retornadas.

Se uma solicitação estiver mal formada ou contiver algum outro erro, o corpo da resposta SOAP conterá um Errorselemento com outros elementos que podem ajudá-lo a solucionar a causa do erro.

A estrutura das mensagens de erro é a seguinte:

O mais importante desses elementos adicionais é o seguinte:

  • ShortMessage
  • LongMessage
  • ErrorCode

Informações adicionais podem aparecer como parte de ErrorParametersType. Por exemplo, se a resposta retornada dentro do ParamIDelemento for ProcessorResponse, o Valueelemento conterá um erro específico do processador de placa de terceiros, como 0091. Os valores definidos no ErrorParametersTypenão são definidos pelo PayPal; em vez disso, eles são passados ​​da fonte.

Nota: o PayPal apenas transmite os valores selecionados em ErrorParametersType.

O exemplo a seguir mostra a resposta de erro se o nome de usuário e a senha da API não corresponderem a um nome de usuário e senha legítimos da API registrados no PayPal.

Exemplo da resposta de erro SOAP: Nome de usuário ou senha inválidos

<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV: Envelope [DETAILS NOT SHOWN]>
  <SOAP-ENV:Header>[DETAILS NOT SHOWN]</SOAP-ENV:Header>
  <SOAP-ENV:Body id="_0">
    <GetTransactionDetailsResponse xmlns="urn:ebay:api:PayPalAPI">
    <Timestamp xmlns="urn:ebay:apis:eBLBaseComponents">2005-02-09T21:51:26Z</Timestamp>
    <Ack xmlns="urn:ebay:apis:eBLBaseComponents">Failure</Ack>
    <Errors xmlns="urn:ebay:apis:eBLBaseComponents" xsi:type="ebl:ErrorType">
      <ShortMessage xsi:type="xs:string">Authentication/Authorization Failed</ShortMessage>
      <LongMessage xsi:type="xs:string">Username/Password is incorrect</LongMessage>
      <ErrorCode xsi:type="xs:token">10002</ErrorCode>
      <SeverityCode xmlns="urn:ebay:apis:eBLBaseComponents">Error</SeverityCode>
    </Errors>
    <CorrelationID xmlns="urn:ebay:apis:eBLBaseComponents">Debugging-Info</CorrelationID>
    <Version xmlns="urn:ebay:apis:eBLBaseComponents">124.00</Version>
    <Build xmlns="urn:ebay:apis:eBLBaseComponents">1.0006</Build>
    <...other elements="" in="" response...="">
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

CorrelationID para relatar problemas ao PayPal

O valor retornado CorrelationIDé importante para o PayPal determinar a causa precisa de qualquer erro que você possa encontrar. Se você tiver que solucionar um problema com suas solicitações, sugerimos que você capture o valor CorrelationIDpara que você possa denunciá-lo ao PayPal.

Codificação de caracteres UTF-8

A API do PayPal supõe que todos os dados nas solicitações estejam em Unicode, especificamente, o formato de codificação de 8 bits (UTF-8) Unicode (ou UCS) Transformation Format.

Nas respostas, a API sempre retorna dados em UTF-8.

Formatos de data / hora

O esquema da API do PayPal para o SOAP define valores de data / hora como Hora Universal Coordenada (UTC / GMT), usando o formato ISO 8601 e do tipo ns:dateTime.

Um exemplo de data / hora é 2006-08-24T05: 38: 48Z

Tipo de dados do valor da moeda central

O tipo de dados da quantia monetária principal é chamado BasicAmountTypee é derivado de string. Todos os campos de valor monetário têm a seguinte estrutura:

  1. currencyIDatributo é obrigatório.
  2. O valor deve ter duas casas decimais, exceto no caso de moedas que não suportam valores decimais .
  3. O separador decimal deve ser um período (“.”).
  4. Você não deve usar nenhum separador de milhares.
  5. BasicAmountTypetem um tipo de dados ebl:CurrencyCodeType, que define um grande número de diferentes códigos de moeda. No entanto, para que seu processamento seja bem-sucedido, você deve definir currencyCode como um código de moeda válido .

Exemplo

O nome do campo Amount, é um exemplo; os nomes dos campos reais podem variar dependendo da operação específica da API .

<Amount currencyCode="USD">3.00</Amount>


FONTE: https://developer.paypal.com/docs/classic/api/PayPalSOAPAPIArchitecture/

NOVO PROCESSO DE PRODUÇÃO DE ÒXIDO DE GRAFENO À TEMPERATURA AMBIENTE

NOVO PROCESSO DE PRODUÇÃO DE ÒXIDO DE GRAFENO À TEMPERATURA
AMBIENTE
FRANCISLEI SANTA ANNA SANTOS1*
1 Msc. em Engenharia Química, UFBA, Salvador-BA, Fone: (71) 99978- 3702,francisleisantos@yahoo.com.br
Apresentado no
Congresso Técnico Científico da Engenharia e da Agronomia – CONTECC’2016
29 de agosto a 1 de setembro de 2016 – Foz do Iguaçu, Brasil

 

 

RESUMO: As tecnologias convencionais de obtenção do óxido de grafeno (OG) são de baixo rendimento e baixa reprodutibilidade. O baixo rendimento aumenta o preço do produto final. O grama do OG chega a ser vendido por $ 150 no mercado internacional. O alto preço do OG restringe as pesquisas aplicadas com esse material a poucos laboratórios especializados em nanotecnologia. O alto preço do óxido de grafeno e as limitações tecnológicas atuais inibem sua aplicação em larga escala pelas indústrias nacionais e estrangeiras. Objetiva-se por este trabalho, apresentar um novo processo de produção de óxido de grafeno (OG) a temperatura ambiente. O novo processo em patente é caracterizado pela oxirredução de uma substância rica em carbono a temperatura ambiente. A nova rota de processo pode ser usada para obtenção do OG nas escalas de laboratório e industrial. O produto obtido pela nova rota de processo de produção de OG foi caracterizado por Espectroscopia Raman, MEV, DRX e Microscopia Óptica. Os resultados mostram a formação de compostos do tipo grafíticos (característicos de OG) e carbono amorfo (aC).
PALAVRAS–CHAVE: óxido de grafeno, métodos de produção, carbono amorfo.

NEW PROCESS FOR PRODUCTION OF GRAPHENE OXIDE AT ROOM TEMPERATURE
ABSTRACT: Conventional technologies for obtaining graphene oxide (OG) are low-income and low reproducibility. The low yield increases the price of the final product. Gram’s OG comes to be sold for $ 150 on the international market. The high price of OG restricts the applied research with this  material a few specialized laboratories in nanotechnology. The high price of the graphene oxide and the current technology limitations inhibit its large-scale application of national industry and foreign. The objective for this work is to present a new graphene oxide production process (GL) at room temperature. The new process is characterized by the patent redox carbon-rich material at room temperature. The new process route can be used for obtaining GL on laboratory and industrial scale. The product obtained by the new route OG production process was characterized by Raman spectroscopy, SEM, XRD and optical microscopy. Results show the formation of graphitic compounds of the type (characteristic OG) and amorphous carbon (aC). KEYWORDS: graphene oxide, production methods, amorphous carbon.

INTRODUÇÃO
Atualmente, tem-se utilizado o termo grafeno de forma um pouco mais ampla, abrangendo não só o material original (formado por uma única folha com espessura monoatômica), mas também a uma família de materiais formados por duas, três, quatro folhas de grafeno empilhadas de forma organizada cujas propriedades são diferentes entre si, devido às diferentes interações entre as várias folhas em
cada estrutura (Mehl, 2014). O óxido de grafeno reduzido ou simplesmente grafeno, como é mais conhecido atualmente, foi o primeiro cristal bidimensional estável isolado, com seu longo sistema pconjugado, onde os elétrons estão confinados em duas dimensões, o que confere propriedades excepcionais (Zarbine et all., 2013) tais como condutividade elétrica, resistência mecânica, leveza entre outras peculiaridades que diversificam a sua aplicação.
O grafeno é o alótropo mais novo da família do carbono ao lado do diamante e do carbono amorfo. O grafeno foi isolado e caracterizado pela primeira vez em 2004, através de sucessivas etapas de PEELING de um pedaço de grafite, com o auxílio de uma fita adesiva. O trabalho rendeu o prêmio Nobel de física de 2010 a seus autores, A. Geim e K. Novoselov, da Universidade de Manchester.
(Zarbine et all, 2013).Outro método muito difundido de obtenção do grafeno a partir do grafite se chama ESFOLIAÇÂO QUÌMICA, onde procura enfraquecer as ligações que unem as folhas de grafeno.Existem mais de uma rota de processo estudada por vários pesquisadores, porém a mais conhecida usa o grafite natural como substância rica em carbono. Esse grafite é aquecido em solução ácida, (H2SO4, HCl entre outros) e ainda utilizando-se do recurso de micro-ondas para produzir o óxido de grafite. Este óxido, já com as folhas de grafeno distanciadas umas das outras, é lavado com água deionizada e submetido a um processo de esfoliação (separação das folhas) utilizando-se
ultrassom ou a expansão térmica. Formando assim, o óxido de grafeno que pode ser reduzido com hidrazina para obtenção do grafeno ou óxido de grafeno reduzido. Neste método, o grafeno é submetido a um processo agressivo que acaba provocando vários defeitos na estrutura molecular. Os defeitos inviabilizam a produção do grafeno em larga escala além de diminuir a qualidade desejada
através da ESFOLIAÇÂO QUÌMICA.

As rotas apresentadas acima são de baixo rendimento e alto impacto ambiental pela extração do grafite natural obtido pelo processo de extração mineral. Outra forma de obter o grafite que é através do processo CVD (Carbon Vapour Deposition). O CVD é um método que sintetiza o grafite a partir de gases ricos em carbono, em especial o etileno que é aquecido a 1400 oC em um forno especial. Nesta etapa, o grafeno se forma em filme único sobre um substrato metálico (cobre), porém ainda não se conseguiu produzir grafeno em larga escala com áreas maiores através do método CVD. Fato este que limita a reprodutibilidade do método em questão. Poucos países, por exemplo: EUA, China e Cingapura, produzem o óxido de grafeno em larga escala e comercializam a altos preços que variam de $50 a $250/ grama a depender da pureza. Esta realidade restringe as pesquisas aplicadas com esse material a poucos laboratórios no mundo e inibem os investimentos em inovação; apesar do comprovado potencial de impacto nos setores de energia, biomedicina, agricultura, industrial,
eletrônicos, energias renováveis, ambiental, aeronáutico, aplicações médicas, têxteis. A importância desse material é proporcional ao alto número de patentes publicadas nos últimos anos. Zarbin et all.(2013) afirma que o principal desafio ainda está no desenvolvimento de métodos massivos de produção de amostras de óxido de grafeno reduzido com qualidade estrutural, e com controle do número de camadas. Afirma Mehl (2014) que há um grande interesse no desenvolvimento de rotas de preparação do grafeno, que sejam viáveis do ponto de vista prático (com alto rendimento e pureza, com e boa qualidade estrutural) e economicamente viável.
Esse trabalho foi resultado do estudo individual sobre eletrólise, nanotecnologia e interação molecular que deram as bases teóricas para a construção do protótipo em funcionamento. O novo método brasileiro, cujo título da patente é “PRODUção de nanopartículas de carbono a temperatura ambiente” (BR 10 2016012475 1) foi denominado de “ROTA NHK” que neste trabalho foi usado para
obtenção de OG. O destaque do novo método está na reprodutibilidade, na baixa emissão de poluentes e controle das etapas de produção. O objetivo desse trabalho é apresentar um novo processo de produção do óxido de grafeno a temperatura ambiente.
MATERIAL E MÉTODOS
A substância rica em carbono usada neste novo processo de produção de óxido de grafeno foi o carbono natural; e constitui o eletrólito de uma célula eletrolítica onde será submetido aos processos de oxidação e redução.Os testes experimentais foram realizados em instalação adaptada a um laboratório que está, atualmente, localizado na cidade de Alagoinhas-BA. As pesquisas foram financiadas com recursos próprios.
O produto obtido pela “ROTA NHK”, foi analisado por espectroscopia Raman empregando-se um espectrômetro Raman Witec (Alpha 500), acoplado a um detector CCD Witec (modelo DV401ABV-352) do Laboratório de Corrosão e Proteção do IPT. A focalização do laser na amostra e a coleta da radiação espalhada foram feitas através de um microscópio óptico Witec (Carl Zeiss, Serien-Nr
334000409). Foi utilizada linha de excitação na região do infravermelho próximo em 785,0 nm de um laser de diodo (XTRA 00222, Toptica) e na região do visível em 532,0 nm de um laser de argônio (WiTec) e em 633,0 nm de um laser de hélio-neônio (Modelo 30584, Optics Inc.). Os espectros são resultado da média de dez espectros obtidos com tempo de integração de 1 s, utilizando-se rede de
difração de 600 linhas/mm; lente de aumento de 100x (número de abertura 0,55, CF Plan). A Figura 1 a seguir representa o novo método de obtenção de óxido de grafeno a temperatura ambiente. Onde mostra uma fonte rica em carbono natural (1), na concentração de 0,576g/ml que constitui o meio reacional. A carga positiva constitui o anodo (3) de prata onde ocorrerá a etapa de
oxidação das partículas de carbono para obtenção do grafito oxidado em suspensão. Em paralelo, o outro eletrodo inerte (ex: Ag, Au) é alimentado com carga negativa e constitui o catodo (3) onde ocorrerá a reação de redução do grafito oxidado a óxido de grafeno reduzido em suspensão. Cada eletrodo é conectado por fios condutores de eletricidade (5) e são imersos no reator (2) de 30ml de capacidade com massa total de 15g aproximadamente. Uma fonte de energia elétrica (4) gera a diferença de potencial (ddp) necessário para o processo de oxirredução. O tempo de reação estimado para esse processo é de 9,0 min/ml de suspensão na CNTP em recipiente fechado, podendo variar em função da concentração. O óxido de grafeno quando exposto à luz excessiva sofre degradação. A Figura 1 representa o sistema da nova rota do processo em narrativa.

Figura 1 – ROTA NHK de produção de óxido de grafeno a temperatura ambiente.

RESULTADOS E DISCUSSÃO
O novo processo de produção de óxido de grafeno é caracterizado pela reação redox na mistura reacional que origina a formação de nano partículas de óxido de grafeno em suspensão no reator que opera a temperatura ambiente. Toda a carga de carbono é convertida em alótropos. As vantagens são a redução do custo energético, redução na geração de resíduos, controle das etapas de produção e reprodutibilidade do processo. A Figura 2 mostra o produto final em suspensão aquosa (A) cuja concentração mássica do produto obtido foi de aproximadamente de 0,600 g/ml em suspensão, as imagens (B) e (C) são o MEV e o DRX do produto obtido pelo novo método.
Figura 2 – (A) Nanopartículas de OG em suspensão aquosa, (B) MEV e (C) DRX da amostra.

A respeito dos testes para caracterização por espectroscopia Raman da amostra de carbono verificou que amostra apresenta elevada sensibilidade às radiações empregadas, o que resulta em sua degradação durante a irradiação com laser, mesmo em potência mínima (Figura 3) indicando que a amostra é fotossensível e pode formar outros alótropos do carbono a exemplo do carbono amorfo. Figura 3 – Imagens de microscopia óptica em aumento de 100x da Amostra de OG antes e após irradiação por laser para obtenção do espectro Raman nos comprimentos de onda (A) 532,0 nm, (B) 633,0 nm e (C) 785,0 nm.

Devido à sensibilidade da amostra, espectros Raman foram adquiridos com tempo curto de aquisição (50 ms) e 10 acumulações de maneira a diminuir o tempo de exposição à radiação do laser. Desta maneira, a qualidade dos espectros, razão sinal ruído, é baixa (Figura 4). O padrão espectral na página seguinte, para uma mesma radiação excitante, varia de acordo com o ponto de análise, indicando que a amostra não é homogênea (Figuras 4B e 4C) podendo conter óxido de grafeno e outros alótropos do carbono. Os espectros apresentados nas Figuras 4A e 4B apresentam duas bandas largas em aproximadamente 1350 cm-1 e 1580 cm-1 . Estas bandas podem ser atribuídas às bandas G e D de compostos sp2 de carbono como o óxido de grafeno, respectivamente (Dresselhaus et all. , 2010). Estas bandas também são observadas nos espectros de carbono amorfo (Marton et all., 2013). Para os espectros nas radiações 532,0 nm e 633,0 nm (Figura 4A e 4B) a banda D (~1380 cm-1 ) é mais intensa que a banda G (~1350 cm-1 ). Esta razão de intensidade está de acordo com aquela observada para compostos grafíticos, tais como óxidos de grafeno (Stankovich et all., 2007). A elevada largura das bandas G e D indica a presença de carbono amorfo. Os compostos sp2 de carbono (grafite, OG, grafeno, nanotubos de carbono, fulerenos) apresentam efeito Raman ressonante. No efeito Raman ressonante, a energia do fóton da radiação excitante é comparável ou mesmo coincidente com a energia de transição eletrônica da molécula em estudo (cromóforo). Neste caso, ocorre uma intensificação na ordem de 105 vezes das bandas associadas aos modos vibracionais do cromóforo. Por conta disso, não é possível afirmar, a partir dos espectros Raman, qual a proporção entre o óxido de grafeno e o carbono amorfo presentes na amostra analisada.

 

A amostra apresenta elevada sensibilidade ao laser empregado para caracterização por espectroscopia Raman. Os espectros Raman nas radiações excitante 532,0 nm e 633,0 nm apresentam bandas largas em aproximadamente 350 cm-1 e 1580 cm-1 , sendo a segunda mais intensa que a primeira. Tais resultados indicam que a amostra contem compostos do tipo grafítico (característico do óxido de grafeno) e carbono amorfo, porém não permite determinar se as estruturas grafíticas de óxido de grafeno estão presentes em elevada concentração na amostra devido ao efeito Raman ressonante. Este fato mostra a oportunidade de melhoria nas próximas etapas do nosso trabalho.

CONCLUSÕES
O novo método produz óxido de grafeno à temperatura ambiente.
AGRADECIMENTOS
-Deus pelos desafios que a vida impôs.
-Minha Família pelo apoio e confiança depositados neste trabalho.
-IF/UFBA e ao DEQ/UFCG pelas caracterizações do MEV e DRX respectivamente.

REFERÊNCIAS
Dresselhaus, M.S.; Jorio, A.; Hofmann, M.; Dresselhaus, G.; Saito, R. Perspectives on carbono
nanotubes and graphene Raman Spectroscopy. Nano letters, v. 10, p. 751-758, 2010.
Li, X.; Cai, W.; An, J.; Kim, S.; Nah, J.; Yong, D.; Piner, R.; Veldmakanni, A.; Juerg, I.; Tutuk, E.;
Banerjee, S. K.; Colombo, L.; Ruoff, R. S.; Science, p.324 e p.1312, 2009.
Marton, M.; Vojs, M.; Zdravecká, E.; Himmerlich, M.; Haensel, T.; Krishock, S.; Michiniak, P.;
Vesely, M.; Redhammer, R. Raman spectroscopy of amorphous carbono prepared by pulsed arc
discharge in various gas mixture. Journal of Spectroscopy, v. 2013, 6p. 2013.
Mehl, Hiany. The effect of variation of reactional parameters in the preparation of graphene by
oxidation and reduction of graphite. Quím. Nova, vol.37, n.10, pp.1639-1645. 2014.
Stankovich, S.; Dikin, D.A.; Piner, R.D; Kohlhaas, K.A.; Kleinhammes, A.; Jia, Y.; Wu, Y.; Nguyen,
S.T.; Rouff, R.S. Synthesis of graphene-based nanosheets via chemical reduction of exfoliated
grafite oxide. Carbon, v. 45, p. 1558-1565, 2007.
Zarbin, Aldo J. G. e Oliveira, Marcela M.. Carbon nanostructures (nanotubes and graphene): Quo
Vadis?. Quím. Nova, vol.36, n.10, pp.1533-1539. 2013.

 

Fonte: www.confea.org.br/media/contecc2016/quimica/novo%20processo%20de%20produção%20de%20òxido%20de%20grafeno%20à%20temperatura%20ambiente.pdf

Fonte: https://www.youtube.com/watch?v=h5aeVZzsvKY

Betelgeuse

Alpha Orionis (α Orionis) conhecida como Betelgeuse é uma estrela de brilho variável sendo a 10ª ou 12ª estrela mais brilhante das que podem ser vistas da Terra. É também a segunda estrela mais brilhante na constelação de Orion. Apesar de ter a designação α (“alpha”) na Classificação de Bayer, ela não é mais brilhante que Rigel (β Orionis).

Betelgeuse é na verdade mais brilhante do que Rigel no comprimento de onda infravermelho, mas não nos comprimentos de onda visíveis.

Características

Betelgeuse é uma estrela supergigante vermelha, e uma das maiores estrelas conhecidas, sendo de grande interesse para a astronomia. O diâmetro angular de Betelgeuse foi medido pela primeira vez em 19201921 por Michelson e Pease, sendo uma das cinco primeiras a serem medidas usando um interferómetro no telescópio de 100 polegadas do Monte Wilson. O seu diâmetro varia entre 887 ± 203[1] e 1180 vezes o do Sol.[2] No diâmetro máximo, a estrela seria maior que a órbita de Saturno se colocada no lugar do Sol. Apesar de ser apenas 14 vezes mais massiva que o Sol, é cerca de algumas centenas de milhões de vezes maior em volume, como uma bola de futebol comparada a um grande estádio de futebol. A sua proximidade à Terra e o seu enorme tamanho fazem dela a estrela com o terceiro maior diâmetro angular vista da Terra [1], menor apenas que o Sol e R Doradus. É uma das 12 estrelas em que os telescópios atuais podem visualizar o seu disco real. Betelgeuse possui uma temperatura à superfície de cerca de 3.500 K.[3]

Supernova

Os astrónomos prevêem que Betelgeuse pode passar por uma supernova tipo II. No entanto, as opiniões estão divididas quanto ao momento em que isto deve ocorrer. Alguns sugerem que a variabilidade actual como um sinal de que já está na fase de queima de carbono do seu ciclo de vida, e deve sofrer uma explosão supernova aproximadamente nos próximos mil anos. Céticos discordam com esse ponto de vista e afirmam que a estrela deve sobreviver muito mais tempo.

Há consenso de que tal supernova seria um evento astronómico espectacular, mas não seria uma ameaça para a vida na Terra, dada a enorme distância a que se encontra. Mas a estrela vai tornar-se pelo menos 10000 vezes mais brilhante, o que significa um brilho equivalente ao de uma Lua crescente. Entretanto alguns crêem que ela pode chegar ao brilho de uma Lua cheia (mv = -12.5). Esse fenómeno deve durar por alguns meses, parecendo uma pequena Lua cheia com a cor de uma lâmpada incandescente à noite e facilmente visível durante o dia. Após esse período a estrela vai apagar-se gradualmente até que após alguns meses ou anos desapareça completamente e Orion perca o ombro direito.

 

https://pt.wikipedia.org/wiki/Betelgeuse

CALCULADORA DE CONSUMO DE GÁS

E aí pessoal como vão as coisas? Recentemente tive a necessidade de fazer alguns cálculos de custo de produção para um colega, e entramos na parte de consumo de gás. Este item é geralmente ignorado quando se fala em produção artesanal de alimentos, mas pode ser um fator decisivo para determinar a sua margem de lucro com maior precisão.

Fiz várias pesquisas e conversei com um colega que trabalha com gás, e depois da leitura de algumas dezenas de manuais, tabelas e estudos cheguei a esta planilha, onde você poderá calcular de maneira rápida o seu custo com consumo de gás.

A Fórmula utilizada é simples:

 

Gasto em R$ = (((T/60)*Kg/h)/B)*PB
Onde:
T = Tempo de uso em minutos dividido por 60;
Kg/h = Consumo por queimador, em Kg/h (ver o manual do fabricante do fogão)
B = Capacidade do botijão (13 ou 45 Kg);
PB = Preço do Botijão.


Mas note que este cálculo é uma estimativa e pode sofrer pequenas variações. Ele serve apenas para gás GLP vendido em botijões P13 – aquele comum residencial ou P45, que é aquele maior, cilíndrico. Se você utiliza “gás encanado”/GN, este cálculo não se aplica.

Pelos estudos que fiz, a média de kg/h de uma boca grande de um fogão/cooktop doméstico em “fogo médio” é de 0,225 Kg/h por queimador. A média de gasto do forno do fogão costuma ser de 0,180 Kg/h. Já de fogões industriais varia bastante, já que existem diversos modelos (alta pressão, baixa pressão, queimadores simples ou duplos, etc.). A média de consumo para um queimador simples de fogão industrial de baixa pressão costuma ser 0,300 Kg/h. Altere este valor se tiver esta informação no manual do seu fogão. Se estiver usando um fogão tipo industrial, veja no manual de instruções do fogão qual o consumo em Kg/h.

É isso aí pessoal, até a próxima.

 

CLIQUE AQUI PARA BAIXAR A PLANILHA

 

 

Fonte: https://cristianoash.wordpress.com/2017/06/04/calculadora-de-consumo-de-gas/

FrameTrail – Crie, Anote e Remix Vídeos interativos

FrameTrail é um software de código aberto que permite que você experimente, gerencie e edite vídeos interativos diretamente no seu navegador.
Permite-lhe hiperligar conteúdos fílmicos, incluir documentos multimédia adicionais (por exemplo, sobreposições de texto, imagens ou mapas interactivos) e adicionar materiais suplementares (anotações) em pontos específicos
Nos últimos 6 meses, o FrameTrail recebeu financiamento público pelo Ministério Federal da Educação e Pesquisa (BMBF), através do Prototype Fund, para desenvolver novas tecnologias e interfaces de anotação de vídeos . 
Desde então, muitas coisas mudaram, incluindo o formato de dados e até mesmo alguns dos conceitos fundamentais. A documentação e a página de demonstração ainda não foram atualizadas, então espere mais algumas semanas até começar a trabalhar com a nova versão (bis dahin wird endlich auch die Website auf Deutsch übersetzt sein). 
Se você quiser experimentar o FrameTrail imediatamente, baixe a versão DEVELOPMENT do GitHub.
Uma coisa não mudou: extraia o arquivo zip, faça o upload para o servidor e está pronto para ir.





Características

Documentos baseados no tempo

Use qualquer arquivo de vídeo ou mesmo um vídeo vazio com um comprimento definido como base para a sincronização.

Fragmentos de vídeo vinculados

Crie redes não-lineares de fragmentos de vídeo (Hypervideos) que possam ser navegadas livremente pelo usuário.

Superposições interativas

Coloque documentos no topo do vídeo (por exemplo, texto, imagens, páginas da web ou mapas interativos) e decida como e quando eles devem ser exibidos.

Anotações multimídia

Adicione materiais suplementares em certos pontos do tempo e compare aqueles com as linhas de tempo de anotação de outros usuários.





Videos interativos não são novidades : https://en.wikipedia.org/wiki/Interactive_movie (na verdade antes dos laser discs já se tinham iniciativas)
Projeto interessante:
https://github.com/OpenHypervideo/FrameTrail

Uma proposta de padronização:
https://github.com/memex/trails-proposal

Mas acredito que o 1º passo a ser dado com o frametrail é ter um player como o soundcloud dos videos.
 O objetivo é ter um player como esse:

 

L.IVE: Um ambiente de aprendizagem interativo baseado em vídeo integrado

Existem inúmeras iniciativas e estudos sobre interfaces (e interatividade nos atuais “live”), segue um exemplo:

 

Apresentamos o L.IVE: um ambiente de aprendizagem em linha interativo baseado em vídeo com um design e arquitetura alternativos que integrais três principais componentes de interface: vídeo, tópicos de comentários e avaliações. Isso contrasta com a abordagem das interfaces existentes que separam visualmente esses componentes. Nosso estudo, que compara L.IVE com ambientes de aprendizagem populares em vídeo baseados em vídeo, sugere vantagens nesta abordagem integrada, em comparação com a abordagem separada na aprendizagem.

 

FONTE:

http://sisdipe.com.br/i-educar/interno/player.php

https://frametrail.org/

Nosso Futuro da Memória Cultural Ameaçada

A indústria de manipulação de vídeo é uma bomba de tempo

Apornografia trocada, como muitos desenvolvimentos tecnológicos e sociais de nossa época, parece uma coisa ruim, mas é, de fato, muito, muito pior. Não é difícil concluir que os hobbyists de pornografia sintética, ajudando-se mutuamente ensinar-se a ensinar os computadores a colar as semelhanças de novas pessoas com o video pornográfico existente, estão fazendo algo violador; PornHub declarou que o produto resultante não é consensual e viola seus termos de serviço.

Mesmo que a perspectiva de aparecer involuntariamente em um vídeo de sexo incondicional é perturbadora em seus próprios termos, porém, é muito mais perturbador como um caso de teste, uma versão caseira barata do projeto maior e bem financiado de fazer um video plausível de coisas que nunca aconteceu – o que o Charlie Warzel, da BuzzFeed, descreveu este mês como “um potencial projeto de Manhattan de novidades falsas”.

A diferença entre a manipulação de vídeo e o projeto real de Manhattan é que os cientistas no Projeto Manhattan sabiam que eram membros do esforço de guerra e que seu objetivo era construir o dispositivo de morte mais poderoso do mundo. Uma vez que o construíram, os cientistas entenderam que eles mudaram o mundo de uma forma grave e terrível.

A indústria de manipulação de vídeos parece não ter consciência de tudo o que torna possível. Em uma apresentação do produto Adobe Photoshop a partir do final do ano passado, uma multidão aplaude enquanto os representantes da empresa demonstram como a tecnologia Adobe Cloak do projeto pode remover uma lamparina desagradável de um vídeo de uma catedral russa. Mas espere! Tem mais!

Para novos aplausos, os representantes continuam a exibir imagens de dois caminhantes passando por uma garganta , e o software remove uma correia de uma das suas mochilas. Isso pode remover as pessoas? “Sim, podemos – podemos remover as pessoas”, diz o apresentador. “Sim”. E as pessoas estão envolvidas em um contorno roxo, como um elemento visual indesejável, isolado e removido.

“Tudo o que sabemos sobre a nossa sociedade, ou mesmo sobre o mundo em que vivemos, sabemos através dos meios de comunicação”, escreveu Niklas Luhmann em seu livro The Reality of the Mass Media: Memória cultural no presente (1996). “Isto é verdade não só do nosso conhecimento da ciência e da história, mas também do nosso conhecimento da natureza. O que sabemos sobre a estratosfera é o mesmo que Platão sabe sobre a Atlântida: ouvimos dizer isso. “

Para viver assim, dependemos de palavras, sons e, especialmente, de imagens, em massa distribuídas mecanicamente. As coisas que aparecem no vídeo são mais reais do que as coisas sobre as quais simplesmente somos informados. Havia muitas boas razões para que o executivo de fast food, Andrew Puzder, não se tornasse secretário de trabalho, mas aquele que garantiu a derrota de sua indicação era a aparência de sua ex-esposa, disfarçada de uma peruca e grandes óculos tingidos, em uma fita de vídeo de um antigo episódio de Oprah sobre o abuso do casal.

As alegações de abuso haviam sido relatadas há muito tempo, juntamente com o fato de que ela as recuou no decurso de um acordo de custódia. Mas os visuais fizeram a diferença. Uma estranheza no escândalo, testemunhando o poder sobrenatural do formato, foi que a empresa que originalmente exibira o vídeo se recusou a cooperar com o esforço para encontrá-lo e torná-lo público. Oprah apresentou a imagem da mulher sob um pseudônimo, como representante do problema genérico ou escândalo de “mulheres maltratadas de classe alta”. Agora, porém, era evidência sobre uma pessoa específica e poderosa, uma coisa mais potente do que os produtores já quis criar.

Ele saiu de qualquer jeito, assim como a fita do Access Hollywood de Donald Trump pegou, apesar do desejo da NBC de caminhar lentamente pelas notícias. Nos 22 anos desde que Luhmann descreveu a inescapabilidade dos meios de comunicação de massa, os meios de comunicação de massa perderam um grande controle que eles gozavam como instituições. A produção e a disseminação foram fraturadas e tornaram-se participativas ou criaram novas simulações de alta velocidade de participação.

No entanto, o espaço em que os meios de comunicação funcionam continua sendo o único espaço que existe. Ainda não há outra maneira de saber nada sobre as escalas nas quais as coisas exigem ser conhecidas: a nação, o governo, a economia, o mundo, a cultura. Mas o conhecimento agora está quebrado e desestabilizado. Imagens e histórias podem ser distribuídas para grandes extensões do planeta por qualquer pessoa, ou podem ser distribuídas para um conjunto pequeno e restrito de pessoas. Na parte receptora, eles são vivenciados exatamente da mesma maneira.

Os colegas de rosto entendem isso como uma verdade, seja ou não ao nível de percepção. Para fins de produção de pornografia sintética, um ator de cinema principal e uma pessoa em um clipe de pornografia existem em um único plano de realidade ou irrealidade. Ambos são imagens em movimento, nada mais, para serem recebidos e consumidos. É a lógica amoral das próprias máquinas de aprendizagem: Aqui estão duas versões do mesmo tipo de entrada a serem retrabalhadas para uma nova saída desse mesmo tipo. Qualquer distinção de significado e valor – da realidade subjacente, como as pessoas podem querer entender – equivale a substituir facilmente metadados.

É fácil e sombrio pensar as possibilidades: observações escandalosas que um candidato político nunca pronunciou, confissões falsas, actos falsificados de violência. Tropas em diferentes uniformes, sob várias bandeiras, fazendo as mesmas coisas. As multidões inaugurais transbordam o Mall e empacotaram as várzeas da rota do desfile.

Ninguém realmente se propôs a demolir a realidade. Ninguém estabeleceu para inscrever a população mundial em um sistema de vigilância em tempo integral, também. Eles apenas criaram smartphones, e esses telefones precisavam manter contato com as redes de comunicação em torno deles. E cada vez mais serviços trocaram informações sobre movimento e uso e comportamento e atenção, e os telefones se tornaram plataformas de publicidade, e os anunciantes queriam saber o quanto pudessem sobre potenciais clientes – o que acabou por ser aproximadamente tudo.

E, da mesma forma, mesmo que algumas pessoas estejam construindo ferramentas para fazer vídeos de eventos que nunca aconteceram, outras pessoas estão construindo ferramentas para distribuir esse material através de canais separados, opacos e inexplicáveis. O Facebook funciona como um serviço de microtargeting sob a aparência de um vasto fórum público, para que ninguém possa dizer o que o Facebook de qualquer outra pessoa pode ter. Demorou meses de crise, uma eleição presidencial e as investigações federais antes que a empresa decidiu que começaria a trabalhar em formas de tornar as campanhas publicitárias visíveis e responsáveis . O Twitter oferece anúncios ligados a contas inexistentes do Twitter , por isso é impossível saber de onde elas vieram ou quem mais as viu. O contexto é tão inviável quanto o conteúdo.

Até agora, o susto de notícias falsas concentrou-se principalmente nos remetentes – agentes estrangeiros, russos, um inimigo escondido, mas que pode ser retratado. Mas o remetente está quase ao lado do ponto. O horror está em ser os destinatários, cada um de nós em uma realidade hermética, incapaz de confiar no que vemos ou de saber quais outras realidades podem estar ao nosso lado.

 

Fontehttps://medium.com/s/story/our-future-of-warped-cultural-memory-4598ab103b05

FERRAMENTA PENTEST – T50

T50 é uma ferramenta para DoS desenvolvida pelo brasileiro Nelson Brito, sendo de fácil uso.
O código fonte do T50 encontra-se no link abaixo:
Deve ser compilado (como root) em um terminal linux (pode ser qualquer um, eu uso o Debian como Distro) com make.
Para realizar uma simulação de DoS contra um determinado IP e uma determinada porta, digite no terminal:
./t50 –flood –turbo –S –p 80 192.168.1.1 –flood –turbo –S
A sintaxe para se usar o ataque de DoS “-p” indica que a porta 80 será atacada e 192.168.1.1 indica o IP da vítima – No exemplo o roteador.

 

https://sourceforge.net/projects/t50/files/latest/download

Roubo de endereço IP (Mystification/Spoofing)

Como acontece a usurpação de endereço IP

usurpação de endereço IP (spoofing IP) é uma técnica que consiste em substituir o endereço IP do remetente de um pacote IP pelo endereço IP de outra máquina. Esta técnica permite que o hacker envie pacotes anonimamente. Não se trata de mudar o endereço IP, mas de um disfarce do endereço IP ao enviar os pacotes.

Algumas pessoas tendem a assimilar o uso de um proxy (que permite, de certa forma, mascarar o endereço IP) com o spoofing IP. No entanto, os proxys só enviam os pacotes. Assim, ainda que o endereço esteja aparentemente mascarado, você pode encontrar facilmente um hacker graças ao arquivo de registos do proxy.

Ataque por usurpação

A técnica da usurpação de endereço IP pode permitir que um hacker envie pacotes a uma rede sem que estes sejam interceptados pelo sistema de filtragem de pacotes (firewalls).
Na verdade, os sistemas de firewall se baseiam em regras de filtragem que indicam os endereços IP autorizados a se comunicarem com a rede das máquinas internas:

Using spoofing to break through a firewall
Assim, um pacote usurpado com o endereço IP de uma máquina interna parecerá provir da rede interna e será retransmitido à máquina alvo, enquanto um pacote que contém um endereço IP externo será automaticamente rejeitado pelo firewall.

Contudo, o protocolo TCP (protocolo que basicamente garante o transporte fiável de dados pela Internet) se baseia em relações de autenticação e de confiança entre a rede das máquinas. Isto significa que para aceitar o pacote, o receptor deve acusar recepção do emissor, e este, deve acusar recepção da confirmação.

Como modificar o cabeçalho TCP

Na Internet, as informações circulam graças ao protocolo IP, que garante o encapsulamento de dados em estruturas chamadas pacotes (ou, mais exatamente, datagramas IP). Veja a estrutura de um datagrama:

Versão Longitude do cabeçalho Tipo de serviço Longitude total
Identificação Indicador Compensação de fragmento
Tempo de vida Protocolo Soma de verificação do cabeçalho
Endereço IP de origem
Endereço IP de destino
Dados

Usurpar um endereço IP consiste em alterar o campo fonte a fim de simular um datagrama que provém de outro endereço IP. Contudo, na Internet, os pacotes são geralmente transportados pelo protocolo TCP, que garante uma transmissão confiável.

Antes de aceitar um pacote, uma máquina deve acusar recepção deste junto à máquina emissora, e esperar que ela confirme a boa recepção da acusação.

Os links de aprovação

O protocolo TCP é um dos principais protocolos da camada transporte do modelo TCP/IP. Ele permite, a nível das aplicativos, gerenciar os dados oriundos (ou com destino) da camada inferior do modelo (ou seja, o protocolo IP).

O protocolo TCP assegura a transferência dos dados de modo fiável, embora utilize o protocolo IP (que não integra nenhum controle de entrega de datagrama) graças a um sistema de avisos de recepção (ACK) que permitem ao cliente e ao servidor verificarem a boa recepção dos dados.

As unidades datagramas IP introduzem pacotes TCP (chamados segmentos), cuja estrutura é:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Porta Fonte Porta destino
Número de ordem
Número de aviso de recepção
Desfasamento de dados
dados
reservado URG ACK PSH RST SYN FIN Janela
Soma de controle Ponteiro de emergência
Opções
Dados

Na emissão de um segmento, um número de ordem (também chamado de número de sequência) é associado, e uma troca de segmentos com campos específicos (chamados bandeiras – flags) permite sincronizar o cliente e o servidor. Este diálogo (chamado aperto de mãos em três tempos) permite iniciar a comunicação, ele se apresenta em três tempos, como o seu nome indica:

Inicialmente, a máquina emissora (o cliente) transmite um segmento cuja bandeira SYN é de 1 (para assinalar que se trata de um segmento de sincronização), com um número de ordem N, que chamamos de número de ordem inicial do cliente;

Em segundo lugar, a máquina receptora (o servidor) recebe o segmento inicial que provém do cliente, em seguida ele envia um alerta de recepção, ou seja, um segmento cuja bandeira ACK é ‘não nula’ (aviso de recepção) e a bandeira SYN é de 1 (porque ainda se trata de uma sincronização). Este segmento contém um número de sequência igual ao número de ordem inicial do cliente. O campo mais importante deste segmento é o aviso de recepção (ACK), que contém o número de ordem inicial do cliente, incrementado de 1.

Por último, o cliente transmite ao servidor uma acusação de recepção, isto é, um segmento onde a bandeira ACK não seja nula e, cuja bandeira SYN está em zero (não se trata mais de um segmento de sincronização). Seu número de ordem é incrementado e o número de aviso de recepção representa o número de sequência inicial do servidor incrementado de 1.

A máquina usurpada vai responder com um pacote TCP cuja bandeira RST (reset) é não nula, o que cortará a conexão.

Distruir a máquina usurpada

No contexto de um ataque por usurpação de endereço IP, o atacante não tem nenhuma informação de retorno porque as respostas da máquina alvo vão para outra máquina da rede (blind attack – ataque às cegas):

The spoofed machine responds to the ACK with an RST
Além disso, a máquina usurpada priva o hacker de qualquer tentativa de conexão, porque envia sistematicamente uma bandeira RST à máquina alvo. O trabalho do hacker consiste em invalidar a máquina falsificada tornando-a inacessível durante o ataque.

Como prever os números de sequência

Quando a máquina falsificada for invalidada, a máquina alvo espera um pacote que contenha o aviso de recepção e o número de sequência correto. O trabalho do hacker consistirá, então, em adivinhar o número de sequência a enviar ao servidor para que a relação de confiança seja estabelecida.

Para isso, os hackers utilizam a fonte routing, ou seja, eles utilizam o campo Opção do cabeçalho IP para indicar um caminho de retorno específico para o pacote. Assim, graças ao sniffing, o hacker poderá ler o conteúdo das tramas de retorno:

Search for sequence numbersAssim sendo, conhecendo o último número de sequência emitido, o hacker estabelece estatísticas relativas ao seu incremento e envia avisos de recepção até obter o número de sequência correto.

 

Fonte: http://br.ccm.net/contents/40-roubo-de-endereco-ip-mystification-spoofing

CENTRAL TELEFÔNICA CONECTA+

Os softwares programador e bilhetador são compatíveis com as versões de Windows 7, 8 e 10. Para a utilização desses softwares nas
centrais Conecta Mais e Modulare Mais é necessário que a versão de firmware da central seja igual ou superior a versão 2.0.0. Você pode
consultar a versão do firmware digitando o comando *1000 em qualquer ramal da central, de preferência com identificador de
chamadas. Para maiores informações consulte a seção 7.1 do manual do usuário disponível no site. Se a versão do sistema operacional e firmware da sua central atendem estes requisitos, realize o download do software programador e bilhetador clicando no link abaixo:

 

http://www.intelbras.com.br/sites/default/files/downloads/comunicado_programador_conecta_mais_e_modulare_mais.pdf

 

 

 

http://www.intelbras.com.br/empresarial/telefonia/pabx/analogica/conecta-mais

 

CONSTELAÇÃO FAMILIAR

A Consteladora Familiar Valéria Maria Skrebsky participara da Meditação Mundial ao vivo ESPECIAL DE UM ANO! Falará sobre as leis da ajuda, ordens do amor e as novas constelações de Bert Hellinger. Responderá suas perguntas no chat. Falaremos das as curiosidades desta técnica fantástica que está apenas no começo da grande revolução que irá proporcionar no mundo. Conto com tua presença! CONTATO VALÉRIA: Espaço Mohana Nalini – Whatsapp: (55) 98111-9894 Facebook: https://www.facebook.com/EspacoMohana… ✔ Inscreva-se no Canal! ✔ Twitter: @CanaldoPAVA ✔ INSTAGRAM: (@canaldopava)

Instalando o e-cidade a partir dos fontes no Linux CentOS 7

O e-cidade destina-se a informatizar a gestão dos Municípios Brasileiros de forma integrada. Esta informatização contempla a integração entre os entes municipais: Prefeitura Municipal, Câmara Municipal, Autarquias, Fundações e outros.
A economia de recursos é somente uma das vantagens na adoção do e-cidade, além da liberdade de escolha dos fornecedores e garantia de continuidade do sistema, uma vez apoiado pelo Ministério do Planejamento.

1. Instalação do CentOS 7.x

O CentOS, abreviação de Community ENTerprise Operating System, é uma distribuição Linux de classe Enterprise derivada de códigos fonte gratuitamente distribuídos pela Red Hat Enterprise Linux e mantida pelo CentOS Project. Como o uso em servidores pode exigir uma maior compatibilidade com o hardware, a versão indicada para o uso com esta documentação é a CentOS 7.x.

1.1 Obtendo a mídia de instalação

A mídia de instalação pode ser obtida diretamente do site do projeto e gravada em CD, DVD ou pendrive. No site http://www.centos.org/download/ esta disponível a versão mais recente, mas utilizaremos a versão 7 x86_64 disponível em http://mirror.globo.com/centos/7/isos/x86_64/ (CentOS-7-x86_64-Minimal-1611.iso) por questões de compatibilidade com o produto.

1.2 Instalando o CentOS 7.x

O processo de instalação do sistema operacional não é coberto por esta documentação, mas recomendamos a utilização da imagem mínima, em “pt_BR” Português do Brasil.

Dica: Maiores informações sobre a instalação e personalização do sistema operacional podem ser obtidas em:
http://wiki.centos.org/Documentation

1.3 Editando os arquivos de configuração

Durante o processo de configuração descrito nesta documentação, é necessário editar e modificar diversos arquivos de texto. Para realizar estas modificações, sugerimos a utilização do editor “vim”, mas você pode usar qualquer outro editor de texto de sua preferência.

Para instalar o editor de arquivos execute o comando:

[linux]# yum -y install vim

Dica: Mais informações sobre o editor de textos “vim” podem ser obtidas em:
http://www.vim.org/.

1.4 Desabilitando o SELinux

Atenção: Se você tiver problemas com a execução do Apache, certifique-se que o contexto de seus arquivos de configuração do Apache estão corretamente configurados no SELinux, ou altere o modo de execução do SELinux para permissivo, ou desative-o.

Para desativar o SELinux, edite o arquivo de configuração através do comando:

[linux]# vim /etc/selinux/config

Altere a linha de:

SELINUX=enforcing

Para:

SELINUX=disabled

Dica: Note que o valor correto é disabled, muitos usuários digitam apenas disable.

1.5 Instalando o repositório EPEL

Para instalar o repositório de Pacotes Adicionais para Enterprise Linux (EPEL), execute o comando abaixo:

[linux]# yum -y install epel-release

1.6 Instalando o repositório REMI

Para instalar o repositório, execute o comando abaixo:

[linux]# yum -y localinstall http://rpms.famillecollet.com/enterprise/remi-release-7.rpm

1.7 Atualizando o sistema operacional

Após a instalação, recomendamos a atualização dos pacotes do sistema operacional, para realizar esta tarefa, execute o comando abaixo:

[linux]# yum -y update

1.8 Reinicie o servidor

Para reiniciar o servidor, utilize o comando:

[linux]# shutdown -r now

2. Instalação do PostgreSQL 9.5.x

PostgreSQL é um sistema gerenciador de banco de dados objeto relacional (SGBDOR), desenvolvido como projeto de código aberto sem custo de licença. Este é o programa que vai gerenciar e armazenar o banco de dados relacional utilizado pelo e-cidade.

Dica: Mais informações sobre o PostgreSQL podem ser obtidas em:
http://www.postgresql.org/.

2.1 Configurando o repositório

Para instalar o PostgreSQL 9.5.x e suas dependências, utilizaremos o gerenciador de pacotes yum, que nos prove as últimas atualizações dos pacotes requeridos através de um canal seguro e confiável.

2.1.1 Instale o repositório através do comando:
[linux]# yum -y localinstall https://yum.postgresql.org/9.5/redhat/rhel-7.2-x86_64/pgdg-centos95-9.5-3.noarch.rpm

Dica: Mais informações sobre o gerenciador de pacotes “yum” podem ser obtidas em:
https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/ch-yum.html

2.2 Ajustando o encoding

2.2.1 Configurando e regerando o ‘locale’

Para o servidor do banco de dados, é necessário alterar a ordenação do locale, para realizar esta tarefa, edite o arquivo de configuração com o comando abaixo:

[linux]# vim /usr/share/i18n/locales/pt_BR

Localize o bloco de configuração LC_COLLATE e END LC_COLLATE, e adicione dentro do bloco as seguintes linhas:

reorder-after <U00A0>
<U0020><CAP>;<CAP>;<CAP>;<U0020>
reorder-end
2.2.2 Regerando o ‘locale’

Para criação do cluster do e-cidade precisamos ter o locale pt_BR ISO-8859-1 disponível no sistema, para regerar utilize o comando abaixo.

[linux]# localedef -i pt_BR -c -f ISO-8859-1 -A /usr/share/locale/locale.alias pt_BR.ISO-8859-1

2.3 Instalando o PostgreSQL 9.5.x

Para realizar a instalação do PostgreSQL 9.5.x através do gerenciador de pacotes execute os comandos:

[linux]# yum -y install postgresql95 postgresql95-contrib postgresql95-server

2.4 Criando e configurando o cluster

O e-cidade utiliza encoding LATIN1 (ISO-8859-1) no cluster do PostgreSQL 9.5.x. Por isso vamos criar e iniciar o cluster quer será utilizado pela aplicação.

Dica: Mais informações sobre a configuração do cluster:
http://www.postgresql.org/docs/9.5/static/sql-cluster.html

2.4.1 Vamos criar o novo cluster do banco de dados como LATIN1 usando os comandos:
[linux]# export LC_ALL=pt_BR.ISO-8859-1
[linux]# su - postgres -c "/usr/pgsql-9.5/bin/initdb -A trust -D /var/lib/pgsql/9.5/data -E LATIN1 --locale=pt_BR.ISO-8859-1 -U postgres"
2.4.2 Para a correta integração com o e-cidade, é necessário alterar algumas configurações do cluster criado através do comando:
[linux]# vim /var/lib/pgsql/9.5/data/postgresql.conf

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere as linhas do arquivo do arquivo de configuração, descomentando-as se necessário (remover o caractere # do início da linha), substituindo os valores correspondentes conforme a indicação abaixo.

listen_addresses = '*'
max_connections = 20
bytea_output = 'escape'
max_locks_per_transaction = 256
default_with_oids = on
escape_string_warning = off
standard_conforming_strings = off
2.4.3 Inicie o servidor PostgreSQL através do comando:
[linux]# systemctl start postgresql-9.5
2.4.4 Verifique o resultado da configuração usando o comando:
[linux]# psql -U postgres -h localhost -l

A saída do comando deve ser parecida com os valores abaixo.

   Nome    |   Dono   | Codificação |     Collate      |      Ctype       | Privilégios de acesso
-----------+----------+-------------+------------------+------------------+-----------------------
 postgres  | postgres | LATIN1      | pt_BR.ISO-8859-1 | pt_BR.ISO-8859-1 |
 template0 | postgres | LATIN1      | pt_BR.ISO-8859-1 | pt_BR.ISO-8859-1 | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres
 template1 | postgres | LATIN1      | pt_BR.ISO-8859-1 | pt_BR.ISO-8859-1 | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres
2.4.5 Adicione o serviço do PostgresSQL a inicialização do sistema operacional usando o comando:
[linux]# systemctl enable postgresql-9.5

2.5 Criando a estrutura de banco de dados para o e-cidade

Vamos criar os usuários necessários para o funcionamento do e-cidade através dos comandos:

Atenção: Em ambientes de produção, nunca utilize senhas que tenham o mesmo nome da conta de usuário. Mais informações sobre segurança de senhas podem ser obtidas em:
http://cartilha.cert.br/senhas/.

psql -U postgres -c "CREATE ROLE ecidade WITH SUPERUSER LOGIN PASSWORD 'ecidade';"
psql -U postgres -c "CREATE ROLE plugin WITH LOGIN PASSWORD 'plugin';"
psql -U postgres -c "CREATE ROLE dbseller WITH LOGIN PASSWORD 'dbseller';"

Em seguida, utilize o comando abaixo para criar o banco de dados:

psql -U postgres -c "CREATE DATABASE ecidade OWNER ecidade;"

3. Instalação do Apache

Apache é o servidor web mais usado em sistemas Linux. Servidores web são usados para servir páginas Web que, normalmente, são solicitadas pelos computadores clientes através de navegador, como o Firefox, Chromium, etc.

Dica: Mais informações sobre o Apache podem ser obtidas em:
http://www.apache.org/.

3.1 Instalando o Apache

Para realizar a instalação do servidor web Apache através do gerenciador de pacotes, execute o comando:

[linux]# yum -y install httpd

3.2 Configurando o Apache

3.2.1 Para a correta integração com o e-cidade, é necessário alterar algumas configurações do apache, edite o arquivo de configuração através do comando:
[linux]# vim /etc/httpd/conf/httpd.conf

Localize o bloco abaixo:

<Directory "/var/www/html">
    #
    # Possible values for the Options directive are "None", "All",
    # or any combination of:
    #   Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
    #
    # Note that "MultiViews" must be named *explicitly* --- "Options All"
    # doesn't give it to you.
    #
    # The Options directive is both complicated and important.  Please see
    # http://httpd.apache.org/docs/2.4/mod/core.html#options
    # for more information.
    #
    Options Indexes FollowSymLinks

    #
    # AllowOverride controls what directives may be placed in .htaccess files.
    # It can be "All", "None", or any combination of the keywords:
    #   Options FileInfo AuthConfig Limit
    #
    AllowOverride None

    #
    # Controls who can get stuff from this server.
    #
    Require all granted
</Directory>

E altere para:

<Directory "/var/www/html">
    Options -Indexes +FollowSymLinks +MultiViews
    AllowOverride All
    Require all granted
</Directory>

LimitRequestLine 16382
LimitRequestFieldSize 16382
Timeout 12000
AddDefaultCharset ISO-8859-1
SetEnv no-gzip 1

Localize o bloco abaixo:

<IfModule dir_module>
    DirectoryIndex index.html
</IfModule>

E altere para:

<IfModule dir_module>
    DirectoryIndex index.php index.html
</IfModule>

Dica: Mais informações sobre o VirtualHost podem ser obtidas em:
http://httpd.apache.org/docs/current/vhosts/examples.html.

3.3 Adicione o serviço do Apache a inicialização do sistema operacional usando o comando:

[linux]# systemctl enable httpd

4. Instalação do PHP 5.6 e PHP-FPM

PHP é uma linguagem interpretada livre, usada originalmente apenas para o desenvolvimento de aplicações presentes e atuantes no lado do servidor, capazes de gerar conteúdo dinâmico na World Wide Web.

O PHP-FPM é uma alternativa ao PHP FastCGI com muitas funcionalidades voltadas a sites com grande número de acessos e carga.

Dica: Mais informações sobre o PHP podem ser obtidas em:
http://www.php.net/ e http://php-fpm.org/

4.1 Instalando o PHP 5.6 e o PHP-FPM

Para realizar a instalação do PHP 5.6 através do gerenciador de pacotes, execute o comando:

[linux]# yum -y install php56 php56-php-cli php56-php-common php56-php-pear php56-php-pecl-jsonc php56-php-pecl-zip php56-php-process php56-php-xml php56-runtime php56-php-bcmath php56-php-gd php56-php-interbase php56-php-pecl-jsonc php56-php-mbstring php56-php-mcrypt php56-php-pgsql php56-php-soap php56-php-pecl-sqlite php56-php-xmlrpc php56-php-pecl-zip php56-php-fpm unzip zip xz xz-lzma-compat bzip2

4.2 Configurando o PHP 5.6 e o PHP-FPM

4.2.1 Habilitar as dependências de configuração através do comando:
[linux]# vim /etc/httpd/conf.d/php5.6-fpm.conf
<IfModule !mod_php5.c>
<IfModule proxy_fcgi_module>
    <IfModule setenvif_module>
    SetEnvIfNoCase ^Authorization$ "(.+)" HTTP_AUTHORIZATION=$1
    </IfModule>
    <FilesMatch ".+\.ph(p[3457]?|t|tml)$">
        SetHandler "proxy:fcgi://127.0.0.1:9000/"
    </FilesMatch>
    <Proxy "fcgi://127.0.0.1:9000/">
    </Proxy>
    <FilesMatch ".+\.phps$">
        Require all denied
    </FilesMatch>
    <FilesMatch "^\.ph(p[3457]?|t|tml|ps)$">
        Require all denied
    </FilesMatch>
</IfModule>
</IfModule>
4.2.2 Configurar o arquivo de pool do PHP-FPM através dos comandos:
[linux]# vim /opt/remi/php56/root/etc/php-fpm.d/www.conf

Localize as linhas abaixo:

php_admin_value[error_log] = /opt/remi/php56/root/var/log/php-fpm/www-error.log
php_admin_flag[log_errors] = on

E altere para:

;php_admin_value[error_log] = /opt/remi/php56/root/var/log/php-fpm/www-error.log
;php_admin_flag[log_errors] = on
4.2.3 Configurar o arquivo de log do PHP-FPM através dos comandos:
[linux]# touch /var/log/php_errors.log
[linux]# chown apache.apache /var/log/php_errors.log
4.2.4 Para a correta integração com o e-Cidade, é necessário alterar algumas configurações do PHP através do comando:
[linux]# vim /opt/remi/php56/root/etc/php.ini

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere as linhas do arquivo do arquivo de configuração, descomentando-as se necessário (remover o caractere ; do início da linha), substituindo os valores correspondentes conforme a indicação abaixo.

short_open_tag = On
session.gc_maxlifetime = 7200
date.timezone = "America/Sao_Paulo"
[linux]# ln -s /opt/remi/php56/root/usr/bin/php /usr/bin/php
4.2.6 Reinicie o serviço do PHP-FPM e do Apache usando os comandos:
[linux]# systemctl restart php56-php-fpm
[linux]# systemctl restart httpd

4.3 Adicione o serviço do PHP-FPM a inicialização do sistema operacional usando o comando:

[linux]# systemctl enable php56-php-fpm

5. Instalação do LibreOffice

O LibreOffice é uma suite de escritório livre compatível com as principais suítes de escritório do mercado. Oferece todas as funções esperadas de uma suite profissional: editor de textos, planilha, apresentação, editor de desenhos e banco de dados.
No e-cidade, o LibreOffice é utilizado para exportar documentos baseados em modelos de formulários.

Dica: Mais informações sobre o LibreOffice podem ser obtidas em:
https://pt-br.libreoffice.org/.

5.1 Instalando dependências

Antes de instalarmos o pacote do LibreOffice, devemos instalar uma dependência através do comando:

[linux]# yum -y localinstall https://downloads.sourceforge.net/project/mscorefonts2/rpms/msttcore-fonts-installer-2.6-1.noarch.rpm

5.2 Instalando o LibreOffice

Para realizar a instalação do LibreOffice através do gerenciador de pacotes, execute o comando:

[linux]# yum -y install libreoffice-writer

6. Instalação do e-cidade

6.1 Obtendo o pacote de instalação

O pacote de instalação pode ser obtido diretamente do site do Portal do Software Público. No endereço da comunidade do e-cidade (https://softwarepublico.gov.br/social/e-cidade) estão disponíveis as últimas versões e suas atualizações. Como estamos realizando uma nova instalação, você deve baixar o pacote completo, um exemplo de nome do pacote seria: e-cidade-x.x.xx-linux.completo.tar.bz2.

6.2 Configurando o servidor

6.2.1 Vamos criar um usuário administrativo para o e-cidade, neste exemplo criaremos o usuário dbseller através do comando:
[linux]# useradd -d /home/dbseller -g apache -G wheel -k /etc/skel -m -s /bin/bash dbseller
6.2.2 Em seguida, vamos definir uma senha para este novo usuário usando o comando:
[linux]# passwd dbseller

Dica: Neste exemplo, defina a senha como o mesmo nome de usuário, como “dbseller”.

Atenção: Em ambientes de produção, nunca utilize senhas que tenham o mesmo nome da conta de usuário. Mais informações sobre segurança de senhas podem ser obtidas em: http://cartilha.cert.br/senhas/.

6.2.3 Agora vamos habilitar a autenticação do grupo wheel editando o arquivo usando o comando:
[linux]# vim /etc/pam.d/su

Localize e descomente a linha como mostrado abaixo.

auth            required        pam_wheel.so use_uid
6.2.4 Para encaminhar os e-mails destinados ao usuário root para o usuário dbseller, edite o arquivo através do comando:
[linux]# vim /etc/aliases

Mova o cursor até o fim do arquivo e insira alinha como mostrado abaixo.

root:           dbseller

Em seguida, execute o comando:

[linux]# newaliases
6.2.5 Também devemos corrigir a máscara de criação de arquivos modificando os arquivos através dos comandos:
[linux]# vim /etc/login.defs

Atenção: Os demais parâmetros, não descritos aqui, não precisam ser alterados.

Localize e altere a linha do arquivo do arquivo de configuração, descomentando-a se necessário (remover o caractere # do início da linha), substituindo o valor correspondente conforme a indicação abaixo.

UMASK           002

Em seguida, execute o comando abaixo para ajustar os arquivos criados pelo apache:

[linux]# echo "umask 002" >> /etc/sysconfig/httpd

6.3 Instalando o e-cidade

6.3.1 Descompacte o pacote do e-cidade através do comando:
[linux]# tar xjf e-cidade-x.x.xx-linux.completo.tar.bz2
6.3.2 Copie o diretório do e-cidade para o diretório raiz do Apache usando o comando:
[linux]# cp -r e-cidade-x.x.xx-linux.completo/e-cidade /var/www/html/

6.4 Configurando o e-cidade

6.4.1 Crie o arquivo de configuração de acesso ao banco de dados através do comando:
[linux]# cp -a /var/www/html/e-cidade/libs/db_conn.php.dist /var/www/html/e-cidade/libs/db_conn.php

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]# vim /var/www/html/e-cidade/libs/db_conn.php

Em seguida, atualize as configurações conforme o exemplo abaixo.

$DB_USUARIO = "ecidade";
$DB_SENHA = "ecidade";
$DB_SERVIDOR = "localhost";
$DB_PORTA = "5432";
$DB_PORTA_ALT = "5432";
$DB_BASE = "ecidade";
6.4.2 Crie o arquivo de configuração de acesso dos plugins através do comando:
[linux]# cp -a /var/www/html/e-cidade/config/plugins.json.dist /var/www/html/e-cidade/config/plugins.json

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]# vim /var/www/html/e-cidade/config/plugins.json

Em seguida, atualize as configurações conforme o exemplo abaixo.

{
  "AcessoBase" : {
    "usuario" : "plugin",
    "senha" : "plugin"
  }
}
6.4.3 Configure o servidor de envio de e-mails do e-cidade através do comando:
[linux]# vim /var/www/html/e-cidade/libs/config.mail.php

Em seguida, atualize as configurações, com os dados do seu servidor de e-mail, conforme o exemplo abaixo.

$sClass = 3;
$sSslt  = ''; // qual o tipo de ssl q sera utilizados ( ex: tls), por padrao é vazio
$bAuth  = true; // autenticacao habilitada
$sUser  = 'exemplo@exemplo.com.br';
$sPass  = 'senhaexemplo';
$sHost  = 'smtp.exemplo.com.br';
$sPort  = '25';
6.4.4 Faça a carga do schema do e-cidade através do comando:
[linux]# psql -U ecidade -d ecidade -f e-cidade-x.x.xx-linux.completo/sql/e-cidade-x.x.xx.sql 2> /tmp/erros.txt

Após a carga, execute o comando abaixo para otimizar as consultas:

[linux]# psql -U ecidade -d ecidade -c "VACUUM ANALYZE VERBOSE;"
6.4.5 Ajuste as permissões dos diretórios através dos comandos:
[linux]# chown -R dbseller.apache /var/www/html/e-cidade
[linux]# chmod -R 775 /var/www/html/e-cidade
[linux]# chmod -R 777 /var/www/html/e-cidade/tmp

6.5 Agendando a migração da auditoria

6.5.1 Edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para migracao do acount para nova estrutura "db_auditoria"
*/30 * * * * cd /var/www/html/e-cidade/integracao_externa/auditoria; ./auditoria_migracao.sh 0 10 1 > log/auditoria_migracao.log 2>&1
*/10 * * * * cd /var/www/html/e-cidade/integracao_externa/auditoria; php -q auditoria_adiciona_fila.php > log/auditoria_adiciona_fila.log 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

6.6 Agendando a verificação do gerenciador de tarefas

6.6.1 Para criar o script de verificação execute os comandos:
[linux]# mkdir -p /opt/dbseller/scripts
[linux]# vim /opt/dbseller/scripts/ativadorGerenciadorTarefasEcidade.sh

Em seguida, adicione as linhas indicadas abaixo.

#!/bin/bash
sDiretorioEcidade="/var/www/html/e-cidade"
if [ ! -d $sDiretorioEcidade ]; then
  echo "Diretorio $sDiretorioEcidade nao existe"
  exit 1;
fi

sContador=$(ps aux | grep '<defunct>' | grep -v 'grep' | wc -l)
if [ "$sContador" -gt "5" ]; then
  sPid=$(ps aux | grep "con4_gerenciadortarefas002.php" | grep -v "grep" | awk '{print $2}');
  kill ${sPid}
fi

sTarefa=$(ps aux | grep "con4_gerenciadortarefas002.php" | grep -v "grep");
if [ "$sTarefa" == "" ]; then
  cd $sDiretorioEcidade;
  /usr/bin/php -q FrontIntegracaoExterna.php --executable con4_gerenciadortarefas002.php > tmp/log_gerenciador_tarefas.log 2> tmp/erros_gerenciador_tarefas.log &
fi

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

6.6.2 Antes de agendar o script de verificação, ajuste a permissão utilizando o seguinte comando:
[linux]# chmod +x /opt/dbseller/scripts/ativadorGerenciadorTarefasEcidade.sh

Em seguinda, edite o crontab do usuário root através do comando:

[linux]# crontab -e

E adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script de verificacao do gerenciador de tarefas
*/15 * * * * cd /opt/dbseller/scripts && su -s /bin/bash apache -c "bash ativadorGerenciadorTarefasEcidade.sh"

6.7 Acessando o e-cidade

Após finalizar os procedimentos de instalação e configuração, abra um navegador e acesse o e-cidade através do endereço IP ou nome do servidor. EX: http://ip_do_servidor/e-cidade, utilize como nome de usuário dbseller, e deixe o campo senha em branco.

Atenção: Certifique-se que o bloqueador de pop-up esteja permitindo o acesso ao endereço IP ou nome do servidor em que o e-cidade foi instalado.

7. Instalação do e-cidadeonline

7.1 Instalando o e-cidadeonline

7.1.1 Copie o diretório do e-cidadeonline para o diretório raiz do Apache usando o comando:
[linux]# cp -r e-cidade-x.x.xx-linux.completo/e-cidadeonline /var/www/html/

7.2 Configurando o e-cidadeonline

7.2.1 Crie o arquivo de configuração de acesso ao banco de dados através do comando:
[linux]# cp -a /var/www/html/e-cidadeonline/libs/db_conn.php.dist /var/www/html/e-cidadeonline/libs/db_conn.php

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]# vim /var/www/html/e-cidadeonline/libs/db_conn.php

Em seguida, atualize as configurações conforme o exemplo abaixo.

$DB_INSTITUICAO = 1;
$DB_SERVIDOR = "localhost";
$DB_BASEDADOS = "ecidade";
$DB_USUARIO = "ecidade";
$DB_PORTA = "5432";
7.2.2 Configure o servidor de envio de e-mails do e-cidadeonline através do comando:
[linux]# vim /var/www/html/e-cidadeonline/libs/config.mail.php

Em seguida, atualize as configurações, com os dados do seu servidor de e-mail, conforme o exemplo abaixo.

$sClass = 3;
$sSslt  = ''; // qual o tipo de ssl q sera utilizados ( ex: tls), por padrao é vazio
$bAuth  = true; // autenticacao habilitada
$sUser  = 'exemplo@exemplo.com.br';
$sPass  = 'senhaexemplo';
$sHost  = 'smtp.exemplo.com.br';
$sPort  = '25';
7.2.3 Ajuste as permissões dos diretórios através dos comandos:
[linux]# chown -R dbseller.apache /var/www/html/e-cidadeonline
[linux]# chmod -R 775 /var/www/html/e-cidadeonline
[linux]# chmod -R 777 /var/www/html/e-cidadeonline/tmp

7.3 Acessando o e-cidadeonline

Após finalizar os procedimentos de instalação e configuração, abra um navegador e acesse o e-cidadeonline através do endereço IP ou nome do servidor. EX: http://ip_do_servidor/e-cidadeonline, utilize como nome de usuário dbseller, e deixe o campo senha em branco.

8. Configurando a carga de integrações

Dica: Preste atenção aos horários de agendamento do crontab de múltiplas integrações. Procure verificar o tempo de duração da execução de cada integração, ajustando o horário de excução conforme a necessidade.

Dica: Sempre que possível, execute manualmente a linha agendada para certificar o correto funcionamento do agendamento.

8.1 Configurando a integração de carga do cubo do BI

8.1.1 Crie o arquivo de configuração de acesso FTP para a carga do cubo do BI através do comando:
[linux]# cp -a /var/www/html/e-cidade/libs/db_cubo_bi_config.php.dist /var/www/html/e-cidade/libs/db_cubo_bi_config.php

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]# vim /var/www/html/e-cidade/libs/db_cubo_bi_config.php

Em seguida, atualize as configurações conforme o exemplo abaixo.

$configCuboBi['ftp']['server']        = "endereco.ip.do.servidor";
$configCuboBi['ftp']['usuario']       = "nome-usuario-ftp";
$configCuboBi['ftp']['senha']         = "senha-do-usuario-ftp";
$configCuboBi['ftp']['diretorio']     = "diretorio-de-destino";
$configCuboBi['ftp']['passive_mode']  = true;

8.2 Configurando a integração de carga do Webservice HORUS BASICO

8.2.1 Crie o arquivo de configuração de através do comando:

Dica: Mais informações sobre o Werbservice HORUS BASICO podem ser obtidas em:
http://portalsaude.saude.gov.br/index.php/o-ministerio/principal/leia-mais-o-ministerio/218-sctie-raiz/daf-raiz/ceaf-sctie/qualifarsus-raiz/eixo-informacao/l1-eixo-informacao/8508-envio-de-dados-webservice

[linux]# cp -a /var/www/html/e-cidade/libs/db_config_horus.php.dist /var/www/html/e-cidade/libs/db_config_horus.php

Utilize o seguinte comando para editar o arquivo de configuração:

[linux]# vim /var/www/html/e-cidade/libs/db_config_horus.php

Em seguida, atualize as configurações conforme o exemplo abaixo.

Atenção: Consulte a documentação das URLs no portalsaude.saude.gov.br antes de utilizar a integração.

// Homologação
$sUrlWebService = "http://189.28.128.37/horus-ws-basico/RecebeDadosWS?wsdl";
$sLogin         = "nome-usuario-horus";
$sSenha         = "senha-do-usuario-horus";

8.3 Configurando as integrações de limpeza de cadastros duplos CGM e CGS

8.3.1 Para agendar a limpeza de cadastros duplos CGM, edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para limpeza de cadastro duplos CGM
0 22 * * * cd /var/www/html/e-cidade/ ; /usr/bin/php FrontIntegracaoExterna.php --executable duplos.php > duplos.log 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.3.2 Para agendar a limpeza de cadastros duplos CGS, edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para limpeza de cadastro duplos CGS
0 22 * * * cd /var/www/html/e-cidade/ ; /usr/bin/php FrontIntegracaoExterna.php --executable duploscgs.php > duploscgs.log 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.4 Configurando a integração GISS

O script de execução da integração GISS possui dois parametros de configuração:

1) Se o programa for agendado sem nenhum parâmetro, ou com o parametro 1, a integração processará somente os registros alterados.

.../iss4_gissonline002.php 1 > /dev/null 2>&1

2) Se o programa for agendado com o parâmetro 2, a integração processará todos os registros.

.../iss4_gissonline002.php 2 > /dev/null 2>&1
8.4.1 Edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para execução da integração GISS
0 22 * * * cd /var/www/html/e-cidade/ ; /usr/bin/php FrontIntegracaoExterna.php --dir integracao_externa/gissonline --executable integracao_externa/gissonline/iss4_gissonline002.php > /dev/null 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.5 Configurando a integração SIGCORP

8.5.1 Edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para execução da integração SIGCORP
0 22 * * * cd /var/www/html/e-cidade/ ; /usr/bin/php FrontIntegracaoExterna.php --dir integracao_externa/sigcorp --executable integracao_externa/sigcorp/iss4_sigcorp001.php > /dev/null 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.6 Configurando a integração WEBISS

8.6.1 Edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para execução da integração WEBISS
0 22 * * * cd /var/www/html/e-cidade/ ; /usr/bin/php FrontIntegracaoExterna.php --executable integracao_externa/webiss/iss4_webiss001.php > /dev/null 2>&1

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.7 Configurando a integração de geração das tabelas débitos

8.7.1 Para agendar a geração das tabelas débitos, edite o crontab do usuário dbseller através do comando:
[linux]# crontab -u dbseller -e

Em seguida, adicione o seguinte bloco ao final do arquivo:

# DBSeller - Agendamento do script para geração das tabelas débitos
0 20 * * * cd /var/www/html/e-cidade/integracao_externa/debitos ; ./debitos.sh &> /dev/null

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

8.7.2 Configurando a integração débitos

O script de execução da integração débitos necessita de um arquivo de configuração para ser executado.
Para criar o script de configuração, execute os comandos abaixo:

[linux]# cd /var/www/html/e-cidade/integracao_externa/debitos/libs
[linux]# cp -a debitos.conf.dist debitos.conf

Em seguida edite o arquivo através do comando:

[linux]# vim debitos.conf

Informe o valor das variáveis conforme as descrições abaixo:

# Permite definir a periodicidade com que a manutencao da tabela debitos
# sera executada. O valores permitidos sao: -1=desativa, 0=todos ou dia da semana (1=segunda, 2=terca ... 7=domingo).
#
# Exemplo:
# DEBITOS_PERIODO="7"
#
DEBITOS_PERIODO=""

# Permite definir o numero de dias no passado para manter os registros na debitos.
#
# Exemplo:
# DEBITOS_DIAS_MANTER="14"
#
DEBITOS_DIAS_MANTER=""

# Permite definir o codigo da(s) instituicao(oes) que deve(em) ser gerada debitos. Se houver
# mais de uma instituicao, os seus codigos devem ser separados por espa�o.
#
# Exemplo:
# DEBITOS_INSTITUICOES="1"
# DEBITOS_INSTITUICOES="1 3"
#
DEBITOS_INSTITUICOES=""

Atenção: Lembre-se de ajustar o caminho para o diretório do e-cidade conforme o ambiente em que foi instalado.

Glossário

Termo Significado
encoding http://en.wikipedia.org/wiki/Character_encoding
cluster http://www.postgresql.org/docs/8.2/interactive/creating-cluster.html
apt-get http://www.debian.org/doc/manuals/apt-howto
apt-get http://pt.wikipedia.org/wiki/Advanced_Packaging_Tool
vim http://www.vim.org
Firefox http://www.mozilla.org/firefox
DBSeller Sistemas http://www.dbseller.com.br
proxy http://pt.wikipedia.org/wiki/Proxy
squid http://pt.wikipedia.org/wiki/Squid

Batalha de Porongos

Massacre de Porongos ou Traição dos Porongos foi o penúltimo confronto da Revolução Farroupilha (18351845[1] e ocorreu em 14 novembro de 1844.[2] A batalha foi a principal responsável pelo fim da maior revolução da história brasileira.[2]

Em novembro de 1844, cerca de um ano antes do fim da Guerra dos Farrapos, e com as negociações de paz já em andamento, os mais de 1200 republicanos, liderados pelo general David Canabarro, foram cercados e completamente abatidos pelos mais de 1100 guerrilheiros apoiadores do Império, conduzidos por Francisco Pedro de Abreu. Por conta do cerco e da estratégia militar construída por Francisco de Abreu, foi possível abater os republicanos e, consequentemente, paralisar o movimento revolucionário anti-imperial.[2]

Para os revolucionários, a batalha de Porongos resultou na morte de 110 apoiadores da república, na prisão de 333 homens – sendo 35 oficiais -, cinco estandartes, um canhão, utensílios, arquivos e mais de 1000 cavalos. Por conta disso, o episódio ficou conhecido como uma das maiores perdas que o movimento republicano teve até então na Guerra dos Farrapos.[2]

 

Contexto Histórico

Revolução Farroupilha ficou marcada na história como um movimento do período regencial brasileiro contra a imposição de presidente de província pelo Governo Central, isto é, sem consultar o governo provincial. O movimento, tinha um caráter liberal e pretendia conseguir mais autonomia provinciana frente a um governo central autoritário, recém terminado no Primeiro Reinado Brasileiro. [2]

O termo farroupilha remete aos combatentes populares que compunham as tropas, que eram conhecidos por trajarem roupas esfarrapadas, embora as lideranças políticas estivessem sempre representada por setores da elite agrária local.[1] A Guerra conseguiu durar por 10 anos, porque os farrapos recebiam continuamente mantimentos dos países de fronteira e a charque das províncias era contrabandeada para o Uruguai e entrava no Brasil como se fosse de procedência uruguaia. Isso contribuiu para a sustentação econômica dos republicanos.[3]

Os senhores de terra, de gado e de escravos do sul estavam insatisfeitos com as decisões que estavam sendo tomadas pela côrte brasileira, principalmente à respeito dos impostos cobrados das províncias. O Rio Grande do Sul, na época, tinha entre os principais produtos da sua economia o gado e a fabricação de charque, utilizado na alimentação dos escravos de todas as províncias brasileiras. Os rio-grandenses, como eram chamadas as autoridades provincianas, acusavam o Governo Central de prejudicar seus interesses econômicos, principalmente ao permitir que a charque do Uruguai adentrasse no mercado brasileiro a um preço mais barato.[3]

Além disso, era a côrte que determinava qual porcentagem dos impostos arrecadados nas províncias ficava e qual deveria ser destinada ao Rio de Janeiro, sede do governo. Além desse caráter econômico, havia também uma insatisfação política, uma vez que era o Governo Central que determinava qual seria o governante que comandaria as terras provincianas. Esses homens eram selecionados sem uma consulta aos donos de terras nas províncias e muitas vezes os líderes selecionados não atendiam os pleitos desses donos de terra e, consequentemente, aos interesses da região.[3]

Havia também uma insatisfação quanto às campanhas militares que estavam acontecendo nas fronteiras do sul. O Rio Grande do Sul sempre havia contribuído doando homens para ajudar o Brasil nas guerras com os povos platinas, mas, mesmo assim a liderança das tropas era sempre destinada a alguém de fora. Por conta da somatórias desses fatores, em 20 de setembro de 1835 deu início à Revolução Farroupilha.[3]

O movimento já ganhou a atenção nacional no ano seguinte, em 1836, quando a província rio-grandense decretou a República Rio-Grandense. O movimento foi liderado por Bento Gonçalves da Silva, militar e estancieiro.[3]

Nos nove anos seguintes, esse primeiro momento de exímio desempenho bélico sofreria mudança. Até o ano de 1840, houve um período de ascensão farroupilha, dadas as vitórias no campo militar, embora tenha havido momentos de fracasso, como a derrota na Batalha da Ilha do Fanfa, em outubro de 1836. Do período compreendido desde a Proclamação da República até 1840, os farrapos visaram a manutenção e organização do novo Estado, bem como a sua sedimentação. [4] A partir de 1840, iniciou-se um período de declínio das forças revoltosas. A situação se intensificou após as reuniões da Assembleia Constituinte, em 1842, quando as divergências entre os líderes farroupilhas e os dois grupos se intensificaram. [4]

Nesse embate, o grupo “minoria” adquiriu grande poder com o desenrolar do conflito, principalmente por conta do afastamento de Bento Gonçalves do governo, em agosto de 1843. A partir do final de 1841 e início de 1842, concomitante à instauração de Dom Pedro II como Imperador do Brasil, o poder de direção da Guerra foi para as mãos da “minoria”. Por conta da necessidade do imperador de utilizar o território rio-grandenses para a manutenção das fronteiras sulistas do Brasil, o movimento apresentou um desfecho favorável para os revolucionários. Em 1845, apesar de ter a permissão do monarca para agir com violência, Luís Alves de Lima e Silva escolheu a diplomacia. Utilizou-se de um apelo ao patriotismo dos revolucionários e simultaneamente apontou Manuel Oribe e Juan Manuel de Rosas, presidentes do Uruguai e da Argentina respectivamente, como os reais inimigos. Lima e Silva foi aclamado “pacificador do Brasil” e adquiriu o título de Conde de Caxias, que foi agregado à presidência da Província Rio-Grandense.[4]

A Guerra dos Farrapos contribuiu para a construção da imagem do gaúcho como um homem heroico e independente. Essa imagem possibilitada com a guerra é enaltecida e cultuada até hoje na região.[5]

 

Antecedentes

Com a independência política brasileira sob Portugal ocorrida em 1822, o Brasil decretou uma Monarquia Centralizadora, na qual o poder passou a ser exercido em função do café, principal produto de exportação brasileiro e principal fonte de renda para a economia nacional do século XIX. O monarca, D. Pedro I, governou o pais em convergência com os interesses da elite cafeicultora, conhecida como “os barões do café”. A côrte, sediada no município do Rio de Janeiro, dava as ordens e as diretrizes da economia nacional e os líderes provinciais eram obrigados a segui-la.[3]

Por volta de 1827D. Pedro I recebe uma carta do francês Benjamin Constant, aconselhando-o a abdicar do trono brasileiro e deixar um governo regencial governar o Brasil até que D. Pedro II atingisse a maioridade. Assim, segundo o francês, estariam mantidas na nova Monarquia a ordem e o próprio regime monárquico. Desse modo, o imperador passaria a ser enxergado na Europa como um apoiador das liberdades e não da tirania.[6]

Esses conselhos estavam relacionados com a crise política e econômica que o Brasil estava enfrentando. No âmbito político, o governo central intensificou a disputa com o poder Legislativo, que estava em curso há anos. Além disso, o imperador constantemente ordenava interferências políticas na península Ibérica, poucos anos após a independência do Brasil, o que não estava agradando a elite local por mostrar vínculos políticos com Portugal. Já à respeito da economia, o Brasil estava com uma inflação alta e uma política econômica que não privilegiava o mercado nacional, uma vez que as taxações sobre o produto importado era baixa para os cofres nacionais. Ademais, o país carregava uma dívida financeira por conta dos armamentos devido à Guerra da Cisplatina (18251828)[7] e um desgaste moral e político no Brasil, já que a Cisplatina (atual Uruguai) conseguira se desvincilhar do território nacional.[6]

A crise interna se intensificara. D. Pedro I estava sendo visto como um déspota (autoritário) e havia constantes comparações negativas do imperador com Simon BolívarCarlos X, e Fernando VII. Para tentar conter o descontentamento interno, o imperador reúne o Conselho do Estado, porém sem conseguir um consenso quanto às atitudes que poderiam ser adotadas. Diante desse cenário, surge no Rio de Janeiro, entre os dias 11 e 14 de março, uma revolta violenta entre brasileiros e portugueses, que ficou conhecida como Noite das Garradas (1831). O conflito potencializou a insatisfação e a revolta no Brasil.

Para tentar solucionar o caso, em 5 de abril do mesmo ano, o monarca estrutura um novo gabinete ministerial com cinco marqueses e um visconde. Porém, essas medidas apenas contribuíram para aumentar o isolamento político do imperador. No dia 07 de abril de 1831, D. Pedro I, seguindo as palavras da carta de Constant, abdica do seu trono e volta para Portugal deixando aqui no Brasil o seu filho, D. Pedro de Alcântara, futuro monarca do Brasil.[6]

Porém, D.Pedro de Alcântara, na época, tinha apenas 5 anos de idade, e por isso, incapaz de governar o país. Por tal razão, instaura-se o período da Regência no Brasil. Segundo o texto da Constituição, assumiu uma Regência Trina. Em 1832Bernardo Pereira de Vasconcelos e Diogo Antônio Feijó projetaram um golpe de estado com o objetivo de transformar a Câmara em um Assembleia Nacional Constituinte porém não houve êxito. Somente em 1834, os legisladores aprovaram a reforma de alguns pontos da Constituição. O projeto foi apresentado por Vasconcelos, transformando-o em Ato Adicional de 1834. Esse documento, de cunho liberal, introduziu elementos do federalismo com a criação das Assembleias Provinciais no lugar dos Conselhos Gerais, a separação das rendas provinciais das nacionais e abolição do Conselho de Estado. O documento possibilitou um maior poder das províncias.[8]

Por conta dessas questões e da herança deixada no Primeiro Reinado ao Brasil, o período Regencial foi marcado por um intenso enfrentamento dos conflitos internos de poder, que alguns se transformaram em sangrantas revoluções e por um combate aos grupos contrários ao regime monárquico, à escravidão e de uma maneira mais ampla, à própria existência do Brasil.[8]

 

O confronto e o movimento

Mesmo que o movimento liderado por Canabarro converge para interesses em comum de cunho liberal, havia no próprio entre os próprios apoiadores da tropa interesses sociais, econômicos e políticos diversos. Os farroupilhos estavam divididos em dois grandes grupos ou partidos. O que ficou conhecido como “Maioria”, que apresentava ideias mais radicais e tinha como principais nomes: Bento Gonçalves da SilvaDomingos José de AlmeidaMariano de MatosAntonio de Souza Neto e Gomes Jardim. O outro grupo denominado como da “Minoria”. Esse apresentava um comportamento e ideias mais reformistas e menos autoritárias e alguns buscavam também a reconciliação com o Governo Central. O principal nome era David Canabarro, mas também tinha entre os seus apoiadores, Antonio Vicente da Fontoura, Francisco Ferreira Jardim Brasão, Martins da Silveira Lemos, Onofre PiresPaulino da FontouraJoão Antonio de Oliveira, entre outros.[9]

Além de terem representantes diferentes, os dois grupos também apresentavam visões distintas sobre os rumos que a nova república deveria tomar. Os mais radicais defendiam o fim da escravidão, ao mesmo tempo em que criticava a monarquia e a Igreja católica. Já para os mais reformistas e moderados, os pleitos eram um pouco mais homogêneos. Eles queriam manter o escravismo, defendiam o catolicismo, a Igreja e a reintegração da província ao Império.[9]

A batalha de Porongos, ocorrida em novembro e no final da Guerra dos Farrapos, ainda deixa suspeitas se o confronto teria sido combinado ou não com o exército imperial. Embora o movimento republicano tenha sido quase extinto, Canabarro não foi pego nesse cerco militar, porque não chegou a ser reconhecido por conta dos trajes sujos e rasgados que utilizara.[9] Segundo alguns relatos, Canabarro teria sido avisado da aproximação de Moringue.[9]

De acordo com os relatos, há uma carta que teria sido enviada ao Coronel Francisco Pedro de Abreu pelo Barão de Caxias instruindo Francisco Pedro de Abreu a atacar o corpo de Lanceiros Negros e afirmando que tal situação estaria acertada com Canabarro. Esta carta foi mostrada em Piratini a um professor ligado aos demais comandantes farrapos. A autenticidade da carta foi questionada, e há a possibilidade de ela ter sido forjada para desmoralizar Canabarro, à época um dos mais importantes líderes militares da República Riograndense e um dos negociadores da paz pelo lado farroupilha. O documento, com a devida assinatura de Caxias, é reconhecido como autêntico pelo Arquivo Histórico do Rio Grande do Sul.[10] Os estudiosos que acreditam que o documento seja verídico argumentam que a essa traição teria ocorrido para acelerar e facilitar o acordo de paz, visto que o Império Brasileiro não se mostrava disposto a liberar os escravos que haviam lutado ao lado dos republicanos. Já os que acreditam na falsificação desses escritos argumentam que o episódio de Porongos foi realmente uma surpresa para todos os integrantes e tal carta fora escrita para gerar uma tensão para destruir o grupo.[5]

Na memória desse massacre está o grupo de lanceiros negros como sendo os únicos mortos. Os homens estavam separados no acampamento entre brancos, negros e índios. Os imperiais atacaram especificamente o acampamento dos negros e os demais homens fugiram. Nessa batalha Teixeira Nunes, comandante dos lanceiros negros, foi morto. Com esse confronto, o movimento revolucionário republicano foi extinto e um ano mais tarde, foi decretado o Tratado de Paz Ponche Verde.[9] Em primeiro de março de 1845, o acordo foi firmado e entre os principais pontos, pode-se destacar a anistia plena aos que sobreviventes da batalha de Porongos, a libertação dos escravos que combateram no Exército e a escolha de um novo presidente provincial pelos farroupilhas.[11]

 

 

Lanceiros Negros

 

Os negros durante a Guerra dos Farrapos foram fundamentais e tiveram uma participação ativa ao longo dos 10 anos do confronto. Estima-se que, ao todo, eles representariam aproximadamente um terço à metade do exército republicado e posteriormente, foram integrados ao grupos dos farrapos na cavalaria ou na infantaria. A primeira foi criada em 12 de setembro de 1836 e a segunda em 31 de agosto de 1838, respectivamente.[5] Em 31 de agosto de 1838, 426 combatentes juntaram-se ao exército.[12]

Eles foram recrutados entre os campeiros e domadores das Serras dos Tapes e do Herval, localizadas entre os municípios de Canguçu, Piratini, Caçapava, Encruzilhada e Arroio Grande. No primeiro momento, foram comandados pelo Tenente Coronel Joaquim Pedro Soares, mais tarde tiveram por chefe o Major Joaquim Teixeira Nunes.[12]

Antes da criação dos Lanceiros Negros, os negros já tinham tido um papel de destaque em confrontos nacionais, como a tomada de Porto Alegre em 1835 e de Pelotas em abril de 1836. Os grupos eram compostos por negros livres e alforriados, índios, mestiços e escravos fugidos de outros países, principalmente o Uruguai. Além de soldados e grandes defensores dos farrapos, os negros também trabalhavam como tropeiros, mensageiros, campeiros e ajudavam na fabricação de pólvora e no cultivo do fumo e erva-mate, apreciadas pelo grupo.[13]

Embora a Guerra dos Farrapos e o grupo de negros não tenham conseguido abolir a escravatura, que só seria encerrada cerca de 40 anos depois, ele foi de suma importância para questionar a ordem escravocrata e várias outras questões que estavam em curso no Brasil e não condiziam com os ideais liberais seguidos pelos farrapos.[14]

Atualmente, os Lanceiros Negros são lembrados por alguns movimentos sociais visando salientar a pouca importância dada na época à participação dos negros na Guerra dos Farrapos. De uma certa maneira, o objetivo desses grupos é legitimar as ações, as memórias e os acontecimentos dos Lanceiros Negros na Guerra dos Farrapos. Em razão da manutenção dessa memória foi construído em 2004 um monumento a eles na cidade de Caçapava do Sul, localizada no Rio Grande do Sul.[15]

O desastre dos Porongos levou Canabarro a um tribunal militar farroupilha. Com a paz em 1845, o trâmite seguiu por anos na justiça militar, tendo sido arquivado em 1866. Durante toda a sua vida, o general Canabarro insistiu em sua inocência e na tese da difamação.

 

Ver também

Referências

 

  1.  «PORTO ALEGRE E AS MANIFESTAÇÕES SOCIAIS: ALGUNS ANTECEDENTES E DESDOBRAMENTOS»
  2. ↑ Ir para:a b c d e «Dicionário das Batalhas Brasileiras»
  3. ↑ Ir para:a b c d e f PESAVENTO, SANDRA JATAHY (Agosto de 1895). «A REVOLUÇÃO FARROUPILHA». Consultado em 9 de novembro de 2017
  4. ↑ Ir para:a b c Dornelles, Laura de Leão (7 de dezembro de 2010). «Guerra Farroupilha: considerações acerca das tensões internas, reivindicações e ganhos reais do decênio revoltoso.»Revista Brasileira de História & Ciências Sociais2 (4). ISSN 2175-3423
  5. ↑ Ir para:a b c Salaini, Cristian J (2006). «”Nossos heróis não morreram” : um estudo antropológico sobre formas de “ser negro” e de “ser gaúcho” no estado do Rio Grande do Sul»
  6. ↑ Ir para:a b c Morel, Marco (2003). O período das regências (1831-1840). [S.l.]: J. Zahar. ISBN 9788571107465
  7. Ir para cima «Guerra da Cisplatina (1825 – 1828) – Mundo Educação»Mundo Educação. Consultado em 13 de novembro de 2017
  8. ↑ Ir para:a b Vasconcelos, Bernardo Pereira de; Carvalho, José Murilo de (1999). Bernardo Pereira de Vasconcelos. [S.l.]: Editora 34. ISBN 9788573261547
  9. ↑ Ir para:a b c d e «A REVOLUÇÃO FARROUPILHA: O MASSACRE DE CERRO DOS PORONGOS»
  10. Ir para cima O Massacre de Porongos faz 164 anos, jornal A Nova Democracia.
  11. Ir para cima Marli Bonna Secchi, Neusa. «REVOLUÇÃO FARROUPILHA 1835 a 1845 – Decênio Heróico». O caderno Piá 21
  12. ↑ Ir para:a b Carrion, Raul. «OS LANCEIROS NEGROS NA REVOLUÇÃO FARROUPILHA»
  13. Ir para cima Carvalho, Comin De; Paula, Ana (2005). «O memorial dos lanceiros negros: disputas simbólicas, configurações de identidades e relações interétnicas no Sul do Brasil»Sociedade e Cultura8 (2). ISSN 1415-8566
  14. Ir para cima Carvalho, Daniela Vallandro de. «Fronteiras da Liberdade: Experiências Escravas de Recrutamento, Guerra e Escravidão: (Rio Grande de São Pedro, c. 1835-1850)»
  15. Ir para cima Salaini, Cristian Jobi. «Memória, mídia e imaginário social: o caso Porongos». Consultado em 10 de novembro de 2017

 

 

Bibliografia

  • DONATO, Hernâni.Dicionário das Batalhas Brasileiras. São Paulo: Ibrasa, 1987.
  • MACHADO, Cesar Pires. Porongos : Fatos e Fábulas. Evangraf, 2011.

Link:   https://pt.wikipedia.org/wiki/Batalha_de_Porongos

 

 

Nick Leeson

Nicholas Leeson (25 de fevereiro de 1967) é um ex-funcionário do banco de investimentos inglês Barings que ficou mundialmente conhecido por ter sido o responsável, sozinho, pela quebra do banco, até então uma tradicional instituição financeira da Inglaterra, o mais antigo banco de investimentos do país, reconhecido em todo o planeta. Atualmente, Nick é CEO do time de futebol irlandês Galway United.

 

Trajetória

Leeson nasceu em Watford, nordeste de Londres, e estudou na escola Parmiter. Tendo concluído o período escolar em 1984, conseguiu um emprego no banco Coutts. Trabalhou em diversos outros bancos até chegar ao Barings, no início da década de 1990. Em 1992, Nick assumiu o cargo de operador de mercados futuros na bolsa de valores de Singapura, a SIMEX (Singapore International Monetary Exchange).[2] O Barings tinha uma cadeira na SIMEX havia algum tempo, porém ela só foi ativada com a chegada de Leeson.

A partir de então, Leeson realizou diversas operações especulativas que, no início, chegaram a gerar ganhos da ordem de £10 milhões, o equivalente a 10% dos ganhos anuais da Barings. Nick recebeu um bônus de £130 mil em seu salário de £50 mil.

Sua sorte, no entanto, mudou de lado, e ele começou a utilizar uma das contas de erros do Barings (contas utilizadas para corrigir erros de negociação) para esconder suas perdas. Ele criou a conta 88888 – um número considerado de “extrema sorte” na numerologia chinesa. Leeson alegou que a conta foi usada pela primeira vez para esconder um erro cometido por uma de suas funcionárias, chamada Kim: nervosa com a gritaria no balcão de operações, Kim vendeu 20 contratos, ao invés de comprar, causando um prejuízo de £20 mil ao Barings.

No entanto, Leeson acabou utilizando a conta para encobrir outras operações mal-sucedidas. Ele disse que nunca a utilizou em benefício próprio, mas no ano de 1996, o New York Times noticiou investigações sobre contas em vários bancos, todas associadas a Leeson, totalizando 35 milhões de dólares.

A gerência do Barings em Londres ainda permitiu que Leeson acumulasse as funções de operador-chefe e operador comum, funções que normalmente seriam ocupadas por duas pessoas diferentes, tornando a tarefa de enganar a alta administração do Barings ainda mais simples.

A queda

No final do ano de 1992, as perdas da conta 88888 totalizavam £2 milhões, chegando a £208 milhões ao final de 1994.

O começo do fim aconteceu no dia 16 de janeiro de 1995, quando Leeson executou uma operação apostando que o mercado japonês não mudaria de tendência até o dia seguinte. No dia seguinte, um terremoto atingia a cidade japonesa de Kobe, jogando abaixo os mercados asiáticos. Ele tentou recuperar suas perdas realizando uma série de operações severamente arriscadas, desta vez apostando numa rápida recuperação do Nikkei. A recuperação não veio, e tudo o que Leeson fez foi cavar um buraco ainda mais fundo.

O Barings declarou insolvência no dia 26 de fevereiro de 1995. Leeson viajou para a Malásia, para a Tailândia e acabou sendo preso na Alemanha. No dia 2 de março de 1995, foi extraditado para Singapura, enquanto sua esposa Lisa recebeu permissão para voltar a Londres. Leeson foi acusado somente pelos crimes de fraude que cometeu no cargo de operador-chefe, pois todas as suas transações eram autorizadas por seus superiores. Inúmeros estudiosos do caso, e até o próprio Leeson, puseram a maior parte da culpa pelo ocorrido no próprio Barings, cuja auditoria havia cometido inúmeras falhas. As próprias autoridades de Singapura alegaram que os superiores de Leeson deveriam saber da existência da conta 88888.

Condenado a seis anos e meio de cadeia, Leeson foi solto em 1999, com um câncer no cólon recém-diagnosticado, e ao qual sobreviveu – e sobrevive até os dias de hoje.

Leeson escreveu sua autobiografia na prisão, dando ao livro o título de Rogue Trader (Especulador), publicando-o em 1996. A crítica do New York Times sobre o livro dizia que ele “(…) deveria ser lido por banqueiros e auditores de todo o planeta”. No ano de 1999, o livro virou filme, com Ewan McGregor no papel de Leeson.

Leeson hoje

Leeson vive em Barna, oeste da Irlanda. Lisa, a mulher com quem era casado durante seus anos como operador em Singapura, pediu divórcio e se casou novamente. O Barings foi comprado pelo banco holandês ING pela simbólica quantia de £1.

Em junho de 2005, Leeson lançou um novo livro, Back from the Brink: Coping with Stress.

 

Publicações

Fonte: https://pt.wikipedia.org/wiki/Nick_Leeson