Diego Bittencourt

Eletrônica - Circuito Termopar

2011-09-23T12:16:00.001-03:00

Boa Tarde!

Conforme combinado anteriormente a figura 1 representa o circuito que amplifica dos sinais do termopar para um nível de tensão que possibilite a medição de sua temperatura com facilidade, este circuito, além disso, também compensa a junta fria na qual eu expliquei no artigo anterior.

Figura 1 - Circuito Termopar

Amplificador de Sinal do Termopar:

Esta etapa amplifica o sinal do sensor termopar, além de conter um filtro que limpa os ruídos que o sensor termopar pode conter em sua tensão.

Em sua saída “TERMO”, vamos contar com uma tensão de 1mV por grau centigrado do termopar, sendo que esta tensão pode ser negativa dependo das condições que o termopar estiver operando.

Observa-se que esta etapa de amplificação utilizando o amplificador operacional OP07, amplifica os sinais do termopar tipo T em aproximadamente 24,5 vezes (490K/20K), para outros tipos de termopares ou até mesmo aplicações onde o termopar vá medir uma faixa maior de temperatura que o circuito proposto neste artigo (0°C até 50°C ou 0V até 2,5V).

Segundo o que já vimos até o momento veremos alguns exemplos de temperatura na junta de medida de temperatura, na junta fria e como seria a saída no terminal “TERMO” com estes exemplos:

1) Sensor termopar = 25°C, Junta fria = 20°C, com estas condições descontando a temperatura da junta fria, o sensor termopar representaria ter 5°C produzindo no terminal “TERMO” uma tensão de +5mV.

2) Sensor termopar = 35°C, Junta fria = 10°C, com estas condições descontando a temperatura da junta fria, o sensor termopar representaria ter 25°C produzindo no terminal “TERMO” uma tensão de +25mV.

3) Sensor termopar = 5°C, Junta fria = 30°C, com estas condições descontando a temperatura da junta fria, o sensor termopar representaria ter -25°C produzindo no terminal “TERMO” uma tensão de -25mV.

Amplificador de referencia de junta fria:

O sensor de temperatura LM35 gera em sua saída 10mV a cada 1°C, sendo que o circuito proposto em sua etapa de amplificação do sensor termopar amplifica o sinal do mesmo até 1mV a cada 1°C, logo para compensar a junta fria do termopar é necessário um ajuste na saída de tensão do LM35, este é o papel do bloco de amplificação do LM35, que na verdade não amplifica mas sim divide esta tensão por 10 e por se tratar de um amplificador operacional montado em uma configuração inversora, seu sinal é dividido e invertido para -1mV °C, sinal este disponibilizado no terminal “AMB” do circuito elétrico da figura 1.

Veremos alguns exemplos de como seria a saída “AMB” em algumas condições:

1) Considerando que a temperatura ambiente a qual o LM35 seja 25°C, com isso o sensor LM35 produziria em sua saída uma tensão de +250mV, após a amplificação realizada pelo circuito amplificador inversor a saída “AMB” seria igual a -25mV.

2) Considerando que a temperatura ambiente a qual o LM35 seja 0°C, com isso o sensor LM35 produziria em sua saída uma tensão de +0mV, após a amplificação realizada pelo circuito amplificador inversor a saída “AMB” seria igual a -0mV.

3) Considerando que a temperatura ambiente a qual o LM35 seja 5°C, com isso o sensor LM35 produziria em sua saída uma tensão de +50mV, após a amplificação realizada pelo circuito amplificador inversor a saída “AMB” seria igual a -5mV.

Amplificador que Une os Sinais:

Como o diz o próprio nome está etapa é encarregada de unir os sinais produzidos pelas etapas de amplificação anteriores.

Esta etapa conta com um amplificador operacional operando com a configuração subtrator no qual vai amplificar a diferença entre as duas tensões de entrada, sendo que a tensão do terminal “SAIDA” do circuito é dada pela expressão:

SAIDA = AMB – TERMO * GANHO

Sendo que o ganho é dado pela razão entre os resistores do circuito (100K e 2k):

GANHO = 100 / 2

GANHO = 50

Considerando estas equações vamos analisar alguns exemplos:

1) Temperatura de junta fria deve ser a mesma temperatura do sensor LM35 neste exemplo 25°C, a Temperatura no nosso sensor termopar será igual a 35°C com isso:

AMB = -25mV

TERMO= +10mV

SAIDA = -25 – 10 * 50 = 2,5V

Bom agora vamos pensar desta forma, -25mV – 10mV seria igual a -35mV * 50, a tensão no terminal “SAIDA” seria de -2,5V ao invés de 2,5V positivos ?

Seria se estivéssemos falando de um amplificador somador mas esta etapa conta com um amplificador de diferenças não de somas, ou seja, a diferença entre -25 e +10 é de 35mV.

2) Temperatura de junta fria deve ser a mesma temperatura do sensor LM35 neste exemplo 30°C, a Temperatura no nosso sensor termopar será igual a 10°C com isso:

AMB = -30mV

TERMO= -20mV

SAIDA = -30 – 20 * 50 = 1V

Sendo que a diferença entre, -30mV – 20mV seria igual a -50mV * 50, a tensão no terminal “SAIDA” seria de -2,5V ao invés de 1V positivos ?

Como eu disse no exemplo anterior seria se estivéssemos falando de um amplificador somador, mas esta etapa conta com um amplificador de diferenças não de somas, ou seja, a diferença entre -30mV – 20mV é de +10mV pois da primeira tensão para a segunda ouve uma diferença de +10mV.

Contudo, basicamente o circuito proposto acima vai gerar uma tensão de 50mV a cada 1°C que o sensor termopar possuir, desde que o circuito esteja corretamente calibrado, sendo que o circuito possui 3 trimpots para esta calibragem.

Por hoje era isso, em breve estarei preparando mais material sobre eletrônica para postar por aqui.

Eletrônica – Sensores Termopar

2011-09-19T19:48:00.001-03:00

Boa noite!

Vou falar sobre sensores de temperatura termopar, como disse são sensores de medição de temperatura muito utilizados na indústria hoje para a medição de temperaturas em uma faixa de -270C° até 2000C°, como tudo na eletrônica os sensores termopar possuem boas e más caracteriscas, por exemplo, você pode trocar um sensor termopar por outro sensor termopar do mesmo tipo do sensor a ser substituído, não sendo necessário fazer ajuste de calibragem algum no circuito de medição, pois os sensores praticamente possuem a mesma característica. Outra boa característica é o preço de um sensor deste tipo, pois possui uma ampla faixa de medição, podendo ser aplicado em diversas aplicações em diversos ambientes adversos, e ter a certeza de que o sensor vai funcionar perfeitamente, diferentemente de outros sensores como os termistores, ou os sensores de temperatura digitais, que dependendo de sua característica não vão funcionar corretamente em locais com condições adversas.

Um sensor termopar basicamente são dois condutores (fios) de diferentes ligas metálicas, que uma vez unidos, no ponto desta união o condutores vão apresentar uma diferença de potencial(tensão ou voltagem como preferir) em suas extremidades, sendo que esta diferença de potencial vai variar para mais ou para menos conforme a temperatura a que a junta dos dois condutores for exposta.

Esta tensão gerada pela junta do sensor, é uma tensão que gira na ordem do micro volts até algums mili volts quando exposto a uma temperatura alta, segue uma breve descrição de dois tipos de termopares mais utilizados atualmente e que no caso eu já tive contato com os dois tipos:

Tipo T (Cobre / Constantan)

o É dos termopares mais indicados para medições na gama dos -270 °C a 400 °C, porém não é aconselhado a sua utilização em temperaturas altas, acima de 150 200 °C, pois o cobre comessa a deteriorar nesta temperatura, influenciando na precisão do sensor.

o Termo elemento positivo (TP): Cu100%

o Termo elemento negativo (TN): Cu55%Ni45% (Constantan)

o Faixa de utilização: -270 °C a 400 °C

o Tensão produzida: -6,258 mV a 20,872 mV

Tipo K (Cromel / Alumel)

o O termopar tipo K é um termopar de uso genérico. Tem um baixo custo e, devido à sua popularidade estão disponíveis nas mais variadas sondas. Cobrem temperaturas entre os -200 e os 1200 °C, tendo uma sensibilidade de aproximadamente 41µV/°C.

o Termo elemento positivo (KP): Ni90%Cr10% (Cromel)

o Termo elemento negativo (KN): Ni95%Mn2%Si1%Al2% (Alumel)

o Faixa de utilização: -270 °C a 1200 °C

