Linguagem Elixir

Elixir é uma linguagem dinâmica e funcional projetada para a criação de aplicativos escaláveis ​​e de manutenção.

O Elixir aproveita a Erlang VM, conhecida por executar sistemas de baixa latência, distribuídos e tolerantes a falhas, além de ser usada com sucesso no desenvolvimento da Web e no domínio de software incorporado.

Para saber mais sobre o Elixir, consulte nosso guia de introdução e nossa página de aprendizado para outros recursos . Ou continue lendo para obter uma visão geral da plataforma, idioma e ferramentas.

Recursos da plataforma

Escalabilidade

Todo o código Elixir é executado dentro de threads de execução leves (chamados processos) que são isolados e trocam informações por meio de mensagens:

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

Devido à sua natureza leve, não é incomum ter centenas de milhares de processos em execução simultaneamente na mesma máquina. O isolamento permite que os processos sejam coletados de maneira independente, reduzindo as pausas em todo o sistema e usando todos os recursos da máquina da maneira mais eficiente possível (escala vertical).

Os processos também podem se comunicar com outros processos em execução em máquinas diferentes na mesma rede. Isso fornece a base para a distribuição, permitindo que os desenvolvedores coordenem o trabalho em vários nós (escala horizontal).

Tolerância ao erro

A verdade inevitável sobre o software em execução na produção é que as coisas vão dar errado . Ainda mais quando levamos em consideração a rede, os sistemas de arquivos e outros recursos de terceiros.

Para lidar com falhas, o Elixir fornece supervisores que descrevem como reiniciar partes do seu sistema quando as coisas dão errado, voltando a um estado inicial conhecido que é garantido que funcione:

children = [
  TCP.Pool,
  {TCP.Acceptor, port: 4040}
]

Supervisor.start_link(children, strategy: :one_for_one)

A combinação de escalabilidade, tolerância a falhas e programação orientada a eventos por meio da passagem de mensagens faz do Elixir uma excelente opção para arquitetura e programação reativa.

Caracteristicas do idioma

Programação funcional

A programação funcional promove um estilo de codificação que ajuda os desenvolvedores a escrever um código curto, conciso e sustentável. Por exemplo, a correspondência de padrões permite que os desenvolvedores destruam facilmente os dados e acessem seu conteúdo:

%User{name: name, age: age} = User.get("John Doe")
name #=> "John Doe"

Quando combinada com guardas, a correspondência de padrões nos permite combinar e declarar condições específicas para que algum código seja executado:

def drive(%User{age: age}) when age >= 16 do
  # Code that drives a car
end

drive(User.get("John Doe"))
#=> Fails if the user is under 16

O Elixir depende muito desses recursos para garantir que seu software esteja funcionando sob as restrições esperadas. E quando não estiver, não se preocupe, os supervisores estão de costas!

Extensibilidade e DSLs

O Elixir foi projetado para ser extensível, permitindo que os desenvolvedores estendam naturalmente a linguagem para domínios específicos, a fim de aumentar sua produtividade.

Como exemplo, vamos escrever um caso de teste simples usando a estrutura de teste do Elixir chamada ExUnit :

defmodule MathTest do
  use ExUnit.Case, async: true

  test "can add two numbers" do
    assert 1 + 1 == 2
  end
end

async: trueopção permite que tests sejam executados em paralelo, usando o maior número possível de núcleos de CPU, enquanto a assertfuncionalidade pode introspectar seu código, fornecendo ótimos relatórios em caso de falhas. Esses recursos são criados usando as macros do Elixir, possibilitando adicionar novas construções como se fizessem parte da própria linguagem.

Recursos de ferramentas

Um ecossistema em crescimento

O Elixir é fornecido com um ótimo conjunto de ferramentas para facilitar o desenvolvimento. O Mix é uma ferramenta de compilação que permite criar facilmente projetos, gerenciar tarefas, executar testes e muito mais:

$ mix new my_app
$ cd my_app
$ mix test
.

Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
1 tests, 0 failures

O Mix também é capaz de gerenciar dependências e se integra ao gerenciador de pacotes Hex , que executa a resolução de dependências, busca pacotes remotos e hospeda documentação para todo o ecossistema.

Desenvolvimento interativo

Ferramentas como o IEx (shell interativo do Elixir) são capazes de alavancar muitos aspectos do idioma e da plataforma para fornecer ferramentas de depuração automáticas, recarga de código, recarga de código e documentação bem formatada:

$ iex
Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
iex> h String.trim           # Prints the documentation for function
iex> i "Hello, World"        # Prints information about the given data type
iex> break! String.trim/1    # Sets a breakpoint in the String.trim/1 function
iex> recompile               # Recompiles the current project on the fly

Erlang compatível

O Elixir é executado na VM Erlang, oferecendo aos desenvolvedores acesso completo ao ecossistema da Erlang, usado por empresas como Heroku , WhatsApp , Klarna e muito mais para criar aplicativos distribuídos e tolerantes a falhas. Um programador Elixir pode chamar qualquer função Erlang sem custo de tempo de execução:

iex> :crypto.hash(:md5, "Using crypto from Erlang OTP")
<<192, 223, 75, 115, ...>>

Para saber mais sobre o Elixir, consulte o nosso guia de primeiros passos . Também temos documentação online disponível e um Crash Course para desenvolvedores de Erlang .

Fonte: https://elixir-lang.org/

Use o Firebase Cloud Functions para buscar uma imagem e transformá-la em base64

Publicado pela primeira vez: 14 de novembro de 2019
Atualizado em: 14 de novembro de 2019

Você já manipulou imagens em um servidor?

Esse era um requisito que eu tinha um tempo atrás que não sabia como resolver no momento.

Estávamos trabalhando jsPDFpara criar PDFs de relatórios em um de nossos aplicativos Ionic, mas tivemos um problema: todas as nossas imagens eram armazenadas on-line e você não pode passar um URL jsPDFpara as imagens.

Leva apenas base64, URI de dados e acho que o objeto blob.

Nossa primeira tentativa foi fazer o lado do cliente de transformação base64 e enviar todas essas cadeias para criar o PDF. A questão era que, se tivéssemos mais de 10 imagens, elas começavam a ficar lentas.

Por isso, decidimos mudar esse servidor e criamos uma função de nuvem que a tratava para nós.

Para isso, precisamos de uma função de nuvem que:

  • Escuta o banco de dados quando adicionamos o URL das imagens regulares.
  • Redimensiona essa imagem para não armazenar algo pesado.
  • Transforma para base64.
  • Armazena a sequência base64 no banco de dados.

Com isso em mente, vamos para a codificação, este artigo supõe que você já tenha um projeto e tenha o Cloud Functions inicializado; caso contrário, passe por este artigo primeiro .

Instalando os pacotes que precisamos

A primeira coisa que faremos é instalar os pacotes de que precisamos; no nosso caso, são dois, usamos o requestpacote para buscar a URL da imagem e o sharppacote para redimensioná-la.

npm install request sharp

E, em seguida, importe-os na parte superior do arquivo de funções

var request = require('request').defaults({
  encoding: null
});
const sharp = require('sharp');

Estamos usando encoding: nullpara dizer à solicitação que você deseja um buffer, não uma string. Precisamos desse buffer para criar a string base64.

Criar a função de nuvem

Queremos primeiro criar a função que atende ao banco de dados, com algumas verificações no local. No nosso caso, tínhamos uma coleção de projetos e cada documento tinha uma foto antes e depois necessária para o relatório:

exports.convertImageToPDF = functions.firestore
  .document('projects/{projectId}')
  .onWrite(async (change, context) => {
    // We get the project's ID from the context param.
    // We get the actual project data from the change param, we want to
    // use the .after to signal is the new data we're listening to.
    const projectId = context.params.projectId;
    const currentProject = change.after.data();
  });

Então, queremos verificar se estamos atualizando mais alguma coisa nesse projeto e já temos essa propriedade base64, queremos interromper a função.

exports.convertImageToPDF = functions.firestore
  .document('projects/{projectId}')
  .onWrite(async (change, context) => {
    const projectId = context.params.projectId;
    const currentProject = change.after.data();

    let beforePictureBase64 = currentProject.beforePictureBase64;
    let afterPictureBase64 = currentProject.afterPictureBase64;

    if (beforePictureBase64 && afterPictureBase64) {
      console('Both pictures are here');
      return;
    }
  });

