Construindo sua PCB com EasyEDA

EasyEDA é gratis e fácil de usar para design de circuitos, simulação de circuitos e também para design de PCB que corre sobre o seu browser:

Link: https://easyeda.com

Anúncios

O ESP8266+Arduino Mega como WebServer

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

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

O Circuito:

 

Webservercircuit

 

O código:

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

* Web Server with ESP8266

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

* Adapted by Marcelo Jose Rovai

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

#define esp8266 Serial2

#define CH_PD 4

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

#define DEBUG true

void setup()

{

  esp8266.begin (speed8266);

  Serial.begin(9600);

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

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

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

  delay(3000);

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

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

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

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

}

void loop()

{

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

  {

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

    {

      delay(300);

      int connectionId = esp8266.read() – 48;

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

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

      webpage += “D8 status ==> “;

      int a = digitalRead(8);

      webpage += a;

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

      int b = digitalRead(9);

      webpage += b;

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

      int c = analogRead(0);

      webpage += c;

      webpage += “</h2>”;

      String cipSend = “AT+CIPSEND=”;

      cipSend += connectionId;

      cipSend += “,”;

      cipSend += webpage.length();

      cipSend += “\r\n”;

      sendData(cipSend, 1000, DEBUG);

      sendData(webpage, 1000, DEBUG);

      String closeCommand = “AT+CIPCLOSE=”;

      closeCommand += connectionId; // append connection id

      closeCommand += “\r\n”;

      sendData(closeCommand, 3000, DEBUG);

    }

  }

}

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

 // Send AT commands to module

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

{

  String response = “”;

  esp8266.print(command);

  long int time = millis();

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

  {

    while (esp8266.available())

    {

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

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

      response += c;

    }

  }

  if (debug)

  {

    Serial.print(response);

  }

  return response;

}

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

// Reset funtion to accept communication

void reset8266 ()

{

  pinMode(CH_PD, OUTPUT);

  digitalWrite(CH_PD, LOW);

  delay(300);

  digitalWrite(CH_PD, HIGH);

}

A web Page:

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

+CIFSR:STAIP,”10.0.1.2″

Webserverpage

A saída no Serial Monitor:

1. A conexão com o modulo esp8266

 

SerialConxion

2. A comunicação:

SerialOngoingcomm

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

ESP8266 como webserver

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

ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

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

Como Configurar Xbee Explorer

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

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

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

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

XBee_USB_Explorer_Adapter22

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

INSTALAÇÃO XBEE EXPLORER USB:

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

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

Tela-1-Link-XCTU

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

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

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

Tela-4-XCTU-Install-Tela-Inicial

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

Tela-5-XCTU-Install-Tela-Licenca

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

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

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

Tela-7-XCTU-Install-Tela-Path

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

Tela-8-XCTU-Install-Confirmacao

Aguarde o final da instalação :

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

CONFIGURANDO O MÓDULO XBEE:

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

XBee_USB_Explorer_Adapter22

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

Tela-3-Instalacao-drivers

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

Tela-10-XCTU-Tela-inicial

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

Tela-11-XCTU-Dispositivo-Scan

 

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

Tela-12-XCTU-Dispositivo-parametros

 

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

Tela-13-XCTU-Dispositivo-detectado

 

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

Tela-14-XCTU-Lista-Dispositivo

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

Tela-15-XCTU-Dispositivo-parametros-carregados

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

Arduino_Xbee_Shield12

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

A aristocracia operária

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

Pyramid_of_Capitalist_System

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

Publicado do WordPress para Android

Construindo um Blockchain: The Gray Paper

Background

O trem de excitação do blockchain está em um alto histórico! Existem inúmeros artigos e notícias que o chamam de maior invenção desde a internet. Por outro lado, há um acampamento igualmente grande dizendo que, embora a tecnologia seja ótima, não existe um caso de uso real .

Até recentemente, estive em algum lugar do meio. Intrigado por blockchain comecei a pesquisá-lo. Depois de ler vários artigos e white papers, senti-me confortável com alguns dos termos e conceitos. No entanto, eu ainda não tinha esse momento “aha” O conteúdo que eu estava lendo era um nível muito alto e não transmitia claramente o poder eo potencial de construção de aplicativos distribuídos e descentralizados.

Há duas semanas Blockchain Academy TLV iniciou sua sessão inaugural. A premissa da Academia Blockchain é promover uma discussão técnica ativa e produtiva sobre blocos.

Meu objetivo é explicar o que eu aprendi até agora na minha jornada de blocos de bloco, e acompanhar você através de uma implementação de bloqueio inspirado Ethereum, eu tenho trabalhado nas últimas 2 semanas.

O que não posso criar, não entendo

Durante o primeiro encontro do Blockchain TLV, Leonid Beder discutiu os conceitos básicos do blockchain, e codificou uma implementação de bloqueio básico em formato simples. A implementação incluiu a seguinte funcionalidade:

Blockchain: uma lista crescentemente crescente de registros , denominados blocos , que são vinculados e protegidos usando criptografia . Cada bloco geralmente contém um ponteiro hash como um link para um bloco anterior, um carimbo de data e hora e dados de transação. Definimos uma classe inicial com a seguinte interface:

  • Nós armazenamos todos os blocos na cadeia de blocos.
  • Nós armazenamos o conjunto de todas as transações que esperam ser processadas.
  • Método para criar novos blocos
  • Método para envio de novas transações no pool.

Blocos: Todo bloco da nossa cadeia conterá

  • Número do bloco (ou seja, “3º bloco na cadeia”)
  • transações
  • Timestamp – tempo de criação do bloco
  • Número não-arbitrário que só pode ser usado uma vez
  • O hash do bloco anterior – usando o hash anterior, tornamos a cadeia de blocos imutável

Transações: definimos uma classe de transações que continha

  • O endereço público do remetente
  • O endereço público do destinatário
  • O valor da transação.

Enviar um nó : um bloco é um banco de dados distribuído e descentralizado, onde cada nó da rede possui uma cópia completa do histórico de transações Uma vez que estamos desenvolvendo uma cadeia de bloqueio sem permissões, todos podem participar. Este método nos permite adicionar nós à rede.

Enviar uma transação : um bloco de cadeias serve como registro do histórico de transações. Embora uma transação possa ser definida de forma ampla, o caso de uso mais popular é uma transferência de fundos do usuário A para o usuário B. Esse método nos permite criar transações, esperando ser minado.

Mine a Block : as transações não são refletidas na rede imediatamente. Precisamos investir o poder computacional na validação de transações. Isso é chamado de Prova de Trabalho. Minar um bloco é a ação de executar “Prova de Trabalho” em todas as transações que foram recentemente emitidas, mas ainda não foram validadas. Não há almoços gratuitos em criptografia;)

Consenso : Consenso é o processo de todos os nós que chegam a acordo sobre o estado atual da rede. Escolhemos a abordagem da “Cadeia mais longa” (Greedy Maior Observado Subtree). Esta abordagem afirma que todos os nós aceitarão o bloqueio do nó com a maioria dos blocos. O raciocínio por trás disso, é que a cadeia de blocos mais longa possui o poder mais computacional investido nele (lembre-se, exigimos que os blocos sejam validados via PoW) e, portanto, é o mais confiável / credível.

Confira o código fonte das oficinas aqui.

Embora fosse um monte de material novo para processar em uma hora, fiquei preso 🙂 Para o final da oficina, Leonid anunciou uma surpresa!

                                                            Eu gosto de surpresas

Haveria uma competição para ver quem poderia fazer o pedido de atração mais criativo e “incrível” para o bloco de bloco básico que acabamos de construir.

Meu trabalho nas últimas 2 semanas

Eu estava com vontade de aprender mais sobre blockchain, e acredito que construir um é a melhor maneira de fazer isso. Comecei a criar uma cadeia de blocos inspirada na implementação Ethereum com as seguintes características:

  • Sistema de contabilidade – os usuários poderão registrar contas (contas externas) com um saldo e iniciar transferências de fundos. Além disso, os usuários podem registrar contas de contrato e implantar contratos inteligentes em toda a rede
  • Máquina de estado baseada em transações
  • Transações garantidas e validadas e transições de estados
  • Permita que os usuários escrevam contratos inteligentes e aplicativos descentralizados onde eles podem criar suas próprias regras arbitrárias para propriedade, formatos de transação e funções de transição do estado.

Contas

O estado compartilhado global de nós na rede é composto por contas. As contas detêm informações importantes, como

  • endereço: isso servirá como o nome da conta, semelhante ao que fizemos na oficina.
  • saldo: montante dos fundos de propriedade da conta
  • nonce : se a conta é uma conta de propriedade externa, esse número representa o número de transações enviadas pelo endereço da conta.

Minha implementação de bloqueio tem dois tipos diferentes de contas:

  • Contas externas, que são controladas por chaves privadas (via criptografia RSA)
  • Contas contratuais, que são controladas pelo código do contrato.

Estado compartilhado único em toda a rede

As contas são públicas, e você pode ver qualquer conta, dado seu endereço, e o nó foi registrado. Eu criei contas “globais” informando todos os nós da criação de uma conta na rede. Então, quando as transações da conta são despachadas para um nó, eu propagar essa transação para todos os nós na rede. Desta forma, o bloco é verdadeiramente descentralizado, e não dependemos de nós simples para informações valiosas, como existência de conta ou saldos de contas. Essencialmente, criamos um singular “estado compartilhado” entre os nós.

Registramos cada conta em cada nó, de modo que seja “global”

Diferenças entre contas externas e de contrato