o f.e.m. produzida: -6,458 mV a 48,838 mV

Dentre as más características dos termopares se destaca a chamada junta fria, para entender melhor vamos analisar a figura abaixo que vai representar um circuito com um sensor termopar Tipo T:

Circuito simples de um Sensor Termopar (fonte)

Vamos definir o seguinte para entender melhor :

A – Condutor de Constantam;

B – Condutores de Cobre;

T1, T2 – Juntas de união entre o condutor de Cobre e o condutor de Constantam;

V – Voltímetro;

Em uma extremidade do Constantam eu possuo uma junta entre o constantam e o cobre formando o T1(junta de medição de temperatura), sendo que este, por exemplo, é o sensor que eu vou utilizar para medir a temperatura de uma caldeira digamos assim, porém a segunda extremidade do constantam vai estar ligada ao equipamento de medição por exemplo e no contato onde o condutor de constantam estiver conectado no aparelho de medição será formado um novo sensor de temperatura(T2), este segundo sensor involuntário se assim podemos chama-lo, vai ser formado porque ali naquele contato será formada querendo ou não uma nova junta entre dois condutores diferentes no caso constantam e outro metal, normalmente cobre.

Com isso teremos dois sensores cada um produzindo uma determinada quantia de tensão equivalemte a temperatura que cada um deles está esposto, com isso a temperatura medida no medidor vai ser errônea porque T2(junta fria) vai influenciar na medida de temperatura que realmente me interessa.

Por exemplo:

T1 (sensor da caldeira) = 120°C

T2(junta fria, que normalmente se encontra a uma temperatura ambiente, ou na temperatura igual a temperatura do aparelho de medição) = 25°C

Logo a temperatura que será medida pelo aparelho de medição em questão será igual a 95°C (T1 – T2).

Isso é o que chamamos de junta fria, uma espécie de sensor parasita que se forma (sempre se forma), em um circuito de medição de temperatura que utiliza um sensor termopar.

Logo para resolver este problema normalmente é utilizado um terceiro sensor de precisão que normalmente é localizado junto do contato que faz ligação com o constantam, medindo a temperatura na qual se encontra a junta fria e adicionando esta temperatura a medição final ajustando tais valores para o valor exato da temperatura da caldeira em questão.

Neste artigo fiz uma introdução do que se trata um sensor termopar, no próximo capitulo vou mostrar um pequeno, porém muito eficiente circuito eletrônico para fazer a medida da temperatura de um sensor termopar com a devida compensação de junta fria.

C# - Adicionando, Editando e Deletando dados com SQLite

2011-09-18T23:43:00.006-03:00

Boa Noite!

Seguindo o artigo da ultima postagem, uma vez que temos uma tabela criada já podemos começar a inserir dado edita-los e posteriormente excluí-los.

Então vamos para a pratica, considerando que já possuímos o banco de dados criado, a tabela CLIENTE criada e a conexão com o banco aberta, vamos adicionar o primeiro registro a nossa tabela, antes disso vamos relembrar a estrutura da tabela cliente e quais os comandos para inserir dados nela.

Tabela Cliente:

CREATE TABLE CLIENTE (cliId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, cliNome TEXT NOT NULL, cliEmail TEXT NOT NULL)

Para inserir um dado nesta tabela vamos utilizar o comando INSERT:

INSERT INTO CLIENTE (cliNome, cliEmail) VALUES ("Diego Bittencourt de Oliveira", "dbo.oliveira@gmail.com")

Observe que não foi definido um cliId, pois este é definido pelo próprio SQLite, sendo que isto é definido na criação da tabela onde o campo cliId foi definido como “AUTOINCREMENT”, logo o código do cliente será atribuído automaticamente.

Em C# os comandos seriam assim:

objCommand.CommandText = "INSERT INTO CLIENTE (cliNome, cliEmail) VALUES (@cliNome, @cliEmail )";
objCommand.Parameters.Add(new SQLiteParameter("@cliNome", "Diego Bittencourt de Oliveira"));
objCommand.Parameters.Add(new SQLiteParameter("@cliEmail", "dbo.oliveira@hotmail.com"));
objCommand.ExecuteNonQuery();

Uma vez que se queira editar este registro recém criado acima, se utiliza o comando UPDADE:

UPDATE CLIENTE SET cliNome="Diego Bittencourt de Oliveira", cliEmail="diego_b_oliveira@hotmail.com" WHERE cliId=1

