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/

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

Instalando o Nota Fiscal de Serviços Eletrônica (NFS-e) a partir dos fontes no Linux

 

A Nota Fiscal de Serviços Eletrônica possui integração com entes públicos que utilizam o sistema e-Cidade, gerando cobranças automáticas no momento da emissão de guias e facilitando o processo de fiscalização. Além disso, o produto permite a integração com outros sistemas de gestão pública, visando sempre atender às necessidades dos nossos clientes.

1. Instalação do Ubuntu Server 16.04.x LTS

O Ubuntu Server é a versão do sistema operacional da Canonical voltada para servidores. Como o uso em servidores exige um tempo maior de suporte, a versão indicada para o uso com esta documentação é a Ubuntu Server 16.04.x LTS.

1.1 Obtendo a mídia de instalação

A mídia de instalação pode ser obtida diretamente do site da Canonical e gravada em CD, DVD ou pendrive. No site http://www.ubuntu.com/download/server esta disponível a versão mais recente, mas utilizaremos a versão 16.04.x LTS disponível em http://releases.ubuntu.com/xenial/ (ubuntu-16.04.2-server-amd64.iso) por questões de compatibilidade com o produto.

1.2 Instalando o Ubuntu Server 16.04.x LTS

O processo de instalação do sistema operacional não é coberto por esta documentação, mas recomendamos a instalação mínima padrão, em “pt_BR” Português do Brasil, somente com os softwares “standard system utilities” e “OpenSSH server”.

Dica: Maiores informações sobre a instalação e personalização do sistema operacional podem ser obtidas em:
https://help.ubuntu.com/16.04/serverguide/

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 “nano”, mas você pode usar qualquer outro editor de texto de sua preferência.

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

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 NFS-e.

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 apt, que nos prove as últimas atualizações dos pacotes requeridos através de um canal seguro e confiável.

2.1.1 Crie o arquivo pgdg.list através dos comandos abaixo.
[linux]$ sudo touch /etc/apt/sources.list.d/pgdg.list
[linux]$ echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Dica: Mais informações sobre a configuração do repositório podem ser obtidas em:
https://www.postgresql.org/download/linux/ubuntu/

2.1.2 Baixe e importe a chave de assinatura do repositório através do comando:
[linux]$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv ACCC4CF8

Dica: Mais informações sobre o gerenciador de pacotes “apt” podem ser obtidas em:
https://help.ubuntu.com/16.04/serverguide/package-management.html

2.2 Ajustando o idioma

Atenção: Este procedimento só é necessário se você não instalou o sistema operacional em “pt_BR” – Português do Brasil.

[linux]$ sudo apt -y install language-pack-gnome-pt language-pack-pt-base myspell-pt myspell-pt-br wbrazilian wportuguese

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]$ sudo apt update
[linux]$ sudo apt -y install postgresql-9.5 postgresql-client-9.5 postgresql-contrib-9.5

2.4 Criando e configurando o cluster

O NFS-e utiliza encoding UTF-8 no cluster do PostgreSQL 9.5.x. Por isso vamos parar, remover e recriar o cluster quer será utilizado pela aplicação.

Atenção: O NFS-e não pode ser instalado no mesmo cluster dos demais produtos como: e-cidade, e-cidadeonline, etc. A codificação utilizada pelo NFS-e é UTF-8, enquanto que nos outros produtos é LATIN1!

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 parar o cluster criado pelo processo de instalação do PostgreSQL através do comando:
[linux]$ sudo pg_dropcluster --stop 9.5 main
2.4.2 Vamos criar o novo cluster do banco de dados como LATIN1 usando o comando:
[linux]$ sudo pg_createcluster -u postgres -g postgres -e UTF8 --locale="pt_BR.UTF-8" --lc-collate="pt_BR.UTF-8" 9.5 nfse
2.4.3 Para permitir o acesso de qualquer local ao banco de dados é necessário modificar o arquivo /etc/postgresql/9.5/nfse/pg_hba.conf usando o comando:
[linux]$ sudo nano /etc/postgresql/9.5/nfse/pg_hba.conf

Localize e altere as linhas do arquivo do arquivo de configuração que não estão comentadas (# na frente da linha), substituindo os valores correspondentes por trust, conforme a tabela abaixo.

local all postgres
local all all
host all all 127.0.0.1/32
host all all ::1/128
2.4.4 Para a correta integração com o NFS-e, é necessário alterar algumas configurações do cluster criado através do comando:
[linux]$ sudo nano /etc/postgresql/9.5/nfse/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
2.4.5 Inicie o servidor PostgreSQL através do comando:
[linux]$ sudo systemctl start postgresql.service
2.4.6 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 | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      |
 template0 | postgres | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres
 template1 | postgres | UTF8        | pt_BR.UTF-8      | pt_BR.UTF-8      | =c/postgres          +
           |          |             |                  |                  | postgres=CTc/postgres

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

Vamos criar os usuários necessários para o funcionamento do NFS-e 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 nfse WITH SUPERUSER LOGIN PASSWORD 'nfse';"

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

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

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]$ sudo apt -y install apache2

3.2 Configurando a diretiva VirtualHost

3.2.1 Faça uma cópia de segurança do arquivo de configuração padrão, que é criado pelo Apache durante o processo de instalação através do comando:
[linux]$ sudo cp -a /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/000-default.conf.dist
3.2.2 Para a correta integração com o NFS-e, é necessário adicionar alguns parâmetros ao arquivo de configuração do VirtualHost através do comando:
[linux]$ sudo nano /etc/apache2/sites-available/000-default.conf

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

Adicione as linhas que não existirem e edite as existentes dentro do bloco VirtualHost, conforme é exibido abaixo.

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html/nfse/public

  SetEnv APPLICATION_ENV "production"
  SetEnv no-gzip 1

    <Directory /var/www/html/nfse/public>
        DirectoryIndex index.php
        Options -Indexes +FollowSymLinks +MultiViews
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error-nfse.log
    CustomLog ${APACHE_LOG_DIR}/access-nfse.log combined

</VirtualHost>

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

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 e PHP-FPM podem ser obtidas em:
http://www.php.net/ e http://php-fpm.org/

4.1 Configurando o repositório

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

4.1.1 Instale o repositório PPA através dos comandos abaixo.
[linux]$ sudo apt-add-repository -y ppa:ondrej/php
[linux]$ sudo apt update

4.2 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]$ sudo apt -y install php5.6 php5.6-bcmath php5.6-bz2 php5.6-cli php5.6-common php5.6-curl php5.6-gd php5.6-interbase php5.6-json php5.6-mbstring php5.6-mcrypt php5.6-pgsql php5.6-soap php5.6-sqlite3 php5.6-xml php5.6-xmlrpc php5.6-zip php5.6-fpm

4.3 Configurando o PHP 5.6 e o PHP-FPM

4.3.1 Habilitar as dependências de módulos através do comando:
[linux]$ sudo a2enmod proxy_fcgi setenvif rewrite
4.3.2 Habilitar as dependências de configuração através do comando:
[linux]$ sudo a2enconf php5.6-fpm
4.3.3 Configurar o arquivo de log do PHP-FPM através dos comandos:
[linux]$ sudo touch /var/log/php_errors.log
[linux]$ sudo chown www-data.www-data /var/log/php_errors.log
4.3.4 Para a correta integração com o NFS-e, é necessário alterar algumas configurações do PHP através do comando:
[linux]$ sudo nano /etc/php/5.6/fpm/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"

Também é necessário alterar o arquivo de configuração utilizado pelo php-cli através do comando:

[linux]$ sudo nano /etc/php/5.6/cli/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
date.timezone = "America/Sao_Paulo"
4.3.5 Reinicie o serviço do PHP-FPM usando o comando:
[linux]$ sudo systemctl restart php5.6-fpm.service

5. Instalação do NFS-e

5.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-cidadeonline2.completo.Vxxxxxx.tar.bz2.

5.2 Configurando o servidor

5.2.1 Vamos criar um usuário administrativo para o NFS-e, neste exemplo criaremos o usuário dbseller através do comando:
[linux]$ sudo useradd -d /home/dbseller -g www-data -G sudo,adm,cdrom,dip,plugdev -k /etc/skel -m -s /bin/bash dbseller
5.2.2 Em seguida, vamos definir uma senha para este novo usuário usando o comando:
[linux]$ sudo 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/.

5.2.3 Também devemos corrigir a máscara de criação de arquivos modificando os arquivos através dos comandos:
[linux]$ sudo nano /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, edite o arquivo de configuração de variáveis do apache com o comando abaixo:

[linux]$ sudo nano /etc/apache2/envvars

Adicione a linha abaixo no final do arquivo.

umask 002

5.3 Configurando o acesso do webservice no e-cidade

O NFS-e se comunica com o e-cidade através de um webservice, para que essa comunicação seja possível, é necessário liberar o acesso no e-cidade.

5.3.1 Liberando o acesso ao webservice do e-cidade

Após realizar o login no e-cidade, acesse:

  1. Selecione a instituição da prefeitura;
  2. Selecione o módulo DB:Configuração;
  3. Selecione o módulo Configuração;
  4. Selecione o menu Cadastros;
  5. Selecione o menu Cadastro de Acessos ao Sistema;
  6. Selecione o menu Inclusão;

Em seguida, preencha os campos conforme as instruções abaixo:

  1. No campo Data Início, selecione a data de hoje;
  2. No campo Hora Início, informe o valor 08:00;
  3. No campo Data Final, selecione uma data no futuro, como o valor 31/12/2099;
  4. No campo Hora Final, informe o valor 08:00;
  5. No campo Observação, informe o valor Acesso ao webservice pelo NFS-e;
  6. Clique no botão Incluir.

Após incluir o acesso, clique na aba Usuário e selecione no campo Cod. Usuário o usuário que será utilizado para comunicação com o webservice, em seguida, clique no botão Alterar.

Após incluir o usuário, clique na aba IP/Máscara e informe o valor no campo Máscara do IP o endereço IP do servidor do NFS-e que será utilizado para comunicação com o webservice do e-cidade, em seguida, clique no botão Alterar.

5.4 Instalando o NFS-e

5.4.1 Descompacte o pacote do NFS-e através do comando:
[linux]$ tar xjf e-cidadeonline2.completo.Vxxxxxx.tar.bz2
5.4.2 Copie o diretório do NFS-e para o diretório raiz do Apache usando o comando:
[linux]$ sudo cp -r e-cidadeonline2.completo.Vxxxxxx /var/www/html/nfse

5.5 Configurando o NFS-e

5.5.1 Crie o arquivo de configuração da aplicação através do comando:
[linux]$ sudo cp /var/www/html/nfse/application/configs/application.ini.dist /var/www/html/nfse/application/configs/application.ini

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

[linux]$ sudo nano /var/www/html/nfse/application/configs/application.ini

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

...
doctrine.connectionParameters.dbname                    = "nfse"
doctrine.connectionParameters.host                      = "localhost"
doctrine.connectionParameters.password                  = "nfse"
doctrine.connectionParameters.port                      = "5432"
doctrine.connectionParameters.user                      = "nfse"
// Verifique a versão do sistema em /var/www/html/nfse/versao.txt
ecidadeonline2.versao                                   = "V011114"
resources.mail.transport.host                           = "smtp.exemplo.com"
resources.mail.transport.password                       = "nfse@exemplo.com"
resources.mail.transport.port                           = "587"
resources.mail.transport.username                       = "nfse@exemplo.com"
resources.mail.defaultFrom.email                        = "nfse@exemplo.com"
resources.mail.defaultFrom.name                         = "NFS-e Nome da Prefeitura"
settings.application.cache                              = "011114"
webservice.client.uri                                   = "http://url_acesso_ecidade/e-cidade/"
webservice.client.url                                   = "http://url_acesso_ecidade/e-cidade/"
webservice.client.location                              = "http://url_acesso_ecidade/e-cidade/webservices/requisicao.webservice.php"
// md5 do ID do usuário selecionado na regra de acesso do e-cidade
webservice.cliente.user                                 = "c4ca4238a0b923820dcc509a6f75849b"
...
5.5.2 Crie os arquivos de configuração do webservice através dos comandos:
[linux]$ sudo cp /var/www/html/nfse/application/configs/webservice-ecidade.ini.dist /var/www/html/nfse/application/configs/webservice-ecidade.ini

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

[linux]$ sudo nano /var/www/html/nfse/application/configs/webservice-ecidade.ini

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

