Système de train intelligent : 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Conçu pour augmenter la sécurité, prévenir les accidents et augmenter la réponse positive et productive pour aider en cas d'accident.

Étape 1: Pièces et matériaux

Les images ci-dessus sont placées dans l'ordre de la liste des pièces ci-dessous:

Liste des pièces

1) Un Raspberry PI 3 - Modèle B

2) Une planche à pain

3) Câbles (de haut en bas) - Une alimentation, un Ethernet, un adaptateur

4) un servomoteur

5) Une porte de chemin de fer imprimée en 3D

6) Deux LED (de préférence rouge et verte)

7) Un bouton poussoir

8) Dix fils de cavalier

9) Quatre résistances

10) Ordinateur portable ou ordinateur de bureau avec MATLAB

Étape 2: Configuration

Ci-dessus, des images de la configuration sous plusieurs angles:

Les emplacements des broches (lettre minuscule suivie d'un numéro de ligne) sont répertoriés ci-dessous dans l'ordre suivant le flux actuel.

Fils:

j19 à i47

j8 à b50

b5 à servo

c6 à servo

b7 au servo

a13 à j7

a17 à LED

LED à a37

e40 à j20

j53 à j18

j7 à LED

LED vers j6

Bouton:

e54 à h51

Résistances:

d40 à b37

c50 à d54

i51 à j47

Étape 3: Code et logique

L'objectif de notre système ferroviaire est d'accroître la sécurité et de réduire le risque d'accidents potentiellement mortels aux passages à niveau. Pour ce faire, notre système dispose d'un système d'avertissement de train pour les conducteurs, d'une barrière physique qui est abaissée pour empêcher les voitures de traverser la voie et d'un bouton d'urgence de secours sur lequel le conducteur peut appuyer en cas de défaillance du système d'alerte précoce.

Système d'exploitation du conducteur GUI:

L'interface graphique, illustrée ci-dessus, a été créée pour être utilisée par le conducteur pendant qu'il conduit le train à travers des zones de voie qui ont des passages à niveau pour la circulation automobile.

Dans le coin supérieur droit, il y a une lumière qui informe le conducteur si une barrière de passage à niveau à venir est fermée et permet au conducteur d'ouvrir ou de fermer la barrière si nécessaire. En dessous, le flux des caméras que le train passe est affiché. Dans le coin inférieur gauche, l'emplacement du train est tracé en continu sur un graphique et en dessous du graphique, le nombre de tours que le train a effectués en une journée est indiqué. Au-dessus du graphique de position, il y a un bouton d'urgence et une déclaration d'état. Cela permet au conducteur de signaler une urgence s'il y a une voiture sur la voie ou si la barrière de sécurité ne fonctionne pas correctement.

Code:

classdef micro < matlab.apps. AppBase % Propriétés qui correspondent aux composants de l'application

propriétés (Accès = public)

UIFigure matlab.ui. Figure

RailwaygatestatusLampLabel matlab.ui.control. Label

gateLamp matlab.ui.control. Lampe

OpenGateButton matlab.ui.control. Button

CloseGateButton matlab.ui.control. Button

UIAxes matlab.ui.control. UIAxes

EmergencyButtonStatusLampLabel matlab.ui.control. Label

EmergencyButtonStatusLamp matlab.ui.control. Lamp

SousconditionsnormalesLabel matlab.ui.control. Label

UIAxes2 matlab.ui.control. UIAxes

EF230Group6Label matlab.ui.control. Label

IanAllishKellyBondIanDaffronLabel matlab.ui.control. Label

LoopsCompletedLabel matlab.ui.control. Label

Libellé matlab.ui.control. Label

finir

propriétés (Accès = privé)

compteur int16

finir

méthodes (Accès = public)

fonction timerCallback (app, src, événement)

app. Temp. Text = int2str(app.counter);

app.counter = app.counter + 1;

%appelez toutes les variables dont le programme a besoin - - - - - - - - - - - - -

rpi global

monde s

ouverture mondiale

clôture mondiale

caméra globale

m global

SME global

t_count global

%------------------------- Section de bras de train --------------------- ---------

si ouvert == 0

écriturePosition(s, 50)

app.gateLamp. Color = 'vert';

finir

si proche == 0

écriturePosition(s, 120)

app.gateLamp. Color = 'rouge';

finir

%---------------------- Détection de mouvement via caméra -----------------------

bien que vrai

img = instantané(came);

image(img);

app. UIAxes (dessiner maintenant)

finir

%---------------------- Bras ouvert/fermé ----------------------- --------------

si readDigitalPin(rpi, 20)>1 % lit la broche 17 (bouton) et vérifie le signal

pour i=40: 5: 150 % soulève le pont

écriturePosition(s, i)

finir

pour i = 1:10 % boucles clignotant rouge lumière x nombre de fois

écrireDigitalPin(rpi, 13, 1)

pause(.5)

écrireDigitalPin(rpi, 13, 0)

pause(.5)

finir

writePosition(s, 50) % abaisser la porte

finir

%-------------------- Support/Plot de téléphonie mobile ------------------------ --

m. AccelerationSensorEnabled=1

m.logging=1

données=zéros(200, 1); % initialiser les données pour le tracé glissant

figure (app. UIAxes2)

p=tracer(données)

axe([xbounda, ybounds])

pause(1)

tic

tandis que toc <30 % fonctionner pendant 30 secondes

[a, ~]=accello(m);

si longueur(a) >200

data=a(fin-199:fin, 3);

autre

data(1:longueur(a))=a(:, 3);

finir

%retracer le tracé

p. YDonnées=données;

dessiner

finir

%------------------ Changement soudain de pixel ---------------------------- ------

x1=img; % lit la caméra hors du pi

red_mean = moyenne(mean(x1(:,:, 1))); % lit la quantité moyenne de pixels rouges

green_mean = moyenne(mean(x1(:,:, 2))); % lit la quantité moyenne de pixels verts

blue_mean = moyenne(mean(x1(:,:, 3))); % lit la quantité moyenne de pixels bleus

si red_mean > 150 && green_mean > 150 && blue_mean > 150

t_compte = t_compte + 1;

finir

app. LoopsCompletedLabel. Text = num2str(t_count)

%------------------ Programmation EMS du bouton ----------------------------- ---

configurePin(rpi, 12, 'DigitalOutput'); % définit la broche LED, broche 16, comme sortie

configurePin(rpi, 16, 'DigitalInput'); % définit la broche du bouton, la broche 24, comme entrée

boutonAppuyé = readDigitalPin(rpi, 16); % Lit la valeur d'appui sur le bouton sur la broche 16

si bouton enfoncé == 1

pendant que le bouton est enfoncé == 1

écrireDigitalPin(rpi, 12, 1)

buttonunPressed = writeDigitalPin(rpi, 12, 0); %

end % Termine la boucle « while buttonPressed==1 »

finir

writeDigitalPin(rpi, 16, 0) %Désactive la led lorsque le bouton n'est plus enfoncé setpref('Internet', 'SMTP_Server', 'smtp.gmail.com'); setpref('Internet', 'E_mail', '[email protected]'); % compte de messagerie à envoyer depuis setpref('Internet', 'SMTP_Username', '[email protected]'); % nom d'utilisateur de l'expéditeur setpref('Internet', 'SMTP_Password', 'efgroup6'); % mot de passe des expéditeurs

props = java.lang. System.getProperties;

props.setProperty('mail.smtp.auth', 'true'); props.setProperty('mail.smtp.socketFactory.class', 'javax.net.ssl. SSLSocketFactory'); props.setProperty('mail.smtp.socketFactory.port', '465');

sendmail('[email protected]', 'État d'urgence !', 'Le conducteur a activé le commutateur de dérogation manuelle, demandant une réponse immédiate !')

app. UndernormalconditionsLabel. Text = ems

finir

finir

%app. Label_4. Text = num2str(curr_temp);

méthodes (Accès = privé)

% de code qui s'exécute après la création du composant

fonction startupFcn (application)

%----------Toutes les variables nécessaires à cette fonction--------------------

rpi global %arduino

rpi = raspi('169.254.0.2', 'pi', 'framboise');

global s %servo

s = servo(rpi, 17, 'MinPulseDuration', 5e-4, 'MaxPulseDuration', 2.5e-3);

ouverture mondiale

ouvert = 1;

global fermé

fermé = 1;

caméra globale

cam = cameraboard(rpi);

m global

m=mobiledev;

SME global

ems = 'Une urgence a été signalée, notifiant EMS';

t_count global

t_compte = 0;

le connecteur sur %password est EFGroup6

% Fonction de minuterie pour la boucle --------------------------------

app.counter = 0;

t = minuterie(…

'TimerFcn', @app.timerCallback, …

'StartDelay', 1, … 'Période', 1, …

'ExecutionMode', 'fixedSpacing', …

'TâchesPourExécuter', inf);

début(t);

finir

% fonction de rappel

fonction ManualOverrideSwitchValueChanged (application, événement)

finir

% Fonction de bouton enfoncé: OpenGateButton

fonction OpenGateButtonPushed (application, événement)

clôture mondiale

fermer = 0;

finir

% Fonction de bouton enfoncé: CloseGateButton

fonction CloseGateButtonPushed (application, événement)

ouverture mondiale

ouvert = 0;

finir

finir

% Initialisation et construction de l'application

méthodes (Accès = privé)

% Créer UIFigure et composants

fonction createComponents (application)

% Créer UIFigure

app. UIFigure = uifigure;

app. UIFigure. Position = [100 100 640 480];

app. UIFigure. Name = 'Figure UI';

% Créer RailwaygatestatusLampLabel

app. RailwaygatestatusLampLabel = uilabel(app. UIFigure);

app. RailwaygatestatusLampLabel. HorizontalAlignment = 'right'; app. RailwaygatestatusLampLabel. Position = [464 422 110 22]; app. RailwaygatestatusLampLabel. Text = 'Statut de la porte de chemin de fer';

% Créer gateLamp

app.gateLamp = uilamp(app. UIFigure);

app.gateLamp. Position = [589 422 20 20];

app.gateLamp. Color = [0.9412 0.9412 0.9412];

% Créer OpenGateButton

app. OpenGateButton = uibutton(app. UIFigure, 'push');

app. OpenGateButton. ButtonPushedFcn = createCallbackFcn(app, @OpenGateButtonPushed, true); app. OpenGateButton. Position = [474 359 100 22];

app. OpenGateButton. Text = 'Open Gate';

% Créer CloseGateButton

app. CloseGateButton = uibutton(app. UIFigure, 'push');

app. CloseGateButton. ButtonPushedFcn = createCallbackFcn(app, @CloseGateButtonPushed, true); app. CloseGateButton. Position = [474 285 100 22];

app. CloseGateButton. Text = 'Fermer la porte';

% Créer des axes UIA

app. UIAxes = uiaxes(app. UIFigure);

title(app. UIAxes, 'Flux de caméra')

app. UIAxes. Position = [341 43 300 185];

% Créer EmergencyButtonStatusLampLabel

app. EmergencyButtonStatusLampLabel = uilabel(app. UIFigure); app. EmergencyButtonStatusLampLabel. HorizontalAlignment = 'right'; app. EmergencyButtonStatusLampLabel. Position = [97 323 142 22]; app. EmergencyButtonStatusLampLabel. Text = 'État du bouton d'urgence';

% Créer EmergencyButtonStatusLamp

app. EmergencyButtonStatusLamp = uilamp(app. UIFigure); app. EmergencyButtonStatusLamp. Position = [254 323 20 20];

% Créer l'étiquette des conditions sous-normales

app. UndernormalconditionsLabel = uilabel(app. UIFigure);

app. UndernormalconditionsLabel. Position = [108 285 248 22];

app. UndernormalconditionsLabel. Text = 'Dans des conditions normales';

% Créer UIAxes2

app. UIAxes2 = uiaxes(app. UIFigure);

title(app. UIAxes2, 'Position du train')

xlabel(app. UIAxes2, 'Position X')

ylabel(app. UIAxes2, 'Position Y')

app. UIAxes2. Box = 'on';

app. UIAxes2. XGrid = 'on';

app. UIAxes2. YGrid = 'on';

app. UIAxes2. Position = [18 43 300 185];

% Créer EF230Group6Label

app. EF230Group6Label = uilabel(app. UIFigure);

app. EF230Group6Label. HorizontalAlignment = 'center';

app. EF230Group6Label. FontSize = 28;

app. EF230Group6Label. FontWeight = 'gras';

app. EF230Group6Label. Position = [-4 401 379 64];

app. EF230Group6Label. Text = 'EF 230 Groupe 6';

% Créer IanAllishKellyBondIanDaffronLabel

app. IanAllishKellyBondIanDaffronLabel = uilabel(app. UIFigure); app. IanAllishKellyBondIanDaffronLabel. Position = [94 380 184 22]; app. IanAllishKellyBondIanDaffronLabel. Text = 'Ian Allish, Kelly Bond, Ian Daffron';

% Créer des bouclesCompletedLabel

app. LoopsCompletedLabel = uilabel(app. UIFigure);

app. LoopsCompletedLabel. Position = [18 10 103 22];

app. LoopsCompletedLabel. Text = 'Loops terminées:';

% Créer une étiquette

app. Label = uilabel(app. UIFigure);

app. Label. Position = [120 10 178 22];

app. Label. Text = '####';

finir

finir

méthodes (Accès = public)

% Construire l'application

application de fonction = micro

% Créer et configurer des composants

créer des composants (application)

% Enregistrez l'application avec App Designer

registerApp(app, app. UIFigure)

% Exécuter la fonction de démarrage

runStartupFcn (application, @startupFcn)

si nargout == 0

effacer l'application

finir

finir

% de code qui s'exécute avant la suppression de l'application

supprimer (application)

% Supprimer UIFigure lorsque l'application est supprimée

supprimer (app. UIFigure)

finir

finir

finir

Étape 4: Dernière étape

Une fois que le code a été écrit et que le Raspberry Pi a été câblé, fixez le servomoteur à la porte de voie ferrée imprimée en 3D comme il est attaché dans l'image ci-dessus.

Maintenant, le projet est terminé. Connectez le Raspberry PI à la voie ferrée et observez le nouveau système créant des passages à niveau plus sûrs pour les automobilistes et les conducteurs. Jouez avec le système en interagissant avec l'interface graphique pour déclencher des coffres-forts mis en place pour éviter les accidents.

C'est la fin du tutoriel, profitez de votre nouveau système de train intelligent !