Obs: a expressão “WHERE cliId=1” indica que somente vamos alterar o registro que for identificado pela chave primaria 1, eu sei que a chave do nosso registro é 1 poque foi o primeiro a ser inserido na tabela CLIENTE que criei como exemplo.

Outra observação seria que no comando update eu poderia apenas modificar uma ou outra variável do registro, assim eu poderia especificar somente a variável que foi alterada sendo que as demais não teriam necessidade de aparecer no comando update.

Em C# os comandos para alterar o registro seriam assim:

objCommand.CommandText = " UPDATE CLIENTE SET cliNome=@cliNome,  cliEmail=@cliEmail WHERE cliId=@cliId”;
objCommand.Parameters.Add(new SQLiteParameter("@cliNome", "Diego Bittencourt de Oliveira"));
objCommand.Parameters.Add(new SQLiteParameter("@cliEmail", "diego_b_oliveira@hotmail.com"));
objCommand.Parameters.Add(new SQLiteParameter("@cliId", 1));
objCommand.ExecuteNonQuery();

Bom agora somente nos falta ver como deletar o nosso registro da tabela cliente, para isso em SQL existe um comando chamado DELELE, que deleta um registro ou mais registros conforme for especificado o comando.

Por exemplo um DELETE pode deletar todos os registros que forem pertencentes a uma determinada cidade ou até mesmo deletar de uma cadastro de dependentes todos os dependentes que forem maiores de 18 anos, no nosso caso vamo deletar o registro 1 do nosso cadastro de clientes:

DELETE FROM CLIENTE WHERE cliId=@cliId

Em C# os comandos para deletar o registro seriam assim:

objCommand.CommandText = "DELETE FROM CLIENTE WHERE cliId=@cliId";
objCommand.Parameters.Add(new SQLiteParameter("@cliId", 1));
objCommand.ExecuteNonQuery();

Bom basicamente seria isso que gostaria de mostrar neste artigo, no próximo artigo veremos como selecionar os dados inseridos em uma tabela de um banco de dados SQLite.

C# - SQLite Criação de Tabelas

2011-09-14T22:35:00.004-03:00

Antes de partir para o código em C# para executar uma query e assim criar as tabelas no banco de dados SQLite que neste artigo é o objetivo do mesmo, temos de falar sobre os tipos de dados que o SQLite implementa.

No SQLite, existem apenas 5 tipos de dados, sendo eles:

NULL - comum em qualquer outro banco de dados.
INTEGER - inteiro com sinal, armazenado em 1, 2, 3, 4, 6 ou 8 bytes dependendo da grandeza do valor.
REAL - valor de ponto flutuante armazenado em 8 bytes.
TEXT - uma string armazenada usando UTF-8, UTF-16BE ou UTF-16LE.
BLOB - armazena um blob, como indica o nome.

A biblioteca do SQLite implementa recursos de compatibilidade com outros bancos de dados, no site do desenvolvedor essa compatibilidade é tratada como uma espécie de afinidade. Por exemplo, um tipo de dados INT comum em diversos bancos de dados é tratado como um INTEGER no SQLite, abaixo segue uma tabela com uma listagem das afinidades entre os tipos de dados e o SQLite:

Tipo de Dados de Outros Bancos de Dados	Tipo de Dados do SQLite
INT	INTEGER
INTEGER
TINYINT
SMALLINT
MEDIUMINT
BIGINT
UNSIGNED INT BIG
INT2
INT8
CHARACTER (20)	TEXT
VARCHAR (255)
CHARACTER VARYING (255)
NCHAR (55)
CHARACTER NATIVA (70)
NVARCHAR (100)
TEXTO
CLOB
BLOB	BLOB
REAIS	REAL
DOUBLE
DOUBLE PRECISION
FLOAT
NUMERIC	NUMERIC
DECIMAL (10,5)
BOOLEAN
DATA
DATETIME

Basicamente são estes os tipos de dados mais Informações podem ser vistas no site do desenvolvedor do SQLite nesta página.

Partindo para o tema do artigo, vamos estudar como utilizar a classe do System.Data.SQLite, classe esta que executa comandos no banco de dados. O SQLiteCommand é a classe responsável por esta execução de comandos no banco de dados.