...
DB_id_usuario          = 'Id do usuário que criou a regra de acesso';
DB_login               = 'Login o usuário que criou a regra de acesso';
DB_ip                  = 'IP de acesso ao servidor do E-cidade';
SERVER_ADDR            = 'IP local do servidor do E-cidade';
SERVER_PORT            = 'Porta local do servidor do E-cidade';
DOCUMENT_ROOT          = 'Diretório raiz do E-cidade ex: /var/wwww';
SERVER_ADMIN           = 'e-mail do administrador do servidor web';
PHP_SELF               = 'webservices/requisicao.webservice.php';
HTTP_HOST              = 'Nome do host do E-cidade ex localhost';
...
[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl

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

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/producao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/producao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/producao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl

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

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/homologacao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/homologacao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/homologacao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

[linux]$ sudo cp /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl.dist /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl

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

[linux]$ sudo nano /var/www/html/nfse/public/webservice/wsdlValidations/integracao/modelo1.wsdl

Em seguida, altere todos os valores {URL}, pela URL do NFS-e conforme o exemplo abaixo.

...
xmlns:ii="http://{URL}/webservice/index/integracao"
...

Um exemplo de como ficaria a configuração, se fosse configurado um nome de domínio no VirtualHost:

...
xmlns:ii="http://nfse.prefeitura.gov.br/webservice/index/integracao"
...

Atenção: Existem diversas linhas que devem ser substituídas, você deve verificar todo o arquivo.

Atenção: Utilize a mesma URL configurada no VirtualHost do apache, ou o endereço IP do servidor.

5.5.3 Ajuste as permissões dos diretórios através dos comandos:
[linux]$ sudo chown -R dbseller.www-data /var/www/html/nfse
[linux]$ sudo chmod -R 775 /var/www/html/nfse

Em seguida, limpe qualquer cache existente através do comando:

[linux]$ sudo rm -rf /var/www/html/nfse/application/data/Proxy/*
5.5.4 Faça a carga do schema do NFS-e através do comando:
[linux]$ cd /var/www/html/nfse
[linux]$ php bin/ruckus.php db:migrate
5.5.5 Reinicie o serviço do Apache usando o comando:
[linux]$ sudo systemctl restart apache2.service

5.6 Acessando o NFS-e

Após finalizar os procedimentos de instalação e configuração, abra um navegador e acesse o NFS-e através do endereço IP ou nome do servidor. EX: http://nfse.prefeitura.gov.br/, utilize como nome de usuário admin, e e como senha 123456.

Atenção: Altere a senha ao realizar o primeiro acesso. Mais informações sobre segurança de senhas podem ser obtidas em: http://cartilha.cert.br/senhas/.

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
nano http://www.nano-editor.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

ALLEN ATLAS CEREBRAL

Visão geral

Esta base de dados de células cerebrais é uma pesquisa de características biológicas derivadas de dados de células únicas, de humanos e ratos.

O banco de dados contém propriedades eletrofisiológicas , morfológicas e transcriptômicas coletadas de células individuais e modelos simulando atividade celular. Nesta fase inicial da geração de dados, a cobertura da pesquisa foi focada em áreas selecionadas do córtex cerebral e nos neurônios talâmicos.

Procure os dados de resposta eletrofisiológica e as morfologias neuronais reconstruídas usando a ferramenta de Pesquisa de Caracteres Celulares . Os dados transcriptômicos podem ser acessados ​​através da página de download .

Use o Kit de Desenvolvimento de Software Allen (SDK) para acessar e analisar programaticamente dados em bruto e executar modelos.

Os dados podem ser baixados selecionando experimentos individuais na ferramenta de Pesquisa de Caracteres de Celular, acessando arquivos RNA-Seq transcriptômicos através da página de Download , ou através do SDK ou API Allen

 

 

 

Dados de rato

As células são adquiridas de áreas cerebrais selecionadas em ratos adultos. As células são identificadas para o isolamento com base em linhas de ratos transgênicos que abrigam repórteres fluorescentes conduzidos por drivers específicos do tipo celular. Para análises eletrofisiológicas e morfológicas, foram selecionadas células excitatórias com expressão enriquecida em camada e células inibitórias baseadas em marcadores clássicos. As áreas cerebrais selecionadas para análise incluem sub-regiões do córtex visual, córtex motor e córtex motor lateral anterior (ALM), na área do motor secundário (MOs).

Para a análise transcriptômica, foram realizadas dissecções regionais e laminares em espécimes de linhas transgênicas pan-neuronais, pan-excitatórias e pan-inibitórias, para amostra de forma abrangente. Os dados do núcleo geniculado lateral (LGd) também estão incluídos.

Este diagrama interativo de Venn mostra quantas células estão disponíveis para cada modalidade de dados (eletrofisiologia, morfologia, transcriptômica) e modelos. Selecione uma categoria para visualizar o subconjunto de células.

Existem 1058 células de mouse para as quais temos dados de eletrofisiologia.

 

 

Dados humanos

As células são adquiridas a partir do tecido cerebral doado nos lobos temporais ou frontais com base em anotações estruturais descritas no Atlas de referência do cérebro humano Allen . Para análises eletrofisiológicas e morfológicas no córtex, as células são selecionadas com base na forma do soma e na localização laminar.

Para a análise transcriptômica, diferentes camadas de córtex são dissecadas e os núcleos neuronais são isolados. A amostragem laminar é guiada pelo número relativo de neurônios presentes em cada camada.

 

 

 

Sobre eletrofisiologia

As gravações de grampos de patch de células inteiras fornecem informações básicas sobre propriedades de disparo celular. As gravações são realizadas usando uma variedade de protocolos de estímulo, incluindo pulsos curtos, passos longos, rampas lentas e ruído naturalista para caracterizar as propriedades intrínsecas desses neurônios. Os protocolos detalhados são descritos no whitepaper técnico de visão geral de eletrofisiologia .

Sobre Morfologia

A estrutura celular informa a função e a diversidade neuronal. Para ver a forma da célula, as células são preenchidas com biocitina e imagens em série para visualizar suas morfologias. Imagens planar e reconstruções de células 3D podem ser visualizadas com os dados de eletrofisiologia da célula, ou baixados para análise off-line. Os protocolos detalhados são descritos no whitepaper técnico da síntese de morfologia .

Sobre Transcriptomics

A seqüência de ARN pode fornecer um perfil transcriptômico para cada célula. Os transcritos genéticos são isolados, amplificados e seqüenciados, e as leituras estão alinhadas com um genoma de referência. A expressão de ARN por gene é relatada como uma média de isoformas de transcrição. Os dados estão disponíveis para células inteiras e, em alguns casos, isolados de frações nucleares. Para os núcleos, uma proporção significativa de lições se alinha aos intrões. Todos os dados podem ser baixados e os protocolos detalhados são descritos no quadro técnico geral da transcriptomics .

Sobre Modelos

Uma variedade de modelos neuronais que simulam propriedades de células intrínsecas estão disponíveis. Os modelos incluem: modelos generalizados de injeção e fogo, modelos biofisicamente realistas, de neurônio único com dendritos passivos e soma ativo (perisomático) e com condutâncias ativas (tudo ativo). As simulações podem ser vistas em linha ao lado das respostas celulares medidas, quando disponíveis. Todos os modelos podem ser baixados, e protocolos detalhados são descritos nos whitepapers técnicos: GLIF , perisomatic , all-active .

 

Fonte:  http://celltypes.brain-map.org/

Como implementar o Blockchain em JavaScript

Ouvimos falar sobre Bitcoin, Ethereum além de outras moedas praticamente todos os dias. 2017 afinal, foi o ano dascryptocurrencies.

Nesse post porém, não vou focar em nenhuma dessas moedas digitais. Mas sim na tecnologia por trás delas, que muitas pessoas dizem ser tão revolucionárias quanto a própria internet, o Blockchain.

A ideia é implementar passo-a-passo uma versão simplificada do Blockchain em JavaScript e ir explicando como essa tecnologia disruptiva funciona por baixo dos panos.

Então, continue lendo esse post para aprender:

  • O que é e como funciona o Blockchain
  • Proof of Work?
  • Pra que servem os Blocos
  • O que é Mineração

Introdução

O Blockchain parece uma tecnologia de outro mundo e gera muitas dúvidas. Apesar disso, é algo extremamente fácil de definir:

O Blockchain nada mais é do que um banco de dados aberto e distribuído.

Esse banco de dados é composto de Blocos. E todos esses Blocos são ligados entre si em uma sequência. Daí o nome, Blockchain (cadeia de blocos).

Além disso, esse banco de dados é imutável.
E faz sentido que seja.

Imagina se fosse possível que alguém intencionalmente modificasse sua conta. Agora os 10 Bitcoins que você possui viraram 1.

Blocos

Vamos começar a implementação pela parte mais fácil: os Blocos. A estrutura de um Bloco deve possuir os seguintes campos:

  • index
  • timestamp
  • hash
  • previousHash
  • data

Crédito: https://medium.com/@lhartikk/a-blockchain-in-200-lines-of-code-963cc1cc0e54

index e o timestamp são campos comuns em praticamente todos bancos de dados. O campo data serve principalmente pra guardar transações mas podemos também colocar outras informações. O hash é calculado internamente e serve pra manter a integridade de cada Bloco e a segurança de todo o sistema (como vamos ver no final do post). E por final, o previousHash é o elo de ligação que liga cada Bloco ao seu Bloco anterior.

Com isso, temos a primeira implementação de um Bloco:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.hash = this.generateHash()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp).toString()
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

A função generateHash usa a biblioteca externa crypto-js pra gerar o hash seguindo o padrão sha256.

Parece complicado, mas tudo o que você precisa saber é que essa função vai receber uma string como por exemplo:

foo

E vai retornar uma string encriptada:

2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae

Blockchain

Agora que já temos uma versão mínima de um Bloco, já podemos começar a construir o Blockchain, que como falei anteriormente é uma sequência de Blocos ligados entre si.

Com isso, essa é a primeira versão do Blockchain:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

No construtor da classe, temos o array de Blocos inicializado já com o Genesis Block (o primeiro bloco criado no registro do Bitcoin). Adicionei também o index para poder incrementar toda vez que um novo Bloco for adicionado no Blockchain.

Além disso duas funções foram criadas:

  • getLastBlock
  • addBlock

A primeira é extremamente simples, ela serve pra pegar o último Bloco que foi criado.

A segunda é uma pouco mais complicada, mas também não é nada de outro mundo. Ela serve pra adicionar novos Blocos ao Blockchain.

Integridade

Apesar de a versão anterior já funcionar razoavelmente bem, precisamos adicionar alguma garantia de que o Blockchain não tenha sido alterado por algum ataque malicioso.

Precisamos adicionar uma nova função para checar a integridade do Blockchain:

isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}

Lembrando que para verificarmos a integridade do Blockchain precisamos garantir três características:

  • hash de cada Bloco foi gerado corretamente
  • index dos Blocos está em sequência
  • Os Blocos estão ligados entre si através dos hashes

Com essa simples função podemos testar se modificações maliciosas foram feitas e se o Blockchain deve ser invalidado:

const Blockchain = require(./blockchain)
const blockchain = new Blockchain()
blockchain.addBlock({ amount: 4 })
blockchain.addBlock({ amount: 50 })
console.log(blockchain.isValid()) // true
blockchain.blocks[1].data.amount = 30000 // ataque malicioso
console.log(blockchain.isValid()) // false

E finalmente com isso já temos uma primeira versão básica e funcional do Blockchain em JavaScript:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

Problemas

Apesar de já termos uma versão inicial funcionando, ainda podemos melhorar bastante a nossa implementação.

Um dos problemas com essa versão atual é que usuários podem criar novos Blocos de forma muito rápida, podendo invalidar o Blockchain, ou coisas ainda piores. Não vou entrar em muitos detalhes dessa particularidade da tecnologia, mas o post abaixo faz um excelente trabalho nesse sentido:

Explaining blockchain — how proof of work enables trustless consensus

Em resumo, precisamos de alguma ferramenta que não permita que usuários possam criar Blocos desenfreadamente.

Proof of Work

O conceito de Proof of Work, como o próprio nome já sugere, é um mecanismo que faz com que um usuário tenha um trabalho computacional significativo ao realizar determinada tarefa.

Essa ferramenta já era utilizada antes do Bitcoin ser inventado para evitar por exemplo spams e ataques DoS.

No Bitcoin, o Proof of Work funciona da seguinte forma: o hash que é gerado automaticamente em cada Bloco deve começar com uma quantidade X de zeros, dependendo da dificuldade geral do sistema.

Por exemplo, se a dificuldade geral do sistema for 1, esse hash é inválido porque não começa com um zero:

a5036427617139d3ad9bf650d74ae43710e36d4f63829b92b807da37c5d38e8d

Porém, esse outro hash é válido porque começa com um zero:

07da8bff6cfea68a3f0a5bafc9b24d07f503e2282db36ffb58d43f9f4857c54b

Sempre que um usuário for criar um novo Bloco, ele vai precisar criar diversos hashes até que um deles tenha a quantidade de zeros no começo fazendo com que a regra geral do sistema seja atendida.

Ah, o nome disso é Mineração.

Lembrando que quanto maior o número de zeros que devem estar no começo do hash, maior o poder computacional necessário para a tarefa.

Dito isso, vamos agora implementar a versão final do Blockchain com a mineração.

Primeiramente vamos alterar os Blocos.

class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
/* */
}
view rawblock.js hosted with ❤ by GitHub

No construtor, adicionamos os campos difficulty (dificuldade geral do sistema) e nonce (quantidade de tentativas até que o hash correto seja criado). Além disso, temos também um chamada para a função mine.

mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
view rawblock.js hosted with ❤ by GitHub

A função mine vai criar hashes até que a quantidade de zeros à esquerda do hash seja atentida.

Lembrando que para que os hashes criados sejam diferentes, devemos adicionar o campo nonce na função generateHash:

generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
view rawblock.js hosted with ❤ by GitHub

Com isso temos a versão final do Blocos com a mineração:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

Agora basta alterarmos o Blockchain para que o campo difficulty seja passado para os Blocos:

const Block = require(./block)
class Blockchain {
constructor(difficulty = 1) {
this.blocks = [new Block()]
this.index = 1
this.difficulty = difficulty
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const difficulty = this.difficulty
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data, difficulty)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

E é só isso 🙂

Lembrando que o código está todo no GitHub.

Ah, se você quiser saber mais sobre o Blockchain:

Outras implementações:

Fonte: https://tableless.com.br/como-implementar-blockchain-em-javascript/?utm_source=tablelessRelatedLink

Web Speech API – Reconhecimento de voz com JavaScript

Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

O reconhecimento de voz tem várias aplicações no mundo real. Muitas pessoas tornaram-se familiarizadas com este conceito graças a softwares como o Siri e S-Voice. Esta aplicação pode melhorar drasticamente a usabilidade dos websites, principalmente para deficientes visuais. Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

 

 

O que é Web Speech API?

A Web Speech API foi lançada no final de 2012 e permite que os desenvolvedores forneçam a entrada de voz e recursos de saída de texto-para-voz em um navegador web. Esta API cuida da privacidade dos usuários, pois antes de deixar o site para acessar a voz através do microfone, o usuário deve explicitamente conceder a permissão. Curiosamente, o pedido de autorização é o mesmo que a API getUserMedia, apesar de não precisar da webcam. Se a página que executa esta API usa o protocolo HTTPS, o navegador solicita a permissão apenas uma vez.

 

 

Então veremos logo abaixo, um exemplo básico de como podemos implementar esta nova API aos nossos projetos:

Criando a primeira página com reconhecimento de voz:

Passo 1 – Estrutura HTML:

A estrutura HTML é bem simples, vejamos a marcação abaixo:

<p id="ola">Olá tableless, você falou:</p>

<button id=”rect”>Gravar</button> <span id=”unsupported” class=”hidden”>API not supported</span>

Onde:

  • Transcription – Onde se encontrará o texto informando oque o usuário falou
  • Rect – Botão para reconhecer a voz do usuário
  • unsupported – Caso a API não seja suportada pelo browser

Passo 2 – Testando

Como qualquer API, temos que verificar primeiramente se o browser suporta SpeechRecognition:

// Test browser support
window.SpeechRecognition = window.SpeechRecognition ||
window.webkitSpeechRecognition ||
null;

//caso não suporte esta API DE VOZ            
if (window.SpeechRecognition === null) {
    document.getElementById('unsupported').classList.remove('hidden');
}else {
    //......
}

Passo 3 – Métodos e propriedades

Depois de testar a compatibilidade da API, iremos instanciar o reconhecedor de  voz, usando o speechRecognition(). Como o código listado abaixo:

var recognizer = new window.SpeechRecognition();

Este objeto expõe os seguintes métodos:

  • onstart: Define um callback que é disparado quando o serviço de reconhecimento começou a ouvir o áudio com a intenção de reconhecer.
  • onResult: Define um callback que é disparado quando o reconhecedor de voz retorna um resultado.
  • onerror: Define um callback que é acionado quando ocorre um erro de reconhecimento de voz.
  • onend: Define um callback que é disparado quando o serviço foi desligado. O evento deve sempre ser gerado quando a sessão termina, não importa o que a razão.

Iremos criar uma varável que será responsável por exibir o texto que o usuário falou e também iremos definir a propriedade continuous = true, que faz com que o reconhecedor de voz não pare de ouvir, mesmo que tenha pausas do usuário.

var transcription = document.getElementById("transcription");

            //Para o reconhecedor de voz, não parar de ouvir, mesmo que tenha pausas no usuario
            recognizer.continuous = true;

Agora iremos definir a função “onresult” que define um callback que é disparado quando o reconhecedor de voz retorna um resultado.

recognizer.onresult = function(event){
                transcription.textContent = "";
                for (var i = event.resultIndex; i < event.results.length; i++) {
                    if(event.results[i].isFinal){
                        transcription.textContent = event.results[i][0].transcript+' (Taxa de acerto [0/1] : ' + event.results[i][0].confidence + ')';
                    }else{
                        transcription.textContent += event.results[i][0].transcript;
                    }
                }
            }

Vamos analisar este código um pouco mais detalhadamente:

transcription.textContent = “”;    Faz com que limpe o texto que se encontra dentro da “

for (var i = event.resultIndex; i < event.results.length; i++) {  Loop que pecorre o evento que contém o texto que o usuário falou.

Note que dentro deste loop, há uma condição, que verifica se o evento se encontra na última posição (event.results[i].isFinal), caso seja verdadeira, ele irá imprimir todo o texto, junto com a taxa de acerto, que vai de “0” até “1”. Caso seja falsa, ele vai adicionar mais texto na nossa div

Passo 4 – Anexando o evento de click

Agora iremos anexar um evento de click, ao nosso botão, segue 0 código abaixo :

document.querySelector("#rect").addEventListener("click",function(){
                try {
                    recognizer.start();
                  } catch(ex) {
                    alert("error: "+ex.message);
                  }
            });

Onde:

recognizer.start(); – Inicia o record ( a gravação );

catch(ex) {

alert(“error: “+ex.message);

} –  tratamento de log, caso exista, algum erro de gravação

É importante observarmos que o reconhecedor demora um pouco para poder interpretar a sua voz, mais ou menos uns 3 à 4 segundos, esta API ainda está em teste e que infelizmente até agora, só é  suportada no chrome,

Finalizando

Bem pessoal, essa foi uma breve introdução sobre Web Speech API. Futuramente irei trazer mais artigo

Disponibilizei o código no github e também disponibilizei uma demo.

Clique aqui para ver a demo online

Clique aqui, para ir ao código completo.

 

Fonte:https://tableless.com.br/web-speech-api-reconhecimento-de-voz-com-javascript/

 

 

 

 

 

Software para Windows de Eugene Muzychenko

Software comercial

Cabo de áudio virtual (VAC)

Driver de multimídia do Windows que cria um ” cabo virtual ” representado por dois dispositivos de forma de onda, entrada e saída, com ligação interna entre eles. Permite transferência de som direta e intocada entre diferentes aplicativos. Útil para gravar a saída de áudio do aplicativo em tempo real e salvar um fluxo de som de saída de aplicativos que não permitem gravá-lo diretamente no arquivo WAV. VAC é uma “versão de onda” do “cabo de loopback MIDI”, como os drivers Loopback do MultiMid ou do Hubi . Ao contrário do Total Recorder, você pode simplesmente salvar o fluxo de áudio, o VAC permite rotear em tempo real.,Foobar2000 , AIMP , Audacity , Audition , Skype , Flex-Radio etc.).

Cabo de áudio virtual 4 páginas (XP / 2k3 / Vista / Win 7/8 / 8.1 / 10)

Cabo de áudio virtual 3 páginas (9x / ME / NT4 / 2k / XP / 2k3)

Software grátis

Wave Clone

Ferramenta multimídia do Windows para compartilhar as portas Wave (MME) entre várias aplicações. Traz um recurso multi-cliente para qualquer dispositivo Wave. O Wave Clone é uma “versão de onda” dos “complementos de múltiplos clientes MIDI”, como os drivers de Loopback do MultiMid ou do Hubi .

Página Wave Clone (9x / ME / NT4 / 2k / XP / 2k3)

 

Manuais MIDI

Permite dividir seu teclado MIDI em dois manuais independentes (zonas), atribuir-lhes diferentes instrumentos MIDI e tocar as duas mãos ao mesmo tempo, produzindo peças de duas partes. Você não pode fazer isso usando um software de sequenciador popular.

Página de Manuales MIDI  (todos os sistemas)

 

FlushVol

Utilitário para liberar, uma vez ou periodicamente, buffers de arquivos de volume. Funciona como sync.exe de Mark Russinovich, mas enumera todos
os volumes fixos, incluindo montado em NTFS Mount Points . Pode ser instalado como um serviço para iniciar automaticamente e liberar buffers de volume com uma interfal dada.

Baixe FlushVol 1.4.2 (2k / XP / 2k3 / Vista / Win7 / 8/10 )

 

mscetool

O mscetool opera com o arquivo de cabeçalho MSCE dos arquivos WinCE CAB (um arquivo com extensão .000 que descreve o processo de instalação). O principal objetivo desse utilitário é mudar a arquitetura e / ou os campos do número de versão do WinCE no cabeçalho. Existem muitos programas que podem funcionar sob versões específicas do WinCE, mas são distribuídos em arquivos CAB com uma arquitetura forte e os números de versão mínima / máxima especificados.

Faça o download do mscetool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

b000fftool

O b000fftool opera com arquivos de imagem gravados MS B000FF (MSBIN) contendo imagens do Windows CE / ROM móvel. Pode ser útil para corrigir valores de endereço de carga incorretos em imagens CE6 BIN produzidas por BOOOFF, XipPort, Remaker e ferramentas similares.

Baixe o b000fftool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

tcctoolce

O tcctoolce executa algumas operações específicas para os dispositivos baseados em CPU ARCH da Telechips sob o WinCE (apenas a implementação de imagens instantâneas está implementada).

Baixe tcctoolce 1.0.1 (WinCE 4.2 ou superior)

 

TaskbarControlCE

TaskbarControlCE destina-se a controlar a aparência da barra de tarefas do Explorer em caso de alternar entre janelas normais e em tela cheia. Inicialmente desenvolvido para a estação multimídia do carro Createc / Joy-J-2619.

Baixar TaskbarControlCE 1.0.1 (WinCE 4.2 ou superior)

 

Driver SiLabs CP210x VCP para WinCE 4.2

Um driver VCP (Virtual Communication Port) para CP210x (CP2101, CP2102, CP2103, CP2104), chips USB para Serial Bridge fabricados pela Silicon Laboratories (anteriormente Cygnal). O driver cria COMn: porta serial virtual disponível para qualquer aplicativo de comunicação serial (emuladores de terminal, software de navegação GPS, etc.).

O driver funciona apenas em CPUs ARMV4 no Windows CE 4.2 (por exemplo, Windows Mobile 2003 SE ou Pocket PC 2003). Os drivers do CE 5.0 e 6.0 estão disponíveis no site do SiLabs .

Baixe cp210xvcp_ce42_2_0_1_0 (CE 4.2)

 

shrinkvd

shrinkvd é um utilitário de linha de comando para encadear arquivos de disco virtual VMware pré-alocados de acordo com um espaço realmente ocupado por partições. Útil para otimizar os hóspedes do Vista / Win7 / Win8.

Baixar shrinkvd 1.2 (todos os sistemas PC Windows)

 

pegue a senha

getpassword é um utilitário de linha de comando para solicitar uma senha do teclado, escondendo a entrada e retornando via saída padrão (por exemplo, para um arquivo de comando / lote).

Baixe o getpassword 1.0 (todos os sistemas PC Windows)

 

getfileinfo

getfileinfo é um utilitário de linha de comando para extrair e imprimir várias informações de arquivo (data, hora, versão, especificação). Os resultados da versão do arquivo podem ser úteis para criar nomes de arquivos versionados. Os qualificadores de especificação de arquivo podem ser úteis para extrair substituição de argumento de unidade, caminho, nome e extensão, como o processador de lote (cmd.exe), mas sem expandir caracteres curiosos para nomes de arquivos existentes. As peças de especificação extraídas contendo curingas podem ser usadas para processamento posterior de arquivos.

Baixe o getfileinfo 1.9 (todos os sistemas PC Windows)

 

MixerInfo

MixerInfo mostra todas as informações sobre um mixer de áudio fornecido.

Baixar MixerInfo (com código fonte)

 

ArrangeChildren

ArrangeChildren destina-se a organizar várias janelas filho na área de cliente da janela MDI do aplicativo. Ele pode ser usado para arrumar janelas de projeto em IDEs (ambientes de desenvolvedores integrados), como Visual Studio , Sound Forge , Photoshop e outros.

Download ArrangeChildren 1.00

Baixe ArrangeChildren 1.04

 

CopyFileFragm

CopyFileFragm é um utilitário de console destinado a manipular fragmentos de arquivos binários e expandir / encolher arquivos. Pode extrair um fragmento de arquivo para outro arquivo ou stdout, escrever um fragmento em outro arquivo no lugar, substituir / expandir arquivos etc.

Baixar CopyFileFragm 1.11

 

copywobuf

copywobuf é um utilitário de linha de comando do console que copia um arquivo (sem curingas), abrindo arquivos de origem e de destino com
FILE_FLAG_NO_BUFFERING para impedir o armazenamento em cache de arquivos. É útil copiar arquivos de / para pastas compartilhadas em convidados da VMware para evitar o bloqueio do arquivo host pelo processo vmware-vmx.exe.

Baixe copywobuf 1.3

 

waveinfo

waveinfo é um utilitário de linha de comando do console que mostra informações sobre arquivos RIFF / WAVE (.wav).

Baixe o waveinfo 1.3

VMWRefresh

O VMWRefresh permite que você use o SoftICE 3.x ou 4.x no Windows 2000 / XP executado no VMWare 4.5.1 forçando a janela de convidado do VMWare a atualizar periodicamente.

Faça o download do VMWRefresh 1.04

 

picoc para Win32

Picoc é um intérprete de linguagem C muito pequeno, projetado para sistemas baseados em UNIX. Existe uma porta para Win32 (x86 / x64).

Baixar picoc para Win32 2,2 m

 

RASPPPoE 0.98b patch de tempo limite

Um patch para os drivers do protocolo RASPPPeE escrito por Robert Schlabbach . Aumenta RASPPPoE tempo limite para 120..150 segundos para permitir sessão PPP a persistir durante a reconexão modem DSL.

Baixe o patch de tempo limite RASPPPo 0.98b

 

Fonte: http://software.muzychenko.net/eng/

DNALinux – Uma solução Linux para Bioinformática

Programas de bioinformática incluídos no DNALinux

 

 

O ApE- A Plasmid Editor
Funciona no Windows (testado em 98, XP, NT), OS X (10.3, 10.4 e 10.5) e Linux / Unix, destaca sites de restrição na janela de edição, mostra tradução, Tm,% GC, ORF de DNA selecionado em tempo real, lê os arquivos DNA Strider, Fasta, Genbank e EMBL, copiar e salvar gráficos como metarquivos do Windows (somente MS Windows) em outros recursos. Para mais informações, visite o website.

Web site: http://www.biology.utah.edu/jorgensen/wayned/ape/

Outros documentos:

Citação:

AutodockSuite 4.0.1

AutoDock é um conjunto de ferramentas de encaixe automatizadas. Ele é projetado para prever como pequenas moléculas, como substratos ou medicamentos candidatos, se ligam a um receptor de estrutura 3D conhecida. O AutoDock consiste de dois programas principais: AutoDock executa o encaixe do ligando para um conjunto de grades descrevendo a proteína alvo; O AutoGrid pré-calcula essas grades. Além de usá-los para encaixe, as redes de afinidade atômica podem ser visualizadas. Isso pode ajudar, por exemplo, a orientar químicas sintéticas orgânicas para designar melhores aglutinantes.

Web site: http://autodock.scripps.edu/

Outra documentação:

Citação: Morris GM, Goodsell DS, Huey R, Olson AJ. Distribuição automated docking de ligandos flexíveis para proteínas: aplicações paralelas do AutoDock 2.4. J Comput Aided Mol Des. 1996 Ago; 10 (4): 293-304. Pubmed


O Biopython é um conjunto de ferramentas livremente disponíveis para computação biológica escrita em Python por uma equipe internacional de desenvolvedores.
É um esforço colaborativo distribuído para o desenvolvimento de bibliotecas e aplicações Python que abordam as necessidades dos trabalhos atuais e futuros em bioinformática. O código fonte está disponível sob a licença Biopython, que é extremamente liberal e compatível com quase todas as licenças do mundo. Trabalhamos junto com a Open Bioinformatics Foundation, que generosamente fornece espaço na web e CVS para o projeto.

Web site: www.biopython.org

Outra documentação: Bassi S (2007) A Primer on Python for Life Science Researchers. PLoS Comput Biol 3 (11): e199. doi: 10.1371 / journal.pcbi.0030199 
Python para Bioinformáticalivro de Sebastian Bassi

Citação: Cock PJ, Antao T, Chang JT, Chapman BA, Cox CJ, Dalke A, Friedberg I, Hamelryck T, Kauff F, Wilczynski B e Hoon MJ. Biopython: ferramentas Python livremente disponíveis para biologia molecular computacional e bioinformática. Bioinformática 2009 1 de junho; 25 (11) 1422-3. doi: 10.1093 / bioinformática / btp163 pmid: 19304878. Pubmed

 

Blast 2.2.20

A Ferramenta de Pesquisa de Alinhamento Local Básico (BLAST) encontra regiões de similaridade local entre sequências. O programa compara sequências de nucleotídeos ou proteínas para bases de dados de sequências e calcula a significância estatística dos fósforos. O BLAST pode ser usado para inferir relações funcionais e evolutivas entre sequências, bem como ajudar a identificar membros de famílias de genes.

Site: http://blast.ncbi.nlm.nih.gov/

Outros documentos:

Citação: Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer, Jinghui Zhang, Zheng Zhang, Webb Miller e David J Lipman (1997), “Gapped BLAST e PSI-BLAST: uma nova geração de programas de pesquisa de banco de dados de proteína”, Nucleic Acids Res. 25: 3389-3402.

 

ClustalX

Alinhamento múltiplo de sequências de ácido nucleico e proteína.
Clustal X é uma interface do Windows para o programa de alinhamento de sequências múltiplas ClustalW. Ele fornece um ambiente integrado para realizar alinhamentos múltiplos de seqüências e perfis e analisar os resultados. O alinhamento da seqüência é exibido em uma janela na tela. Um esquema de coloração versátil foi incorporado, permitindo destacar os recursos conservados no alinhamento. Os menus pull-down na parte superior da janela permitem selecionar todas as opções necessárias para o alinhamento de múltiplas sequências e perfis tradicionais.

Site: http://www.clustal.org/

Outros documentos:

Citação: Jeanmougin, F., Thompson, JD, Gouy, M., Higgins, DG e Gibson, TJ (1998) Alinhamento de seqüências múltiplas com Clustal X. Tendências Biochem Sci, 23, 403-5.

 

O EMBOSS é “A Suite Européia de Software de Biologia Molecular Européia”. O EMBOSS é um pacote gratuito de análise de software de código aberto especialmente desenvolvido para as necessidades da comunidade de usuários de biologia molecular (por exemplo, EMBnet). O software lida automaticamente com dados em uma variedade de formatos e até permite a recuperação transparente de dados de sequência da web. Além disso, à medida que as extensas bibliotecas são fornecidas com o pacote, é uma plataforma para permitir que outros cientistas desenvolvam e liberem softwares com um verdadeiro espírito de código aberto. O EMBOSS também integra uma série de pacotes e ferramentas atualmente disponíveis para a análise de seqüências em um todo sem costura. O EMBOSS quebra a tendência histórica para pacotes de software comercial.

Web site: www.emboss.org

Outra documentação:

Citação: Arroz, P. Longden, eu. e Bleasby, A. EMBOSS: The European Molecular Biology Open Software Suite (2000) Tendências em Genética 16, (6) pp276-277.

 

EMNU-1.05
emnu exibe um menu simples baseado em caracteres que permite que você exiba os nomes dos programas em relevo e selecione-os. Ele também exibe os nomes dos arquivos em seu diretório atual e permite exibir seus conteúdos, copiá-los, excluí-los e fazer outras coisas com eles. Emnu permite mover os menus de programas ou arquivos usando as teclas de seta. Pressionando RETURN quando você selecionou um item executará um programa ou exibirá um arquivo.

Web site: http://web.mit.edu/emboss_v4.0.0/www/embassy/emnu/emnu.html

Outros documentos:

Citação:

ESIM4-1.0.0
Alinhar um mRNA a um

site de sequência de DNA genômico : http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/esim4/esim4.html

Outros documentos:

Citação: Florea L, Hartzell G, Zhang Z, Rubin GM, Miller W. “Um programa de computador para alinhar uma sequência de cDNA com uma sequência de DNA genômico”. Genoma Res 1998 Sep; 8 (9): 967-74

 

FinchTV – Visualizador de rastreamento de cromatografia de sequência de DNA. 
O utilitário FinchTV para visualização de arquivos de cromatograma é um aplicativo autônomo que os pesquisadores usam para visualizar e editar facilmente seus dados de seqüência com interatividade dinâmica.

Web site: http://www.geospiza.com/Products/finchtv.shtml

Outros documentos:

Citação:

HMMER-2.3.2 Os
modelos escondidos do Markov do perfil (HMMs do perfil) podem ser usados ​​para fazer pesquisa de banco de dados sensível usando descrições estatísticas do consenso de uma família de seqüência. HMMER é uma implementação livremente distribuível do software HMM de perfil para análise de seqüência de proteínas.

Web site: http://hmmer.janelia.org/

Outra documentação:

Citação: A teoria por trás do perfil HMMs: R. Durbin, S. Eddy, A. Krogh e G. Mitchison, análise de seqüência biológica: modelos probabilísticos de proteínas e ácidos nucleicos, Cambridge University Press, 1998. IPRSCAN-4.3.1 Web site: documentação adicional: Citação:

Kalign 2.03
Kalign é uma ferramenta de linha de comando para realizar o alinhamento múltiplo de seqüências biológicas. Ele emprega o algoritmo Wu-Manber string-matching, para melhorar tanto a precisão quanto a velocidade do alinhamento. Ele usa abordagem de alinhamento global e progressivo, enriquecendo empregando um algoritmo aproximado de correspondência de cadeias para calcular distâncias de seqüência e incorporando combinações locais no alinhamento de outra forma global. Nas comparações feitas por seus autores, Kalign era cerca de 10 vezes mais rápido do que o ClustalW e, dependendo do tamanho do alinhamento, até 50 vezes mais rápido do que os métodos iterativos populares.

Web site: http://msa.sbc.su.se/cgi-bin/msa.cgi

Outra documentação:

Citação: Timo Lassmann e Erik LL Sonnhammer. Kalign – um algoritmo de alinhamento de sequências múltiplo preciso e rápido. BMC Bioinformatics 2005, 6: 298doi: 10.1186 / 1471-2105-6-298

MEMENEW-0.1.0 Web site de
detecção de motivos

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/memenew/ememe.html

MIRA-2.8.2
O assembler do fragmento mira genome é um montador especializado para projetos de seqüenciamento classificados como “difíceis” devido ao alto número de repetições similares. Para transcrições de EST, miraEST é especializada na reconstrução de transcritos de ARNm prístinos enquanto detecta e classifica polimorfismos de nucleotídeos únicos (SNP) ocorrendo em diferentes variações.
O sistema de montagem está usando estratégias multipassos iterativas centradas no uso de regiões de alta confiança dentro de seqüências e tem uma estratégia de retorno para usar regiões de baixa confiança quando necessário.

Site: http://chevreux.org/projects_mira.html

 

MSE-1.0.0 Web site do 
Editor de Sequências Múltiplas

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/mse/mse.html

 

MYEMBOSS-6.0.0 O
MYEMBOSS fornece uma estrutura de diretório e stubs de makefile para desenvolver suas próprias aplicações mais facilmente do que em versões anteriores a 3.0.0.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/myemboss/

 

NCBI Toolkit

O NCBI Toolkit é uma coleção de utilitários desenvolvidos para a produção e distribuição do GenBank, Entrez, BLAST e serviços relacionados pelo Centro Nacional de Informação Biotecnológica. Inclui as ferramentas populares de bioinformática formatdb e blastall.

Web site: http://www.ncbi.nih.gov/IEB/ToolBox/SDKDOCS/INDEX.HTML

 

Polyxmass 0.9.7

PHYLIP (o pacote de inferência PHYLogeny) é um pacote de programas para inferir filogenias (árvores evolutivas). Está disponível gratuitamente na Internet e escrito para trabalhar em tantos tipos diferentes de sistemas de computador quanto possível.
Felsenstein, J. 2005. PHYLIP (Phylogeny Inference Package) versão 3.6. Distribuído pelo autor. Departamento de Ciências do Genoma, Universidade de Washington, Seattle.

Web site: http://evolution.gs.washington.edu/phylip.html

 

polyxmass é um conjunto de software para espectrometria de massa (bio) de polímero que é o Software Livre desenvolvido no GNU / Linux. Permite a definição de química de polímeros e a simulação / análise de dados espectrométricos de massa obtidos em (bio) polímeros.

Citação: Filippo Rusconi, GNU polyxmass: uma estrutura de software para simulações de espectrometria de massa de analitos lineares (bio-) poliméricos. BMC Bioinformatics 2006, 7: 226doi: 10.1186 / 1471-2105-7-226

 

Primer3 1.1.4 / Primer3plus (GUI da Web para primer3) O 
Primer3 é um programa amplamente utilizado para projetar iniciadores de PCR (PCR = “Reação em Cadeia de Polimerase”). O PCR é uma ferramenta essencial e omnipresente em genética e biologia molecular. O Primer3 também pode projetar sondas de hibridação e iniciadores de seqüenciamento.

Web site: http://primer3.sourceforge.net/

Outra documentação:

Citação: Rozen S, Skaletsky H (2000) Primer3 na WWW para usuários em geral e para programadores biologicos. Em: Krawetz S, Misener S (eds) Métodos e Protocolos de Bioinformática: Métodos em Biologia Molecular. Humana Press, Totowa, NJ, pp 365-386

 

Pymol 1.0r2 O
PyMOL é um sistema de visualização molecular de código aberto, criado por Warren Lyford DeLano e comercializado pela DeLano Scientific LLC, que é uma empresa de software privada dedicada à criação de ferramentas úteis que se tornam universalmente acessíveis para comunidades científicas e educacionais.

Site: http://www.pymol.org/

 

Rasmol 2.7.3.1
RasMol é um programa de gráficos moleculares destinado à visualização de proteínas, ácidos nucleicos e moléculas pequenas.

Site: http://www.rasmol.org/

 

 

readseq 1.7
Lê e grava seções nucleicas / proteínas em vários formatos. Os arquivos de dados podem ter múltiplas seqüências.

 

Sigma Align 1.1.1
A maioria das ferramentas para o alinhamento de sequências múltiplas são focadas no alinhamento da seqüência de proteínas ou da sequência de DNA que codifica a proteína. Sigma (“Alinhamento múltiplo codicioso simples”) é um programa de alinhamento com um novo algoritmo e esquema de pontuação projetado especificamente para seqüência de DNA não codificante.

Site: http://www.imsc.res.in/~rsidd/sigma/

Outros documentos:

Citação: Rahul Siddharthan, “Sigma: alinhamento múltiplo de sequências de DNA não codificantes fracamente conservadas”, BMC Bioinformatics 7: 143 ( 2006). Pubmed

 

SIGNATURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/signature/

 

STRUCTURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/structure/

 

TREEFINDER calcula árvores filogenéticas a partir de seqüências moleculares. O programa infere árvores mesmo grandes por máxima probabilidade sob uma variedade de modelos de evolução de seqüência. Ele aceita dados de nucleotídeos e aminoácidos e leva em consideração a heterogeneidade da taxa. Modelos separados podem ser assumidos para partições de dados definidas pelo usuário, taxas separadas, comprimentos de borda separados, composições de caracteres separadas. Todos os parâmetros podem ser estimados a partir dos dados. A pesquisa de árvores pode ser guiada por restrições topológicas fornecidas pelo usuário e iniciar árvores.

Web site: http://www.treefinder.de/

Outros documentos: o manual está disponível em formato pdf .

Citação: Jobb, G., A. von Haeseler e K. Strimmer. TREEFINDER: Um poderoso ambiente de análise gráfica para filogenética molecular. 2004. BMC Evolutionary Biology. Pubmed

 

TreeView 0.5.1
TreeView fornece uma maneira simples de ver o conteúdo de um arquivo de árvore de formato NEXUS, PHYLIP, Hennig86, Clustal ou outro formato. Enquanto PAUP e MacClade possuem excelentes instalações de impressão de árvores, pode haver momentos em que você só deseja ver as árvores sem ter que carregar o conjunto de dados de que foram geradas. O pacote PHYLIP contém programas de desenho de árvores que oferecem uma maior variedade de árvores que o TreeView, mas são um tanto desgastantes de usar. O próximo PAUP * para Windows não possui uma interface gráfica, portanto, o TreeView permite que você crie árvores de qualidade de publicação a partir de arquivos PAUP, diretamente ou gerando arquivos gráficos para edição por outros programas.

Web site: http://taxonomy.zoology.gla.ac.uk/rod/treeview.html

Outra documentação:

Citação: Page, RDM 1996. TREEVIEW: uma aplicação para exibir árvores filogenéticas em computadores pessoais. Aplicações informáticas nas Biociências 12: 357-358.

 

 

TOPO-1.0.0
TOPO cria uma imagem de uma proteína transmembranar.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/topo/topo.html

 

Vienna RNA 1.8.25

O Vienna RNA Package consiste em uma biblioteca de código C e vários programas autônomos para a predição e comparação de estruturas secundárias de RNA.
A predição da estrutura secundária do RNA através da minimização de energia é a função mais utilizada na embalagem. Nós fornecemos três tipos de algoritmos de programação dinâmica para a predição da estrutura: o algoritmo mínimo de energia livre de (Zuker & Stiegler 1981) que produz uma única estrutura ótima, o algoritmo de função de partição de (McCaskill 1990) que calcula as probabilidades de pares de bases no conjunto termodinâmico, e o algoritmo de dobragem sub-óptimo de (Wuchty et.al 1999) que gera todas as estruturas sub-ótimas dentro de uma determinada faixa de energia da energia ideal. Para a comparação de estrutura secundária, o pacote contém várias medidas de distância (dissimilaridades) usando o alinhamento de cordas ou a edição de árvores (Shapiro & Zhang, 1990). Finalmente, fornecemos um algoritmo para projetar seqüências com uma estrutura predefinida (dobra inversa).

Web site: http://www.tbi.univie.ac.at/RNA/

Outros documentos:

Citação: Ivo L. Hofacker, Walter Fontana, Peter F. Stadler, L. Sebastian Bonhoeffer, Manfred Tacker e Peter Schuster. Folding Rápido e Comparação de Estruturas Secundárias de RNA. Apareceu em: Monatsh.Chem. 125: 167-188 (1994).

 

 

Faça o download do DNALinux

DNALinux Virtual Desktop. Python for Bioinformatics Edition (NOVO! Jun 2009)

Instruções de instalação