Queremos perguntar, se não há imagem antes ou depois da imagem e convertê-las em base64.

Chamaremos uma função para fazer a transformação, cobriremos isso assim que terminarmos com a função de nuvem que fala com o banco de dados.

exports.convertImageToPDF = functions.firestore
  .document('projects/{projectId}')
  .onWrite(async (change, context) => {
    const projectId = context.params.projectId;
    const currentProject = change.after.data();

    let beforePictureBase64 = currentProject.beforePictureBase64;
    let afterPictureBase64 = currentProject.afterPictureBase64;

    if (beforePictureBase64 && afterPictureBase64) {
      console('Both pictures are here');
      return;
    }

    if (!beforePictureBase64) {
      // currentProject.beforePicture is the online URL of the before picture
      beforePictureBase64 = await toDataURL(currentProject.beforePicture);
    }

    if (!afterPictureBase64) {
      // Same as above but for the after picture
      afterPictureBase64 = await toDataURL(currentProject.afterPicture);
    }

    // If we get to this point and still we have no transformed images,
    // we want to stop the function.
    if (!beforePictureBase64 && !afterPictureBase64) {
      console.log('No pictures here');
      return;
    }

    // And then we want to store the base64 pictures in the same project.

    return admin
      .firestore()
      .doc(`projects/${projectId}`)
      .update({
        beforePictureBase64: beforePictureBase64 || null,
        afterPictureBase64: afterPictureBase64 || null
      });
  });

Agora, vamos falar sobre a toDataURL()função, já que toda a transformação da imagem está acontecendo lá.

Primeiro, precisamos da função de usar o URL on-line como parâmetro e retornar uma Promessa, pois faremos coisas assíncronas.

function toDataURL(url) {
  return new Promise((resolve, reject) => {});
}

Então, vamos usar o requestmódulo para buscar a imagem, se não houver erro e tudo correr bem, fazemos a manipulação da imagem, se algo estiver errado, lançamos o erro.

function toDataURL(url) {
  return new Promise((resolve, reject) => {
    request.get(url, function(error, response, body) {
      if (!error && response.statusCode === 200) {
        // Do the transformation
      } else {
        throw error;
      }
    });
  });
}

Então, redimensionaremos a imagem original, lembre-se: um documento do Firestore tem um limite rígido de 1 MB e uma imagem base64 geralmente é 30% mais pesada que a original.

function toDataURL(url) {
  return new Promise((resolve, reject) => {
    request.get(url, function(error, response, body) {
      if (!error && response.statusCode === 200) {
        return sharp(body)
          .resize(100, 100)
          .toBuffer()
          .then(resizedImage => {
            // Transform to base64
          })
          .catch(err => {
            throw err;
          });
      } else {
        throw error;
      }
    });
  });
}

Estamos usando o sharpmódulo para redimensioná-lo, passando a altura e a largura que queremos para a imagem e, em seguida, certificando-nos de que a resposta também seja um buffer.

E, finalmente, estamos formando nossa string base64:

function toDataURL(url) {
  return new Promise((resolve, reject) => {
    request.get(url, function(error, response, body) {
      if (!error && response.statusCode === 200) {
        return sharp(body)
          .resize(100, 100)
          .toBuffer()
          .then(resizedImage => {
            data =
              'data:' +
              response.headers['content-type'] +
              ';base64,' +
              new Buffer(resizedImage).toString('base64');

            resolve(data);
            return data;
          })
          .catch(err => {
            throw err;
          });
      } else {
        throw error;
      }
    });
  });
}

E é isso, a toDataURL(url)função retornará uma string base64 válida que podemos armazenar no Firestore e usar para a manipulação do pdf 🙂

Deixe-me saber se você tiver algum problema com este, foi uma grande dor para nós, tentamos várias coisas diferentes antes de chegar a isso.

Fonte: https://javebratt.com/cloud-function-image-base64/

Kit de laboratório doméstico de engenharia genética

 

 

 

Descrição do Produto

NOTA: A maneira como podemos oferecer este kit a um preço tão baixo é encontrando as melhores ofertas com nossos parceiros e fabricantes. Isso significa que este kit leva de 1 a 2 meses para ser enviado. Por favor, seja paciente e entenda que estamos fazendo o possível para chegar até você.

Consulte-nos sobre códigos de desconto para nossas aulas on-line com a compra deste kit.

Escolha nossa opção de plano de pagamento no check-out para fazer 4 pagamentos mensais.Veja mais informações aqui .

Este kit inicial do laboratório de bricolage fornece todo o equipamento, reagentes e materiais necessários para começar em biologia molecular e engenharia genética. Além disso, inclui um  kit de genotipagem e suprimentos do nosso  kit DIY CRISPR  para que você possa realizar seus primeiros experimentos! Vem com tutoriais explicando a ciência e como usar o equipamento.

Este kit vem com

  • Máquina de PCR com tampa aquecida
  • Tubos de PCR
  • Um conjunto de 3 novas pipetas de grau laboratorial
  • Pontas de pipeta para cada pipeta
  • Caixa de eletroforese em gel de agarose e molde de gel com pente
  • Rack de tubo
  • Uma fonte de alimentação para executar a eletroforese
  • 2 powerchords
  • Almofada de aquecimento com temperatura controlada para culturas em crescimento
  • 10g Agarose
  • 50g de mistura de tampão TAE (27g de base Tris / 23g de acetato de Tris / 0,5g de EDTA)
  • 5g de sulfato de canamicina
  • 5g de ampicilina de sódio
  • 40g de ágar LB
  • 20g LB Media
  • Manga de 20 placas de Petri
  • Balanças de 0,01g – 200g e balanças
  • Óculos trans-eye-luminator e luz azul
  • 5 x 15mL Tubes
  • 5 x tubos de 50 ml
  • bactérias ativadas por luz pDusk, pDawn
  • pJE202 bactérias brilhantes bioluminescentes geneticamente modificadas
  • 100uL Gel Verde Mancha 10.000x
  • 500uL 5x Taq Master Mix
  • Corante de carregamento de DNA de 200 uL
  • 100uL 100bp DNA Ladder
  • 100uL 1kbp DNA Ladder
  • Kit de Genotipagem
  • Suprimentos do  kit DIY CRISPR
  • Microcentrífuga 10k novíssima

https://www.the-odin.com/genetic-engineering-home-lab-kit/

Jython – A linguagem que mistura Java com Python

Essa linguagem une duas boas ferramentas numa só. 🐍

Introdução

Jython é uma implementação da linguagem Python que gera bytecode para máquinas Java (JVM – Java Virtual Machine). Com ela é possível fazer o desenvolvimento de aplicações híbridas que unem código em Java e Python.

Esta ferramenta é muito útil também para embutir uma linguagem para criação de scripts em aplicações que requerem este tipo de funcionalidade. Também inclui um compilador que converte código fonte Python em Java bytecode, permitindo que programadores Python possam escrever classes que possam ser utilizadas por um programa Java.

Entre suas vantagens, destacam-se:

  • 🐍 – Velocidade de desenvolvimento: Python é uma linguagem de desenvolvimento rápido (RAD – Rapid Application Development).
  • 🐍 – Praticidade: Não é necessário compilar o código Jython para testá-lo. Isto torna a depuração muito mais rápida. Depois de terminado o processo, utiliza-se o compilador Jythonc para compilar o programa, para incluir as bibliotecas do Jython existe a opção do freeze.
  • 🐍 – Tempo de aprendizado: Por ter uma sintaxe simples, limpa e coerente o seu aprendizado é muito fácil.

Instalação

Procedimento no Linux

  • 1. – Instale as dependências Primeiramente você precisará ter o instalados no seu sistema:
  • JDK – Ambiente de desenvolvimento para Java;
  • e o IcedTea – Um software de integração.

Use o gerenciador de pacotes da sua distribuição para instalá-los, exemplo, como instalei aqui no Gentoo:

sudo USE="-cups -alsa" emerge -a dev-java/openjdk-bin dev-java/openjdk-jre-bin

Nesse caso eu rejeitei os módulos: cups e alsa e o icedtea foi instalado automaticamente, pois é uma dependência.

Agora baixe o Jython no endereço: https://sourceforge.net/projects/jython/ . Após baixar extraia o pacote:

Antes crie e entre um diretório, para os arquivos não ficarem espalhados

mkdir ambiente && cd ambiente/
mv ../jython* .
jar xj jython.jar
java -jar jython_installer-*.jar

Após esse último comando, ele abrirá um wizard para você seguir, acompanhe as imagens abaixo:

Jython WizardJython WizardJython Wizard

Nessa 4º imagem ↓ parte você ainda poderia escolhe um diretório personalizado, exemplo de de ~/.config/jython, seria o mais ideal para não poluir sua pasta pessoal.Jython Wizard

Jython WizardJython WizardJython WizardJython WizardJython WizardJython Wizard

Após o finish agora vamos editar o seu vim ~/.bashrc e adicione a seguinte linha:

Nesse caso minha versão e nome do diretório é 2.5.2 , verifique a sua.

PATH="${PATH}:${HOME}/jython2.5.2/bin/"

Depois rode o comando source ~/.bashrc ou feche e abra o terminal para poder que o comando jython seja encontrado.

Criando sua primeira aplicação

Um mini aplicativo que efetua soma de dois números. Crie um arquivo como nome vim soma.py

import javax.swing as libswing 
pnumero = libswing.JOptionPane.showInputDialog("Digite um Numero Inteiro: ") 
snumero = libswing.JOptionPane.showInputDialog("Digite um Numero Inteiro: ") 
soma = int(pnumero) + int(snumero) 
libswing.JOptionPane.showMessageDialog(None, "A soma eh %d " % soma)

Salve e rode da seguinte maneira:

jython soma.py

No Shell irá aparecer as saídas do programa, mas não significa que é um problema, e sim que está enviando os outputs corretamente.

Jython WizardJython Wizard

Perceba que nesse caso eu somei 8 + 8 e o resultado foi o esperado. 😁️

Explicando o código

  • import javax.swing as libswing – Importa a biblioteca do Java.
  • pnumero = libswing.JOptionPane.showInputDialog("Digite um Numero Inteiro: ") – Mostra a primeira caixa de diálogo e armazena o valor na variável pnumero.
  • snumero = libswing.JOptionPane.showInputDialog("Digite um Numero Inteiro: ") – Mostra a segunda caixa de diálogo e armazena o valor na variável snumero.
  • soma = int(pnumero) + int(snumero) – Converte os valores de pnumero e snumero para inteiros e soma os dois armazenando o resultado na variável soma.
  • libswing.JOptionPane.showMessageDialog(None, "A soma eh %d " % soma) – Mostra na tela o resultado da soma, simples não é?

Conclusão

Eu particularmente curti o Jython 🙌️ e vou me aprofundar mais sobre ele e provavelmente haverá mais tutoriais aqui sobre o mesmo. E você ?! Curtiu ?! Conte-nos usando o campo de comentários . Abraços!

 

Fontehttps://terminalroot.com.br/2019/10/jython-a-linguagem-que-mistura-java-com-python.html?utm_source=dlvr.it&utm_medium=facebook

Integração fiscal com equipamentos Bematech

Windows – SAT BEMATECH
http://bematechpartners.com.br/wp01/?page_id=308

Plataforma Fiscal Bematech
http://www.bematechpartners.com.br/wp01/upload-files/downloads/oneapi/DOCUMENTACAO_GERAL/help/APIOne.html#_o_que_é_a_a_apione

Integrando a Plataforma Fiscal através da APIOne.
http://www.bematechpartners.com.br/wp01/upload-files/downloads/oneapi/DOCUMENTACAO_GERAL/help/APIOne.html#_instalação_da_plataforma_fiscal_fiscal_manager

CENTRAL DE DOWNLOADS
http://bematechpartners.com.br/wp01/

Electron JS

 

 

Crie um aplicativo de desktop usando a tecnologia da Web (Javascript, HTML, CSS, Nodejs e mais), escrevendo o código javascript do zero usando o Electron.js como estrutura.

 

 

http://www.faztweb.com/curso/electron-primera-aplicaci%C3%B3n

https://github.com/FaztWeb/electron-products-test/blob/master/src/views/index.html

https://github.com/electron/electron-api-demos

 

http://photonkit.com/

 

 

 

 

Como instalar um servidor web no Raspberry Pi (Apache + PHP + MySQL)

Por que um Raspberry Pi como um servidor web?

Mas por que usar uma raspberry como um servidor web , em vez de usar provedores de serviços especializados em hospedagem na web?

Primeiro, do ponto de vista econômico, você deve saber que os serviços de hospedagem não são gratuitos e que você tem que pagar todos os meses / ano. Ao contrário do framboesa que só precisa de uma conexão . 
Além disso, escolhendo Raspberry, você tem a possibilidade de modificar seus serviços como você deseja (exemplos: o tamanho do disco, a hospedagem do banco de dados, etc.), que geralmente não é o caso de hosts especializados , que geralmente vendem compartilhada hospedagem com baixa capacidade de configuração . 
No entanto, para suportar mais usuários, você deve usar um Raspberry Pi 3 (o Pi 3 pode ser encontrado aqui ), o Raspberry Pi com 1 GB de RAM, em vez do Raspberry tipo B + (512 MB de RAM)

A questão que surge agora é, como fazer um servidor web no Raspeberry Pi ? Instalação do servidor Apache com Raspbian

O que é o Apache?

Primeiro, vamos instalar o Apache, que é o servidor web como tal . 
Quando falamos de um servidor web, geralmente pensamos na máquina, mas esse termo também se refere ao software que permite que a máquina analise solicitações de usuários (em formato http) e retorne o arquivo correspondente à solicitação (Ou um erro se o arquivo não for encontrado ou a consulta for formulada incorretamente). 
Como parte do Apache, é um software sobre o qual falamos .

No momento, o Apache é o servidor web mais utilizado , com cerca de 60% de participação de mercado. O Apache tem sua própria licença, usada por muitos outros projetos. Além disso, o uso maciço do Apache (que se tornou o padrão para servidores da Web), juntamente com sua alta popularidade, levou a uma tremenda abundância de documentação, cursos e outros livros relacionados ao seu uso, e sua segurança, como esta. livro .

Seja para o Raspberry Pi e o Raspbian, ou para uma máquina mais genérica, o Apache é, portanto, uma opção segura , e as habilidades que você poderá adquirir no assunto sempre serão úteis.

Instalação do Apache

Antes de instalar o servidor, verifique se temos uma máquina atualizada. Para fazer isso , devemos ter direitos de administrador , seja por causa do comando sudo.

sudo apt update

sudo apt upgrade

sudo apt update

Quando o Raspberry Pi estiver atualizado, instalaremos o servidor Apache.

sudo apt instalar apache2


A propósito, aproveitamos para dar direitos ao arquivo do apache
para que você possa gerenciar facilmente seus sites. 
Para fazer isso, execute os seguintes comandos:

sudo chown -R pi: www-data / var / www / html / 
chmod sudo-R 770 / var / www / html /

Verifique se o Apache está funcionando

Quando a instalação estiver concluída, podemos testar se o Apache está funcionando corretamente , indo para o endereço do Raspberry. 
Para fazer isso, é necessário tentar acessar o Raspberry a partir da porta 80 (essa porta não será aberta de fora, ela terá que fazer desde o próprio Raspberry). Não se preocupe, é muito fácil. Simplesmente abra o navegador da Web Raspberry e vá para “http://127.0.0.1”. Você deve então receber uma página com uma mensagem como “Funciona! “E muitos outros textos. 
Se você ainda não tem uma GUI no seu Raspbian ou usa o SSH para se conectar ao seu Raspberry, você pode usar o seguinte comando:

wget -O check_apache.html http://127.0.0.1

Este comando salvará o código HTML da página no arquivo “check_apache.html”no diretório atual. 
Então você só tem que ler o arquivo com o comando

cat ./check_apache.html

Se você vir marcado em um local no código “Funciona! É que o Apache está funcionando.

O Apache usa o diretório “/ var / www / html” como a raiz do seu site. Isso significa que quando você chama seu Raspberry na porta 80 (http), o Apache procura o arquivo em “/ var / www / html”. 
Por exemplo, se você chamar o endereço “http://127.0.0.1/example”, o Apache procurará o arquivo “exemplo” no diretório “/ var / www / html”. 
Para adicionar novos arquivos, sites, etc., você precisará adicioná-los a este diretório.