O exemplo abaixo mostra como cria no banco da dados SQLite uma tabela chamada Cliente com três campos cliId, cliNome e o cliEmail, vamos aproveitar a rotina mostrada no ultimo artigo que mostrava como criar e abrir uma conexão com o banco de dados SQLite:

SQLiteCommand objCommand;
SQLiteConnection objConnection; // Objeto de com o arquivo do banco de dados
StringBuilder strConnection = new StringBuilder();// String de com o arquivo do banco de dados
// Busco o Diretório de onde minha aplicação esta sendo executada
string path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
// pego o caminho de onde a aplicação esta sendo executada concateno o diretório com o nome do 
// arquivo do banco de dados
path = path + @"\BaseDados.db";
// Comesso a montar a String de Conexão definindo o Data Source
strConnection.Append("Data Source=BaseDados.db;");
// Definindo a versão
strConnection.Append("Version=3;");
// Verifico se o arquivo do banco de dados existe para criar ou não um novo banco de dados
if (File.Exists(path))
    strConnection.Append("New=False;");
else
    strConnection.Append("New=True;");
// Defino que quero o arquivo em um formato comprimido para economizar espaço em disco
strConnection.Append("Compress=True;");
// adiciono ao objeto de conexão a string de conexão formada
objConnection= new SQLiteConnection(strConnection.ToString());
// Abro o banco de dados
objConnection.Open();
// Crio um novo comando para executar comandos SQL no banco de dados
objCommand = objConnection.CreateCommand();
// Adiciono o comando ao SQLiteCommand
objCommand.CommandText = "CREATE TABLE CLIENTE (cliId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
                         " cliNome TEXT NOT NULL, cliEmail TEXT NOT NULL)";
// Executo a Nom Query (nom query porque não está me retornando dados)
objCommand.ExecuteNonQuery();
// Executo o metodo dispose para liberar os recuses que não serão mais utilizados
objCommand.Dispose();
// Fecha a conexão com o banco de dados
objConnection.Open();
// Executo o metodo dispose para liberar os recuses que não serão mais utilizados
objConnection.Dispose();

O SQLite possui diversas formas de executar este comando de criação de uma tabela nesta página do site do Desenvolvedor do SQLite, o comando de criação de uma tabela também pode ser escrito de outra forma como a mostrada abaixo:

"CREATE TABLE IF NOT EXISTS CLIENTE..." – Sendo que este comando criaria a tabela cliente caso a não exista no banco de dados.

Para se excluir uma tabela do banco de dados SQLite, não existe nenhum segredo ele basicamente funciona da mesma forma que funciona em outros bancos de dados:

"DROP TABLE CLIENTE" – Exclui a tabela cliente do banco de dados.
"DROP TABLE IF EXISTS CLIENTE" – Exclui uma tabela no banco de dados caso a mesma exista.

Bom basicamente é desta forma que criamos e excluímos uma tabela no banco de dados Sqlite, no próximo artigo veremos como inserir dados no SQLite usando os recursos oferecidos pelo componente ADO.NET System.Data.SQLite.

C# - Conexão com o SQLite

2011-09-14T14:34:00.000-03:00

Boa Tarde!

