Sistema de Informação de Disponibilidade de Assentos de Trem - FGC: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Este projecto baseia-se na implementação, à escala, de um comboio que permite às pessoas que se encontram na estação saberem quais os lugares que estão disponíveis. Para a realização do protótipo, o software Arduino UNO é utilizado em conjunto com o Processing para a parte gráfica.

Este conceito possibilitaria revolucionar o mundo do transporte público, pois otimizaria ao máximo todos os assentos do trem, garantindo a utilização de todos os vagões, além da possibilidade de coletar dados e realizar estudos precisos, posteriormente. sobre.

Etapa 1: projetar o modelo 3D

Em primeiro lugar, fizemos uma pesquisa abrangente sobre modelos de trens. Com todas as informações coletadas, foi escolhido o trem GTW (produzido pela Stadler Rail) utilizado no FGC (Ferrocarrils de la Generalitat de Catalunya).

Posteriormente, foi projetado com o software 3D PTC Creo o modelo para a impressão 3D subsequente.

Etapa 2: impressão do modelo 3D e acabamentos

Depois que o trem é projetado, ele é passado para a impressão 3D. Uma vez que a peça é impressa, ela deve ser polida para obter uma superfície lisa.

Este projeto também pode ser feito com os modelos de trens existentes.

Depois de impressos, os acabamentos finais são dados.

Etapa 3: Componentes

Para o desenvolvimento deste projeto são necessários os seguintes componentes:

- FSR 0.04-4.5LBS (sensor de pressão).

- resistores de 1,1K ohms

Etapa 4: codificação (Arduino e processamento)

Agora é hora de escrever o código do Arduino que permitirá que os sensores enviem um sinal para o software de processamento que transmitirá as informações graficamente.

Como sensores temos 4 sensores de pressão por arduino que variam sua resistência de acordo com a força que é aplicada sobre eles. Assim, o objetivo é aproveitar o sinal enviado pelos sensores (quando os passageiros se sentam) para alterar as telas gráficas no Processing.

Em seguida, criamos a parte gráfica na qual levamos em consideração o design gráfico dos Ferrocarrils de la Generalitat de Catalunya, para emular a realidade da melhor maneira possível.

No processamento foi escrito um código que é conectado diretamente ao software arduino, desta forma, toda vez que alguém senta em um assento, ele muda de cor, permitindo ao usuário na plataforma do trem saber em tempo real a disponibilidade de assentos do trem.

Aqui você pode ver a codificação

ARDUINO:

pote int = A0; // Conecte o pino do meio do potenciômetro a este pino pot2 = A1; pote interno 3 = A2; pote interno 4 = A3; int lectura1; // variável para armazenar os valores do potenciômetro;

int lectura2; int lectura3; int lectura4;