Agora você pode usar seu Raspberry para criar um site em HTML, CSS e JavaScriptinternamente. 
No entanto, você pode querer permitir rapidamente interações entre o site e o usuário . Por exemplo, para permitir que o usuário se registre, etc. Para isso, você precisará do PHP.

Instalação do PHP no seu Raspberry Pi

O que é PHP?

Primeiro de tudo, você deve saber que o PHP é uma linguagem interpretada . E como no caso dos servidores, a sigla PHP pode ter vários significados . De fato, quando falamos sobre PHP, podemos falar sobre o idioma ou o interpretador . 
Aqui, quando falamos sobre a instalação do PHP, isso significa que vamos instalar o interpretador , a fim de usar a linguagem.

O PHP (o idioma desta vez) é usado principalmente para tornar um site dinâmico, isto é, o usuário envia informações para o servidor que retorna os resultados modificados de acordo com essas informações . Por outro lado, um site estático não se adapta às informações fornecidas por um usuário . É salvo como um arquivo de uma vez por todas e sempre entregará o mesmo conteúdo.

O PHP é gratuito e mantido pela PHP Foundation, assim como pelo Zend Enterprise, e várias outras empresas (deve-se notar que Zend também é o autor do famoso framework Zend PHP, amplamente utilizado e reconhecido no mundo dos negócios). .

É uma das linguagens de programação mais utilizadas e é até a mais utilizada para programação web, com cerca de 79% de market share.

Mais uma vez, todas as habilidades que você pode adquirir, no idioma, ou na instalação e configuração do interpretador, sempre serão úteis. Então, só podemos aconselhá-lo a aprender o PHP, que é realmente uma linguagem maravilhosa e muitas vezes subestimada.

Como instalar o PHP

Voltaremos a usar o administrador para instalar o PHP com a linha de comando.

sudo apt instalar php php-mbstring

Saber se o PHP está funcionando

Para saber se o PHP está funcionando corretamente, não é muito complicado, e o método é bastante semelhante ao usado para o Apache .

Você primeiro excluirá o arquivo “index.html” no diretório “/ var / www / html”.

sudo rm /var/www/html/index.html

Em seguida, crie um arquivo “index.php” neste diretório, com esta linha de comando

echo "<? php phpinfo ();?>"> /var/www/html/index.php

A partir daí, a operação é a mesma da verificação do Apache . Você tenta acessar sua página, e você deve ter um resultado próximo a esta imagem (se você não tiver uma interface, use o mesmo método de antes, e procure as palavras “Versão do PHP”).

Capturando um phpinfo de um servidor em Raspbian.

Tabela gerada pelo comando phpinfo em uma framboesa.

Um banco de dados MySQL para o seu servidor

Um DBMS, o  que é isso? Por que o MySQL?

Agora que configuramos o PHP, você provavelmente desejará armazenar informações para uso em seus sites. Para este propósito, os bancos de dados são usados ​​com mais freqüência. 
Vamos, portanto, configurar um DBMS (Database Management System), ou seja, o MySQL.

O MySQL é um DBMS gratuito , poderoso e usado maciçamente (cerca de 56% de participação no mercado de DBMSs gratuitos). Aqui, novamente, o MySQL é tão essencial para o desenvolvimento, seja qual for a linguagem, que você deve aprender e dominar completamente, com este livro, por exemplo .

Como instalar o MySQL

Para fazer isso, vamos instalar o mysql-server e o php-mysql (que servirão como um link entre o php e o mysql)

sudo apt instale o mysql-server php-mysql

Verifique se o MySQL está funcionando corretamente

Para verificar o funcionamento do MySQL, desta vez vamos usar apenas a linha de comando . Para fazer isso, simplesmente nos conectaremos pelo comando:

sudo mysql --user = root

Não excluiremos o usuário root padrão do mysql e criaremos um novo usuário root do mysql, porque o padrão só pode ser usado com a conta root do Linux, e portanto não disponível para os scripts do servidor web e php.

Para fazer isso, uma vez que você se conectar ao MySQL, simplesmente execute esses comandos (substitua passwordpela senha que você quer):

DROP USER 'root' @ 'localhost'; 
CREATE USER 'root' @ 'localhost' IDENTIFICADO POR 'senha'; 
GRANT ALL PRIVILEGES ON *. * TO 'root' @ 'localhost'

Então você agora tem um servidor web, conectado ao PHP e MySQL . Isso é tudo que é preciso.

(Nas suas conexões de nexts, você poderá se conectar ao mysql sem usar o sudo, com o comando mysql --user=root --password=yourmysqlpassword).

Adicionar PHPMyAdmin

A instalação do PHPMyAdmin é absolutamente desnecessária. Nesta instalação, não vamos nos preocupar com nenhuma configuração de segurança especial!

A instalação do PHPMyAdmin é muito rápida e fácil, nós simplesmente temos que usar o gerenciador de pacotes com este comando:

sudo apt instala phpmyadmin

O programa de instalação do PHPMyAdmin fará algumas perguntas. Sobre o dbconfig-commoncomponente, opte por não usá-lo (como já configuramos nosso banco de dados). Sobre o servidor para configurar o PHPMyAdmin para, escolha Apache. E a senha do root é aquela que você definiu para o MySQL.

Você também deve ativar a extensão mysqli usando o comando acima:

sudo phpenmod mysqli 
sudo /etc/init.d/apache2 reiniciar

Verifique se o PHPMyAdmin está funcionando corretamente

Para verificar se o PHPMyAdmin funciona, você simplesmente tentará acessá-lo, usando o endereço do seu Raspberry seguido de / phpmyadmin. Por exemplo, localmente será http://127.0.0.1/phpmyadmin

Se você ainda receber um erro, pode ser porque o PHPMyAdmin foi movido para outro diretório. Neste caso, tente o comando

sudo ln -s / usr / share / phpmyadmin / var / www / html / phpmyadmin

Agora, podemos acessar o PHPMyAdmin do navegador do Raspberry Pi, com o URL: http://127.0.0.1/phpmyadmin

Tornar um servidor acessível a partir da web

Seu servidor da web está pronto. No entanto, você provavelmente não pode acessá-lo da internet . De fato, seria necessário que o seu modem redirecionasse os pedidos para o seu Raspberry, as boas portas. 
Para colocar esses redirecionamentos no lugar, e até mesmo obter um URL, você deve olhar para DynDNS e encaminhamento de porta!

Fonte

https://howtoraspberrypi.com/how-to-install-web-server-raspberry-pi-lamp/

https://stackoverflow.com/questions/39281594/error-1698-28000-access-denied-for-user-rootlocalhost

API de sensor genérico – W3C

Cada vez mais, os dados dos sensores são usados ​​no desenvolvimento de aplicativos para permitir novos casos de uso, como geolocalização, contagem de etapas ou rastreamento de cabeças. Isso é especialmente verdadeiro em dispositivos móveis nos quais novos sensores são adicionados regularmente.

A exposição de dados de sensores à Web até agora tem sido lenta e ad-hoc. Poucos sensores já estão expostos à web. Quando eles são, muitas vezes é de maneiras que limitam seus possíveis casos de uso (por exemplo, expondo abstrações que são muito alto nível e que não funcionam bem o suficiente). As APIs também variam muito de um sensor para o outro, o que aumenta a carga cognitiva dos desenvolvedores de aplicativos da Web e diminui o desenvolvimento.

O objetivo da Generic Sensor API é promover consistência entre APIs de sensores, habilitar casos de uso avançados graças a APIs de baixo nível e aumentar o ritmo no qual novos sensores podem ser expostos à Web, simplificando a especificação e os processos de implementação.

Uma lista abrangente de sensores sólidos que são baseados na API do Sensor genérico, casos de uso aplicáveis ​​e exemplos de código pode ser encontrada nos documentos do [GENERIC-SENSOR-USECASES] e [MOTION-SENSORS] .

https://w3c.github.io/sensors/#high-level

Biblioteca Modernizr

O que é a Modernizr

Modernizr é uma pequena biblioteca Javascript que detecta a disponibilidade das novas características do HTML5 e CSS3 nos browsers. Muitas destas características já estão implementadas nos browsers, mas é muito chato você decorar quais novidades os browsers já estão suportando. O que a Modernizr faz é simples: ela te diz quais features um determinado browser suporta e insere classes no HTML para que você possa utilizar para fazer uma versão alternativa de visual ou solução.