Hoje vamos começar a ver alguma coisa sobre o SQLite na pratica, utilizando o componente desenvolvido para o Visual Studio (C++, Vb.net ou C#) disponível no site do System.Data.Sqlite, sendo que este componente incorpora a biblioteca do SQLite 3 em seu código fonte, ou seja, não existe dependência da DLL do SQLite.

No site do System.Data.Sqlite existe um Vídeo que mostra a integração do componente System.Data.Sqlite com o Visual Studio.

Nos artigos vamos supor que já tenha sido criado um projeto com Visual Studio C# com referencia a DLL do System.Data.Sqlite.

Vamos mostrar neste artigo como fazer a string de conexão com banco de dados SQLite:

String de conexão Básica

Data Source =Arquivo; Version =3;

Onde:

Data Source =Arquivo – é o arquivo do banco de dados, sendo que se o arquivo conter somente o nome do arquivo o componente System.Data.Sqlite vai considerar que a localização do arquivo será no mesmo diretório de onde se encontra a DLL do componente System.Data.Sqlite se encontra (ex: Data Source =”banco.db”;), porém se for especificado o caminho do arquivo logicamente que o System.Data.Sqlite vai procurar o arquivo no caminho especificado.

Version =3 – indica a versão do motor do banco de dados, ou seja, a versão do código fonte puro do SQLite original, sendo que o System.Data.Sqlite é um componente que da ao SQLite as funcionalidades do ADO.NET.

String de conexão usando UTF16

Data Source = Arquivo; Version =3; UseUTF16Encoding =True;

String de conexão especificando senha de Acesso

Data Source = Arquivo; Version =3; Password =senha;

Onde:

Password =senha – “senha” especifica a senha de acesso ao banco de dados (ex: Password= “123mudar”).

String de conexão para abrir o banco de dados no modo de somente leitura

Data Source = Arquivo; Version =3; Read Only =True;

String de conexão para criar um novo banco de dados

Data Source = Arquivo; Version =3; New =True;

String de conexão para não criar um novo banco de dados

Data Source = Arquivo; Version =3; New =False;

String de conexão indicando que o banco possui um formato comprimido

Data Source = Arquivo; Version =3; Compress =True;

Normalmente eu utilizo a rotina abaixo para criar um conexão com meu banco de dados :

SQLiteConnection objConnection; // Objeto de com o arquivo do banco de dados

StringBuilder strConnection = new StringBuilder();// String de com o arquivo do banco de dados

// Busco o Diretório de onde minha aplicação esta sendo executada

string path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);

// pego o caminho de onde a aplicação esta sendo executada concateno o diretório com o nome do

// arquivo do banco de dados

path = path + @"\BaseDados.db";

// Comesso a montar a String de Conexão definindo o Data Source

strConnection.Append("Data Source=BaseDados.db;");

// Definindo a versão

strConnection.Append("Version=3;");

// Verifico se o arquivo do banco de dados existe para criar ou não um novo banco de dados

if (File.Exists(path))

strConnection.Append("New=False;");

else

strConnection.Append("New=True;");

// Defino que quero o arquivo em um formato comprimido para economizar espaço em disco

strConnection.Append("Compress=True;");

// adiciono ao objeto de conexão a string de conexão formada

objConnection= new SQLiteConnection(strConnection.ToString());

// Abro o banco de dados

objConnection.Open();

Nas próximas postagens veremos como enviar comandos SQL para o banco de dados SQLite para que possamos ver melhor a performance deste excelente banco de dados.

SQLite

2011-09-12T23:23:00.000-03:00

Boa Noite!

Vamos Inaugurar o blogue com a primeira de algumas postagens sobre esta biblioteca escrita em Linguagem C, que implementa um poderoso banco de dados amplamente utilizado nos dias em hoje em diversos softwares já consagrados como por exemplo o navegador Google Crome, estando também implementado nativamente nas bibliotecas do SDK QT, uma poderosa biblioteca de desenvolvimento C++, sendo que não podemos nos esquecer do Sistema Operacional Android, que em sua SDK também implementa nativamente as bibliotecas do SQLite.

A biblioteca SQLite, basicamente implementa um banco de dados em um arquivo, onde ele lê e escreve todas as informações que são submetidas e requeridas através da Linguagem SQL.

O uso desta biblioteca é recomendado quando não se tem a necessidade dos incontáveis recursos de um Gerenciador de Banco de dados Convencional como o SQL Server, Oracle e Mysql por exemplo.

Sendo que o SQLite é recomentado para aplicações onde:

Sites (com menos de cem mil requisições por dia);
Dispositivos e sistemas embarcados;
Aplicações desktop;
Ferramentas estatísticas e de análise;
Aprendizado de banco de dados;
Implementação de novas extensões à SQL.

O SQLite não é recomendado para aplicações onde:

Sites com muitos acessos;
Grande quantidade de dados (maior que algumas dúzias de gigabytes);
Sistemas com grande concorrência;
Aplicações cliente/servidor.

Vejamos algumas características do SQLite:

Software livre/domínio público e Multiplataforma;
Mecanismo de armazenamento seguro com transações ACID;
Não necessita de instalação, configuração ou administração;
Implementa a maioria do SQL92;
O Banco de Dados é guardado em um único arquivo;
Suporta bases de dados acima de 2 terabytes;
Sem dependências externas.

O Site do Desenvolvedor do SQLite se encontra no link abaixo:

http://www.sqlite.org/

Nas próximas postagens vamos ver como implementar SQLite junto de aplicações desenvolvidas com C# e mais adiante Android.