  1. Baixe o arquivo torrent .
  2. Faça o download do DNALinux usando o torrent com um programa compatível com bittorrent como “Bittorrent”, Bittorrnado, Vuze ( veja aqui para obter uma lista completa )
  3. Faça o download do VMWare Free Player
  4. Baixar 7zip uncompressor
  5. Descompacte DNALinux.7z usando o 7zip e reproduza o arquivo vmk com o VMWare Player.

Download direto no RapidShare (12 partes):

Instrução para arquivos baixados do Rapidshare:

Para juntar as peças no Windows:

copiar / b dbasea * dnalinux.7z

Para juntar as peças no Linux:

gato dbasea *> dnalinux.7z

Soma de verificação MD5: f75e88f48e08161be62b70a8ef465e17

Versão antiga (não suportada):

Servidor DNALinux

Nota: A nova versão (VDE Python para Bioinformatcs) já é um servidor, portanto a edição do servidor é interrompida.

 

 

 

 

 

 

 

 

Fonte: http://www.dnalinux.com/installedsoftware.html

Hyperledger

 

Hyperledger (ou o “Projeto Hyperledger”) é um projeto colaborativo envolvendo várias indústrias, iniciado em dezembro de 2015 pela Linux Foundation,[1] seu objetivo é suportar livros razão distribuídos com base na Blockchain. O seu foco é livros razão feitos para suportar transações de indústrias globais, incluindo as principais empresas de tecnologia, financeiras e logísticas, com o objetivo de melhorar vários aspectos da performance e robustez.[2] O projeto aspira unir um número de tentativas independentes para desenvolver protocolos e padrões abertos, provendo um framework modular que suporta componentes diferentes para usuários diferentes. Isso inclui uma variedade de blockchains, cada uma com seu consenso, modelos de persistência, e serviços para identidade, controle de acesso e contratos.

Histórico

Em Dezembro de 2015, a Linux Foundation anunciou a criação do projeto Hyperledger. Os primeiros fundadores do projeto foram anunciados em Fevereiro de 2016, e mais 10 membros que compõem o conselho de administração foram anunciados em 29 de Março.[3] Em 19 de Maio, Brian Behlendorf foi apontado como diretor executivo do projeto.[4]

No inicio de 2016, o projeto começou a aceitar propostas para bases de código e outras tecnologias a serem incubadas, para potencial inclusão como componentes centrais do Hyperledger. Uma das primeiras propostas foi para uma base de código que combina trabalhos prévios feitos pela Digital Asset Holdings (Blockstream’s libconsensus) e a OpenBlockchain da IBM.[5]Posteriormente, esse projeto foi renomeado para Fabric.[6] Em maio, o livro razão distribuído da Intel (Sawtooth) também foi incubado.[7]

Membros

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

De acordo com o Whitepaper do Hyperledger [8]:

As a fledgling technology, existing blockchain implementations have fallen short of meeting the multitude of requirements inherent in the complex world of business transactions. Scalability challenges, and the lack of support for confidential and private transactions, among other limitations, make its use unworkable for many business-critical applications. […] To meet the varied demands of the modern marketplace, Hyperledger has been designed for a broad array of industry-focused use cases, thereby extending the work of the pioneers in the field by addressing the existing shortcomings.

Em outras palavras, baseado no cenário atual de requisitos da indústria, foi identificado que as implementações atuais de blockchain não são suficientes. Problemas de escalabilidade, falta de suporte para transações privadas e outras limitações são citados como os principais culpados. A proposta do Hyperledger é justamente suprir esses requisitos a partir de uma série de casos de uso. A ideia também consiste de estender trabalhos existentes com o objetivo de mitigar as suas limitações. Vale destacar que o Hyperledger tem o foco na indústria, mais especificamente nas relações B2B e B2C.[8]

Objetivos

O objetivo principal do Hyperledger é criar uma plataforma útil, fácil de usar e robusta onde qualquer individuo interessado em construir um software baseado em blockchain pode usa-lá como base. Por motivos práticos, o Hyperledger pode nunca alcançar esse ideal que cobre todos os casos possíveis, mas o objetivo do time é chegar o mais perto possível.[8]

De maneira mais tangível, o projeto também define objetivos mais específicos como: modularidade, extensibilidade, facilidade de uso, variedade de métodos criptográficos. Cada um desses objetivos contribui para a visão geral do Hyperledger. Por exemplo, a modularidade contribui para a interoperabilidade entre sistemas que, por sua vez, potencializa a flexibilidade do projeto, e aumenta a cobertura de casos. A extensibilidade também contribui para aumentar a cobertura de novos casos, já que funcionalidades novas podem ser adicionadas.[8]

A conceito da modularidade é importante porque incentiva o desenvolvimento externo. Uma empresa não relacionada pode desenvolver novos módulos e contribuir para a melhora de módulos existentes. Generalizando, deve ser possível construir uma blockchain que não usa nenhum componente central do Hyperledger, mas ainda assim, se encaixar no seu framework. A troca de componentes a fim de satisfazer requisitos específicos também é um conceito central do Hyperledger. Por exemplo, alguns casos pedem um algoritmo rápido de consenso que requer alguma confiança, enquanto outros casos podem pedir menos velocidade com mais confiança.[8]

A extensibilidade e modularidade se provam como requisito central do projeto porque é inviável prever todos os usos futuros do Hyperledger e de tecnologias blockchain de uma maneira geral. Facilitar as contribuições externas pode incentivar o envolvimento de pessoas que contribuirão e usarão o Hyperledger.[8]

Requisitos propostos

Transações privadas e contratos confidenciais

O Hyperledger pretende suportar uma variedade de ferramentas criptográficas que devem garantir a presença de confidencialidade e privacidade. Essas ferramentas não devem prejudicar as propriedades de privacidade. Alguns casos de uso requerem confidencialidade mais básicas e otimizadas para performance que não são adequadas para o uso financeiro. O objetivo é suportar tanto o caso otimizado par performance quanto os casos mais sofisticados que pedem algoritmos criptográficos mais complexos.[8]

Identidade e auditabilidade

Em adição as transações privadas e confidenciais, o conceito de identidade baseado numa infraestrutura de chave pública completa os algoritmos criptográficos provendo a confidenciabilidade do Hyperledger. Além da infraestrutura de chave pública, o Hyperledger também deve prover suporte a uma documentação compreensível e imutável sobre essas identidades – incluindo os requisitos de confidenciabilidade associada a elas. O objetivo da documentação é suportar os casos que envolvem troca de identidade e auditoria. É importante notar que sempre deverá ser respeito o contrato inicial sobre a anonimidade da identidade. Por exemplo, se é previso que certa entidade é totalmente anonima, a documentação não incluirá nada que quebre esse acordo.[8]

Interoperabilidade

Como o Hyperledger propõe a utilização de vários componentes independentes, a interoperabilidade é proposta para que a interação entre esses elementos ocorra apesar de possíveis implementações fundamentalmente diferentes. Por exemplo, é esperado que haja a cooperação entre mais de um tipo de blockchain. Dessa forma, é dito que existe interação quando informação é trocada e utilizada por esses componentes. Para prover esse caso de uso, é definido um protocolo que permite a comunicação entre 2 ou mais blockchains.[8]

Portabilidade

A portabilidade em um nível de infraestrutura garante que o projeto Hyperledger funcione da mesma maneira em ambientes computacionais heterogêneos. O valor da portabilidade é explicitado ao ressaltar que o projeto deverá rodar com base numa grande combinação de blockchains, falhar em prover a portabilidade fere um principio geral do Hyperledger. A portabilidade em um nível de arquitetura tem significado parecido com o de modularidade: significa abstrair as interfaces dos componentes centrais para que não haja acoplamento de ambientes. Por exemplo, o componente de contratos inteligentes pode ser movido para uma unidade diferente de produção sem que haja necessidade de mudança a esse componente. [8]

Arquitetura

A arquitetura geral do Hyperledger consiste de 4 categorias:

  • Identidade (Identity)
  • Política (Policy)
  • Blockchain e contratos inteligentes (Smart Contracts)

De uma forma geral, essas categorias possuem responsabilidades específicas: a identidade é responsável por identificar as entidades participantes, a policy é responsável por regular o acesso e responsabilidades dessas entidades e o blockchain provê o serviço p2p que guarda o estado do sistema. Vale destacar que essas categorias são divisões lógicas do software e não necessariamente significam serviços fisicamente separados.[8]

Serviços de identidade

O requisito deste componente é identificar os componentes participantes da rede. Esses componentes incluem organizações participantes, validadores e transactors; Objetos contidos no livro razão e componentes mais tangíveis como: redes, servidores e ambiente de execuções.[8]

Serviços de política 

Os serviços de política permitem o gerenciamento das políticas de acesso ao sistema. Algumas dessas políticas incluem o gerenciamento do registro de novos membros e o controle de suas entradas e saídas. Esse serviço também é responsável pelo níveis de privacidade e as políticas de confiabilidade, responsabilidade e consenso. [8]

Blockchain

Os serviços de blockchain consistem de 3 partes:

  • Protocolo P2P.
  • Livro razão distribuído.
  • Gerenciador de Consenso.

O protocolo P2P funciona em cima da infraestrutura atual da internet e provê as capacidades de intercomunicação do sistema. O livro razão distribuído é a parte central do sistema e tem características parecidas com a de outros sistemas de criptomoedas. Por exemplo, o livro razão é responsável por manter e processar o estado do sistema e isso também é comum a bitcoin. Outras responsabilidades do livro razão distribuído sob o contexto do Hyperledger incluem: validar transações; calcular o hash de toda a base de dados de forma eficiente após cada bloco; minimizar a quantidade de dados necessários necessários para uma participante operar.[8]

Por fim, o gerenciador de consenso provê uma abstração para que outras partes do sistema utilizem os algoritmos de consenso de forma transparente. A ideia central é facilitar o uso e ao mesmo tempo prover um sistema flexível o suficiente para que novos procedimentos de consenso também possam ser adicionados.[8]

Incubação de projetos

Como um dos objetivos do Hyperledger é agregar contribuições externas, é adotada uma política de incubação para o gerenciamento dessas contribuições. Unidades de trabalhos são chamados de Projetos, e esses Projetos possuem um ciclo de vida [9]:

  • Proposta
  • Incubação
  • Maturidade
  • Depreciado
  • Fim de vida

Metodologias de gerenciamento similares são comuns a outros projetos open source, como o eclispe,[10] apache [11] e o OSGEO.[12] Até Julho de 2016, o Hyperledger possui dois projetos em fase de incubação, o Fabric e o Sawtooth.[13]

Sawtooth

O projeto Sawtooth, consiste na implementação de uma plataforma para construir e rodar livros razões distribuídos. O seu objetivo de modularidade é alinhado ao Hyperledger e é um dos motivos pela sua incubação. Diferente do Bitcoin, a proposta do Sawtooth é oferecer flexibilidade, desde transferências internacionais até aplicações de internet das coisas.[14]

Fabric

O fabric também é um projeto de tecnologias blockchain que oferece a possibilidade de encaixar várias implementações para certas funcionalidades. A versão de preview disponível em Julho de 2016 possui as seguintes features[15]:

  • Blockchain permissiva com finalidade imediata
  • Ambientes para a execução de contratos inteligentes
  • Módulos de consenso PBFT, NOOPS e SIEVE
  • Framework de eventos que suporta eventos predefinidos e customizados
  • SDK Client e API REST Básicas e Ferramentas CLI

Nessa mesma versão, estão presentes alguns BUGs e limitações, como [15]:

  • Alto tempo de resposta depois de testes de estresse.
  • Não possui eventos para peers no SDK.
  • Atributos no TCert não estão encriptados.

Referências

  1.  «Linux Foundation Unites Industry Leaders to Advance Blockchain Technology». 17 de dezembro de 2015
  2. Ir para cima «Linux Foundation’s Hyperledger Project Announces 30 Founding Members and Code Proposals To Advance Blockchain Technology». 9 de fevereiro de 2016. Consultado em 17 de fevereiro de 2016
  3. Ir para cima «Open Source Blockchain Effort for the Enterprise Elects Leadership Positions and Gains New Investments». 29 de março de 2016
  4. Ir para cima «Founder of the Apache Software Foundation Joins Linux Foundation to Lead Hyperledger Project». 19 de maio de 2016
  5. Ir para cima «Incubating Project Proposal: Joint DAH/IBM proposal». Tamas Blummer, Christopher Ferris. 29 de março de 2016. Consultado em 21 de junho de 2016
  6. Ir para cima «hyperledger/fabric»GitHub. Consultado em 23 de junho de 2016
  7. Ir para cima «Sawtooth Lake Hyperledger Incubation Proposal». Mic Bowman, Richard Brown. 14 de abril de 2016. Consultado em 21 de junho de 2016
  8. ↑ Ir para:a b c d e f g h i j k l m n o «Hyperledger Whitepaper». Consultado em 5 de julho de 2016
  9. Ir para cima «Hyperledger Project Lifecicle». Consultado em 6 de julho de 2016
  10. Ir para cima «Eclipse Development Process 2015». Consultado em 6 de julho de 2016
  11. Ir para cima «Apache Incubator». Consultado em 6 de julho de 2016
  12. Ir para cima «OSGEO Incubation Process». Consultado em 6 de julho de 2016
  13. Ir para cima «Hyperledger github». Consultado em 6 de julho de 2016
  14. Ir para cima «Sawtooth introduction». Consultado em 6 de julho de 2016
  15. ↑ Ir para:a b «Fabric Releases». Consultado em 6 de julho de 2016

Bitcoin e Blockchain para leigos

O ativo financeiro digital mais famoso da internet é o BitcoinQue funciona em cima de uma tecnologia chamada “Blockchain”, que registra todas as transações envolvendo bitcoins, eletronicamente numa espécie de livro-razão imutável e criptografado.

Uma das característica do Bitcoin é mecanismo é que o registro dos negócios não é centralizado ou administrado por uma única instituição. O histórico das transações é armazenado em blocos que somente se encaixam se for utilizada certo tipo de assinatura digital.

E para haver a efetiva liquidação das operações, a cadeia de transações deve ser validada pelos demais participantes do mercado(mineradores, que emprestam sua força computacional para validar transações e criar novos bitcoins na rede, com isso ganham frações de bitcoins), para isso precisam confirmar a veracidade da chave pública divulgada. O desenvolvimento dessa intrincada engrenagem é atribuído a uma pessoa – ou a um grupo – que usou o pseudônimo de SatoshiNakamoto. Tecnologia criada em 2008, que seu autor até hoje permanece no anonimato.

Na prática a tecnologia do “Blockchain” implica mudança significativa na forma como a internet pode ser utilizada. Como distribuir e compartilhar informações, passa ser possível a transferência eletrônica da propriedade de ativos.

Por essa razão, a expectativa é que, no futuro próximo, será construída uma internet dos valores. Nesse novo ambiente, ao enviar um arquivo contendo determinado código, a propriedade do bem será automaticamente transferida.

Com o Blockchain já é possível imaginar diversos usos para a tecnologia, tais como contratos inteligentes onde se encerram e automaticamente, operações no mercado financeiro onde você poderá custodiar suas ações e trocá-las, transações de comércio internacional e a compra e venda de imóveis, registros de casamentos, nascimento e falecimento.

Hoje já existem 16,5 milhões de bitcoins no mercado. Por definição, o estoque máximo de bitcoins emitidos será de 21 milhões de unidades.

Nota: “Um” bitcoin é dividido em oito casas decimais (1.00000000), fracionando o seu valor, sendo assim você pode comprar frações de bitcoins, que no momento que foi escrito esse texto, a cotação atual comprando R$ 50,00 reais daria por volta de 0,00600000 bitcoins.

Os verificadores das transações, chamados no jargão do mercado de mineradores, podem criar bitcoins conforme o volume de cálculos executados, a rede dificulta a quantidade de bitcoins criados, pela quantidade de mineradores trabalhando nela e com tempo pelo seu processo deflacionário, escassez. A rede de mineradores é que garante o processamento das transações e a segurança do mercado(mineradores, são quaisquer pessoas que emprestam sua força computacional para validar e registrar as transações).

Leia também  Novo regulamento de criptomoedas da Coréia do Sul proíbe completamente Marketing Multinível

À prova de balas e transparente

Ninguém foi capaz, pelo menos por enquanto, de invadir o sistema para criar bitcoins falsos. Isso tem garantido a confiança na segurança da estrutura e atraído novos participantes.

Nas operações bancárias tradicionais, o Banco é a instituição responsável pelo controle do livro caixa das transações. E cobra altas tarifas por esse serviço, e sem contar que a qualquer momento pode “confiscar a sua poupança”, como já vimos há tempos atrás.

Por exemplo, para enviar um TED ou DOC, o Banco exige o pagamento de determinada remuneração. O mesmo acontece para manter a conta corrente ativa e emitir extratos, já o Bitcoin, você não precisa pagar taxas de custódia, manutenção, extratos, apenas paga pela sua transferência, uma taxa irrisória.

As operadoras de cartão de crédito também cobram para processar as transações entre lojistas e consumidores e também taxas de anuidade. O mesmo acontece com as bolsas de valores e de mercadorias para administrar a posição de cada investidor cobrando taxa de custódia e corretagens.

Em algumas transações os custos podem ser tão altos a ponto de inviabilizar as operações de pequeno montante, como no caso das transferências internacionais de valores financeiros, onde são inseridas novas taxas e ainda pode demorar dias para se concretizar, se concretizar… Onde pode aumentar o prazo, dependendo de finais de semanas e feriados.

Aceitação do Bitcoin no mundo

Uma das ideias do Bitcoin, portanto, é baratear os custos das transações, com valores irrisórios comparados a Bancos. A consequência pode ser o aumento no volume de negócios.

Por exemplo, um desenvolvedor de softwares no Brasil pode contratar os serviços de um programador na Ucrânia e pagar pelo trabalho por meio da transferência de bitcoins. Nessa situação o Bitcoin é usado como um meio de troca.

Considerando que a atual estrutura da internet já viabiliza a troca de arquivos sem barreiras geográficas, o uso em larga escala do bitcoin teria o efeito de estimular o comércio global de bens e serviços, com transferência de bitcoin para qualquer parte do mundo, com tempo médio de 10 minutos..

Leia também  Coreia do Sul prepara-se para taxar o uso do Bitcoin

Dado que o bitcoin possui cotação tanto em dólares quanto nas demais moedas mundiais, o programador ucraniano do exemplo poderia optar por manter parte de sua remuneração recebida do desenvolvedor brasileiro em bitcoins, como uma poupança.

Por fim, a decisão do programador ucraniano poderia ser a de gastar parte dos bitcoins na compra de produtos e serviços para serem consumidos, ou comprar produtos para o aperfeiçoamento do seu trabalho, tal como computadores e eletrônicos. A empresa americana Dell Computer, que fabrica computadores e notebooks, é um das lojas que aceitam bitcoin, na compra de seus produtos. Existe também um site brasileiro, chamado “Classificados BTC“, onde é possível comprar e vender produtos e serviços, com bitcoin.

Mesmo o Bitcoin não sendo considerado uma “moeda” (meio de troca, unidade de conta e reserva de valor; baseado no conceito econômico), pelos economistas, ainda sim é um excelente meio de troca, universalmente aceito, ainda que galgando.

O Bitcoin possui um valor especulativo. A cotação de um bitcoin saltou de pouco menos de US$ 300 em julho de 2015 para mais de US$ 2 mil em julho de 2017.

Para negociar Bitcoin, vale o alerta: como em todo investimento especulativo, é fundamental conhecer os riscos envolvidos, mas ao mesmo tempo o Bitcoin não é definido pelo preço, e sim sua tecnologia disruptiva que vamos descrever abaixo:

Bitcoin