A principal diferença entre os dois tipos de contas está enraizada na forma como eles podem se comunicar com outras contas na rede. Uma conta externa pode se comunicar de duas maneiras

  1. Mensagens de outras contas externas (ou seja, uma transação que move fundos da conta A para B).
  2. Invocando a execução do método em contas contratuais. Esses métodos variam, pois dependem apenas do autor do contrato e do contrato que ele / ela criou.

É importante esclarecer que as contas do contrato, em contraste com as contas externas, não podem enviar despachos explícitos para a rede. Em vez disso, as contas de contrato só podem emitir transações em resposta a outras transações que receberam.

Contas Externas

A autenticação de contas é feita via criptografia RSA. Após a inicialização da conta, um par privado de chave pública é criado e gravado no disco.

Teclas criadas no construtor ExternalAccounts. À direita, vemos a chave pública

Essas chaves são usadas para assinar digitalmente pedidos de transações de saída com as credenciais da conta. Uma implementação mais robusta sempre pede uma conta, quer ele quer ou não assinar o pedido antes de enviá-lo. Você pode ver uma implementação rudimentar deste em requestAuthForTransaction.sh.

requestAuthForTransaction.sh

Um pressuposto que fiz para esta implementação é que todas as contas concordam em assinar todos os pedidos de transações com suas credenciais.

Contas de Contrato

As contas do contrato são controladas pelo seu código. Eles simplesmente executam um código específico quando invocados e têm controle direto sobre o equilíbrio.

Um dos desafios aqui foi descobrir como suportar isso em uma maneira dinâmica, distribuída, descentralizada e de confiança. O Ethereum usa uma máquina virtual acessível a nível mundial (dado um ponteiro para o código de byte do contrato) para executar o código do contrato. Mas JS não tem uma VM globalmente acessível fora da caixa para todos os nós a serem consultados. Inicialmente, tentei implantar um contrato para todos os nós na rede como um objeto JSON com stringência, de modo que a execução do contrato poderia ser invocada de forma independente em cada nó, analisando o objeto recebido. Infelizmente, o JSON.stringify ignora métodos e funções, portanto, eliminando contratos inteligentes de suas funcionalidades em gravações. A minha solução alternativa para o envio de contratos de forma dinâmica (não codificada em cada instância de nó) em toda a rede foi a seguinte:

Implantando um Contrato

  1. Escreva um contrato inteligente como um objeto JS simples.

2. Envolva-o com parênteses para torná-lo uma string e remova todas as novas linhas para que possa ser processado através do método JS eval incorporado quando outros nós a recebem.

3. Envie a string como dados para todos os nós na rede.

Implantando um contrato em toda a rede

Isso permite que os nós criem contratos on-line e os implante na rede. Agora, um nó pode receber um contrato que não conheceu antes e executar seu código! 😀😀😀

Escrevendo atualizações do contrato

Inicialmente, podemos analisar o contrato stringificado usando o método JS eval incorporado, que leva uma seqüência de caracteres e o avalia como uma declaração JS.

Depois de executar um método que altera o estado do contrato (ou seja, altera o saldo do contrato), queremos armazenar o contrato na íntegra, sem perder o acesso aos nossos métodos.

Portanto, usaremos o método de stringis JSON e passamos uma função “substituição” personalizada , instruindo-o sobre como seqüenciar as funções.

No futuro, para ler a versão especialmente rigorosa do contrato, passaremos um “reviver” personalizado para o método JSON.parse.

Emitir transações através da execução do contrato

Algumas mutações contratuais só podem atualizar o estado interno do contrato. Outras execuções de contrato podem “emitir” transações que efetuam o estado da rede. Por exemplo, um contrato que detém fundos (os contratos regem seus próprios fundos) pode enviá-los a um usuário específico após uma determinada condição ser cumprida. Essas transações emitidas são ouvidas e colocadas na fila de mineração, de forma semelhante a outras transações na rede. Eles devem ser validados antes de serem gravados no bloco. O fluxo parece assim:

Uma transação emitida por meio de um pedido de mutação do contrato, anexado ao mempool

Contratos inteligentes com permissões

Chamar um contrato inteligente simplesmente invoca um método que resulta em uma emissão de transação. Os contratos são implantados globalmente e gostaríamos de uma maneira fácil de controlar quem pode invocar métodos de contrato. Gostaríamos de permitir que os usuários criem contratos que suportem permissões de usuários. Por exemplo, em uma eleição, nós só queremos que os usuários elegíveis possam votar (podemos determinar a elegibilidade, no entanto, achamos adequado). Como todas as transações solicitadas são assinadas digitalmente via criptografia RSA pelo solicitante, podemos verificar com segurança o usuário que solicitou a execução do contrato e decidir se ele está ou não autorizado a fazê-lo.

Exemplo DAOVotingContract.ts com permissões

Validação de transação

Durante a primeira oficina, implementamos uma versão bruta das transações. Porque não tínhamos contas, nenhuma forma de identificação e nenhum saldo para atualizar, não tinham significado. Depois de implementar o acima, agora podemos verificar a legalidade, ou “correção” de uma transação solicitada

Função de transição estatal

O white paper da Ethereum descreve um cronograma de cryptocurrency como um sistema de transição do estado, onde o estado é composto pelo status de propriedade da moeda dentro do sistema. Na minha implementação, cada nó possui contas que possuem um saldo específico. Mas como o estado (equilíbrio) muda ao longo do tempo? Ethereum especifica uma Função de Transição de Estado da seguinte forma:

Ilustração do Livro Branco Ethereum

Em nossa implementação, tomaremos uma abordagem semelhante para validar transições de estado. Nós vamos:

  1. Verifique se uma transação adere à estrutura solicitada e possui todos os valores necessários.
  2. Todas as transações têm um SenderNodeId e um SenderAddress. Embora esta seja uma hipótese insegura, para a implementação atual e para a falta de um cliente de usuário apropriado, assumiremos que todas as contas concordam e assinam digitalmente todos os pedidos de transações de saída com suas credenciais. Antes de ser submetido à fila de mineração, verificaremos essa assinatura digital .
  3. Verifique se o nonce corresponde ao nonce na conta do remetente .
blockchain.ts

Depois de verificar a transação através do método stateTransitionValidation , podemos adicionar a transação para a fila de mineração e a minha. É importante notar que essas transações ainda não modificaram o estado da rede . Após o consenso, se essas transações pertencem à cadeia mais longa, e é uma transação que move fundos, validaremos que o remetente tenha um saldo de conta adequado. Um exemplo de filtragem de transações ilegais (o remetente A que envia mais fundos, ele possui) pode ser visto em apropriadoFunds.sh.

apropriadoFunds.sh

Para visualizar este processo:

Exemplo de Contratos

Agora que nosso bloco possui contas, transações validadas e uma maneira de criar e propagar contratos em toda a rede, podemos observar alguns contratos reais. Esses contratos são bastante legais e mostram a flexibilidade e o potencial de criar contratos inteligentes na cadeia de blocos.

Contra-contrato

Para começar as coisas, vejamos um contrato simples que atua como um contador. Toda vez que o método incrementValue do contrato é chamado, incrementaremos o contador. Observe que qualquer pessoa pode invocar este código de contrato.

const CounterContract = {
balance: 0,
counter: 0,
incrementValue: function() {
this.counter++;
},
id: 1,
fromAddress: Alice,
call: function() {
return {
getBalance: this.balance,
getFromAddress: this.fromAddress
};
},
send: function() {
return {
incrementValue: this.incrementValue
};
},
abi: function() {
return {
sendables: this.incrementValue.toString()
};
}
};

Invocamos o código do contrato enviando uma solicitação mutateContract /: CounterContract PUT . Este contrato tem seu próprio estado interno que governa. Quando o incrementValue é chamado, o estado do contrato emite uma transação, solicitando a mutação do estado do contrato. Depois de ser minado, a mutação é escrita na cadeia de blocos, de modo que tenhamos um registro de quem usou o contrato (iniciou o pedido de mutação) e como o contrato foi usado.

Este contrato pode ser executado através do cliente Postman ou executando o script counter_contract.sh no diretório shell-scripts.

Transferir fundos após a data arbitrária Contrato

Um cenário mais realista para um contrato inteligente é transferir fundos da conta A para a conta B. O contrato a seguir é baseado no cenário em que Bob quer transferir 400 moedas para Alice, após uma data arbitrária ter passado. Em vez de usar um serviço de terceiros, ou sistema de custódia, ele pode criar um contrato inteligente que verifica quando a data passou, e iniciar uma transferência de fundos.

const MoveFundsAfterDateContract = {
balance: 400,
expirationDate: new Date(October 13, 2016 11:13:00),
id: 2,
fromAddress: Bob,
call: function() {
return { getBalance: this.balance, getFromAddress: this.fromAddress };
},
send: function() {
return { changeBalance: this.changeBalance };
},
abi: function() {
return { callables: this.call(), sendables: this.send() };
},
moveFunds: function() {
var currentDate = new Date();
if (currentDate > this.expirationDate) {
return {
senderNodeId: B,
senderAddress: Bob,
recipientNodeId: A,
recipientAddress: Alice,
value: 20,
action: TRANSACTION_EXTERNAL_ACCOUNT
};
}
return null;
}
};

Quando o método moveFunds do contrato é invocado, ele verificará a data, verá que passou e transferiu fundos para Alice.

Este contrato pode ser executado através do cliente Postman ou executando o script move_funds_after_data_contract.sh no diretório shell-scripts.

DAO Vote para o contrato de bônus

Este cenário envolve um DAO (organização autônoma descentralizada) que quer dar um bônus a um de seus funcionários. Como este DAO é uma organização completamente justa 😀😀😀, devemos votar em quem é merecedor do bônus.

