Architecture des ordinateurs
Framework Spring/Les beans
Un bean en Java est une convention d'interfaçage entre objets pour accéder à leur propriétés.
Cette convention est utilisée dans les bibliothèques d'interfaces graphiques de Java (AWT, Swing, JavaFX), les outils de création d'interface et les frameworks Java.
Pour une propriété simple nommée "exemple" de type "type", la classe doit posséder certaines méthodes :
Pour une propriété de composition (liste de valeurs) :
Afin de pouvoir sérialiser les objets, la classe doit également posséder un constructeur par défaut (sans arguments) public et implémenter l'interface codice_6.
= Interaction entre deux beans =
Les beans sont les enveloppes des classes configurées par Spring et permettent ainsi une interaction entre eux.
Dans l'exemple Hello world! on avait un seul bean :
 <bean class = "mainPackage.MessageDisplayer">
 <property name = "message" value = "Hello world!"/>
 </bean>
Pour interagir avec le classe MessageDisplayer on crée la classe MessageDisplayerInserter :
 package mainPackage;
 public class MessageDisplayerInserter 
 private int i;
Pour l'instant on met un simple entier sans accesseurs. Dans le fichier bean.xml on ajoute un nouveau bean pour configurer la classe MessageDisplayerInserter :
 <bean class = "mainPackage.MessageDisplayerInserter">
 <property name = "i" value = "42"/>
 </bean> 
En faisant cela on a le message d'erreur : " - No setter found for property 'i' in class 'mainPackage.MessageDisplayerInserter'". Cela provient du fait que Spring a besoin d'accesseurs pour les variables qui doivent être initialisées, même en les mettant en public. On obtient alors la classe suivante :
 package mainPackage;
 public class MessageDisplayerInserter {
 public int i;
 public int getI()
 return i;
 public void setI(int i) 
 this.i = i;
Pour faire l'insertion d'un bean dans l'autre on modifie le fichier Beans.xml :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean class = "mainPackage.MessageDisplayer">
 <property name = "message" value = "Hello world!"/>
 <property name = "messageDisplayerInserter" ref = "mainPackage.MessageDisplayerInserter"/>
 </bean>
 <bean class = "mainPackage.MessageDisplayerInserter">
 <property name = "i" value = "42"/>
 </bean> 
</beans>
Ici on met la valeur 42 pour i dans MessageDisplayerInserter et on insère cette classe dans la classe MessageDisplayer. On se sert du mot clé ref ici avec l'identifiant par défaut qui est le nom du package suivi du nom de la classe.
Ensuite il faut que la classe MessageDisplayer puisse implémenter MessageDisplayerInserter. On ajoute donc une variable de ce type avec le getter et setter pour que Spring puisse y accéder.
package mainPackage;
public class MessageDisplayer 
 private String message;
 private MessageDisplayerInserter messageDisplayerInserter;
 public void setMessage(String message)
 this.message = message;
 public void displayMessage()
 System.out.println("message : " + message+" messageDisplayerInserter.getI() : "+messageDisplayerInserter.getI());
 public MessageDisplayerInserter getMessageDisplayerInserter()
 return messageDisplayerInserter;
 public void setMessageDisplayerInserter(MessageDisplayerInserter messageDisplayerInserter) 
 this.messageDisplayerInserter = messageDisplayerInserter;
En résultat on obtient cet affichage :
On a bien le résultat 42 affiché depuis la classe MessageDisplayer alors qu'il a été initialisé dans MessageDisplayerInserter.
= Identification d'un bean =
Un bean peut être identifié avec l'attribut name et/ou l'attribut id. La différence est que name peut servir d'alias, on peut mettre plusieurs alias dans name alors que l'id doit être unique. Dans ce cas on peut modifier bean.xml de la manière suivante :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean class = "mainPackage.MessageDisplayer">
 <property name = "message" value = "Hello world!"/>
 <property name = "messageDisplayerInserter" ref = "MessageDisplayerInserter"/>
 </bean>
 <bean id="MessageDisplayerInserter" name="alias1,alias2" class = "mainPackage.MessageDisplayerInserter">
 <property name = "i" value = "42"/>
 </bean> 
</beans>
Le bean pour la classe MessageDisplayerInserter est maintenant identifié par son nom de classe sans avoir besoin d'ajouter le package. On peut aussi s'y référer via alias1 ou alias2.
= Paramétrage via constructeur =
Dans le paramétrage des beans, au lieu d'insérer dans un attribut de la classe on peut faire appel au constructeur. On a alors le main de la forme suivante :
 package mainPackage;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 public class MainClass 
 public static void main(String[] args) 
 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Beans.xml");
 MessageDisplayer messageDisplayer = (MessageDisplayer) classPathXmlApplicationContext.getBean("mainPackage.MessageDisplayer");
 messageDisplayer.displayMessage();
 classPathXmlApplicationContext.close();
Le fichier Bean.xml a la forme suivante :
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean class = "mainPackage.MessageDisplayer"> 
 <constructor-arg value="42"/> 
 </bean> 
 </beans>
Les paramètres vont être lus dans l'ordre qui sont indiqués dans le bean. Si besoin est, on peut indiquer index dans le bean.

Débutez avec le Zynq-7000 et ZYBO
Ce livre est un wiki !
Ce livre est un wiki, et peut donc être amélioré par tous. Il est distribué sous licence "Attribution-ShareAlike 3.0 Unported" (CC-BY-SA 3.0) : vous êtes libres de le copier, le redistribuer, l'adapter, à condition de le repartager sous une licence identique ou compatible et d'indiquer son auteur ainsi que sa provenance.
__NOEDITSECTION__

Débutez avec le Zynq-7000 et ZYBO/Premiers pas

Après avoir installé la suite logicielle, cet exemple introductif vise à démontrer le confort que représente l'utilisation d'une architecture "Zynq", au travers de l'emploi de blocs IP et de la séparation PL/PS.
"Hello World!".
Dans le cadre de ce premier exemple, nous allons utiliser le programme "Hello World!" fourni par Xilinx, en nous contentant d'abord de le faire fonctionner sur la carte "ZYBO". Pour cela, nous allons d'abord configurer l'interface PL du matériel avec "Vivado", puis nous utiliserons le SDK pour exécuter un programme sur la "ZYBO".
Configuration du PL avec "Vivado".
Avant d'aller plus loin, nous allons créer un répertoire unique dans lequel nous stockerons tous nos projets. Nous vous proposons de le nommer "Projets_Zynq" et de le positionner :
Gestion des GPIO.
Nous allons utiliser la PL comme un gestionnaire de "General Purpose Input/Output" (GPIO).
Le matériel est maintenant connecté au PS.
Génération du "bitstream" et export.
Cette dernière étape avec "Vivado" va nous conduire à la génération d'un fichier VHDL puis à la génération du "bitstream".

Débutez avec le Zynq-7000 et ZYBO/Sommaire

Débutez avec le Zynq-7000 et ZYBO/Gestion des interruptions