void setup () {// inicializa as comunicações seriais a uma taxa de transmissão de 9600 Serial.begin (9600); }

void loop () {String s = ""; // // Llegir sensor1 lectura1 = analogRead (pot); // lectura o valor analógico if (lectura1> 10) {s = "1"; atraso (100); } mais {s = "0"; atraso (100); } Serial.println (s);

}

EM PROCESSAMENTO:

import processing.serial. *; // esta biblioteca lida com a conversa serial String val = ""; Imagem s0000, s0001, s0010, s0011, s0100, s0101, s0110, s0111, s1000, s1001, s1010, s1011, s1100, s1101, s1110, s1111; Serial myPort; // Criar objeto da classe Serial

void setup () // executa apenas uma vez {fullScreen (); background (0); // definindo a cor de fundo para preto myPort = new Serial (this, "COM5", 9600); // dando parâmetros ao objeto da classe serial, coloque o com ao qual seu arduino está conectado e a taxa de transmissão

s0000 = loadImage ("0000.jpg"); s0001 = loadImage ("0001.jpg"); s0010 = loadImage ("0010.jpg"); s0011 = loadImage ("0011.jpg"); s0100 = loadImage ("0100.jpg"); s0101 = loadImage ("0101.jpg"); s0110 = loadImage ("0110.jpg"); s0111 = loadImage ("0111.jpg"); s1000 = loadImage ("1000.jpg"); s1001 = loadImage ("1001.jpg"); s1010 = loadImage ("1010.jpg"); s1011 = loadImage ("1011.jpg"); s1100 = loadImage ("1100.jpg"); s1101 = loadImage ("1101.jpg"); s1110 = loadImage ("1110.jpg"); s1111 = loadImage ("1111.jpg");

s0000.resize (displayWidth, displayHeight); s0001.resize (displayWidth, displayHeight); s0010.resize (displayWidth, displayHeight); s0011.resize (displayWidth, displayHeight); s0100.resize (displayWidth, displayHeight); s0101.resize (displayWidth, displayHeight); s0110.resize (displayWidth, displayHeight); s0111.resize (displayWidth, displayHeight); s1000.resize (displayWidth, displayHeight); s1001.resize (displayWidth, displayHeight); s1010.resize (displayWidth, displayHeight); s1011.resize (displayWidth, displayHeight); s1100.resize (displayWidth, displayHeight); s1101.resize (displayWidth, displayHeight); s1110.resize (displayWidth, displayHeight); s1111.resize (displayWidth, displayHeight);

val = trim (val);} void draw () {if (val! = null) {

if (val.equals ("0001")) {imagem (s0001, 0, 0); } else if (val.equals ("0010")) {imagem (s0010, 0, 0); } else if (val.equals ("0011")) {imagem (s0011, 0, 0); } else if (val.equals ("0100")) {imagem (s0100, 0, 0); } else if (val.equals ("0101")) {imagem (s0101, 0, 0); } else if (val.equals ("0110")) {imagem (s0110, 0, 0); } else if (val.equals ("0111")) {imagem (s0111, 0, 0); } else if (val.equals ("1000")) {imagem (s1000, 0, 0); } else if (val.equals ("1001")) {imagem (s1001, 0, 0); } else if (val.equals ("1010")) {imagem (s1010, 0, 0); } else if (val.equals ("1011")) {imagem (s1011, 0, 0); } else if (val.equals ("1100")) {imagem (s1100, 0, 0); } else if (val.equals ("1101")) {imagem (s1101, 0, 0); } else if (val.equals ("1110")) {imagem (s1110, 0, 0); } else if (val.equals ("1111")) {imagem (s1111, 0, 0); } else {imagem (s0000, 0, 0); }}}

void serialEvent (Serial myPort) // sempre que um evento serial acontece, ele executa {val = myPort.readStringUntil ('\ n'); // certifique-se de que nossos dados não estão vazios antes de continuar if (val! = null) {// apara espaços em branco e caracteres de formatação (como retorno de carro) val = trim (val); println (val); }}

Etapa 5: Circuito

Depois de toda a programação, é hora de conectar todos os sensores com a placa Arduino UNO.

Os sensores são colocados em 4 assentos (que posteriormente serão cobertos por um pano) e soldados a cabos que vão diretamente para a placa-mãe do Arduino UNO. O sinal recebido na placa é enviado para um computador conectado via USB que envia as informações para Processing em tempo real, mudando a cor do assento.

Você pode ver um esquema das conexões.

Etapa 6: teste de protótipo

Uma vez que o código foi carregado para a placa arduino e o programa de processamento e arduino ativado, os sensores são testados. Na tela você verá as alterações dos assentos devido à mudança de imagens no display informando sobre os assentos ocupados e não.

Etapa 7: Simulação real

O aplicativo real tentaria instalá-lo em trens e plataformas da rede FGC para atender viajantes.

Etapa 8: APROVEITE

Você finalmente fez um Trem Sensor de Força (protótipo) que permite ao usuário na plataforma do trem saber qual assento está disponível em tempo real.

BEM VINDO AO FUTURO!

Projeto feito por Marc Godayol e Federico Domenech