Mas lembre-se, o blockchain é um livro público! Portanto, no momento em que carregamos para contratar a rede, qualquer pessoa pode vê-lo e fazer chamadas para o código do contrato. Nós gostaríamos de restringir a votação somente aos funcionários da DAO. Como mencionei anteriormente, cada solicitação com credenciais de contas, é assinada digitalmente por essa conta, com sua chave privada. Desta forma, é fácil verificar a verdadeira origem dos eleitores. Então, este contrato tem um campo “autorizadoVoters” que verificaremos contra, sempre que uma conta tentar votar.

const DAOVotingContract = {
balance: 400,
id: 3,
authorizedVoters: [
{ nodeId: A, address: Alice },
{ nodeId: B, address: Eve },
{ nodeId: A, address: Gal Gadot }
],
votes: [
{
nodeId: C,
address: Gal Gadot,
votes: 0
},
{
nodeId: C,
address: Ben Affleck,
votes: 0
}
],
fromAddress: Bob,
candidateA: {
nodeId: C,
address: Gal Gadot
},
candidateB: {
nodeId: A,
address: Selena Gomez
},
call: function() {
return {
getBalance: this.balance,
getFromAddress: this.fromAddress
};
},
send: function() {
return {
moveFunds: this.changeBalance
};
},
moveFunds: function(userData, vote) {
// Check if vote requester is authorized
const authorizedVoterIdx = this.authorizedVoters.findIndex(
user =>
user.nodeId === userData.nodeId && user.address === userData.address
);
if (authorizedVoterIdx === 1) return null;
// Check if candidate requester is voting for exists
const candidateIndex = this.votes.findIndex(
candidate => candidate.address === vote
);
if (candidateIndex === 1) return null;
// Cast Vote and verify users can’t vote twice
this.votes[candidateIndex].votes++;
this.authorizedVoters.splice(authorizedVoterIdx, 1);
// Users still need to cast vote
if (this.authorizedVoters.length > 0) return;
this.votes.sort((voteA, voteB) => voteB.votes voteA.votes);
return {
senderNodeId: B,
senderAddress: Bob,
recipientNodeId: this.votes[0].nodeId,
recipientAddress: this.votes[0].address,
value: 400,
action: TRANSACTION_EXTERNAL_ACCOUNT
};
}
};

Este contrato pode ser executado através do cliente Postman ou executando o script vote_permissions_contract.sh no diretório shell-scripts.

Estes são apenas vários exemplos de contratos inteligentes. A estrutura atual permite que qualquer pessoa faça o upload de qualquer contrato (desde que adira ao formato analisável que estou usando), implante-o na rede em sessão e comece a executá-lo. Podemos criar contratos para eleições, armazenamento de arquivos distribuídos e muito mais.

Conclusão

A programação dessa cadeia de bloqueio de prova de conceito foi um desafio! É apenas a ponta do iceberg em termos de formas de melhorar e garantir. Fui um excelente momento pesquisando os conceitos e aprendendo sobre implementações e mecanismos de cadeias de blocos.

Um grande agradecimento a Leonid Beder pela graciosa introdução do blockchain e aos colaboradores da Kin , Orbs e Samsung Next para organizar a Academia Blockchain .

Você pode verificar minha implementação completa aqui.

Se você quiser continuar a discussão do blockchain, sinta-se à vontade para alcançar o Linkedin .

Por último, se você chegou até aqui, obrigado por ficar com isso 🤗🤗🙌🙌🖖🏼

 

Fonte:  https://hackernoon.com/building-a-blockchain-the-grey-paper-5be456018040

Como ver quais sites o seu computador acessa secretamente

Dos computadores que você tem em casa, quantos deles estão conectados na internet? Praticamente todas as máquinas que saíram das lojas nos dois últimos anos, seja notebook ou PC, estão ligadas à rede mundial de computadores, o que faz com elas se tornem alvo de usuários mal-intencionados.

Existem diversos programas que ajudam a proteger sua máquina dessas pragas, mas nem sempre eles são suficientes para impedir que elas invadam o computador. Outro problema bem comum é que os aplicativos de proteção não conseguem detectar 100% dos invasores que batem à porta do usuário.

Um tipo bem comum de spyware é aquele que não tem a intenção de roubar dados, mas sim de utilizar o computador como zumbi, utilizando a sua conexão com a internet para hackear sites e serviços disponíveis na rede. Mas existe uma forma de monitorar a sua conexão com a internet e ver todo e qualquer site ou endereço de IP que é acessado por meio do seu roteador.

 

Como fazer?

O primeiro passo para descobrir quais serviços estão sendo acessados do seu computador é iniciar o prompt de comandos do Windows com os privilégios de administrador. Para isso, abra o Menu Iniciar e escreva “cmd” na caixa de pesquisa. Em seguida, clique com o botão direito do mouse sobre a opção encontrada e escolha o item “Executar como administrador”.

O “-a” do comando significa que todas as conexões e portas serão ouvidas e armazenadas no arquivo; o “-b” mostrará quais aplicações estão criando os caminhos para acesso à internet; o “-f” gravará os DNS completos de cada conexão, para facilitar a compreensão dos dados. Caso queira que apenas os endereços IPs sejam gravados, coleque o -n no lugar do “-f”, ficando ”-abn”. O valor “5” indica o intervalo de tempo, em segundos, entre uma leitura e outra.

Não será mostrado nada na tela enquanto o comando estiver sendo executado. Depois de alguns minutos, pressione Ctrl+C para encerrar a leitura das conexões e finalizar a gravação dos dados no arquivo. Agora é só abrir o arquivo de? texto criado e começar a investigar quais são os serviços acessados a partir do seu computador.

Como interpretar os resultados?

Ao abrir o arquivo activity.txt você poderá notar que o conteúdo está dividido em quatro colunas principais: “Proto”, “Endereço local”, “Endereço externo” e “Estado”. A primeira indica o protocolo de comunicação utilizado pelo processo. A segunda e a terceira mostram os endereços IP utilizados e a última coluna exibe a atividade que estava sendo realizada no momento da leitura.

É na terceira coluna que os esforços serão concentrados, pois ela indica as URLs e endereços IP externos acessados utilizando a sua máquina. Uma maneira fácil de encontrar alguma atividade suspeita é olhar o nome dos processos, apresentados entre colchetes ao longo do documento.

Ao notar um processo estranho, verifique o endereço externo que ele utiliza. Se mesmo assim você não conseguir identificar do que se trata, uma boa saída é procurar pelo nome da atividade no Google. Se for algo comum nos computadores, certamente há algum site explicando do que se trata.

Outra forma de descobrir o serviço acessado é utilizando algum serviço que rastreia endereços IP. Duas boas opções são o IP Address Tracer e o Global Whois Search. Nos dois casos, você só precisa copiar o IP nos campos de pesquisa e aguardar até que a busca seja finalizada e os dados comecem a aparecer na tela.

 

Outras ferramentas

Existem diversos aplicativos que ajudam a monitorar as portas e conexões abertas em um computador. O CurrPorts é um dos mais usados pelos usuários com um pouco mais de experiência, pois é relativamente fácil de usar e a interpretação dos resultados exibidos na tela se dá de forma mais natural.

Há ainda o Wireshark, mais indicado para quem possui uma rede de computadores em casa, pois ele também analisa a troca de mensagens entre as máquinas conectadas pelo hub (ou switch). Assim, caso algum PC esteja infectado e a invasão acabe se propagando pela rede, você consegue detectá-la sem maiores problemas.

 

O que faço depois?

Se o resultado das investigações apontarem que o processo é, de fato, um invasor, é preciso tomar algumas providências para que ele seja eliminado do computador e não utilize mais a sua conexão. A maneira mais simples de fazer isso é utilizando aplicativos de segurança, como anti-spywares, que varrem a máquina em busca de possíveis sanguessugas de internet.

 

 

Caso as ferramentas não tenham efeito algum sobre o possível invasor, uma alternativa é buscar na rede mundial de computadores por injeções específicas para determinada praga. O Google sempre ajuda nessas horas. É muito comum as empresas de segurança lançarem soluções gratuitas para combater apenas determinadas ameaças.

…..

Agora que você já sabe como usar o “netstat” e viu como é fácil interpretar os dados e utilizar as informações fornecidas, comece as investigações em seu computador para descobrir se não há nenhum processo rodando escondido e que esteja prejudicando a sua conexão. Depois não se esqueça de voltar aqui para deixar um comentário contando a sua experiência.

 

Fonte: https://www.tecmundo.com.br/seguranca-de-dados/16199-como-ver-quais-sites-o-seu-computador-acessa-secretamente.htm

Learn CI: Teste Automatizado e Publicação em 10 min

Aqui está um modelo para iniciar e executar testes automatizados e publicação de código JS cliente ou servidor

Há muitas dependências por aí. Claramente, o mundo precisa de mais testes automatizados. Mas, precisamos nos instalar rapidamente.

Objetivos:
deve ser livre, como em dinheiro.
Deve ter pequena curva de aprendizado, poucas palavras mágicas para aprender!
Deve ser UI grátis. Teste o código do cliente usando o uso de Chrome sem cabeça
Travis CI para testes automatizados, com emblema de aprovação / falha no github
Execute testes em cada commit
Fácil publicação no NPM e URL memorável para incluir scripts em páginas da web

