voila le probleme : c'est crer 2 programme client et serveur.le prg du client ets générer sur un microprocesseur SC12 et le prg du serveur est en simple java avec un petite interface graphique ou il y a un boutton. quand on presse sur le bouton, il envois qqch au microprocesseur et le micro processeur affiche un accuser de réception comme quoi il a bien recu le coli.
client : tourne sur le microprocesseur SC12 il est en code java embarqué
serveur : tourne sur la machine en java orienté objet
les deux application se parle grace au réseau mon pc est connecter au réseau et le microserveur aussi grace au hub.
voila j ai ce travail a fait mais je ne comprend vraiment pas comment il faut faire quelle méthode enployer pour les deux prg surtout pour le client qui de la programmation embarqué ¨
ja i fait un le code du serveur : si ca peut vous aider pour maider merci de votre aide
code serveur :
package boutton;
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import com.borland.jbcl.layout.*;
/**
* <p>Title: </p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author not attributable
* @version 1.0
*/
public class boutton extends JFrame {
// Exécuter l'application
public static void main (String args[]){
boutton application = new boutton();
application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
application.LancerServeur();
}
XYLayout xYLayout1 = new XYLayout();
JToggleButton Benvoie = new JToggleButton();
private ObjectOutputStream sortie;
private ObjectInputStream entree;
private ServerSocket server;
private Socket connexion;
private int compteur = 1;
XYLayout xYLayout2 = new XYLayout();
public boutton() {
super("Serveur");
try {
jbInit();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
void jbInit() throws Exception {
Benvoie.setFont(new java.awt.Font("Dialog", 1, 30));
Benvoie.setHorizontalAlignment(SwingConstants.CENTER);
Benvoie.setHorizontalTextPosition(SwingConstants.CENTER);
Benvoie.setText("Envoyez");
Benvoie.addActionListener(new serveur_Benvoie_actionAdapter(this));
Benvoie.addActionListener(new serveur_Benvoie_actionAdapter(this));
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setLocale(java.util.Locale.getDefault());
this.setState(Frame.NORMAL);
this.getContentPane().setLayout(xYLayout2);
this.getContentPane().add(Benvoie, new XYConstraints(100, 82, -1, -1));
}
// Préparer et lancer le serveur
public void LancerServeur() {
// Préparer le serveur à recevoir une connexion;
// traiter ces connexion
try {
// Etape 1 : créer un ServerSocket
server = new ServerSocket(2000, 100);
while (true) {
// Etape 2 : attendre un connexion
attendreUneConnexion();
// Etape 3 : obtenir les flux d'entree et sortie
obtenirLesFlux();
// Etape 4 : traiter la conexion
traiterConnexion();
// Etape 5 : Fermer la connexion
fermerConnexion();
++compteur;
}
}
// Traiter l'EOFException quand le client clôt la connexion
catch (EOFException eofException) {
System.out.println("Le client a interrompu la connexion");
}
// Traiter les éventuels problèmes d'E/S
catch (IOException ioException) {
ioException.printStackTrace();
}
}
//attendre l'arrivee d une connexion, puis en afficher les infos
private void attendreUneConnexion() throws IOException {
System.out.println("En attente de connexion.\n");
// Faire en sorte que le serveur accepte une connexion
connexion = server.accept();
System.out.println("Connexion" + compteur + "reçu de :" +
connexion.getInetAddress().getHostName());
}
// Obtenir les flux d'envoi et de reception de donnees
private void obtenirLesFlux() throws IOException {
// mettre en plce le flux de sortie pour les objets
sortie = new ObjectOutputStream(connexion.getOutputStream());
// vidanger le tampon de sortie pour envoyer les information d'en-tête
sortie.flush();
// mettre en place le flux d'entrée pour les objets
entree = new ObjectInputStream(connexion.getInputStream());
System.out.println("\n J'ai reçu les flux d'E/S\n");
}
// Traiter la connexion avec le client
private void traiterConnexion() throws IOException {
// Envoyer le message de succès de connexion client
String message = " SERVEUR>>> Connexion réussie";
System.out.println(message);
sortie.flush();
}
// Clore les flux et le socket
private void fermerConnexion() throws IOException {
System.out.println("\nL'utilisateur a fermer la connexion");
sortie.close();
entree.close();
connexion.close();
}
void Benvoie_actionPerformed(ActionEvent e) {
envoyerDonnees(e.getActionCommand());
}
// envoyer message au client
private void envoyerDonnees(String message){
// Envoyer un objet au client
try{
System.out.println("SERVEUR>>>"+message);
sortie.flush();
System.out.println("\nSERVEUR>>>"+message);
}
// Traiter le problème à l'envois des objets
catch (IOException ioException){
System.out.println("\nErreur à l'écriture d'un objet");
}
}
}
class serveur_Benvoie_actionAdapter implements java.awt.event.ActionListener {
boutton adaptee;
serveur_Benvoie_actionAdapter(boutton adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.Benvoie_actionPerformed(e);
}
}
Bon ben pour le serveur, tu crées un serversocket, tu le mets en attente avec accept();
Cette méthode accept() va bloquer l'exécution jusqu a la connexion du client....
Alors que faire coté client?
Et bien ouvrir un Socket avec l'IP du serveur, en faisant gaffe que les firewalls et ca emmerdent pas, une fois ce Socket construit, récupérer ses InputStream et OutputStream, sur lesquels on peut récupérer des BufferedReader / printStream (les noms m'échappent là, désolé).
Et utiliser la méthode println() pour écrire des données dans le flux de sortie.
De l'autre coté, le serveur va recevoir la connexion, et le Socket retourné par accept() permet de lire et envoyer des données.
JE m'excuse je dois faire court, j ai rendez vous là...
voila ja i déja un bout de code qui permet la connexion avec le serveur bien sur il y a des fautes et il me mnaque un truc a réaliser que j arrive pas du tout au lieu de donée pas séquence mes méthode ( connexion serveur, obtenirLesFlux,...) et bien je doit l implémenter dans un boulce qui fait que le client regarde tjrs si il recoit qqch donc dans un boucle avec la methode (getReceivedBytes). Et c'est la que je suis complètement perdu aider moi merci!
package boutton;
/**
* <p>Title: </p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author not attributable
* @version 1.0
*/
/**
* <p>Title: Client - Serveur</p>
*
* <p>Description: Mettre en place un serveur qui attend la connextion
* d'un client, lui envoie une chaîne de caractère et ferme la connextion </p>
*
* <p>Copyright: Copyright (c) 2004</p>
*
* <p>Company: EISI</p>
*
* @author Hennin Julie
* @version 1.0
*/
import javax.events.*;
import java.util.*;
import sc12.hw.*;
import sc12.comm.*;
import sc12.net.*;
import java.io.*;
class boutton{
// variables :
String serveur = "157.26.96.177";
short port = 2000;
private FileOutputStream sortie;
private FileInputStream entree;
private Socket client;
private String input;
private String output;
private String application;
private int compteur = 1;
// Exécuter l'application
public static void main (String Args[]){
// Se connecter au serveur, obtenir les flux et traiter la connexion.
while (true) {
// Etape 1 : créer un Socket pour établir la connexion
seConnecterAuServeur();
// Etape 2 : obtenir les flux d'entrée et de sortie
obtenirLesFlux();
// Etape 3 : traiter la connexion
traiterConnexion();
// Etape 4 : fermer la connexion
fermerConnexion();
compteur++;
}
}
// Se connecter au serveur
private void seConnecterAuServeur() throws IOException{
Console.println("Essai de connexion...\n");
//Créer le socket pour mettre en place la connexion au seveur.
UDPSocket socket = new UDPSocket(serveur,port);
}
// Obtenir les flux pour envoyer et recevoir les donneés.
private void obtenirLesFlux() throws IOException{
// Mettre en place le flux de sortie des objects.
sortie = new FileOutputStream(output);
// Vidanger tampon de sortie pour envoyer information d'en-tête.
sortie.flush();
// Mettre en place le flux d'entrée pour les objets.
entree = new FileInputStream(input);
Console.println("\nJ'ai reçu les flux d'E/S\n");
}
// Gérer la connexion au serveur
private void traiterConnexion() throws IOException{
// Traiter les message envoyés par le serveur
//do{
// try{
// message = (String)entree.readObject();
// zoneAffichage.append("\n"+message);
//zoneAffichage.setCaretPosition(zoneAffichage.getText().length());
//}
//Capturer les problèmes de lecture à partir du serveur
// catch (ClassNotFoundException classNotFoundException){
// zoneAffichage.append("\nObjet reçu de type inconnu");
// }
//}while (!message.equals("SERVEUR>>> TERMINER"));
} // Fin de la methode traiterConnexion
// Clore les flux et le socket
private void fermerConnexion() throws IOException{
Console.println("\n Clôture de la connexion.");
sortie.close();
entree.close();
client.close();
}
}