Entenda que a Modernizr não é um sniffing de browser. Ela é diferente. A Modernizr faz o trabalho de detectar das seguintes formas:

  • Ela testa 40 features de CSS3 e HTML5 em alguns milisegundos.
  • Depois ela cria objetos javascript que contém os resultados destes testes.
  • Aí são adicionadas classes no elemento HTML descrevendo exatamente quais propriedades e novidades são ou não nativamente suportadas.
  • Depois disso você consegue ter os resultados descritos nos navegadores dinamicamente e então pode tomar decisões criando alternativas para aquelas propriedades não suportadas pelos browsers antigos.

 

 

 

 

 

Fontes:

 

https://tableless.com.br/utilizando-a-biblioteca-modernizr/

https://github.com/Modernizr/Modernizr

 

SENSOR ULTRASÔNICO JSN-SR04T

O JSN-SR04T é um sensor de distância ultra-sônico à prova d’água, fácil de usar, com uma faixa de 25 a 450 cm. Se você está planejando construir um sistema de medição do nível de água ou se você precisa fazer outras medições de distância fora, então este é o sensor que você precisa!

Eu incluí um diagrama de fiação e códigos de exemplo para que você possa começar a experimentar seu sensor.

 

O que este artigo cobre

Informações sobre o sensor

O sensor vem com um cabo de 2,5 m de comprimento que se conecta a uma placa de fuga que controla o sensor e faz todo o processamento do sinal. Note que apenas o sensor e o cabo em si são à prova d’água, se você colocar água na placa de fuga, coisas ruins acontecerão.

Um sensor de distância ultra-sônico funciona enviando ondas de ultra-som. Essas ondas de ultra-som são refletidas de volta por um objeto e o sensor ultrassônico as detecta. Ao cronometrar quanto tempo passou entre enviar e receber as ondas sonoras, você pode calcular a distância entre o sensor e um objeto.

Distância (cm) = Velocidade do som (cm / µs) × Tempo (µs) / 2

Onde Tempo  é o tempo entre enviar e receber as ondas sonoras em microssegundos.

Então, quais são as diferenças entre este sensor e o HC-SR04? A principal diferença, além de ser à prova d’água, é que este sensor usa apenas um transdutor ultrassônico. Este transdutor serve tanto como transmissor quanto receptor das ondas de ultra-som.

Para mais informações sobre como os sensores ultrassônicos funcionam, você pode conferir o artigo no HC-SR04 abaixo. Neste artigo, o princípio de funcionamento é explicado com muito mais detalhes.

JSN-SR04T Especificações

Tensão operacional 5V
Corrente de operação 30mA
Corrente quiescente 5mA
Freqüência 40 kHz
Faixa de medição 25 a 450 cm
Resolução 2 mm
Ângulo de medição 45 a 75 graus
Dimensões do sensor Cabo de 23,5 x 20 mm, 2,5 m de comprimento
Dimensões do PCB 41 x 28,5 mm
Orifício de montagem 18 mm

Para mais informações, você pode conferir a folha de dados aqui.

Componentes

* Nota: os links acima são afiliados, o que significa – sem nenhum custo adicional para você – se você comprar algo usando eles, você está ajudando a apoiar o meu trabalho neste site. Meus humildes agradecimentos (eu realmente agradeço)! 

Ao comprar o sensor, você pode encontrar a versão atualizada,  JSN-SR04T-2.0 . Essa versão mais recente funciona exatamente da mesma forma, mas alguns usuários encontraram problemas ao usar os sensores em uma voltagem mais baixa. Esta versão mais recente está classificada para 3 a 5 V.

Usar um pulso de gatilho mais longo de pelo menos 20 µs em vez de 10 µs parece ajudar se você estiver tendo leituras defeituosas.

Fiação – Conectando o JSN-SR04T ao Arduino UNO

O diagrama de fiação / esquema abaixo mostra como conectar o sensor JSN-SR04T ao Arduino. A placa de desagregação da JSN-SR04T possui a mesma pinagem que a HC-SR04, portanto, pode ser usada como substituta imediata. O cabo do sensor em si pode ser conectado ao conector na parte de trás da placa de fuga.

JSN-SR04T com diagrama de fiação do Arduino

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, mas é claro que você pode mudar isso para qualquer pino digital desejado.

Conexões JSN-SR04T

JSN-SR04T Arduino
5V 5V
Trig Pino 2
Eco Pino 3
GND GND

Exemplo de código para o JSN-SR04T com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e fazer o upload de algum código. O sensor pode ser usado sem uma biblioteca do Arduino. Mais tarde, mostrarei um exemplo com a biblioteca NewPing, que torna o código muito mais curto.

Você pode fazer o upload do seguinte código de exemplo para o seu Arduino usando o  Arduino IDE . Em seguida, vou explicar como o código funciona. (Este código também funciona para o JSN-SR04T-2.0).

/* JSN-SR04T Ultrasonic Distance Sensor with Arduino Example Code. More info: https://www.makerguides.com */

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 3

//Define variables
long duration;
int distance;

void setup()
{
//Define inputs and outputs
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

//Begin Serial communication
Serial.begin(9600); // Starts the serial communication at a baudrate of 9600
}

void loop()
{
//Clear the trigPin by setting it LOW
digitalWrite(trigPin, LOW);
delayMicroseconds(5);

//Trigger the sensor by setting the trigPin high for 10 microseconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

//Read the echoPin. pulseIn() returns the duration (length of the pulse) in microseconds.
duration = pulseIn(echoPin, HIGH);
// Calculate the distance
distance= duration*0.034/2;

//Print the distance on the Serial Monitor (Ctrl+Shift+M)
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(100);
}

Se houver a necessidade de leitura de mais sensores, isso pode ser feito facilmente com a biblioteca NewPing. Basta criar duas ou mais instâncias da classe NewPing e adicionar um gatilho e um eco adicionais:

#define trigPin 2 
#define echoPin 3 
#define trigPin2 4 
#define echoPin2 5

Sonar NewPing (trigPin, echoPin, MAX_DISTANCE); 
Sonar 2 de NewPing (trigPin2, echoPin2, MAX_DISTANCE);

Agora, se você quiser ler o primeiro sensor, você pode usar o sonar.ping_cm () e o segundo sensor sonar2.ping_cm ().

 

DOWNLOAD DA BIBLIOTECA NEW PING

 

FONTE: https://www.makerguides.com/jsn-sr04t-arduino-tutorial/

 

Projeto em Python que acessa a webcam e move os olhos em direção aos olhos dos espectadores

Rastreamento de rostos com personagens de anime

Fonte:  https://github.com/Aditya-Khadilkar/Face-tracking-with-Anime-characters?utm_source=mybridge&utm_medium=blog&utm_campaign=read_more

 

 

yuriRequisitos: Ter o python3 instalado. (Eu usei o Python3.6 no python IDLE) instale o OpenCV, os, math, ctypes, time, pygame (você provavelmente só precisará baixar o OpenCV eo PyGame)

Agora pegue o arquivo “YURI FULLSCREEN.py” deste repositório no seu computador. salve as imagens yuri2.bmp e eyes e dê o caminho para essas imagens no código (você também pode usar seu próprio waifus se quiser) baixe o haarcascade e dê a sua localização no código. Execute o código e divirta-se com o seu waifu … weeb

Faça o seu próprio:

Você precisará apenas de 2 imagens

  1. personagem sem olhos yuriwoeyes
  2. os olhosolhossó usam essas imagens e você está pronto para ir!

Versão 2: Yuri agora tem proximidade

Se você mover seu rosto para perto da webcam, ela cora!
Eu adicionei alguns novos arquivos: yuriblush.py (Porque nós não damos espaços em nomes de arquivos :)), Yuri blush.png, Yuri cute.png, Yuriceyes.png,

O processo é o mesmo acima, em vez de baixar YURI FULLSCREEN.py use yuriblush.py. Copie e cole os caminhos e você é bom!

yuri fofayuri blush

Um Modelo Bioinspirado para Localização e Mapeamento Simultâneos de Robôs Subaquáticos em Ambientes com a Influência da Correnteza

Resumo