Então, em cada compromisso com o repositório Github :

  1. A Travis CI iniciará sua instância de teste
  2. Instale a última versão do nó e o navegador Chrome
  3. Inicie o Chrome para testes sem cabeça
    (apenas necessários para projetos que sejam clientes JS)
  4. Execute dois exemplos de scripts de teste. Um para testar aplicativos de servidor e outro para navegador JS
    (Um deles pode ser eliminado dependendo se o seu é um aplicativo de nó ou script de cliente)
  5. Mostrar resultado do teste
  6. Publicar no NPM se for bem-sucedido
  7. Mostre os cartões de aprovação / aprovação para o projeto no NPM e no github.

Você pode adicionar / remover para isso conforme necessário, dependendo das necessidades do seu projeto.

Aqui estão todos os arquivos :

Para Travis CI, que hospedará o teste, apenas um  arquivo .travis.yml é necessário.

Se o projeto for um aplicativo de nó e não o cliente JS, você não precisa das peças do Chrome.

Também publicará para npm. Para scripts de clientes, podemos usar um link curto e fácil de lembrar usando unpkg.com

Não há estruturas de teste extravagantes para aprender aqui. Nós simplesmente escrevemos nossos scripts de teste, que lançam erros de falha.

A estrutura de teste é a seguinte , qualquer erro nativo constitui um teste falhado.

Para aplicativos de nó, test-server.js

main.js é o arquivo principal no aplicativo. O que está sendo testado.
Se tivéssemos chamado test_fail, o teste falharia e Travis nos diria assim.

test-browser.js para scripts de clientes.
Como realmente queremos automatizar as coisas, não podemos ter UI. Ninguém estará prestes a clicar nas coisas. Então, o cromo sem cabeça é usado para executar testes.

testchrome , é apenas um invólucro simples na interface remota cromada usada para testes sem cabeça.

Testchrome passa a usar uma API simplificada, apenas
.evaluar (JS no navegador)
.get (JSON de um URL)

Alternativamente, você pode usar os outros módulos de teste de Headless Chrome que estão disponíveis, como o marionetismo.

Conseguir esta configuração localmente em uma máquina pode ser desagradável. Travis CI realmente brilha aqui!

Indo para travisci.org (para reposos públicos) e siga as instruções para configurar seu repo. Conecte seu Travis CI acct ao github e especifique seu repo para teste.

Existe uma configuração necessária no Travis, seu token NPM que permitirá que o Travis publique o aplicativo, em Configurações:

Em seguida, apenas comprometa-se com o repo, ou use o console, para iniciar um teste.

Monitorize seu teste no console do Travis:

e ver resultados

Uma última coisa, o distintivo. Na README.md do repo:

que sempre mostra nosso emblema de aprovação / falha no NPM e no Github.

Finalmente, precisamos de um URL facilmente lembrado (para scripts de clientes). Usando o unpkg.com sem necessidade de configuração adicional, porque ele irá puxar o mais recente do NPM.

<script src = // unpkg.com/reponame> </ script>

Claro, para aplicativos de servidor, simplesmente

npm instalar o reponame

É isso mesmo, para a nossa estrutura que fornece testes e publicação automatizados. Por favor comente com quaisquer pensamentos ou sugestões. O exemplo de repo está em https://github.com/digplan/learn-ci

Testes felizes!

 

Fonte: https://hackernoon.com/learn-ci-automated-test-and-publish-in-10-min-3096717dc81e

Equipes de software de segurança psicológica, tolerância ao risco e alto desempenho

Alguns anos atrás, o Google decidiu pesquisar o que foi o ingrediente chave que fez algumas equipes de software na empresa mais bem sucedidas do que outras . Para sua surpresa, o traço-chave mais correlacionado com as equipes de sucesso não foi a proeza técnica, as personalidades ou os antecedentes educacionais dos membros da equipe. Em vez disso, foi a noção de segurança psicológica – ” uma crença compartilhada dos membros de uma equipe de que a equipe está segura para a tomada de riscos interpessoais “.

Segurança psicológica e cultura tecnológica às probabilidades

A pesquisa do Google mostrou que os membros de uma equipe de software de alto funcionamento compartilham um senso de confiança de que a equipe não vai embaraçar, rejeitar ou punir alguém por compartilhar suas idéias ou falar sua mente. Essa capacidade de assumir riscos e experimentar as idéias da caixa sem medo ou constrangimento leva a idéias e abordagens mais inovadoras que podem parecer estranhas ou até mesmo idiotas no início (alguém se lembra do livro de quadrinhos do Chrome ?).

No entanto, a cultura tecnológica, especialmente como definida pelas lendas de software que surgiram na década de 1980 e 1990, é inversa. Envergonhar as pessoas por idéias que alguém acredita serem precárias como forma de inspirá-las é uma abordagem familiar. Nós temos exemplos como Steve Jobschamando equipes de engenharia “f ** ing dickless a ** holes”, Bill Gates como com sua linha infame favorita “essa é a coisa mais estúpida que já ouvi” e claro, Linus Torvalds, cujos lendários inclui informar os mantenedores do kernel do Linux para “fechar o f ** k” para enviar um patch ruim.

Um ambiente de trabalho em que seu chefe o despreza em público é literalmente o oposto da segurança psicológica. Infelizmente, dado o sucesso da Apple, Microsoft e Linux, nossa indústria tem provas de existência que você pode criar produtos e empresas extremamente bem sucedidas em um ambiente de trabalho tóxico.

O alto custo da falta de segurança psicológica

Há agora um grande conjunto de pesquisas que mostram o impacto de organizações onde um ambiente de trabalho tóxico e estressante regra. Abaixo estão alguns excertos do artigo Harvard Business Review. Prova de que as culturas positivas são mais produtivas

Primeiro, os gastos com cuidados de saúde em empresas de alta pressão são quase 50% maiores do que em outras organizações. A American Psychological Association estima que mais de US $ 500 bilhões são retirados da economia dos EUA devido ao estresse no local de trabalho, e 550 milhões de dias úteis são perdidos a cada ano devido ao estresse no trabalho. Sessenta por cento a 80% dos acidentes de trabalho são atribuídos ao estresse, e estima-se que mais de 80% das visitas ao médico são devidas ao estresse. O estresse no local de trabalho tem sido associado a problemas de saúde que variam de síndrome metabólica a doença cardiovascular e mortalidade.

O estresse de pertencer às hierarquias em si está ligado à doença e à morte. Um estudo mostrou que, quanto menor a classificação de alguém em uma hierarquia, maior as chances de doenças cardiovasculares e morte por ataques cardíacos. Em um estudo em larga escala de mais de 3.000 funcionários conduzido por Anna Nyberg no Instituto Karolinska , os resultados mostraram uma forte ligação entre o comportamento de liderança e a doença cardíaca nos funcionários. Os chefes de estresse são literalmente ruins para o coração.

Há uma série de outras deficiências de não criar um ambiente de segurança psicológica no local de trabalho no artigo, mas eu pensei que a última frase acima realmente leva o ponto para casa. Um chefe que prospera na criação de um ambiente de trabalho de alta pressão está literalmente enviando seus funcionários para uma sepultura precoce.

Estruturas de desmontagem que trabalham contra a segurança psicológica

Entre as equipes, existem estruturas formais e informais que impedem as pessoas de se sentir completamente seguras de confiar e compartilhar todas as suas idéias com a equipe, independentemente de quão inane eles possam parecer ao primeiro. Em muitas empresas, a maior estrutura formal que funciona contra esse senso de confiança é um sistema de revisão de desempenho que usa alguma forma de classificação forçada .

O ranking forçado é quando os gerentes exigiam que os funcionários fossem distribuídos em uma cota fixa de trabalhadores de alto desempenho que sejam bem recompensados, artistas de médio porte que recebem menos recompensas e artistas de baixa qualidade que recebem pouca ou nenhuma recompensa ou despedido. Uma vez que existe um conjunto fixo de 10% de desempenho inferior ou 20% de melhores desempenhos, os funcionários estão basicamente competindo uns contra os outros por seus aumentos em vez de trabalhar em conjunto para o sucesso conjunto. Ninguém quer dar o seu gerente de forragem para colocá-los no final de 10%, compartilhando uma idéia aparentemente idiota , embora isso possa acabar por ser puro gênio se for perseguido .

As estruturas informais que reduzem a confiança entre os membros de uma equipe são mais difíceis de notar, mas limitam a colaboração irrestrita. É fácil dizer que se deve reduzir o snark, o gerenciamento de imagens ou garantir que pessoas particulares não dominem os outros nas discussões, mas são mais difíceis de se retirar. Aqui estão algumas técnicas que podem ajudar as equipes a se aprimorar ao serem inclusivas

  1. Amplificação: reconheça e amplie a fonte de contribuições nas discussões. Isso serve para o duplo propósito de aumentar a visibilidade da idéia de um colega de trabalho e garantir que sua idéia não seja seqüestrada por uma personalidade mais dominante na discussão. Esta técnica é discutida com mais detalhes no artigo. O truque simples que a mulher na Casa Branca usa para parar de ser interrompido .
  2. Desenhando vozes: trabalhe para garantir que todos na equipe tenham a chance de compartilhar suas perspectivas sobre decisões-chave. Em empresas de tecnologia, nós tentamos contratar pessoas inteligentes e capazes, nunca deixemos que elas falem, enquanto o mesmo grupo de pessoas domina as conversas. Muitas vezes, as pessoas que não falaram têm um ponto de vista sobre o problema que é digno de discussão e podem trazer uma nova visão. Esta prática precisa ser equilibrada, de modo que as pessoas não acabem sendo colocadas no local. Em pessoa, você pode ler a sua linguagem corporal para saber se eles estão envolvidos e quer tocar no telefone, enquanto digitalmente (por exemplo, em um canal Slack) você pode perguntar se as pessoas que não compartilharam uma opinião têm uma.
  3. Check-in antes de finalizar as decisões: Muitas vezes, as decisões-chave acabam sendo feitas por um subconjunto da equipe que é mais apaixonado pelo tema. Muitas vezes é uma boa idéia fazer o check-in com o resto da equipe antes de fechar o tópico porque algumas pessoas podem ter algo importante para adicionar, mas não a energia, para participar de um debate completo. Obtendo a tomada de decisão quando as principais partes interessadas chegaram ao consenso, permite que outros membros da equipe se sintam responsáveis ​​pela decisão enquanto estão conscientes de não reabrir discussões sem justa causa.