  • 24h – Bitcoin funciona 24 horas por dia, 365 dias no ano, nunca para e as transações podem acontecer a qualquer hora do dia ou da noite, independente de finais de semanas e feriados.
  • Rápido – simples como enviar um e-mail ou sms, de um telefone móvel.
  • Descentralizado – não tem um controlador central, podemos transacionar com qualquer pessoa sem depender de um intermediador, uma rede ponto-a-ponto ou peer-to-peer, parecida com a rede do BitTorrent. BTC, também conhecido como Bitcoin, é um sistema livre, que não pode ser confiscado, como já aconteceu com a poupança nos anos 90.
  • Deflacionário – ao contrário do dinheiro emitido a esmo pelos Bancos Centrais, que geram inflação, o bitcoin é deflacionário e poderá ser criado somente 21 milhões, onde são criados em uma ordem decrescente.
  • Sistema de pagamento – O bitcoin é um ativo ao portadorvocê pode ser seu próprio Banco, transacionando e custodiando seus BTCs (a sigla de bitcoin).
  • Meio de troca – uma das maiores construtoras  do Brasil, a Tecnisa, aceita bitcoin como meio de pagamento em seus imóveis e várias pessoas no Brasil já entenderam as vantagens de aceitar Bitcoin e estão vendendo desde eletrônicos, até carros e casas de luxo, no Classificados BTC.
  • Privacidade – você pode ter milhões em Bitcoins, sem ter sua vida exposta pela FORBES, pois o seu nome não será divulgado na rede, você será identificado na rede com uma chave pública(parecida com essa: 1hlY78hOwe46VCd90oNuRX2j80se43WZ).
  • Segurança – a rede conjuntamente faz com que as regras sejam cumpridas, e acompanhada de uma resposta rápida dos seus usuários se alguém tentar fraldar o sistema, e também o custo benefício não compensa
  • Barato – custo irrisório, seja para enviar bitcoin para seu vizinho ou para o Japão, o custo é o mesmo.
  • Transparência – Bitcoin é um sistema de código aberto e as transações estão totalmente disponíveis para auditoria de qualquer pessoa, em tempo real, elas ficão registradas no Blockchain, o livro razão imutável com todas as transações da história do software Bitcoin registradas.
  • Inclusão social – metade da população brasileira não tem acesso a contas bancárias, por “N” motivos, mas o Bitcoin veio para mudar essa situação, onde quem quiser transferir dinheiro para qualquer parte do mundo, seja para se incluir no sistema financeiro ou ajudar em uma catástrofe mundial, você só precisa de um telefone móvel, acesso a internet e baixar o software do Bitcoin para transferir recursos para qualquer parte do mundo ou mesmo se incluir nele.
Com o Blockchain, Bitcoin é apenas o começo!

 

Fonte: https://guiadobitcoin.com.br/bitcoin-e-blockchain-para-leigos/

A segurança do bitcoin pela força computacional

 

A segurança no bitcoin é alcançada pela descentralização e pela força computacional. Este não é um vídeo técnico, mas sim uma visão geral do funcionamento da tecnologia.

Para fontes mais técnicas e detalhas, ver artigos abaixo.

Para saber mais:

Artigo “A grande inovação tecnológica do bitcoin Parte 1/2” http://www.infomoney.com.br/blogs/cam… Mining Bitcoin Wiki: https://en.bitcoin.it/wiki/Mining

Beginners’ Guide to Mining: https://99bitcoins.com/beginners-guid…

Bitcoin Mining Explained: https://chrispacia.wordpress.com/2013…

Everything you need to know about BTC mining: https://www.bitcoinmining.com/

How the bitcoin protocol actually works: http://www.michaelnielsen.org/ddi/how…

“Bitcoin – a Moeda na Era Digital”, livro publicado pelo Instituto Mises Brasil em 2014. http://www.mises.org.br/Ebook.aspx?id=99

Blog “Moeda na Era Digital” no portal InfoMoney http://www.infomoney.com.br/blogs/cam…

Está pensando em usar ou comprar bitcoin? Leia aqui antes: http://www.infomoney.com.br/blogs/cam…

Apoie este canal! Bitcoin: 1C6qa2DctPUcyAasDkgdBTJjhgpXaVjcUE

Contatos: Email: ulrich@mises.org.br

Facebook: https://www.facebook.com/fernando.ulrich

Twitter: https://twitter.com/fernandoulrich

Nós quase demos em construir cérebros artificiais

Hoje, as redes neurais artificiais estão fazendo arte, escrevendo discursos, identificando rostos e até mesmo dirigindo carros. Parece que estamos montando a onda de uma era tecnológica inovadora, mas o aumento atual das redes neurais é realmente uma espécie de renascimento.

Pode ser difícil de acreditar, mas os pesquisadores de inteligência artificial já começaram a ver a promessa nas redes neurais durante a Segunda Guerra Mundial em seus modelos matemáticos. Mas, na década de 1970, o campo estava pronto para desistir deles inteiramente.

“[T] aqui não houve resultados impressionantes até que os computadores crescessem, isto é, até os últimos 10 anos”, diz Patrick Henry Winston, professor do MIT especializado em inteligência artificial. “Continua a ser o facilitador mais importante do aprendizado profundo”.

Redes Neurais

As redes neurais de hoje são essencialmente árvores de decisão que dependem da lógica matemática que se assemelha, por falta de uma melhor analogia, ao disparo de sinapses no cérebro humano. Várias camadas de neurônios artificiais, ou nós, são utilizados para chegar à solução de um problema. À medida que os dados são alimentados através das camadas, uma computação simples ocorre em cada nó e a solução é passada para a próxima camada de neurônios para outra rodada de cálculos. O tempo todo, a matemática que ocorre em cada neurônio está sendo ligeiramente modificada pelo resultado anterior. Desta forma, uma rede neural pode se ensinar padrões em dados que combinam com uma solução desejada e otimizar o caminho para ele, como ajustar um violão. Quanto mais dados você alimenta uma rede neural, melhor fica ao ajustar seus neurônios e encontrar um padrão desejado.

Enquanto o campo emergiu nos últimos anos como um tour de force para especialistas em informática e até mesmo alguns hobbyists, a história da rede neural remonta até o início dos computadores. O primeiro mapa de uma rede neural veio em 1943 em um artigo de Warren Sturgis McCulloch e Walter Pitts. Mas o quadro de McCulloch tinha pouco a ver com a computação; Em vez disso, ele estava focado na estrutura e função do cérebro humano. O modelo de função de neurônio de McCulloch-Pitts, é claro, surgiu durante um tempo em que a tecnologia para monitorar essa atividade não existia.

McCulloch e Pitts acreditavam que cada neurônio no cérebro funcionaria como um interruptor on-off (como números binários 1 e 0), e que as combinações desses neurônios disparariam ou desativariam, produzindo decisões lógicas. Na época, havia muitas teorias concorrentes para descrever a forma como o cérebro operava, mas de acordo com um artigo de Gualtiero Piccinni da Universidade do Missouri, St. Louis, o modelo de McCulloch-Pitts fez algo que os outros não tinham: Funcionam para algo que se assemelhava a um computador simples, e isso despertou interesse em construir um cérebro artificial a partir do zero.

Sucesso inicial

O primeiro sucesso – e esse é um generoso termo – conceito de rede neural foi o algoritmo Perceptron do Frank Rosenblatt da Universidade Cornell. O Perceptron foi originalmente concebido para ser uma máquina, embora a sua primeira implementação fosse como uma classe de redes neurais que pudessem tomar decisões razoavelmente rudimentares. Eventualmente, o algoritmo foi incorporado em um computador com tamanho de geladeira chamado Mark 1, que era uma máquina de reconhecimento de imagem. Possui uma matriz de 400 fotocélulas ligadas à sua rede neural artificial, e poderia identificar uma forma quando era realizada antes do “olho”.

Poucos anos depois, em 1959, ADALINE chegou por meio de pesquisadores da Universidade de Stanford e, na época, era o maior cérebro artificial. Mas, também, só pode lidar com alguns processos por vez e foi concebido como uma demonstração de aprendizagem de máquinas em vez de ser configurado para uma tarefa específica.

Esses pequenos, mas tentadores avanços na computação alimentaram a histeria em torno da inteligência artificial na década de 1950, com a Sciencedirigindo a manchete “Human Brains Replaced?” Em uma questão de 1958 sobre redes neurais. Robôs inteligentes invadiram a ficção científica com um clipe mais rápido. Este mesmo ciclo, porém, repetiu-se com muitos processos automatizados ao longo da história. Como Adelheid Voskuhl apontou nos Andróides no Iluminismo , os autômatos executados no relógio foram construídos no século 18 como uma ameaça para a humanidade e a prova de que as máquinas governariam o mundo no devido tempo. Mas esses andróides do Iluminismo não passaram de marionetes glorificados.

Em meados do século 20, a pesquisa era lenta e não conseguia acompanhar a imaginação pública, como observa o professor de psicologia da Universidade de Toronto, Eyal Reingold. Relata que o cérebro artificial estava prestes a substituir a mente humana tão longe da realidade quanto possível.

“Infelizmente, esses sucessos anteriores causaram que as pessoas exagerassem o potencial das redes neurais, particularmente à luz da limitação na eletrônica, então disponível”, escreveu ele em uma história de inteligência artificial. “Este exagero excessivo, que decorreu do mundo acadêmico e técnico, infectou a literatura geral da época”.

O inverno está chegando

Não era o receio de uma aquisição de robôs que quase mataram a pesquisa da IA ​​no início dos anos 1970, porém; Era uma combinação de fatores. Enquanto o professor de informática do MIT, Marvin Minsky, é muitas vezes acreditado por fornecer um título de morte para Perceptrons, havia muito mais na história.

Havia o problema dos cortes no financiamento do governo. O governo estava canalizando mais dinheiro em programas de tradução que poderiam converter o russo para o inglês quase instantaneamente. As redes neurais iniciais mostraram essas habilidades com um vocabulário de 250 palavras , mas a pesquisa subseqüente foi lenta no melhor. Em meados da década de 1960, uma comissão governamental chamada Comitê Consultivo de Processamento de Linguagem Automática considerou a tradução automática “sem esperança”.

Conforme destacado por Gary Yang, um relatório de 1973 chamado Lightfoot Report também apontou que várias áreas onde a aprendizagem de máquinas poderiam ser aplicadas – como as funções de piloto automático – eram realmente melhor atendidas por métodos muito menos tecnologicamente avançados.

Nils Nilsson, professor aposentado de ciência da computação da Universidade de Stanford, trabalhou nessas primeiras gerações de inteligência artificial. Uma das maiores reivindicações da fama foi Shakey , um robô construído na década de 1960 que poderia realizar um reconhecimento de imagem rudimentar. Foi assim chamado, porque ele se perdeu quando se moveu, usando uma câmera de TV para capturar e entender o mundo ao seu redor. Poderia interpretar as entradas do computador sobre um objeto na sala e interagir com ele de determinadas formas. Também foi um sucesso inicial na rede neural, mas não foi suficiente.

Winston diz que um dos problemas era que as redes neurais não podiam ter uma abordagem abrangente. Ele diz que o documento Perceptron de Marvin Minsky mostrou que outras áreas de pesquisa de inteligência artificial eram necessárias – e que a tecnologia ainda não estava disponível.

“Os escritos de Minsky eram para uma categoria especial de Perceptrons”, diz Nilsson. “A principal razão pela qual a pesquisa sobre redes neurais se desviou na década de 60, que ninguém conseguiu descobrir uma maneira de treinar redes neurais de várias camadas”.

Para resumir: o artigo de Minsky demonstrou que, mesmo no seu mais complexo, a classe Perceptron de AI era muito binária em seus pensamentos, dificultando a habilidade da máquina de aprender a atacar tarefas mais complexas. Na opinião de Minsky, você precisava de diferentes tipos de inteligência artificial para conversar uns aos outros, o que pode ter ultrapassado as capacidades do hardware no momento.

“Minsky era tudo sobre pensar que você precisava de múltiplas representações, métodos e abordagens”, diz ele.

A rede neural começou assim a se retirar da imaginação pública, inaugurando o que foi chamado de “Inverno de Inverno”, onde o financiamento da pesquisa de inteligência artificial secou e muitas linhas de pesquisa pararam. Isso incluiu redes neurais e pesquisa de AI mudou para outras áreas de foco.

“As pessoas trabalharam em uma variedade de coisas: sistemas experientes, o uso da lógica para fazer raciocínio, reconhecimento de fala, visão computacional e robôs”, diz Nilsson. Sistemas experientes, destinados a ser vastos repositórios de conhecimento de especialistas computorizados em declarações de lógica, levaram a um segundo tipo de inverno AI quando suas habilidades também estavam superadas.

Fazendo um retorno

Mas em 1974, Paul Werbos, então estudante de doutorado de Harvard, introduziu uma maneira de melhorar as redes neurais. Ao espalhar várias redes neurais um ao outro, você poderia ter certos erros nos neurônios verificar os outros em um processo chamado backpropagation, uma maneira em que um cérebro artificial poderia “adivinhar” e procurar uma nova decisão.

Isso foi importante. As redes neurais anteriores poderiam ficar penduradas na mesma decisão. Se você colocou várias decisões em um resultado final, a máquina poderia essencialmente usar uma parte da rede neural para verificar novamente outra parte. Isso, de fato, deu uma complexidade em camadas à sua linha de pensamento. Em vez de pensar em preto e branco de entradas verdadeiras / falsas Perceptron, poderia interpretar um valor neutro para chegar a uma decisão pesando vários fatores.

Na verdade, ele iria além das declarações de lógica e na aprendizagem complexa de máquinas.

Era um documento arrojado e avançado – talvez um pouco mais ansioso. Nenhum hardware de computador no momento poderia lidar com operações tão complexas.

Nilsson também aponta para a publicação de 1986 do processamento distribuído paralelo: explorações na microestrutura da cognição de David E. Rumelhart da Universidade da Califórnia em San Diego e James L. McClelland da Universidade Carnegie Mellon. Melhorou o trabalho de Werbos mostrando um dos melhores mapas modernos da rede neural humana, criando o melhor mapa do cérebro.

Este mapa também ajudou a refinar as idéias de Werbo, mostrando como os neurônios funcionaram no cérebro e como você poderia aplicar isso às redes neurais artificiais. Você poderia resolver a incapacidade de entender as funções neutras ao ter outras redes neurais conectadas para obter uma resposta mais “refinada” neutra. Só precisava de um chute de algumas áreas: “grandes avanços no poder do computador e grandes bancos de dados que permitiram” aprendizado profundo “, como disse Nilsson. Esses avanços na computação chegaram. Hoje, os pesquisadores têm o poder de processamento e acesso a troves de dados armazenados em “a nuvem” para ensinar novas funções de algoritmos.

ADALINE e seus primos primitivos podem ter desaparecido da percepção pública, uma vez que a aprendizagem por máquinas passou a ser própria na última década. Mas essa revolução, décadas atrás, não foi dificultada por essas redes neurais. Em vez disso, eles eram de alguma forma muito primitivos e muito avançados para o seu tempo, mas seu tempo certamente chegou.

 

Sistemas Operacionais de Tempo Real – Timers

Introdução

Estava desenvolvendo algumas idéias para um novo artigo técnico, quando encontrei perdida, no fundo de uma gaveta virtual, uma biblioteca de rotinas em C que desenvolvi há algum tempo. É uma preciosidade!!! Eu mesmo já utilizei essas funções em vários projetos. Estou aqui disponibilizando esse material para você.

Vou contar um pouco a história dessa biblioteca. Houve uma época em que o meu trabalho era focado em projetos de desenvolvimento de sistemas dedicados baseados em processadores da família 8051. Desenvolvemos uma célula de carga digital, um sistema de monitoramento ambiental, um mini CLP, um sistema de monitoramento e controle de um processo químico, sistema de controle de elevadores etc. Daí surgiu a ideia de elaborar funções e rotinas padronizadas, pois quase todos esses sistemas tinham alguma coisa em comum, como por exemplo teclas, displays etc. e deveriam operar em tempo real. O objetivo foi diminuir o tempo gasto para o desenvolvimento de um novo projeto. Antes de prosseguir, recomendo a leitura do artigo Sistemas Operacionais de Tempo Real – Introdução, onde são abordados alguns conceitos que serão aplicados neste artigo.

É necessário apresentar aqui alguns esclarecimentos a respeito da filosofia usada na elaboração dessas rotinas. Eu parti do princípio de que os nossos sistemas são de tempo real e que realizam periodicamente algumas funções rotineiras, tais como verificar um teclado, atualizar displays, administrar LEDs de sinalização, realizar medidas, etc. Outras ações são tomadas por demanda, ou seja, apenas quando ocorrem. Essas demandas podem ser periódicas ou assíncronas (aleatórias). Daí já reconhecemos o primeiro elemento a ser implementado no nosso Sistema Operacional: um temporizador (Timer). Para quem não sabe, os processadores tradicionais da família 8051 têm apenas 2 temporizadores, enquanto outras versões oferecem pelo menos mais um. Antes de continuar, acho interessante recordarmos a arquitetura dos microcontroladores da família MCS-51 e os modos de operação dos seus temporizadores. Na parte final desse artigo será desenvolvido um pequeno exemplo prático, cujo código poderá ser compilado e simulado.

TIMERS da família MCS-51

Para ilustrar o que será abordado aqui, vamos nos referenciar aos microcontroladores de fabricação da ATMEL, com a arquitetura baseada no 8051, cujo documento completo você pode consultar aqui: ATMEL 8051 Microcontrollers Hardware Manual. Na Figura 1 podemos observar a arquitetura interna de um microcontrolador AT89S8253, que continua sendo produzido, mostrando em destaque o bloco dos temporizadores.

Timers - Diagrama em blocos da arquitetura interna de um microcontrolador
Figura 1: Diagrama em blocos da arquitetura interna de um microcontrolador AT89S8253

 

Sem entrar nos detalhes referentes aos contadores / temporizadores Timer 0 e Timer 1 dessa família de microcontroladores, basta dizer que eles podem ser programados para funcionarem em 4 modos distintos de operação:

  • Modo 0: O temporizador é configurado como um contador de 13 bits, que pode receber um valor inicial e conta para cima. Na transição do valor limite superior 0x1FFF para  0x0000, é acionado um flag de sinalização;
  • Modo 1: Similar ao modo 0, porém é configurado o contador para 16 bits;
  • Modo 2: O temporizador é configurado como um contador de 8 bits, com um registro de 8 bits associado para recarregar o valor inicial automaticamente. Na transição, é acionado um flag;
  • Modo 3: Nesse modo de operação, o Timer 0 opera como 2 contadores distintos de 8 bits, enquanto o Timer 1 nesse modo de operação permite que se congele a contagem.

Convenções para o uso dos Timers

Para o objetivo de projetar uma biblioteca com rotinas padronizadas, foi definido que o Timer 0 seria o temporizador padrão do sistema e o Timer 1 também poderia ser usado para isso, se acaso não fosse necessário usá-lo para gerar baud-rate da comunicação serial.

O período de interrupção do temporizador deve ser o maior possível e baixo o suficiente para atender às necessidades prioritárias do sistema. Para que se entenda o motivo disso, observe o seguinte exemplo:

Suponhamos que:

  • Um microcontrolador que, por restrições de sua arquitetura e do oscilador (clock) utilizado, possa executar no máximo 10.000 instruções por segundo;
  • Uma rotina de interrupção provocada pelo temporizador execute 20 instruções na média a cada interrupção.

Se numa hipótese absurda o temporizador for dimensionado para gerar 500 interrupções por segundo, a rotina de interrupção vai consumir todo o tempo disponível para executar as instruções do microcontrolador (500 x 20 = 10.000)! Se por exemplo esse número puder cair para 50 interrupções por segundo, sem prejudicar a operação do sistema, a rotina de interrupção vai consumir apenas 10% do total disponível (1.000), deixando os outros 90% para as demais atividades do microprocessador.

A compreensão do que foi ilustrado nesse exemplo é fundamental. As rotinas que são executadas com maior frequência devem ser otimizadas para serem executadas no menor tempo possível e na menor frequência possível também. Voltando ao exemplo das 500 interrupções, se acaso a rotina de interrupção executasse apenas 18 instruções ao invés das 20, já sobrariam 1.000 instruções por segundo que poderiam ser executadas por outras atividades. Em muitos casos isso é suficiente. Note que para esse exemplo em particular, só analisamos uma das soluções possíveis para viabilizar a operação do sistema. Poderia-se também lançar mão de outros recursos, como por exemplo aumentar a frequência do oscilador do microcontrolador.

Assim a frequência da interrupção do nosso timer deve ser dimensionada de modo que:

  • A função que deverá ser executada com maior frequência possa ser atendida pelas interrupções do timer no menor tempo necessário para isso (e maior possível), definindo assim as especificações do timer de referência do sistema;
  • Outras temporizações mais lentas sejam realizadas como múltiplos da interrupção do timer e implementadas por meio de temporizadores virtuais de software.

Um temporizador virtual de software é uma estrutura no programa em que a cada temporizador é associado um valor inicial, que se traduz num número inteiro de interrupções do Timer 0, e um flag de sinalização. A cada interrupção do Timer 0, o temporizador de software é decrementado e testado se zero. Se for zero, é ligado o flag para avisar que a contagem de software foi terminada e o temporizador é reinicializado para o seu valor inicial. O tratamento do final de contagem é realizado no programa principal, testando-se o flag e reinicializando-o depois.

O timer de referência deverá funcionar no modo 2 de operação. Observe que a programação do Timer 0 depende da frequência de clock do microcontrolador, do fator de divisão do clock, que nas CPUs tradicionais do MCS-51 é de 12 vezes, e da frequência requerida de interrupção. Um último limitante é que o valor inicial do Timer nessa configuração é de no máximo 255 (8 bits). Na biblioteca também foi desenvolvido um padrão para a programação do Timer 1, especialmente se não for usado para gerar baud-rate.

Detalhes da Biblioteca em C

O código em C a seguir foi desenvolvido para o compilador KEIL C51 μVision, na versão de avaliação. Se você quiser testar o programa exemplo que desenvolveremos no final deste artigo, recomendo que você baixe e instale esse programa.  O arquivo de biblioteca com os trechos de código em C para a utilização dos timers de forma padronizada está dividido em segmentos. O primeiro segmento define uma série de constantes, que podem ser ajustadas conforme as especificações do projeto. Veja o trecho do código a seguir.

Nesse código há alguns parâmetros que precisam ser alterados, conforme o projeto:

  • #define   FREQUENCIA_DO_CLOCK_DA_CPU 12.0e+6 // Hz —->  12 MHz, por exemplo.

Inicializar essa constante com o valor do clock do seu microcontrolador.

  • #define   FATOR_DE_ESCALA_CLOCK_TIMER    12.0f     // Divide o clock por 12

Valor do pre-scaler.

  • #define   FREQUENCIA_DE_INTERRUPCAO_TIMER_0 5e+3  // Hz —- > 5 kHz, por exemplo.

Define a frequência da interrupção do timer.

São apenas esses três parâmetros que devem ser inicializados. Não é necessário alterar outras partes do código!

O segundo segmento da biblioteca refere-se às inicializações dos timers, conforme o modo de operação, e os comandos para iniciar a operação do temporizador. Observe que nesse segmento é mostrada a rotina principal (void main(void)) e indicado onde devem ser inseridos os trechos do código.

O terceiro segmento mostra como são definidas as rotinas de interrupção.

EXEMPLO

A seguir vamos desenvolver o nosso programa de exemplo. Nesse programa, será programado o Timer 0 no modo 2 de operação, com o microcontrolador operando com um clock de 4 MHz e uma frequência de interrupção de 1,5 kHz. Confira o código no quadro abaixo.

Se você quiser simular o programa exemplo acima e explorá-lo um pouco mais, siga os seguintes passos:

  • Instale o KEIL C51 μVision;
  • Baixe o arquivo Testa_Timer.zip;
  • Instale os arquivos de Testa_Timer.zip num diretório para testes;
  • Navegue até o diretório de testes e acione o arquivo Testa_Timer.uvproj (2 “clickes”)  (Figura 2).

Timers - Arquivos no diretório de teste
Figura 2: Arquivos no diretório de teste

Nesse instante deverá abrir o programa Keil e a tela deverá ser a retratada na Figura 3. Esse painel permite navegar no código em C, editá-lo e compilá-lo. Não é necessário fazer isso para realizar a simulação, mas você poderá posteriormente alterar alguns parâmetros do código e testar o programa com as novas alterações.

Timers - Programa Keil pronto com o programa exemplo carregado
Figura 3: Programa Keil pronto com o programa exemplo carregado

A seguir coloque o programa no modo de Debug (Figura 4, Figura 5 e Figura 6) para que se possa iniciar a simulação.

timers - Selecionando o modo Debug do programa
Figura 4: Selecionando o modo Debug do programa

Antes de entrar no modo de depuração, aparece na tela a mensagem da Figura 4. “Clicke” no  “OK” para continuar.

Timers - Aviso de que no modo de avaliação, o código fica limitado a 2K
Figura 5: Aviso de que no modo de avaliação, o código fica limitado a 2K

timers - Modo Debug de operação
Figura 6: Modo Debug de operação

 

Observe que já estão destacados os painéis de monitoramento do Timer 0 e do Port 3, cujo bit 1 deverá ser alternado a cada término de contagem do temporizador de software. As duas variáveis principais (bFlagTimerDeSoftware e nTimerDeSoftware) poderão ser monitoradas na janela Watch 1 durante a simulação.

É possível utilizar as teclas de função F11 para executar o programa passo a passo ou F5 entrar em execução. Recomendo que você inicie a simulação utilizando o passo  a passo para poder observar detalhadamente como que funciona o mecanismo de operação desse programa.

Resumo

Neste artigo técnico foram apresentados alguns conceitos relativos à utilização de temporizadores de hardware de um microcontrolador associados a temporizadores de software para a implementação de arquiteturas de software típicas de  sistemas operacionais de tempo real. Também foi apresentada e explicada uma biblioteca padronizada para a utilização dos timers de microcontroladores da família MCS-51, codificada em C, para ser compilada no programa da Keil. Depois foi desenvolvido um programa exemplo para que você possa simular o que foi apresentado e observar os detalhes dessa implementação.

Este artigo é o segundo da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos (em breve).

Sistemas Operacionais de Tempo Real

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.

Fonte: https://www.embarcados.com.br/rtos-timers/

Guia completo dos Seletores CSS3

Introdução

O Módulo das CSS3 denominado “Selectors Level 3” atingiu, em 29 de setembro de 2011, o status de Recomendação do W3C. Essa Recomendação descreve os seletores já existentes nas CSS1 e CSS2 e cria novos seletores para as CSS3.

Seletores são “padrões” ou “modelos” que casam com os elementos de uma árvore do documento e portanto podem ser usados para selecionar os nós de um documento XML. Seletores foram otimizados para serem usados com as linguagens de marcação HTML e XML.

CSS (Cascading Style Sheets) é uma linguagem para descrever a renderização de documentos HTML e XML em uma tela, em papel, em sintetizadores de voz, etc.

As CSS usam seletores para atrelar propriedades de estilização aos elementos de um documento.

Tabela de seletores

Padrão Casa com Tipo CSS
* qualquer elemento Seletor universal 2
E elementos do tipo E Seletor tipo 1
E[foo] elementos com o atributo “foo” Seletor atributo 2
E[foo=”bar”] elementos E cujo valor do atributo “foo” é exatamente igual a “bar” Seletor atributo 2
E[foo~=”bar”] elementos E cujo valor do atributo “foo” é uma lista de valores separados por espaço, um dos quais é exatamente igual a “bar” Seletor atributo 2
E[foo^=”bar”] elementos E cujo valor do atributo “foo” começa exatamente com a string “bar” Seletor atributo 3
E[foo$=”bar”] elementos E cujo valor do atributo “foo” termina exatamente com a string”bar” Seletor atributo 3
E[foo*=”bar”] elementos E cujo valor do atributo “foo” contém a substring “bar” Seletor atributo 3
E[foo|=”en”] elementos E cujo atributo “foo” tem uma lista de valores começando com “en” e seguida por um hífen Seletor atributo 2
E:root elemento E raiz do documento Pseudo-classe estrutural 3
E:nth-child(n) elemento E que é o enésimo filho do seu elemento pai Pseudo-classe estrutural 3
E:nth-last-child(n) elemento E que é o enésimo filho (contado de trás para frente) do seu elemento pai Pseudo-classe estrutural 3
E:nth-of-type(n) elemento E que é o enésimo irmão do seu tipo Pseudo-classe estrutural 3
E:nth-last-of-type(n) elemento E que é o enésimo irmão (contado de trás para frente) do seu tipo Pseudo-classe estrutural 3
E:first-child elemento E que é o primeiro filho de seu elemento pai Pseudo-classe estrutural 2
E:last-child elemento E que é o último filho de seu elemento pai Pseudo-classe estrutural 3
E:first-of-type elemento E que é o primeiro irmão de seu tipo Pseudo-classe estrutural 3
E:last-of-type elemento E que é o último irmão de seu tipo Pseudo-classe estrutural 3
E:only-child elemento E que é o único filho de seu elemento pai Pseudo-classe estrutural 3
E:only-of-type elemento E que é irmão único do seu tipo Pseudo-classe estrutural 3
E:empty elemento E que não tem elementos filhos (inclusive nós de texto) Pseudo-classe estrutural 3
E:link
E:visited
elemento E que sendo destino de um link ainda não foi visitado (:link) ou que já tenha sido visitado (:visited) Pseudo-classe link 1
E:active
E:hover
E:focus
elemento E durante determinadas ações do usuário Pseudo-classe ação do usuário 1 e 2
E:target elemento E que é o destino de um fragmento identificador de um URI Pseudo-classe :target 3
E:lang(pt-br) elemento E em um determinado idioma – “exemplo: pt-br” Pseudo-classe :lang() 2
E:enabled
E:disabled
elemento E de uma interface de usuário que está habilitado (:enabled) ou desabilitado (:disabled) Pseudo-classe estado do elemento UI 3
E:checked elemento E de uma interface de usuário que está marcado (:checked) (por exemplo: radio-button ou checkbox) Pseudo-classe estado do elemento UI 3
E::first-line primeira linha formatada do elemento E Pseudo-elemento ::first-line 1
E::first-letter primeira letra formatada do elemento E Pseudo-elemento ::first-letter 1
E::before conteúdo gerado antes do elemento E Pseudo-elemento ::before 2
E::after conteúdo gerado depois do elemento E Pseudo-elemento ::after 2
E.foo elemento E cujo valor da classe é “foo” Seletor classe 1
E#foo elemento E cujo valor do atributo ID é “foo”. Selector ID 1
E:not(seletor) elemento E que não casa com o seletor simples seletor Pseudo-classe negação 3
E F elemento F descendente do elemento E Elemento descendente 1
E > F elemento F filho do elemento E Elemento filho 2
E + F elemento F imediatamente precedido pelo elemento E Elemento irmão adjacente 2
E ~ F elemento F precedido pelo elemento E Elemento irmão geral 3

Criei versões HTML, PNG e SVG desta tabela otimizadas para impressão. Que tal imprimir a tabela e tê-la na sua mesa de trabalho para uma referência e consulta rápida?
versão HTML para impressão desta tabela (link abre em nova janela)
versão PNG para impressão desta tabela (link abre em nova janela)
versão SVG com personalização de cores para impressão desta tabela (link abre em nova janela).

Vamos estudar a seguir cada um dos seletores constantes da tabela.

Incorporamos nesta página, para cada um dos seletores estudados, com uso de IFRAME para o JSFiddle, exemplos que demonstram o efeito de estilização. Você poderá complementar seus estudos clicando o link existente no canto superior direito do IFRAME e editando os códigos dos exemplos de modo interativo.

Seletor universal

♦ Casa com qualquer elementoOs conteúdos de cada um dos elementos da marcação, ao serem renderizados em um navegador, são estilizados com regras CSS mínimas (por exemplo: cor e tipo de fonte, margens, paddings, etc.) que fazem parte de uma folha de estilos nativa do navegador e que na ordem de cascata tem a prioridade mais baixa, ou seja, qualquer declaração de estilo do autor ou usuário sobrescreve a folha de estilos nativa.

Não existe uma padronização para essa folha de estilos e cada navegador implementa sua própria folha de estilos nativa. Como consequência ocorrem inconsistências de renderização, em relação a estilização básica, entre navegadores.

Destas inconsistências a que produz maiores transtornos é a não padronização dos valores para as propriedades margin e padding.

A principal utilização do seletor universal é “zerar” essas propriedades para todos os elementos da marcação. Como consequência o autor terá que definir explicitamente para cada elemento, na sua folha de estilos, aqueles valores.

* {
  margin: 0;
  padding: 0;
  }

O seletor universal quando declarado de forma contextual pode produzir resultados interessantes. Observe os exemplos a seguir:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor tipo

♦ Casa com elementos de um determinado tipoSintaxe: E

Usado para estilizar os elementos da marcação que são de um mesmo tipo; por exemplo: elemento do tipo p(parágrafo), do tipo div, do tipo ol, do tipo strong, e assim por diante.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletores de atributo

♦ Casam com elementos cujo atributo satisfaçam determinadas condições

presença de um atributo

♦ Casa com elementos que contenham um determinado atributoSintaxe: E["foo"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo

♦ Casa com elementos com determinado valor de atributoSintaxe: E[foo="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo pertence a uma lista de valores separados por espaço

♦ Casa com elementos cujo valor de atributo pertença a uma lista de valores separados por espaçoSintaxe: E[foo~="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo começa com string

♦ Casa com elementos cujo valor de atributo começa com uma determinada stringSintaxe: E[foo^="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo termina com string

♦ Casa com elementos cujo valor de atributo termina com uma determinada stringSintaxe: E[foo$="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletores do tipo pseudo-classe

elemento raiz

♦ Casa com o elemento raiz do documentoSintaxe: :root

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Nesse exemplo a cor dos elementos é herdada do elemento raiz.

enésimo filho

♦ Casa com o elemento que é o enésimo filho do seu elemento paiSintaxe: E:nth-child(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo filho de trás para frente

♦ Casa com o elemento que é o enésimo filho do seu elemento pai, contado de trás para frente na marcaçãoSintaxe: E:nth-last-child(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo irmão do seu tipo

♦ Casa com o elemento que é o enésimo irmão (filhos do mesmo elemento pai) do seu tipoSintaxe: E:nth-of-type(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo irmão do seu tipo de trás para frente

♦ Casa com o elemento que é o enésimo irmão (filhos do mesmo elemento pai) do seu tipo, contado de trás para frente na marcaçãoSintaxe: E:nth-last-of-type(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeiro filho

♦ Casa com o elemento que é o primeiro filho do seu elemento paiSintaxe: E:first-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

último filho

♦ Casa com o elemento que é o último filho do seu elemento paiSintaxe: E:last-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeiro do mesmo tipo

♦ Casa com o elemento que é o primeiro irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:first-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

último do mesmo tipo

♦ Casa com o elemento que é o último irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:last-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

único filho

♦ Casa com o elemento que é o único filho do seu elemento paiSintaxe: E:only-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

único irmão

♦ Casa com o elemento que é o único irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:only-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

elemento vazio

♦ Casa com o elemento que não tem filhos (inclusive filhos do tipo nós de texto)Sintaxe: E:empty

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

link

♦ Casa com o elemento que é um link não visitadoSintaxe: a:link

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:link {
  color: red; 
  text-decoration: none;  
}

link visitado

♦ Casa com o elemento que é um link que já foi visitadoSintaxe: a:visited

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:visited {
  color: orange; 
  text-decoration: underline;  
}

ativo

♦ Casa com o elemento que por ação do usuário foi tornado ativoSintaxe: a:active

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
:active {
  outline: 1px solid pink;  
}

sobre

♦ Casa com o elemento que, por ação do usuário, teve um dispositivo apontador colocado sobre eleSintaxe: a:hover

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:hover {
  color: green;
  background: black;  
}

foco

♦ Casa com o elemento que por ação do usuário a ele foi dado o focoSintaxe: E:focus

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Não existe uma padronização relacionando os elementos HTML que podem receber foco. Mas, em geral são eles:

  • Elemento a
  • Elemento area com atributo href
  • Elemento input
  • Elemento select
  • Elemento textarea
  • Elemento button (não desabilitado)
  • Elemento iframe
  • Elemento a
  • Qualquer elemento com o atributo tabindex

alvo

♦ Casa com o elemento que é o alvo do fragmento identificador de um linkSintaxe: E:target

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

idioma

♦ Casa com o elemento que foi marcado em determinado idiomaSintaxe: E:lang

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

habilitado ou desabilitado

♦ Casa com o elemento da interface de usuário que seja habilitado ou desabilitadoSintaxe: E:enabled e E:disabled

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

marcado

♦ Casa com o elemento da interface de usuário que tenha sido marcadoSintaxe: E:checked

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeira linha

♦ Casa com a primeira linha do texto formatado de um elementoSintaxe:
E:first-line — até as CSS2.1
E::first-line — modificada peals CSS3

As CSS3 modificaram a sintaxe para esse seletor. Os navegadores antigos não suportam a nova sintaxe e o modernos suportam as duas sintaxes.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Notas:

1 – Esse seletor aplica-se somente a elementos nível de bloco

2 – Somente às propriedades listadas a seguir podem ser estilizadas por esse seletor

  • propriedades para fontes
  • propriedades para cores
  • propriedades para background
  • word-spacing
  • letter-spacing
  • text-decoration
  • vertical-align
  • text-transform
  • text-shadow
  • line-height
  • clear

primeira letra

♦ Casa com a primeira letra do texto formatado de um elementoSintaxe:
E:first-letter — até as CSS2.1
E::first-letter — modificada pelas CSS3

As CSS3 modificaram a sintaxe para esse seletor. Os navegadores antigos não suportam a nova sintaxe e o modernos suportam as duas sintaxes.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Notas:

1 – Esse seletor aplica-se somente a elementos nível de bloco

2 – Somente às propriedades listadas a seguir podem ser estilizadas por esse seletor

  • propriedades para fontes
  • propriedades para cores
  • propriedades para background
  • propriedades para margens
  • propriedades para padding
  • propriedades para bordas
  • text-decoration
  • vertical-align (para elementos não flutuados)
  • text-transform
  • text-shadow
  • line-height
  • float
  • clear

conteúdo antes

♦ Casa com o conteúdo gerado antes de um elementoSintaxe: E::before

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

conteúdo depois

♦ Casa com o conteúdo gerado depois de um elementoSintaxe: E:after

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

negação

♦ Casa com o elemento que não casa com determinado seletor simples seletorSintaxe: E:not(seletor)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor classe

♦ Casa com o elemento que tem determinado valor para o atributo classeSintaxe: E.foo

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor ID

♦ Casa com o elemento que tem determinado valor para o atributo idSintaxe: E#foo

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor descendente

♦ Casa com o elemento que descende de determinado elementoSintaxe: E F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor filho

♦ Casa com o elemento filho de determinado elementoSintaxe: E>F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor que imediatamente sucede

♦ Casa com o elemento irmão que imediatamente segue-se a determinado elementoSintaxe: E+F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor que sucede

♦ Casa com o elemento irmão que segue-se a determinado elementoSintaxe: E~F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

O IE outra vez! 😦

Os seletores CSS3 são suportados pelos navegadores modernos. Para servir os seletores das CSS3 aos navegadores Internet Explorer 6 até 8 use uma pequena biblioteca JavaScript (4K) chamada Selectivizr.

Basta adicionar o seguinte código na seção head do documento:

<script type="text/javascript" src="[JS library]"></script>
<!--[if (gte IE 6)&(lte IE 8)]>
  http://selectivizr.js
  <noscript><link rel="stylesheet" href="[fallback css]" /></noscript>
<![endif]-->

Boa sorte com os poderosos seletores das CSS!