Neste trabalho é apresentado um modelo bioinspirado para o problema de localização e mapeamento simultâneos para robôs utilizados em ambientes subaquáticos com a influência da correnteza. Devido as suas características específicas, os desafios encontrados e os sensores utilizados nas aplicações em ambientes subaquáticos são apresentados. A abordagem bioinspirada é apresentada, onde são utilizadas para o seu desenvolvimento o comportamento das células place cells, head direction cells e grid cells as quais são encontradas nos cérebros dos mamíferos. Para avaliar o desempenho do modelo utilizam-se simulações do ambiente subaquático com a influência da correnteza desenvolvidas através do simulador Gazebo em conjunto com plugins do UUV Simulator. Os mapas da trajetória realizado pelo robô são obtidos utilizando o modelo proposto e comparados com o ground thruth (valor de referência) e dead reckoning (navegação estimada) obtidos durante a simulação.

 

Palavras-chaves: Localização e mapeamento simultâneos, Algoritmo Bioinspirado, Ambiente Subaquático.

 

Fonte: https://sistemas.furg.br/sistemas/sab/arquivos/bdtd/0000011585.pdf

 

wiringpi.com

Sobre

WiringPi é uma biblioteca de acesso GPIO baseada em PIN escrita em C para os dispositivos SoC BCM2835, BCM2836 e BCM2837 usados ​​em todos os Raspberry Pi. versões. É lançado sob alicença LGPLv3 da  GNU e é utilizável em C, C ++ e RTB (BASIC), assim como em muitos outros idiomas com invólucros adequados (Veja abaixo). Ele foi projetado para ser familiar a pessoas que usaram osistema de “ fiação ” Arduino 1 e é destinado ao uso por programadores C / C ++ experientes. Não é uma ferramenta de aprendizado de novatos.

O WiringPi é desenvolvido diretamente em um Raspberry Pi executando Raspbian de 32 bits. Eu não suporto nenhuma outra plataforma, compilação cruzada ou sistemas operacionais. Ele foi portado para outras plataformas, outros sistemas operacionais e alguns são cross compiling, no entanto, este autor não mantém esses sistemas. Se você está tentando usar wiringPi em uma plataforma diferente do Raspberry Pi com Raspbian então você deve contatar a pessoa que fez o porto e não eu.

O original Raspberry Pi Modelo A e B versão B1 era um computador de placa única de US $ 35 com um conector GPIO (General Purpose Input / Output) de 26 pinos e isso transporta um conjunto de sinais e barramentos. Existem 8 pinos digitais de E / S para fins gerais – estes podem ser programados como saídas digitais ou entradas. Dois desses pinos (em Pi de 40 pinos, apenas um em Pi de 26 pinos) também podem ser designados para saída PWM de hardware. Além disso, há uma interface I2C de 2 fios e uma interface SPI de 4 fios (com uma segunda linha de seleção, totalizando 5 pinos) e a serial UART com mais 2 pinos.

Ao longo dos anos, houve algumas atualizações:

  • O modelo original B com o conector GPIO de 26 pinos.
  • O modelo B, Revision 1.1 Raspberry Pi tem um adicional de 4 linhas GPIO em um conector separado que você tem que soldar na placa.
  • O modelo A é essencialmente o mesmo que o modelo B v1.1, mas sem o hub USB e o conector ethernet.
  • O modelo A + e B + Raspberry Pi representa 2 anos de pesquisa, desenvolvimento e testes e agora possui um único conector GPIO de 40 pinos com 28 pinos GPIO utilizáveis ​​e 4 soquetes USB. (Sem USB ou Ethernet no A +)
  • O modelo B v2 possui um processador quad-core Arm A7 com 1GB de RAM. O mesmo GPIO.
  • O modelo Zero é um Pi A + reduzido (1GHz). Conector GPIO de 40 pinos e muito pouco mais. $ 5 de preço.
  • O modelo B v3 possui um processador quad-core Arm A8 (64 bits) com a mesma RAM e GPIO do modelo 2, mas também possui Wi-Fi e Bluetooth integrados. Ainda o mesmo preço de US $ 35.
  • O modelo Zero-W adiciona o Wi-Fi on-board, o Bluetooth e o conector da câmera Pi ao modelo existente da placa Zero.

As interfaces I2C, SPI e UART também podem ser usadas como pinos de E / S de finalidade geral quando não estão sendo usados ​​em seus modos de barramento, fornecendo um total de 8 + 2 + 5 + 2 = 17 pinos de E / S no conector P1 ( mais mais 4 no conector P5 em uma Revisão 2 Pi) e 28 pinos de E / S nas placas B + e versões 2 e 3 (embora 2 sejam reservados para a interface HAT I2C, mas podem ser usados ​​como GPIOs normais se não forem usados Placa HAT)

O WiringPi inclui um utilitário de linha de comando gpio que pode ser usado para programar e configurar os pinos do GPIO. Você pode usar isso para ler e escrever os pinos e até usá-lo para controlá-los a partir de scripts de shell.

WiringPi é extensível e módulos são fornecidos para ampliar o cabeamentoPi para usar dispositivos de interface analógica no Gertboard, e usar os populareschips de expansão GPIO MCP23x17 / MCP23x08 (I2C 7 SPI), bem como módulos que permitirão blocos de até 4 × 74 × 595 registros de deslocamento para serem encadeados juntos para um valor adicional de 32 bits de saída como uma única unidade. (Você pode ter vários blocos de 4 74x595s, se necessário) Um dos módulos de extensão permite que você use um ATmega (por exemplo, Arduino ou Gertboard) como mais expansão GPIO também – através da porta serial do Pi.

Além disso, você pode escrever facilmente seus próprios módulos de extensão para integrar seus próprios dispositivos periféricos à fiaçãoPi, conforme necessário.

O WiringPi suporta leitura e escrita analógicas, e embora não exista nenhum hardware analógico nativo em um Pi por padrão, os módulos são fornecidos para suportar os chips analógicos Gertboards e outros dispositivos A / D e D / A podem ser implementados com relativa facilidade.

NOTA:

Faça o download da fiação aqui

Existe uma versão do wiringPi hospedada no Github. Não use esta versão do wiringPi . Ele existe apenas para facilitar a construção dos wrappers Ruby e Python que foram escritos por Gadgetoid. Você também pode encontrar outras versões do wiringPi no github – todas elas foram bifurcadas e alteradas para suportar diferentes plataformas de hardware.

A fiação dev devLib

devLib é um conjunto de rotinas de bibliotecas implementadas usando o wiringPi para facilitar o acesso a alguns periféricos populares. Os dispositivos suportados incluem exibições de LCD de caracteres (com base nos chips Hitachi HD44780U) e gráficos – por exemplo, as exibições comuns de 128 × 64 pixels com o chip de driver genérico 12864H. O chip de clock do DS1302 RTC, sensores baseados nos chips Maxdetect (por exemplo, RHT003), as placas de interface Gertboard e PiFace e assim por diante.

Recursos de WiringPi

PiFace

O WiringPi também suporta totalmente a placa PiFace . Veja esta página para mais detalhes.

Gertboard

O WiringPi suporta totalmente o Gertboard. Veja esta página para mais detalhes.

Outros recursos de fiaçãoPi:

Informações adicionais podem ser encontradas nas páginas do Raspberry Pi Wiki .


1 Arduino é realmente duas coisas; uma é uma plataforma de hardware, o outro software e parte do software é um pacote chamado Fiação . A fiação é o núcleo da entrada e saída para o Arduino, então eu pensei que seria bom replicar essa funcionalidade (ou um bom subconjunto utilizável com as extensões do Raspberry Pi) no Raspberry Pi.

CELLO – Automação de design de circuitos genéticos.

Circuito de programação para biologia sintética

À medida que as técnicas de biologia sintética se tornam mais poderosas, os pesquisadores estão antecipando um futuro em que o projeto de circuitos biológicos será semelhante ao projeto de circuitos integrados em eletrônica. Nielsen et al. descreve o que é essencialmente uma linguagem de programação para projetar circuitos computacionais em células vivas. Os circuitos gerados nos plasmídeos expressos em Escherichia coli requeriam isolamento cuidadoso de seu contexto genético, mas funcionavam primariamente conforme especificado. Os circuitos poderiam, por exemplo, regular as funções celulares em resposta a múltiplos sinais ambientais. Tal estratégia pode facilitar o desenvolvimento de circuitos mais complexos por engenharia genética.

 

 