Segurança psicológica e o paradoxo da tolerância

Um dos temas que eu vi repetidos em linha é como o conceito de segurança psicológica enquanto trabalha em uma equipe escova contra o Paradox da Tolerância . Se você não está familiarizado com esse paradoxo, aqui está um breve trecho da entrada da Wikipédia

Menos conhecido é o paradoxo da tolerância : tolerância ilimitada deve levar ao desaparecimento da tolerância. Se ampliarmos a tolerância ilimitada mesmo para aqueles que são intolerantes, se não estamos preparados para defender uma sociedade tolerante contra o ataque do intolerante, então o tolerante será destruído e a tolerância com eles.

Há pessoas como James Damore em seu Manifesto Anti-Diversidade e Sam Altman em seu post E Pur Si Muove que argumentam que alguns funcionários talentosos não podem sentir segurança psicológica se forem capazes de expressar formas de fanatismo como o sexismo ou a homofobia. Esses argumentos ignoram a segurança psicológica de mulheres talentosas e membros LGBTQ de tais equipes.

A recomendação é direta; seja intolerante à intolerância. Não há espaço para empurrões brilhantes em equipes de alto funcionamento. Nas palavras de Reed Hastings, CEO da Netflix, o custo para o trabalho em equipe efetivo é muito alto .

 

Fonte: https://hackernoon.com/psychological-safety-risk-tolerance-and-high-functioning-software-teams-75701ed23f68

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

Sistema de correção de postura sentada em tempo real com base em sensores de pressão têxteis eletrônicos altamente duráveis ​​e laváveis

 

Destaques

•  Foi desenvolvido um sistema de correção de postura assente em tempo real com base em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• A condução de fibras de liga Ni-Ti revestidas com elastômero de poliuretano resultou em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas de sessão foram classificadas com sucesso.
• A exibição em tempo real em um monitor de mudanças na postura sentada, que faz os usuários reconhecer e corrigir o equilíbrio corporal, foi simulada.

 

 

Abstract

Foi demonstrado um sistema de correção de postura sentada em tempo real com base em sensores de pressão têxtil altamente durável e laváveis. Os sensores de pressão têxtil consistiram na condução de fibras de liga de Ni-Ti com uma excelente resistência à fadiga e um elastômero de poliuretano sensível à pressão resultou em mudança de capacitância confiável por uma pressão aplicada em uma faixa de 10 a 180 kPa com uma sensibilidade de 2,39 kPa -1. O desempenho sensitivo foi mantido em 100%, mesmo após a repetida ação de sentar mais de 1000 vezes e a dura lavagem na solução detergente. Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas sentadas, incluindo a sessão vertical, sentado com uma perna cruzada, e sentado com as duas pernas levantadas foram classificadas com sucesso. Finalmente, a exibição em tempo real em um monitor das mudanças na postura sentada foi simulada para permitir aos usuários reconhecer e corrigir o equilíbrio corporal.

Palavras-chave

  • Sensor de pressão têxtil lavável ;
  • Fibras de liga Ni-Ti revestidas com poliuretano;
  • Sensor do tipo capacitância ;
  • Correção de postura sentada

 

Fonte: https://www.sciencedirect.com/science/article/pii/S0924424717312815 

Frequência 528hz

Informações sobre frequência 528Hz

A ciência moderna começou a reconhecer o que os antigos místicos e sábios nos disseram há séculos; que tudo está em um estado constante de vibração. Desde a menor partícula física até as coisas que não podemos perceber com nossos (ainda) limitados sentidos.

O estado mais elementar da vibração é a do som. Tudo tem uma faixa ótima de vibração (frequência), cuja taxa é chamado de ressonância. Quando estamos em ressonância, estamos em equilíbrio. Cada órgão e cada célula do nosso corpo precioso absorve e emite som com uma frequência particular de ressonância ideal. Músicas sintonizadas nas frequências 432hz e 528hz criam ressonância em nosso corpo físico, mental, emocional e espiritual.

Todos os áudios e vídeos lançados pelo Clube de Meditação para Pensamentos Poderosos são ajustados para 432 Hz ou 528 Hz.

Comparado ao padrão A = ajuste de 440Hz, 528Hz é 4 Hz acima afinação padrão; A = 444Hz. Quando a música é ajustada para A = 444Hz que ressoa com C = 528Hz.

A frequência 528Hz, também chamada de frequência do amor é a nota “Milagre” da escala musical Solfeggio original. Confirmada por pesquisadores independentes, foram utilizados pelos antigos sacerdotes e curandeiros em civilizações avançadas para criar manifestações miraculosas do que é fielmente imaginado e intencionado. A frequência 528Hz ainda está sendo usada dessa maneira por aqueles que não esqueceram o seu poder.

528Hz é a bioenergia da saúde e longevidade. É a vibração harmônica que levanta seu coração. É a freqüência do Amor. Mais e mais pessoas estão despertando espiritualmente, mentalmente e emocionalmente e escolhendo estar em sintonia com 528Hz. Esta frequência de cura nos ajuda a fluir em perfeito ritmo e harmonia. Dr. Horrowtiz,  especialista nos efeitos da frequência 528Hz , nos encoraja a usar 528 Hz para restaurar a consciência humana ao seu poder e potencial.

528Hz ressoa no coração do Sol (gravada por cientistas da NASA). Raios de sol, arco-íris, flores, grama e até o zumbido de abelhas vibram em 528Hz. Natureza em equilíbrio vibram em 528Hz. É a frequência da própria vida.

Clorofila e sua cor verde / amarelo vibra em 528Hz, e é o mais poderoso pigmento de cura em biologia. O ar que respiramos é preenchido com Prana / Chi – a força vital Universal vibrando em 528Hz que, naturalmente, está restaurando e revigorando cada cordão do DNA e as células de seu corpo – favorecendo o equilíbrio, saúde e harmonia para sistemas dissonantes por falta de energia de elétrons.

 

DNA – cura – Como isso funciona?

A frequência 528 Hz foi usada por bioquímicos para reparar o ADN humano. A frequência de 528 Hz parece influenciar as moléculas de água que circundam a hélice do DNA, provocando assim efeitos de cura sobre o DNA.

Segundo o Dr. Horowitz, toda cura ocorre a partir de ondas sonoras ou vibrações ressonantes em todo o Universo. Ele afirma que as células humanas usam DNA, como rádios usam antenas, para receber as vibrações de nota e sintonizar o ritmo do corpo com o do cosmos. Ele refere-se à nota 528 Hz Solfeggio como “a frequência do amor”, que, além de proporcionar benefícios para a saúde, abre as portas para a transformação espiritual e despertar.

Isto é ecoado pelo Dr. Candice Pert, que afirma que a energia e vibração percorrem todo o caminho até o nível celular, abre os cromossomos e expõe o DNA às frequências.

Experimentos envolvendo DNA in vitro expostas a diferentes gravações de estilos musicais foram realizados por Glen Rein da Biologia Quantum Research Lab em Nova York.

Quatro estilos de música para a saúde, incluindo cantos gregorianos que usam a escala Solfeggio, foram convertidos para ondas de áudio escalares e jogado através de um leitor de CD para tubos de ensaio contendo no DNA in vitro. Os efeitos da música foram determinados através da medição de absorção de luz UV as amostras do tubo de teste de ADN “depois de uma hora de exposição à música. A absorção de luz UV é considerada como um efeito significativo no ADN porque quando a hélice DNA desenrola-se, permite que tal absorção.

Os resultados das experiências de Glen Rein mostrou que os cantos gregorianos causaram um aumento significativo na absorção de luz UV em relação música, que tinham pouco ou nenhum efeito.

 

Solfeggio 528Hz e frequência 528Hz

Há uma certa confusão em torno do 528Hz solfeggio e música sintonizada para 528Hz. Aqui está a diferença:

A frequência de 528Hz Solfeggio é um tom singular puro. Não pulsando como as batidas binaurais (duas frequências diferentes juntos) ou isocrônico (pulsar único tom).

Frequência 528Hz está relacionada com a afinação de todo o pedaço de música de padrão A = 440Hz – a C = 528Hz. Não tem nada a ver com o som do próprio tom de solfeggio (embora eles vibram no mesmo comprimento de onda).

 

Outros fatos fascinantes da frequência 528Hz

De acordo com o Dr. Leonard Horowitz, 528 Hertz é uma frequência que é central para a “matriz matemática musical da criação. 

O cientista matemática Victor Showell descreve que a vibração 528Hz é fundamental para a antiga Pi, Phi, e a média de Ouro evidente em todo o design natural. Vic Showell e John Stuart Reid (um pioneiro na pesquisa acústica e medições cymatic) provaram que 528 é essencial para a geometria sagrada de círculos e espirais consistente com estruturação DNA e reestruturação hydrosonic. Sem 528Hz, não haveria círculos, nem capacidade de medir o espaço / tempo.

528hz resolve para um 6, o ícone para a manifestação física. Isto é, 5 + 2 + 8 = 15; e 1 + 5 = 6 (usando matemática de Pitágoras). O símbolo “6” reflete a “espiral para baixo do céu para a totalidade da terra.” Na verdade, a frequência de amor pode ser fundamental para transmitir toda a matéria e energia em realidade.

…………………… ..

Ouvir música com frequência 528Hz ressoa dentro do nosso corpo, libera bloqueios emocionais e expande nossa consciência. 528Hz nos permite entrar em sintonia com a sabedoria do Universo, Inteligência Divina e nossa alma. Ele cria unidade em vez de separação. Ela amplia nossos corações e nos torna mais compassivos e amorosos. Uma coisa é certa. Uma pessoa que ressoa com amor ter paz interior – está em harmonia com o ponto de partida para um mundo foram vivemos em unidade, paz e harmonia uns com os outros e-Mãe Terra.

 

Fonte: https://clubedemeditacaoparapensamentospoderosos.wordpress.com/2017/01/16/frequencia-528hz/

Elucidando a Natureza da Consciência Humana Através da Arte

Uma entrevista com Greg Dunn

Por Linda Codega

Depois de receber seu doutorado em neurociência em 2011, o artista Greg Dunn tomou uma decisão não convencional: dedicar-se a sua arte. Um observador há muito tempo da consciência humana, suas imagens do cérebro humano foram exibidas em museus em todo os Estados Unidos, incluindo o Instituto Franklin. Ele falou recentemente com o Garrison Institute sobre sua arte, filosofia da mente e por que ele compara seu trabalho com o de artistas zen.

Como você começou como artista profissional?

Meu plano original era seguir a rota acadêmica. Então eu comecei a pintar o primeiro ano no meu grau de neurociência. Em algum momento, percebi que não estava produzindo nada no laboratório que outros não poderiam ter produzido – eu era um cientista decente, mas não um genial. Eu senti que a combinação dos meus interesses que se manifestava na arte estava fazendo mais uma contribuição. Eu realmente me tornei um artista no último ano da escola de graduação. Foi tão surpreendente para mim como qualquer outra pessoa.

Tanto no seu foco científico quanto no seu trabalho artístico, você se concentrou no cérebro humano. Por quê?

Sempre tive dificuldade em escolher o que eu vou passar o meu tempo. O cérebro é o último denominador comum para tudo o que você poderia fazer ou pensar. Todo mundo tem um. Não é mais expansivo do que isso.

Há tantas maneiras de olhar para o cérebro – do ponto de vista bruto, anatômico e funcional ao produto metafórico. Também estou interessado no equilíbrio do que é hardwired e o que é aprendido. Você poderia passar uma vida explorando isso. E, do ponto de vista prático, não há muitas pessoas que pintam o cérebro. E se eles são, eles geralmente não têm doutorado em neurociência.

Então, em certo sentido, o cérebro é uma tela em branco e todas as telas únicas já criadas. Quais são as diferenças entre abordar o cérebro através da arte e da ciência?

É difícil diferenciar. Eu acho que o máximo que eu já aprendi sobre o cérebro estava trabalhando no Self Reflected , que era um projeto de dois anos desse gigante, microetching animado. Quando eu estava tentando envolver a cabeça sobre como comunicar idéias sobre o cérebro, eu decidi realmente enfatizar que o cérebro está ao lado do equilíbrio da faca entre a ordem e o caos. Tornou-se evidente que, quando o cérebro está se diferenciando, há literalmente dezenas de bilhões de coisas acontecendo.

O grau de sofisticação que o cérebro não conseguiu tolerar essa quantidade de aleatoriedade se não tivesse um mecanismo compensatório. Esse aspecto tornou-se muito claro quando eu tentava orquestrar meio milhão de neurônios e como eles se conectam. Tornou-se evidente que este era um problema substancial que a evolução tinha de resolver em algum momento. Ciência e arte tornaram-se inseparáveis.

Auto refletido por Greg Dunn | 2012

Você pode explicar seu processo para criar as imagens usadas no Self Reflected ?

A idéia básica por trás do microetching reflexivo é um modelo gigante e reflexivo que tem o potencial, através de ângulos de corrosão na superfície do ouro, para descrever o movimento. É um primo para o hológrafo. Podemos codificar animações através de matemática muito precisa de onde a luz é e onde os ângulos são gravados em relação a ela.

Primeiro, pesquisamos todas as regiões do cérebro para descobrir o que os neurônios pareciam, o que eles estavam conectados e os padrões de disparo. Essa informação foi compilada em enormes planilhas, que foram usadas como referências para pintar todos os neurônios do cérebro. Pusimos talvez cinco exemplos de nervos no cérebro, então talvez 150 neurônios diferentes, então os digitalizamos no computador e os transformamos em matemática. Eles se tornaram objetos vetoriais, que é uma descrição matemática de um esboço, o que permite que você trabalhe com esse objeto com muito mais flexibilidade do que você poderia em uma imagem feita de pixels.

Nós pintamos todos os neurônios usando esse método e colocamos provavelmente um milhão deles para baixo. E então, desenhamos a questão branca, que são todas as conexões entre os neurônios. Esses são os axônios que viajam ao longo do cérebro em polegadas. Usando imagens de espectro de difusão com um scanner de ressonância magnética, gravamos uma difusão de moléculas de água em voxels, que é um pixel tridimensional no cérebro. Esta varredura produziu um mapa tridimensional de onde todos esses bilhões de axônios vão e o que eles parecem.

Usamos esses dados como um guia para desenhar os axônios e, em seguida, alimentamos nossos dados de axônios e nossos dados de neurônios em um algoritmo. Começou a formar este grupo de neurônios, a se conectar a axônios e depois enviou alguns desses neurônios, conecte-se a este grupo de axônios, e assim por diante para construir essas cadeias de atividade que criam a forma do cérebro. O algoritmo nos ajudou a fazer essas conexões, finalizar o tempo das conexões e, em alguns casos, ajudar a desenhar como são os axônios. Ele basicamente simulou o que a atividade de meio milhão de neurônios parece ao mesmo tempo.

Demorou meses e meses para descobrir muitas coisas. No final, após cerca de dez dias apenas de processamento informático dedicado, cuspiu as imagens dos dados de temporização. São imagens de cor de arco-íris, onde a cor codifica a animação. Os pixels vermelhos seriam visíveis no início da animação, e então você veria os laranja, depois amarelo, verde, azul e, finalmente, violeta.

Acho que uma coisa que é importante dizer é que não é uma varredura. Nós não tiramos fotos através de um microscópio. Nós fizemos essa peça para poder ver a atividade neural na escala de neurônios individuais e para vê-lo no contexto de todo o cérebro. Essa é a razão pela qual colocamos tantos esforços no Self Reflected , porque queríamos mudar a maneira como as pessoas pensam sobre o cérebro. Tivemos que inventar todas essas técnicas para comunicar o que queríamos.

Auto refletido por Greg Dunn | 2012

Qual é a visão microscópica que você achou tão inspiradora?

É incrível o quanto dela surgir. Os próprios neurônios são imensamente lindos. Suas formas são um testemunho de como o caos governa nosso ambiente. Você vê as formas dos neurônios em ramos de árvores, raios e rachaduras no pavimento. Muitas vezes é a forma que você obtém quando você tem alguma força que está causando uma linha alongada. É a energia encontrar o caminho de menor resistência.

Isso é maravilhoso, a capacidade de ver os neurônios exibidos uma e outra na natureza.

É incrível. Você vê formas neurais em superglus galácticos; Milhares de galáxias orientadas no universo. Você está apenas a coçar a cabeça, perguntando o que isso tem a ver conosco? Comigo? É uma idéia muito bizarra. Você vê isso de forma independente da escala. É mais evidência de que o universo se arrumasse nesses tipos de padrões de repetição.

Você disse que há uma qualidade Zen para os neurônios que você captura. O que você quer dizer com isso?

É muito parecido com formas antigas de arte. Muitos pintores de tinta Sumi-e foram monges que praticaram durante muitos anos para poder pintar com apenas alguns traços simples. Uma coisa que é característica dessa forma de arte é o uso de espaço negativo e padrões de ramificação aleatórios. O cérebro sugere fazer coisas aleatórias. É preciso prática para desbloquear sua mente do desejo de fazer padrões. Aprender a pintar como esse é um método para libertar sua mente. É uma das razões pelas quais os mestres da pintura de Sumi-e passam a vida inteira aprendendo a apagar seu contexto, para que a espontaneidade apareça. Isso é o que eu vejo como Zen; criando sem pensar.

Você tem uma prática contemplativa própria?

No meu início dos anos 20, eu estava muito a sério considerando ser um monge. Eu mantive uma prática ao longo dos anos, e eu tenho um tanque de privação sensorial na minha casa. É uma parte importante da minha vida e quem eu sou.

Uma coisa que eu realmente quero fazer é se divorciar do máximo possível do dogma. Eu falo sobre as mesmas idéias, mas não quero que as pessoas reajam ao fato de que está funcionando de uma forma tradicional. O restante secular evita a reação do joelho.

Quando você está criando essas peças, em que tipo de mentalidade você está?

Eu sempre pinto melhor quando meditei de antemão – todas as vezes. Eu esqueço que às vezes, mas isso sempre, sempre ajuda. Francamente, apenas me deixa melhor em tudo. Apenas em termos de silenciar fisicamente seu corpo e limpar sua mente antes de começar a pintar.

Fonte: https://www.garrisoninstitute.org/blog/human-consciousness-art/

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/

Tutorial: instalando e usando o Sass no Windows

Uma coisa que eu achava antes de mexer com Sass é que eu precisava usar Linux ou Mac, ou que daria muito trabalho instalar tudo no meu PC. Mas dá pra trabalhar com Sass no Windows sim!