http://www.cellocad.org

Resumo estruturado

INTRODUÇÃO

As células respondem ao ambiente, tomam decisões, constroem estruturas e coordenam tarefas. Subjacentes a esses processos estão operações computacionais realizadas por redes de proteínas reguladoras que integram sinais e controlam o tempo de expressão gênica. Aproveitar essa capacidade é fundamental para projetos de biotecnologia que exigem tomada de decisões, controle, detecção ou organização espacial. Foi demonstrado que as células podem ser programadas usando circuitos genéticos sintéticos compostos de reguladores organizados para gerar uma operação desejada. No entanto, a construção de circuitos simples é demorada e pouco confiável.

JUSTIFICATIVA

A automação de projeto eletrônico (EDA) foi desenvolvida para auxiliar os engenheiros no projeto de eletrônicos baseados em semicondutores. Em um esforço para acelerar o projeto de circuitos genéticos, aplicamos princípios da EDA para permitir o aumento da complexidade do circuito e simplificar a incorporação da regulação gênica sintética em projetos de engenharia genética. Usamos a linguagem de descrição de hardware Verilog para permitir que um usuário descreva uma função de circuito. O usuário também especifica os sensores, os atuadores e o “arquivo de restrições do usuário” (UCF), que define o organismo, a tecnologia do gate e as condições operacionais válidas. Violoncelo ( www.cellocad.org) usa essa informação para projetar automaticamente uma seqüência de DNA que codifica o circuito desejado. Isso é feito por meio de um conjunto de algoritmos que analisam o texto Verilog, criam o diagrama de circuito, atribuem portas, equilibram restrições para construir o DNA e simulam o desempenho.

RESULTADOS

O violoncelo desenha circuitos desenhando uma biblioteca de portas lógicas booleanas. Aqui, a tecnologia de gate consiste de lógica NOT / NOR baseada em repressores. A conexão do gate é simplificada definindo os sinais de entrada e saída como fluxos de RNA polimerase (RNAP). Descobrimos que os portões precisam ser isolados de seu contexto genético para funcionar de forma confiável no contexto de diferentes circuitos. Cada porta é isolada usando terminadores fortes para bloquear o vazamento de RNAP, e a permutabilidade de entrada é melhorada usando ribozimas e espaçadores de promotores. Essas peças são variadas para cada porta para evitar quebras devido à recombinação. Medir a carga de cada porta e incorporar isso nos algoritmos de otimização reduz ainda mais a pressão evolutiva.

O violoncelo foi aplicado ao projeto de 60 circuitos para Escherichia coli , onde a função do circuito foi especificada usando o código Verilog e transformada em uma seqüência de DNA. As sequências de DNA foram construídas conforme especificado sem ajuste adicional, exigindo 880.000 pares de bases de montagem de DNA. Destes, 45 circuitos foram executados corretamente em cada estado de saída (até 10 reguladores e 55 partes). Em todos os circuitos, 92% dos 412 estados de saída funcionaram como previsto.

CONCLUSÃO

Nosso trabalho constitui uma linguagem de descrição de hardware para programação de células vivas. Isso exigiu o codesenvolvimento de algoritmos de design com portas que são suficientemente simples e robustas para serem conectadas por algoritmos automatizados. Demonstramos que os princípios de engenharia podem ser aplicados para identificar e suprimir erros que complicam as composições de sistemas maiores. Essa abordagem leva a uma genética altamente repetitiva e modular, em contraste com a codificação de redes regulatórias naturais. O uso de uma linguagem independente de hardware e a criação de UCFs adicionais permitirão que um único design seja transformado em DNA para diferentes organismos, terminais genéticos, condições de operação e tecnologias de gate.

 

 

Programação genética usando violoncelo.

Um usuário especifica a função de circuito desejada no código Verilog, e isso é transformado em uma sequência de DNA. Um circuito de exemplo é mostrado (0xF6); as curvas vermelha e azul são estados de saída preditos para populações de células, e as distribuições de preto sólido são dados de citometria de fluxo experimental. As saídas são mostradas para todas as combinações de estados do sensor; sinais de mais e menos indicam a presença ou ausência de sinal de entrada. RBS, local de ligao ao ribossoma; RPU, unidade promotora relativa; YFP, proteína fluorescente amarela

.Fig. 1 Visão geral do violoncelo.

A ) Usuários de violoncelo escrevem código Verilog e selecionam ou carregam sensores e um UCF. Com base no design do Verilog, uma tabela de verdade é construída a partir da qual um diagrama de circuito é sintetizado. Reguladores são atribuídos a partir de uma biblioteca para cada porta (cada cor é um repressor diferente). O desenho combinatório é então usado para concatenar partes em uma sequência de DNA linear. O SBOL Visual ( 101 ) é usado para os símbolos das peças. Flechas levantadas são promotores, círculos em hastes são isolantes de ribozimas, hemisférios são ERBs, setas grandes são seqüências codificadoras de proteínas e “T” s são terminadores. As cores das peças correspondem aos portões físicos. ( B) A especificação física para a UCF Eco1C1G1T1. O circuito e os sensores são inseridos em um plasmídeo; o outro plasmídeo contém o promotor de saída do circuito, que pode ser usado para dirigir a expressão de uma proteína fluorescente ou outro atuador. Ambos os plasmídeos devem estar presentes na cepa especificada para que o projeto seja válido.

 

Fig. 2 Atribuição de portões genéticos ao diagrama de circuito.

A ) Um conjunto de quatro portas baseadas em diferentes repressores (cores) conectados em várias permutações para construir diferentes funções de circuito. As entradas (A, B e C) são promotores de entrada do sensor; o promotor de saída do circuito (X) controla o gene de atuação. ( B ) As formas das funções de resposta da porta determinam se elas podem ser conectadas funcionalmente. O portão laranja (PhlF) tem um grande alcance dinâmico (linhas tracejadas) que atravessa o limiar do portão roxo (BetI). No entanto, na ordem inversa, os portões não se conectam funcionalmente. ( C) As relações combinatórias dos repressores da biblioteca de portas isoladas são mostradas nas posições a montante (porta A) e a jusante (porta B). A escala de cores à direita indica a mudança relativa (normalizada), calculada como a faixa máxima de saída que pode ser alcançada conectando a porta A ao gate B. Os números indicam diferentes RBSs. Os gráficos da esquerda e da direita mostram quando a porta A regula a posição 1 e a posição 2, respectivamente. Portões que são excluídos da posição 2 por causa do roadblock são mostrados em preto (fig. S9). ( D ) A probabilidade de encontrar um circuito funcional versus o número de portas lógicas. A probabilidade de um circuito funcional é definida como a probabilidade de uma atribuição aleatória passar na análise do limiar de entrada (fig. S31) e não possuir combinações de roadblocking. ( E) A convergência do algoritmo de atribuição de porta de recozimento simulado (fig. S28). Inserções de gráfico de barras: as barras pretas devem estar LIGADAS; as barras cinzas devem estar DESLIGADAS; o eixo y é a saída no RPU em uma escala de log e o eixo x é o estado de entrada (da esquerda para a direita: 000, 001, 010, 011, 110, 101, 110, 111). A pontuação do circuito ( S ) é definida como a razão entre o estado ON previsto mais baixo e o estado OFF previsto mais alto (fig. S26 e eq. S2). Um exemplo de pesquisa é mostrado para o diagrama de circuito nas inserções; as cores correspondem aos repressores atribuídos a cada porta ( Fig. 3B ).

Entradas correspondem à ausência ou presença de IPTG 1 mM (direita – / +) e aTc (2 ng / ml; esquerda – / +) ( 84 ). (B ) As arquiteturas dos portões isolados. Algumas portas têm várias versões com diferentes seqüências RBS. As seqüências de DNA do gate são fornecidas na tabela S8. ( C ) Um exemplo de uma função de resposta para uma porta NOT baseada no repressor PhlF. A mudança no limite para os três RBSs é mostrada. Os dados para todas as portas isoladas são mostrados na fig. S4 ( D ) O impacto de cada porta no crescimento celular como uma função da sua atividade de promotor de entrada. O crescimento celular foi medido como OD 600 e normalizada pelo crescimento do controlo não indutor de 6 horas após a indução ( 84 ). Os quatro portais que reduziram o crescimento em> 20% estão indicados. Barras de erro são um SD de crescimento celular normalizado [ eixo y em (D)] e a mediana [eixo y em (A) e (C); eixo x em (C) e (D)] para três experiências independentes realizadas no mesmo dia.

 