E a galera pediu no post “CSS menos sofrido com Sass” um guia de como trabalhar com Sass no nosso sistema operacional do coração.
Primeiramente mostro como preparar o ambiente e depois um teste rápido.
Então segue um guia de como instalar o Sass no Windows:

1 – Instale o Ruby

Baixe aqui o RubyInstaller de acordo com a sua versão* do Windows e instale se preocupando com a observação da imagem abaixo:

Cuidado: Marque a opção “Add Ruby executable to your PATH”!


* Se não souber  se o seu Windows é 32 ou 64 bits, basta dar o atalho Win+PauseBreak. Será mostrada uma tela com informações do seu sistema, e em “Tipo de sistema”, a versão que você tem instalada.

2 – Confira se está tudo bem

Dê uma conferida se está tudo bem até agora, indo no prompt / terminal (Win+R > cmd) e dando o comando:

ruby -v

Deve aparecer a versão do Ruby como na imagem abaixo:

Não esquente se a versão estiver um pouco diferente.

3 – Ruby instalado, instale o Sass

No prompt mesmo, dê o comando:

gem install sass

Se deu algum erro, confere se o Ruby está instalado mesmo e/ou tenta instalar manualmente a gem.

4 – Verifique o Sass

Aquela conferida básica para ver se o Sass foi instalado mesmo:

sass -v

Deve aparecer a versão do Sass instalada:

5 – Ambiente todo ok, agora um teste!

Crie uma pasta para teste.
Dentro dela crie um arquivo chamado “teste.scss”.
E nesse arquivo, coloque um código como esse:

$cor-legal: #BADA55;
.course {
  color: $cor-legal;
}

6 – Compile o Sass

Agora na pasta de teste, abra o prompt digitando “cmd .” (sem aspas) na barra de endereços.
O prompt vai abrir direto na pasta.
Agora compile o arquivo scss em um arquivo CSS com o comando:

sass teste.scss:teste.css

O ideal é não ter que compilar na mão, mas como estamos testando não tem problema.

7 – Dê uma conferida no CSS

Se foi tudo ok até aqui, foi gerado um teste.css na sua pasta.
Dé uma conferida se ele está parecido com esse:

.course {
  color: #BADA55; }

8 – Agora é só alegria! Tranquilo, né? 🙂

Outros sistemas operacionais?

Se você usa Mac, o Ruby já vem instalado, só instalar o Sass do mesmo jeito que mostrei.
Se você usa Linux, o comando “\curl -sSL https://get.rvm.io | bash -s stable” (sem aspas) instala o Ruby para você.

O Sass não é só variáveis

Eu explico as principais features do Sass no curso da Alura, dá uma olhada no conteúdo do curso de Sass. Escrevi também um livro de Sass em que mostro essa fantástica ferramenta.
Conseguiu instalar e testar 100%? Teve algum problema?

 

 

 

 

Fonte: http://blog.caelum.com.br/tutorial-instalando-usando-sass-no-windows/

Primeiros passos com MongoDB

O MongoDB é um banco de dados documental (Orientado a documentos) open source que proporciona escalabilidade e flexibilidade ao projeto pois ele aninha os dados em documentos JSON e BSON, com isso se tornam simples as buscas. Nesse post farei uma Introdução ao formato “Javascript Object Notation” (JSON), ao BSON e aos primeiros passos com o MongoDB.

O JSON é um formato leve de troca de dados. Para seres humanos, é simples de ler e escrever e para máquinas, é fácil de interpretar e gerar.Quando se fala em aplicações AJAX, o JSON é mais rápido e mais fácil do que o XML.

Com o formato JSON, sempre teremos objetos de Chave-Valor, onde podemos observar alguns pontos característicos:

– As chaves são do tipo “String”.

– O delimitador entre Chave-Valor é o “:” (dois pontos).

– Cada entrada “Chave-Valor” é separada por “,” (vigula).

– Cada objeto JSON é delimitado por “{}” (Chaves).

Utilizando o exemplo abaixo, explicarei os campos que podem compor o “Valor” dentro de um objeto do formato Json.

 

– O nome do livro e a data de lançamento são do tipo “String”.

– A quantidade de páginas é do tipo numérico.

– O status de publicado é do tipo booleano.

– Já o Gênero está recebendo uma matriz.

OBS: Podemos ter valores dos tipos (string, number, object, array, true, false, null)

No mongoDB como complemento ao JSON, existe o BSON que suporta a incorporação de objetos e matrizes dentro de outros objetos e matrizes, ou seja o MongoDB através do BSON cria índices e compara objetos com expressões de consulta em chaves BSON de nível superior que estão aninhadas, isso significa que o MongoDB oferece aos usuários a simplicidade e a flexibilidade dos documentos JSON, juntamente com a velocidade e a riqueza de um formato binário leve.

Basicamente o BSON nasceu com três vértices principais:

– “Lightweight” (Leveza):

O BSON mantem a sobrecarga no mínimo e isso é importante para qualquer formato de representação de dados, especialmente quando usado na rede.

– “Traversable” (Atravessáveis):

O BSON é projetado para mover-se facilmente. Esta é uma propriedade vital para o MongoDB.

– “Efficient” (Eficiente) :

A Codificação de dados e decodificação do BSON pode ser realizada muito rapidamente na maioria das linguagens devido ao uso de tipos de dados C.

Para maiores informações sobre o BSON, segue o link do bsonspec http://bsonspec.org/

Após esta rápida introdução, vamos instalar e dar os primeiros passos com o MongoDB, nesse exemplo vou fazer a instalação em um CentOS, caso você precise instalar em outra plataforma, deixo o link oficial.

– Instalação no Linux.

– Instalação no Windows.

– Instalação no OS X.

Primeiramente vamos adicionar o repositório do MongoDB.

vim /etc/yum.repos.d/mongodb-org.repo

[mongodb-org-3.4]

name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc

 

Vamos atualizar nossa lista de repositórios.

yum repolist

Instalando o MongoDB.

yum install mongodborg

Habilitando o MongoDB em todo boot.

systemctl enable mongod

Iniciando o serviço do MongoDB.

systemctl restart mongod

Nesse momento já podemos acessar a CLI do MongoDB, utilizando o comando “mongo”.

mongo
MongoDB shell version v3.4.3
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 3.4.3
>

Quando acessamos a CLI, nos é mostrado a versão do shell, a string de conexão (mongodb://127.0.0.1:27017) nesse caso localhost e a versão do MongoDB instalado.

OBS: Para limpar a tela, podemos utilizar o “CTRL+L ou cls”

Para termos acesso a uma lista completa de comandos, podemos utilizar o help

 

> help

Vamos listar todos os bancos de dados existentes.

> show dbs
admin 0.000GB
local 0.000GB

 

Por padrão o mongoDB vem com duas bases criadas (local e admin), ambas vazias.

Como o MongoDB é um banco de dados documental, ele não trabalha com tabelas e sim “Collections”, para criarmos as nossas collections precisamos estar dentro de algum banco de dados, para acessamos um banco de dados utilizaremos o comando “use”.

> use livros

 

Percebam que o banco de dados “livros” não existia, quando usamos o comando “use” ele verificou a existência, nesse caso como não existia ele criou automaticamente. Para realizarmos operações de inserção, atualização, leitura e remoção de dados no MongoDB, podemos usar algum script remoto fazendo isso ou podemos executar isso direto no shell. Se executarmos direto no shell, podemos usar uma variável global chamada “db”, essa variável faz referencia ao banco de dados no qual você está conectado, no nosso caso o banco “livros”.

Com esse comando nós vamos fazer uma inserção única em uma collection que ainda não existe.

 

> db.misterios.insertOne({ nome : Ponto de Impacto})
{
acknowledged : true,
insertedId : ObjectId(58ee79afcc3801bb06082423)
}

 

Esse retorno indica duas coisas:

1. A gravação foi reconhecida;

2. Foi gerado um campo único e ele foi atribuído ao documento (todo documento precisa de um _id).

Após isso, a collection “misterios” acabou de ser criada, e possui um documento, para verificar o conteúdo dela, vamos gerar uma listagem completa.

 

1
2
3
> db.misterios.find()
{ “_id” : ObjectId(“58ee79afcc3801bb06082423”), “nome” : “Ponto de Impacto” }

 

Um ponto interessante é que mesmo não passando, o próprio mongo inseriu o campo “_id”, parece ser algo totalmente aleatório, porem segue uma sequencia lógica, é uma string com 12 bytes hexadecimais, como descrito abaixo.

      Data             Mac Address              Pid                 Contador

ObjectId:         _ _ _ _       |           _ _ _            |           _ _         |            _ _ _

Os quatro primeiros campos são criados a partir do segundo atual da máquina, em seguida 3 campos nascem com base no endereço Mac da máquina, depois dois campos surgem do “Process ID” e por último um contador randômico que gera mais 3 bytes.

Farei uma sequencia de posts relacionados a MongoDB, nos posts seguintes, mostrarei outros métodos de inserção e faremos o CRUD utilizando a shell do MongoDB. Espero que esse primeiro post esclareça alguns conceitos do MongoDB e de como ele funciona.

 

 

 

 

Fonte: https://www.fordevops.com/primeiros-passos-com-mongodb/

 

 

NASA CORTA TRANSMISSÃO AO VER FROTA DE “OBJETOS NÃO IDENTIFICADOS” SOBREVOANDO ESTAÇÃO

Uma das maiores curiosidades humanas é se existe ou não vida em outros planetas e universos e se essas vidas, independente de quais sejam, nos observam de longe.
Boatos e imagens de possíveis Ovnis ou objetos estranhos nos céus é o que não faltam na internet, isso sem contar todos os trabalhos de ficção feitos todos os anos, que mexem com o espectador sobre essa possibilidade. Agora, mais um momento pode entrar para a lista das suspeitas se existem ou não ETs e se em alguma hora, eles vão nos fazer uma visita. A NASA estava fazendo a transmissão de uma Estação Internacional no Espaço quando uma frota de objetos não-identificados aparece na imagem. Sem pensar duas vezes, o controlador corta a transmissão.
Ufólogos que estão sempre atrás de evidências para garantir que existe vida fora da Terra conseguiram um trecho da transmissão, que pode se ver ao fundo objetos passando pela Estação Espacial Internacional. Primeiro, um passa sozinho. Em seguida, podem ser observados outros objetos circulares também invadindo a imagem. A NASA sempre afirma qu que pode ser algum objeto espacial, para não entrar no assunto. Mas, ufólogos ficaram impressionados porque os objetos pareciam movimentar-se em uma formação.

 

Vale ainda lembrar que essa não é a primeira vez que a NASA decide cortar transmissões ao vivo quando algo enigmático toma conta da tela. Em outras oportunidades, como em 2014, a agência espacial fez a mesma coisa e não quis dar explicações sobre o que seria aquela “coisa” passeando pelo universo. A gravação foi postada na internet e levantou dúvidas em muitas pessoas. Especialistas no assunto garantem que pelo menos seis objetos são muito maiores do que as partículas de gelo do espaço, que são sempre usadas como explicação pela NASA.
Alguns objetos, como contam os ufólogos, realmente são as partículas de gelo ou pedaços de algum satélite antigo. No entanto, diversas vezes objetos muito estranhos foram vistos e nunca receberam uma explicação plausível do que poderiam ser. Abaixo você confere o vídeo e pode dar a sua opinião, se realmente pode ser outra vida ou se é apenas algum componente perdido do espaço.

 

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

Módulo GPS Skylab SKM53

Este módulo opera com 5V e assim que é energizado começa a transmitir coordenadas no pino TXD (mas só serão válidas após o tempo de fix) , repetindo a cada 1s. A baudrate é 9600bps. O pino RXD só tem utilidade se você quiser reconfigurar o módulo, por isso você pode deixá-lo desconectado.

Teste básico

(não requer que o GPS esteja vendo satélites)

No Arduino Mega

Atenção: qualquer exemplo que você pegar na internet que use a biblioteca Newsoftserial poderá não funcionar no Mega. Nesse modelo de arduino, use as portas seriais reais.

Ligue o TXD do GPS no pino RX1 do Mega

Rode o sketch (não é preciso mudar nada) Examples -> Communication -> MultiserialMega

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

$GPRMC,204433.215,V,,,,,0.00,0.00,131013,,,N*48
$GPGGA,204434.215,,,,,0,0,,,M,,M,,*4B
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,1,1,01,09,,,23*70

 

No Arduino UNO

Instale a biblioteca NewSoftSerial

Ligue o TXD do GPS no pino 2 do Arduino.

Rode o seguinte sketch, ligeiramente adaptado do exemplo TwoPortReceive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <SoftwareSerial.h>
SoftwareSerial portOne(2,3);
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// Start each software serial port
portOne.begin(9600);
}
void loop()
{
// By default, the last intialized port is listening.
// when you want to listen on a port, explicitly select it:
portOne.listen();
Serial.println("Recebido do GPS:");
// while there is data coming in, read it
// and send to the hardware serial port:
while (portOne.available() &gt; 0) {
char inByte = portOne.read();
Serial.write(inByte);
}
delay(1000);
Serial.println("");
Serial.println("");
}

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

 

Recebido do GPS:
$GPGGA,210946.907,,,,,0,0,,,M,,M,,*4E
$GPGSA,A,1,,,,,,,,,,,,,,

Teste completo

Não faça este teste se sua instalação não tiver passado ainda no teste básico.

Neste teste o GPS precisa ver os satélites. Para isso você precisa estar num local que tenha visão direta para o céu e o lado da antena do GPS precisa estar voltado para cima.

Em um Arduino UNO

Instale a biblioteca TinyGPS (documentação e download da v13). Requer NewsoftSerial.

Conecte o TXD do GPS ao pino 4 do UNO.

Carregue o exemplo Examples -> TinyGPS -> test_with_gps_device

Mude a linha

ss.begin(4800);

para

ss.begin(9600);

Faça o upload do sketch.

Em um Arduino Mega

Instale a biblioteca TinyGPS (documentação e download da v13).

Conecte o TXD do GPS a RX1 do Mega.

Atenção: Os exemplos do TinyGPS usam a biblioteca Newsoftserial, que tem certos problemas para funcionar no Mega. Por isso eu fiz ligeiras modificações no exemplo para usar uma porta serial real do Mega.

Faça o upload do seguinte sketch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <TinyGPS.h>
/* Exemplo test_with_gps_device modificado para usar a porta serial 1
do Arduino Mega.
Jefferson Ryan - Automalabs - 13/10/2013
*/
TinyGPS gps;
static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);
void setup()
{
Serial.begin(115200);
Serial1.begin(9600);
Serial.print("Testing TinyGPS library v. ");
Serial.println(TinyGPS::library_version());
Serial.println("by Mikal Hart");
Serial.println();
Serial.println("Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt    Course Speed Card  Distance Course Card  Chars Sentences Checksum");
Serial.println("          (deg)     (deg)      Age                      Age  (m)    --- from GPS ----  ---- to London  ----  RX    RX        Fail");
Serial.println("-------------------------------------------------------------------------------------------------------------------------------------");
}
void loop()
{
float flat, flon;
unsigned long age, date, time, chars = 0;
unsigned short sentences = 0, failed = 0;
static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
gps.f_get_position(&flat, &flon, &age);
print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
print_date(gps);
print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);
gps.stats(&chars, &sentences, &failed);
print_int(chars, 0xFFFFFFFF, 6);
print_int(sentences, 0xFFFFFFFF, 10);
print_int(failed, 0xFFFFFFFF, 9);
Serial.println();
smartdelay(1000);
}
static void smartdelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial1.available())
gps.encode(Serial1.read());
} while (millis() - start < ms);
}
static void print_float(float val, float invalid, int len, int prec)
{
if (val == invalid)
{
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
}
else
{
Serial.print(val, prec);
int vi = abs((int)val);
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i<len; ++i)
Serial.print(' ');
}
smartdelay(0);
}
static void print_int(unsigned long val, unsigned long invalid, int len)
{
char sz[32];
if (val == invalid)
strcpy(sz, "*******");
else
sprintf(sz, "%ld", val);
sz[len] = 0;
for (int i=strlen(sz); i<len; ++i)
sz[i] = ' ';
if (len > 0)
sz[len-1] = ' ';
Serial.print(sz);
smartdelay(0);
}
static void print_date(TinyGPS &gps)
{
int year;
byte month, day, hour, minute, second, hundredths;
unsigned long age;
gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
if (age == TinyGPS::GPS_INVALID_AGE)
Serial.print("********** ******** ");
else
{
char sz[32];
sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
month, day, year, hour, minute, second);
Serial.print(sz);
}
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
smartdelay(0);
}
static void print_str(const char *str, int len)
{
int slen = strlen(str);
for (int i=0; i<len; ++i)
Serial.print(i<slen ? str[i] : ' ');
smartdelay(0);
}

 

 