Continua em: http://science.sciencemag.org/content/352/6281/aac7341

Usando GUIDs (Delphi)

Este exemplo demonstra o uso de algumas rotinas relacionadas ao GUID junto com o próprio tipo.

Código

procedimento  TForm2 . FormCreate ( Sender :  TObject ) ; 
var 
  MyGuid0 ,  MyGuid1  :  TGUID ;

begin 
  {Crie um novo GUID a partir da representação de string. } 
  MyGuid0  : =  StringToGUID ( '{00020400-0000-0000-C000-000000000046}' ) ; 
  Memo1 . Linhas . Adicione ( 'O GUID é:'  +  GUIDToString ( MyGuid0 )) ;

  { 
  Acessando os campos internos do GUID 
  Usando a função Format para obter a mesma saída que GUIDToString 
  } 
  Memo1 . Linhas . Adicionar ( Formatar ( 'GUID usando a formatação é:'  + 
       '{% 0.8X-% 0.4X-% 0.4X-% 0.2X% 0.2X-% 0.2X% 0.2X% 0.2X% 0.2X% 0.2X% 0.2 X} ' , 
       [ MyGuid0 . D1 ,  MyGuid0 . D2 ,  MyGuid0 . D3 , 
       MyGuid0 . D4 [ 0 ] ,  MyGuid0 . D4 [ 1 ] , MyGuid0 . D4 [ 2 ] ,  MyGuid0 . D4 [ 3 ] , 
       MyGuid0 . D4 [ 4 ] ,  MyGuid0 . D4 [ 5 ] ,  MyGuid0 . D4 [ 6 ] ,  MyGuid0 . D4 [ 7 ]])) ;

  {Autogerar um GUID aleatório em tempo de execução. } 
  se  CreateGUID ( MyGuid1 )  <>  0, em  seguida, 
     Memo1 . Linhas . Adicionar ( 'Criando GUID falhou!' ) 
  Else 
     Memo1 . Linhas . Add ( 'O guid gerado é:'  +  GUIDToString ( MyGuid1 )) ;

  {Gerando o segundo GUID aleatório. } 
  CreateGUID ( MyGuid0 ) ;

  {Testando se dois guias são iguais. } 
  se  IsEqualGUID ( MyGuid0 ,  MyGuid1 ), em  seguida, 
     Memo1 . Linhas . Add ( 'Isso não pode acontecer! CreateGUID garante que'  + 
                     '2 GUIDs gerados aleatoriamente não podem ser iguais!' ) ; 
End ;


Fonte:  http://docwiki.embarcadero.com/CodeExamples/Tokyo/en/UsingGUIDs_(Delphi)

Maven no Windows – Como configurar

 

Se a variável de ambiente estiver lotada, basta alterar via registro do windows:

 

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment]

[HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Control\Session Manager\Environment]

[HKEY_LOCAL_MACHINE\SYSTEM\ControlSet002\Control\Session Manager\Environment]

DLL emulador SAT, fechando aplicação ao ser consumida

Bom dia amigos,

estou usando o emulador do SAT encontrado no site da SEFAZ para testar minha aplicação em C# .NET. Estou com um problema que, quando tento consumir a SAT.dll, todos os métodos importados da DLL por qual minha aplicação passa, ela fecha inesperadamente sem dar catch em nenhum exceção.

 

Estou importando a DLL dessa forma:

[DllImport("dllsat.dll", CallingConvention = CallingConvention.Cdecl)] public static extern string EnviarDadosVenda(int iNumSessao, string pcCodAtivacao, string pcDadosVenda);

No meu método, esta assim:

        public static void enviarDadosCFeToSat()
        {
            try
            {
                var xml = readFileXML();
                int numSessao = gerarNumeroSessao();
                string codAtivacao = "123456789";

                var resposta = EnviarDadosVenda(numSessao, codAtivacao, xml);
            }
            catch 
            {
                throw;
            }
        }

Ao passar pelo método EnviarDadosVenda(x, y, z), a resposta no LOG é:

  Citar

[2019-01-16 11:02:41.619]:Erro: Falha na estrutura do XML de venda.
[2019-01-16 11:02:41.626]:ERRO NA EMISSAO: 1999: null

Entendo que o XML possa estar errado, mas a minha aplicação fecha inesperadamente e não importa qual tratamento que dou, ele não apresenta a exceção. Alguém sabe como implementar de forma que a aplicação não feche? Mesmo os métodos que passam com sucesso pela dll acabam por fechar após chamar a DLL.

 

Grato

 

SOLUÇÃO:

 

Já resolvi! Se puderem fechar o post, agradeço. Se alguém passar por isso no futuro, segue a solução abaixo.

Tive que fazer as seguintes modificações no código:

        [DllImport("dllsat.dll", CallingConvention = CallingConvention.Cdecl)] public static extern IntPtr EnviarDadosVenda(int iNumSessao, string pcCodAtivacao, string pcDadosVenda);

e no meu método:

        public static void enviarDadosCFeToSat()
        {
            try
            {
                readFileXML();
                int numSessao = 2;
                string codAtivacao = "123456789";

                IntPtr ptr = EnviarDadosVenda(numSessao, codAtivacao, xml);
                string s = Marshal.PtrToStringAnsi(ptr);
            }
            catch 
            {
                throw;
            }
        }

Fonte: https://www.projetoacbr.com.br/forum/topic/48771-dll-emulador-sat-fechando-minha-aplica%C3%A7%C3%A3o-ao-ser-consumida/?_fromLogin=1#_=_

Google adquire a DORA, o aplicativo móvel RPA da Automation Anywhere e o novo laboratório de robótica da NVIDIA

DevOps Research and Assessment (DORA) foi adquirida pelo Google. A aquisição permitirá que a DORA crie melhores experiências de usuário no Google Cloud para desenvolvedores e operações por meio de insights orientados por dados.

“As melhores e mais inovadoras organizações desenvolvem e entregam seus softwares com mais rapidez, confiabilidade e segurança, e com maior qualidade, com alto desempenho em tecnologia”, disse a Dra. Nicole Forsgren, CEO e cientista chefe da DORA. “Estamos entusiasmados por nos unirmos a uma equipe comprometida com o fornecimento de práticas de DevOps apoiadas por pesquisas e esperamos continuar nosso trabalho para entender os principais recursos, medir resultados orientados a valor e otimizar processos para ajudar as equipes a entregar seus softwares à medida que avançam. nuvem.”

A Automation Anywhere lança um aplicativo móvel para a empresa RPA
Robotic Automation (RPA) A Automation Anywhere anunciou um aplicativo móvel para o gerenciamento seguro de bots RPA construídos usando sua plataforma RPA inteligente. Segundo a empresa, o aplicativo irá ampliar o alcance da RPA na empresa.

“Estima-se que os indivíduos gastam uma média de quatro horas por dia em seus dispositivos móveis”, disse Abhijit Kakhandiki, vice-presidente sênior de Produtos e Engenharia para Automação em Qualquer Lugar. “A capacidade de controlar bots e gerenciar toda a força de trabalho digital a partir de um dispositivo móvel, sempre de fácil acesso, é um gamechanger”.

NVIDIA abre laboratório de pesquisa em robótica em Seattle A
NVIDIA anunciou que está abrindo um novo laboratório de pesquisa em robótica perto da Universidade de Washington em Seattle. O objetivo do laboratório é conduzir pesquisas de robótica para permitir que uma próxima geração de robôs seja capaz de executar tarefas complexas de manipulação e trabalhar com segurança entre seres humanos.

De acordo com a NVIDIA, cerca de 50 pesquisadores, professores visitantes e estagiários estudarão no laboratório. “No passado, a pesquisa em robótica se concentrava em projetos pequenos e independentes, em vez de sistemas totalmente integrados. Estamos reunindo uma equipe interdisciplinar colaborativa de especialistas em controle e percepção de robô, visão computacional, interação homem-robô e aprendizado profundo ”, disse Dieter Fox, diretor sênior de pesquisa em robótica da NVIDIA e professor da UW Paul G. Allen School of Ciência da Computação e Engenharia.