Se seu GPS estiver enxergando os satélites, a saída será parecida com isto (eu dividi em duas partes porque não cabia na tela e alterei as coordenadas por privacidade):

 

Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
9    91   8.022881 34.324093 83   10/13/2013 22:18:40 95   20.00
9    91   8.022881 34.324093 89   10/13/2013 22:18:41 102  20.00
9    91   8.022881 34.324093 101  10/13/2013 22:18:42 113  20.00
9    91   8.022881 34.324093 122  10/13/2013 22:18:43 135  20.00
9    91   8.022881 34.324093 134  10/13/2013 22:18:44 148  20.00
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   39    0         1
60.25  0.00  ENE   7418     22.79  NNE   502   2         1
60.25  0.00  ENE   7418     22.79  NNE   944   4         1
60.25  0.00  ENE   7418     22.79  NNE   1393  6         1
60.25  0.00  ENE   7418     22.79  NNE   1850  8         1
60.25  0.00  ENE   7418     22.79  NNE   2299  10        1
Se seu GPS não estiver enxergando os satélites, a saída de TinyGPS será parecida com isto (eu dividi em duas partes porque não cabia na tela):
Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   0        0         0
****** ***** ***   *******  ****** ***   136    0         0
****** ***** ***   *******  ****** ***   272    0         0
****** ***** ***   *******  ****** ***   408   0         0
****** ***** ***   *******  ****** ***   544   0         0

 

Note que o valor de Chars RX está incrementando em passos fixos (no caso, 136). Isso siginifica que a biblioteca está recebendo dados do GPS, mas não há coordenadas válidas nesses dados. Se Chars RX não estiver incrementando verfique todas as conexões.

Se você realmente precisar reconfigurar esse GPS, o documento MTK NMEA Packet User Manual (link para download no fim do texto) pode ser o que você precisa. Eu não testei, não aconselho seu uso e não dou garantias. Se você mexer nas configurações considere minha garantia finalizada. Estou fornecendo o arquivo apenas para sua conveniência.

 

http://www.automalabs.com.br/download/SkyNav_SKM53_Datasheet.pdf

http://www.automalabs.com.br/download/PMTK_Protocol.pdf

 

Fonte: http://www.automalabs.com.br/modulo-gps-skylab-skm53/#comment-2321