STIC:STIC III (2020)/Forces rouge, rose, vert, jaune ou bleu !

De EduTech Wiki
Aller à : navigation, rechercher
Projet réalisé par Djamileh & Simon

1 Introduction

Durant la dernière année, le passage forcé à la téléformation, soit la formation synchrone à distance, a eu comme effet positif de pousser certains spécialistes de l’éducation à revisiter leurs scénarios pédagogiques pour revenir aux fondamentaux : comment aider les élèves à apprendre ce qu’ils sont sensés apprendre et comment les accompagner au mieux dans leur apprentissage ? Souvent, les difficultés relevées lors des bilans des derniers mois de distantiel ont fait émerger des problèmes qui existaient déjà en présence, mais qui restaient latents ou ignorés.

En ce sens, l’apprentissage est fortement influencé par les émotions par lesquelles passent les élèves au cours de la formation, et en particulier pendant les moments synchrones. Pourtant, il est très complexe de détecter, mesurer, ou même faire exprimer les étudiant-es sur leur ressenti.

En donnant leurs cours en visioconférence, nombreux formateurs et formatrices ont exprimé leur frustration de ne pas réussir à évaluer l’état émotionnel et autres indices non verbaux de leurs participant.e.s, retours essentiels pour adapter une explication ou ajuster le rythme. Et cet effet est loin d’être limité à la distance : il est également bien présent dans une salle de classe où il reste complexe de capter en temps réel les émotions d’un étudiant, processus complexe et dynamique.

Notre projet prend sa racine dans ce constat. Deux questions ont alors émergé :

  • comment mesurer l'état émotionnel d'un-e apprenant-e,
  • et surtout, pour quel usage ?

Dans ce contexte, nous avons pensé un dispositif de partage des ressentis de la classe à destination de l'équipe enseignante, et une utilisation de cette donnée comme retour au groupe.

2 Problème

Le but de ce projet est de proposer une solution ludique à la constitution de groupes en classe, que cela soit en présence, à distance ou de manière comodale. En utilisant un Arduino Uno ou des CPX, la phase de constitution de groupes sera ainsi rapide, aléatoire et "fun" !

Le Problem Statement peut s’exprimer ainsi : « Comment peut-on aider les formateurs et formatrices à identifier rapidement les difficultés dans l’apprentissage et, le cas échéant, à réagir ? »

3 Cahier des charges

3.1 Contexte et public

Le public cible est composé de formateurs et formatrices d’adultes, en entreprise ou en institut. Il pourrait également être élargi aux enseignante.s du scolaire, mais la conscientisation et l’expression d’une émotion sont suffisamment complexes pour limiter notre premier dispositif à des adultes, disposant, à priori, d’une compréhension plus fine de leur état émotionnel. De plus, l’asymétrie dans la relation est supposée moins forte dans un groupe d’adultes en formation que dans une classe avec un enseignant et des enfants ou adolescents.

3.2 Objectifs

Le but du dispositif est de :

  • permettre la communication d'un niveau émotionnel perçu par l'étudiant.e à l'enseignant.e
  • faire émerger un état général de la classe et les différences dans l'acquisition du contenu
  • de manière plus pragmatique, de créer des groupes sur la base des éléments communiqués

3.3 Besoins et contraintes

L'idée du projet a beaucoup évolué entre la phase d'identification des besoins et les constatations sur les possibilités offertes par la technologie et l'expertise à disposition. Nous détaillons ci-dessous les besoins et contraintes qui nous ont menés à la solution présentée plus bas.

Partant au début d’une idée de jauge émotionnelle dynamique, donnant en tout temps l’état émotionnel d’un groupe de participants, nous avons rapidement détecté, en phase d'idéation avec plusieurs spécialistes en éducation, un aspect extrêmement anxiogène pour le formateur dont le groupe enverrait des signaux d’ennui ou de frustration, durant une explication.

Afin de juguler cet effet, tout en conservant la possibilité de communiquer un message sur l’état, nous avons adapté le dispositif pour permettre aux étudiants de transmettre leur état à des moments spécifiques de la formation, intégrés dans le scénario pédagogique. L'émotion étant un élément sensible à conscientiser, exprimer et partager au sein d'un groupe, nous avons estimé plus judicieux de faire exprimer son niveau d'aisance face à un contenu qui vient d'être transmis. Ainsi, un-e enseignant-e scénarisera des moments d'autodiagnostic des étudiant-es sur leur perception de compétence sur la thématique. Cette information peut être utilisée pour réaliser des groupes de travail : (1) les personnes qui ont compris peuvent être orientées sur un contenu plus avancé, en échange pendant que l'enseignant organiser une séance de question-réponse avec les personnes en difficulté ou (2) des groupes peuvent être créés pour intégrer des étudiant-es qui ont compris avec des étudiant-es qui ont besoin d'aide.

Le dispositif est donc pensé comme un outil de sondage à certains moments du cours, pour évaluer les besoins du groupe, dans son ensemble. Il est souvent difficile de récolter des informations sincères lors d’évaluations à chaud, les étudiants réticents à communiquer publiquement leurs difficultés ou désintérêts pour le contenu. Par la technique de transmission, les étudiants pourraient communiquer leur émotion de manière anonyme, favorisant l'authenticité.

De manière intéressante au fur et à mesure de l'avance du projet, il est ressorti des discussions avec un échantillon du public cible que l'aspect de notre projet qui les intéressait était moins la communication des émotions, mais la création facilitée des groupes. En effet, les formateurs et formatrices ayant travaillé à distance durant la dernière année se sont habitués à disposer d'une fonction de création de groupe aléatoire, selon un nombre total de participants et un nombre de groupe visé. Cette fonction serait très utile également en présence, en utilisant une carte Arduino ou un CPX pour calculer une répartition des élèves par groupe, avec en entrée le nombre d'élèves et les sous-groupes. Une fois les groupes constitués, l'étape suivante est de communiquer ces groupes à l'ensemble de la classe au travers de Lilypad ou autres technologies portables qui s'allument selon la couleur de leur groupe.

3.4 Apports

  • Cohésion et sentiment d'appartenance au groupe comme soutien à l'apprentissage
  • Expression d'un état émotionnel épistémique comme bénéfique à l'apprentissage

3.5 Présentation du projet

Suite aux premières itérations dans l'empathie et la définition du projet, nous avons identifié plusieurs points clés qui ont réorienté notre projet :

  • la création d'un réseau de cartes Bluetooth contrôlées par Arduino s'est révélée trop ambitieuse, suite au manque de projets existants ou d'expertise sur lesquels s'appuyer,
  • l'envie marquée de notre échantillon cible qui s'est dirigée sur l'aspect création de groupe plus que sur la connaissance des états affectifs.

Nous avons donc revu le projet en le divisant en 3 niveaux de difficulté, afin de réaliser un prototype utilisable, puis de l'améliorer en fonction des retours et du temps à disposition.

  • Niveau 1 : Création de groupe aléatoire : intérêts : facilitation de la création des groupes (demande reçue d'un formateur : "parce que Zoom nous a bien aidé pour cela à distance, je veux la même chose en présence!")
  • Niveau 2 : Communication du groupe à l’apprenant : intérêts : gamification, sentiment d’appartenance, coopération, cohésion
  • Niveau 3 : Communication de son sentiment de compétence  : intérêts : plus facile que d'exprimer ses émotions, et plus facile à gérer par l'enseignant.e, par exemple les gens qui ont compris avec celles-ceux qui n'ont pas compris

Nous avons réalisé complètement le niveau 1, ainsi que prototypé et testé le niveau 2 avec des câbles avant de pouvoir gérer par Bluetooth un Bluefruit spécifique dans un réseau comprenant plusieurs Bluefruits. Les solutions avec code et prototypes sont décrites dans la section suivante.

4 Solutions explorées

4.1 1er prototype

La première solution envisagée comporte deux objets :

  • Un émetteur : facile d’utilisation et agréable à porter, nous penchons pour la solution d’un bracelet contenant un micro circuit type Lilypad, Arduino Gemma ou Tinyduino. L’apprenant disposerait de 4 boutons-pressoirs pour 4 émotions majeures à transmettre (intérêt, confusion, frustration, incompréhension), symbolisés par des logos ou émoticônes. Les messages sont transmis par Bluetooth.
  • Un récepteur : Une jauge, comprenant une bande Neopixels, connectée à un Arduino Uno. Les LED symboliseraient deux dimensions fournies : la couleur pour le type d'émotion et le nombre pour la quantité d'étudiant.e.s ayant transmis l'information. L'Arduino pourrait gérer l'information, en émettant un son lors du dépassement d'un seuil prédéfini sur une émotion par exemple.

4.1.1 Maquettes

1ère itération

Maquette n°1 du projet

2e itération

L'Arduino Uno lance une séquence de randomisation de couleur, en affiche une, puis les participant.e.s font de même sur leur CPX. Si les couleurs affichées "matchent", le groupe est constitué et on peut ainsi passer à la constitution aléatoire du groupe suivant.

Maquette n°2 du projet

4.1.2 Code

Version 1.0 du code CPX :

input.buttonA.onEvent(ButtonEvent.Click, function () {
    light.setPhotonPenHue(color2)
    durée = 30
    tonalité = 200
    for (let i = 0; i < Math.randomRange(20, 100); i++) {
        light.photonForward(1)
        music.playTone(tonalité, durée)
        pause(40)
        color2 += Math.randomRange(1, 3)
        light.setPhotonPenHue(color2)
    }
    light.photonFlip()
})
input.buttonsAB.onEvent(ButtonEvent.Click, function () {
    control.reset()
})
input.buttonB.onEvent(ButtonEvent.Click, function () {
    light.setPhotonPenHue(color2)
    durée = 30
    tonalité = 300
    for (let i = 0; i < Math.randomRange(20, 100); i++) {
        color2 += 3
        light.photonForward(1)
        music.playTone(tonalité, durée)
        pause(50)
    }
})
let tonalité = 0
let durée = 0
let color2 = 0
light.setBrightness(158)
music.setVolume(167)
forever(function () {
	
})

4.2 2e prototype

4.2.1 Maquette

Boîte émettrice

Plan découpe boîte émettrice CPX
Etiquettes boîte CPX
Rendu de la boîte
Dispositif "Master" d'envoi
Boîte finale

Cadrans récepteurs

Cadrans récepteurs
Dispositif d'envoi et montre récéptrice

4.2.2 Code

Une étape dans le test du code - 5 binomes de noël!

La solution présentée ici s'occupe du niveau 1, soit la création de groupe aléatoire à l'aide d'un CPX Bluefruit. Elle a été codée en CircuitPython. Nous avons rédigé le code nous-mêmes, avec deux supports : la création du dictionnaire pour la randomisation été possible grâce à l'aimable contribution de notre collègue Jérôme. Concernant l'envoi et la réception de données par Bluetooth, nous nous sommes basés sur les tutoriels Adafruit, ainsi que deux projets utilisant des fonctionnalités se rapprochant de notre projet :

Code pour le CPB Emetteur

# Groupify !
# Un projet de S!m & Dja
# Code CircuitPython pour la répartition dans les groupes (MASTER)

"""
SETUP GENERAL
"""

# LIBRAIRIES
import random
import time

# Librairie pour gérer la bande neopixel du bluefruit
from adafruit_circuitplayground.bluefruit import cpb

# Librairies pour gérer la transmission bluetooth
from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.nordic import UARTService

# Librairie pour envoyer la couleur
from adafruit_bluefruit_connect.color_packet import ColorPacket

# Helper function pour gérer la connexion entre plusieurs Bluefruits
# reprise sur https://learn.adafruit.com/circuit-playground-bluefruit-neopixel-
# animation-and-color-remote-control/remote-control-code
def send_packet(uart_connection_name, packet):
    """Returns False if no longer connected."""
    try:
        uart_connection_name[UARTService].write(packet.to_bytes())
    except:  # pylint: disable=bare-except
        try:
            uart_connection_name.disconnect()
        except:  # pylint: disable=bare-except
            pass
        return False
    return True


# Input utilisateur
participants = int(input("Nombre de participants : "))
groupe = int(input("Nombre de groupes : "))

"""
CREATION DES GROUPES
"""

# création listes à long. variable (+ 1 pour compenser la numération depuis 0)
liste_part = list(range(1, participants + 1))  # print(liste_part)
nb_part = len(liste_part) + 1
liste_groupe = list(range(1, groupe + 1))  # print(liste_groupe)

# Déf. grille (dict. de listes) combinations possibles
clé_tableau = str(participants) + "_" + str(groupe)
# !!! ajouter combinaisons pas possible : eg. tour de roue lumineuse/son pourri !!!
grille_repartition = {
    "10_5": [2, 2, 2, 2, 2],
    "10_4": [2, 2, 3, 3],
    "10_3": [3, 3, 4],
    "10_2": [5, 5],
    "9_4": [2, 2, 2, 3],
    "9_3": [3, 3, 3],
    "9_2": [4, 5],
    "8_4": [2, 2, 2, 2],
    "8_3": [2, 3, 3],
    "8_2": [4, 4],
    "7_3": [2, 2, 3],
    "7_2": [4, 3],
    "6_3": [2, 2, 2],
    "6_2": [3, 3],
    "5_2": [2, 3],
    "4_2": [2, 2],
}
# détermination du nb et taille des groupes à créer
taille_groupe = grille_repartition[clé_tableau]
print(taille_groupe)

# création (dict) répartition aléatoire
dict_repartition = {}  # initialisation
for i in range(0, len(taille_groupe)):
    dict_repartition[liste_groupe[i]] = []  # création des items du dictionnaire
    for j in range(0, taille_groupe[i]):
        etu = liste_part[random.randint(0, len(liste_part) - 1)]
        dict_repartition[liste_groupe[i]].append(etu)
        liste_part.remove(etu)
        # print (liste_part)
        # print (dict_repartition)
print(dict_repartition)

# Définition des groupes avec couleurs
groupeList = list(dict_repartition.values())
print(groupeList)

# GESTION NEOPIXEL
cpb.pixels.brightness = 0.05

# Grille de définition des couleurs de groupe
dict_couleur = {
    "gr1": (0, 255, 0),
    "gr2": (255, 0, 255),
    "gr3": (255, 255, 0),
    "gr4": (0, 255, 255),
    "gr5": (255, 0, 0),
}
#  print(dict_couleur)

# transf. dict -> list
liste_couleur = list(dict_couleur.values())
print("liste de couleur totale: ", liste_couleur)

# définition des couleurs selon nb de groupe
dict_neopix = {}
for i in range(0, len(taille_groupe)):
    codecouleur = liste_couleur[i]
    dict_neopix[i] = codecouleur
# print(dict_neopix)

# transf. dict -> list
liste_neopix = list(dict_neopix.values())
print("liste de couleur spécifique: ", liste_neopix)

# Attribution des couleurs par pixel
liste_pixels = []
for i in range(0, nb_part):
    for j in range(0, len(taille_groupe)):
        if i in groupeList[j]:
            pix = liste_neopix[j]
            liste_pixels.append(pix)
print("couleurs des pixels : ", liste_pixels)

"""
TRANSMISSION AUX BLUEFRUITS PARTICIPANTS (SLAVES)
"""
# Setup de la transmission
ble = BLERadio()
uart_service = UARTService()
advertisement = ProvideServicesAdvertisement(uart_service)

uart_connection = None
# Controle sur des connexions disponibles
if ble.connected:
    for connection in ble.connections:
        if UARTService in connection:
            uart_connection = connection
        break

while True:
    # Allumage de la bnde neopixel / visualisation des groupes formés
    for i in range(0, nb_part - 1):
        cpb.pixels[i] = liste_pixels[i]

    # Gestion de la transmission
    if not uart_connection or not uart_connection.connected:
        # Condition : pas de connexion > scan
        print("Scanning...")
        for adv in ble.start_scan(ProvideServicesAdvertisement, timeout=5):  # Scan...
            if UARTService in adv.services:  # si periphérique existe
                print("Found a UARTService advertisement.")
                uart_connection = ble.connect(adv)  # crée une connexion
                break
        # Arrêt du scannage de l'environnement
        ble.stop_scan()

    # si connexion existante :
    while uart_connection and uart_connection.connected:
        if cpb.button_a:  # Transmission des données neopixels avec A
            print("Bouton A - envoi données")
            color = cpb.pixels[0]
            if not send_packet(uart_connection, ColorPacket(color)):
                uart_connection = None
                continue
        time.sleep(0.1)  # Delay to prevent sending packets too quickly.

Code pour le CPB Récepteur (participants)

"""
Code pour les bluefruits participants
"""
import time

from adafruit_circuitplayground.bluefruit import cpb

from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.nordic import UARTService

from adafruit_bluefruit_connect.packet import Packet
from adafruit_bluefruit_connect.color_packet import ColorPacket

num_pixels = 10

# animation initiale - "chase" est une animation de base dans les librairies
# d'animation pour neopixel (cf neopixel überguide)
def color_chase(color, wait):
    for i in range(num_pixels):
        cpb.pixels[i] = color
        time.sleep(wait)
        cpb.pixels.show()
    time.sleep(0.5)


# Grille des couleurs de groupe pour animation
dict_couleur = {
    "gr1": (0, 255, 0),
    "gr2": (255, 0, 255),
    "gr3": (255, 255, 0),
    "gr4": (0, 255, 255),
    "gr5": (255, 0, 0),
}

liste_couleur = list(dict_couleur.values())
print(liste_couleur)

# Setup standard pour la réception
ble = BLERadio()
uart = UARTService()
advertisement = ProvideServicesAdvertisement(uart)

cpb.pixels.brightness = 0.05
receptionGroupe = False

while True:
    ble.start_advertising(advertisement)

    while not cpb.switch:
        for i in range(0, len(liste_couleur)):
            couleurCode = liste_couleur[i]
            color_chase(couleurCode, 0.05)

    if cpb.switch:
        while not ble.connected:
            pass
        ble.stop_advertising()

        while ble.connected:
            if uart.in_waiting:
                packet = Packet.from_stream(uart)
                if isinstance(packet, ColorPacket):
                    cpb.pixels.fill(packet.color)

5 Test(s) de la solution

5.1 Cognitive walkthrough

Pour produire ce cognitive walkthrough, nous nous sommes basés sur les principes du Fluid Project.

5.1.1 Persona

PERSONA INGO NITO.jpg

5.1.2 Objectifs

  • Créer des groupes grâce au dispositif émetteur
  • Communiquer ces groupes aux dispositifs récepteurs
  • Renforcer l'engagement grâce à un dispositif ludique et actif

5.1.3 Scénario d'utilisation

  1. (en amont) Réfléchir à un combien de groupes seront créés en fonction du nombre de participant.e.s disponible.s
  2. Allumage du dispositif
  3. Lancement du dispositif
  4. Réalisation d'une séquence de composition de groupe
  5. Lancement et réalisation de la séquence suivante de communication avec envoi des groupes constitués aux dispositifs distants
  6. Mise hors tension du dispositif

5.2 Tests utilisateur·trice·s

5.2.1 Scénario final

Le test utilisateur est une méthode utilisée pour évaluer l’expérience utilisateur d’un système, mais également les forces et les faiblesses de celui-ci. Cette méthode, consiste à mettre l’utilisateur·trice en situation « réelle » afin d’observer ses comportements et ses actions lorsqu’il exécute des tâches prédéfinies qui lui sont administrées sous la forme d’un scénario. Il leur est alors demandé de nous renseigner sur leurs expériences.

Lors de cette phase, un prototype du projet est présenté à des utilisateur·trices recrutés au sein du public cible. A ce stade, le prototype devrait être suffisamment abouti pour offrir les principales fonctionnalités constitutives de la version finale. Néanmoins, il diffère de celle-ci puisque certaines fonctionnalités accessoires ne pourraient ne pas être encore implémentées. En présentant assez tôt un produit relativement proche de la version finale, nous entendons nous assurer que les directions prises dans les précédentes phases de conception soient les plus à même de répondre aux besoins des utilisateur·trice·s. Le prototype sera modifié en fonction des retours formulés par les observations réalisées ainsi que par les analyses des résultats des tests.

Le test utilisateur se déroulera en 3 étapes :

  1. Accueil des participants
  2. Réalisation des tâches
  3. Entretien succinct

Dans la première étape, le participant sera accueilli, le contexte et le test utilisateur lui seront alors présentés de manière générale. Lors du test, l’utilisateur·trice « découvrira » le dispositif en réalisant des tâches préparées au préalable (scénario des tâches). Ici, nous éprouverons l’expérience de l’utilisateur·trice.

Après avoir exposé le contexte dans lequel le scénario prend place, nous demanderons à la personne d’accomplir les tâches décrites dans le tableau "scénario des tâches". De plus, nous encouragerons le/la participant·e à formuler à voix haute ses pensées et ressentis lors de l’utilisation de l’outil.

Les participant·e·s seront accueillis avec la consigne suivante :

Merci d’avoir accepté de faire ce test avec moi aujourd'hui. Je travaille sur le développement d’un outil pour la constitution aléatoire de groupes de travail dans une classe. Cette technique permet de constituer des groupes rapidement et de communiquer ceux-ci aux participant.e.s quasi instantanément.

Le scénario des tâches se composera de deux éléments : le contexte et les tâches à effectuer par le/la participant.e. Le contexte aura pour but de mettre l’utilisateur·trice dans une situation réaliste qui se rapprochera de son quotidien et/ou du contexte pendant lequel il pourrait être mené à utiliser le dispositif. Le contexte sera formulé de la manière suivante :

Vous êtes au début d’une activité de débat, dans votre classe, avec vos étudiant.e.s. Pour réaliser cette activité, vous devez d’abord constituer des groupes de manière aléatoire, avec les étudiant.e.s qui composent votre cours. Pour se faire, vous allez donc devoir utiliser le dispositif-prototype en annexe.

Le dispositif à tester se compose de plusieurs éléments. Le premier élément est le dispositif émetteur. Il va être utilisé pour composer les groupes d’étudiant.e.s de manière aléatoire et par couleur. Ensuite, avec les boutons présents sur celui-ci, il sera capable de transmettre les données choisies aux dispositifs récepteurs annexes.

Durant le test, vous allez être amené.e à utiliser les différents dispositifs cités afin de réaliser plusieurs tâches. Celles-ci ne devraient pas être trop compliquées et ne nécessiteront, non plus , pas trop de temps de réalisation.

Après avoir exposé le contexte dans lequel le scénario prend place, nous demanderons au participant d’accomplir les tâches décrites dans le tableau "scénario des tâches".

Pour l’étape des tâches, nous donnerons les consignes suivantes :

Avant de commencer le test et les tâches, n’hésitez pas à poser des questions si un/des élément(s) ne vous paraissent pas clair(s). Nous restons bien entendu à disposition, si besoin , durant la réalisation des tâches.

Chaque tâche sera expliquée au fur et à mesure au participant.

Scénario des tâches
Tâche 1 Pour commencer, veuillez trouver comment allumer le dispositif. Une fois que c’est fait, vous pouvez passer à la tâche suivante.
Tâche 2 Comme seconde tâche, veuillez décider de combien de groupes vous aurez besoin selon le nombre d’élèves à votre disposition.
Tâche 3 Comme tâche suivante, renseignez les informations souhaitées sur le dispositif émetteur (nombre de groupes et nombre d’élèves).
Tâche 4 Comme dernière tâche, envoyez les données depuis le dispositif émetteur aux dispositifs récepteurs.

5.2.2 Vidéo du test utilisateur.trice.s

5.2.3 Retours des tests

Nos trois testeurs ont testé autant le côté participant que formateur.

Deux sont des formateurs.trices d'adulte qui animent des groupes de 1 à 25 personnes, en présence, en créant régulièrement des activités de sous-groupes. Ils ont exprimé un réel intérêt à posséder un outil leur permettant de varier la façon de créer des groupes et surtout de ne pas avoir à choisir eux-mêmes, bénéficiant de l'aléatoire comme expérimenté à distance avec des outils de visioconférence.

Le dernier testeur est facilitateur dans des workshops de co-création et Design Thinking. Il est donc régulièrement amené à créer des sous-groupes, pour des groupes de tailles pouvant aller jusqu'à 50 personnes. Pour lui aussi, l'outil présente une plue-value, si son design pouvait être adapté à des groupes plus grands.

Les retours sont classés par rôle (formateur/participant). Comme la plupart des retours ont été très similaires, nous les avons regroupé en spécifiant s'il s'agissait d'une ou plusieurs personnes.

Côté formateur.trice (CPB émetteur)

  • Le son n’est pas indispensable selon le formateur. Mais, une étape de validation ou un autre retour serait à envisager.
  • Pas de manque particulier. Cependant, il faudrait poser des conditions automatiques ou en tout cas que les processus soient automatiques sans une maîtrise de la part du formateur. En gros, n’importe qui de la classe pourrait le faire. Une solution serait de demander à quelqu’un.e dans la classe s’il/elle veut procéder au lancement du processus des groupes.
  • Concernant les couleurs, comme elles ne sont pas arrangées dans un ordre précis et que les positions des LED sont décalées, cela perturbe un petit peu. Mais, on comprend que c’est une logique de programmation. Cela serait simplement plus agréable visuellement pour un utilisateur sur 3.
  • Une remarque a été produite concernant la possibilité de garder en main les objets plutôt que de les avoir comme montre au poignet (participant) ou dans une boîte (formateur). En rendant disponible le dispositif à la main directement cela peut démontrer que tout le monde est logé à la même enseigne et qu’il n’y a pas de différences entre l’enseignant et les élèves. Tout le monde a le même objet.
  • Il serait amusant d’ajouter une compétition afin de déterminer si un.e élève choisit et effectue la composition des groupes plutôt que le formateur. Celui qui a la montre qui s’allume par exemple dans la classe en premier pourra alors lancer la séquence de randomisation au lieu du prof. Cela donnerait un côté ludique et encore plus engageant, voire plus hasardeux et permettrait d’aller plus loin que le seul processus de composition aléatoire des groupes par couleurs.
  • Le retour (ou annulation de fonction) n’est pas possible. Cela n’est pas contraignant en soi mais un peu dérangeant selon le testeur-formateur.
  • Le premier testeur a eu envie de secouer le CPB au moment de créer les groupes. Il aurait aimé ne pas avoir à appuyer sur des boutons, mais d’utiliser l’aspect aléatoire de secouer l’objet, comme une boule 8 magique. Cela lui donnerait une meilleure impression que cela est réellement une génération aléatoire de groupes.
  • Il y a globalement eu un besoin de mieux valider les différentes étapes chez les 3 testeurs. Le premier aurait apprécié intégrer les données avec les boutons A et B, valider avec la slider et avoir un retour visuel (changement de couleur des LED) pour valider l’action. Contrairement aux deux autres testeurs, il a aimé devoir appuyer sur un bouton pour envoyer les données aux récepteurs participants. Cela démontre des différences dans les envies et besoins de contrôle des utilisateurs.


Côté participant.e (CPB récepteur)

  • Le “slider” ne devrait pas être obligatoire à utiliser car il devrait y avoir une étape automatique et directe de réception de la couleur de groupe. Remarque identique pour la seconde participante.
  • La découverte du dispositif est agréable, “cool”. On a envie de savoir comment cela fonctionne. Le rendu et la structure, cela rend bien. La rotation des couleurs du dispositif de réception fait penser à un casino ; l’attente devient cool et excitante : la participante était impatiente de connaître son groupe.
  • Il devrait y avoir du son ou une vibration pour valider les étapes ou en tout cas un retour visuel qui viendrait sanctionner les manipulations sur le dispositif. Cela pourrait être une petite musique qui annonce le groupe attribué. La 2e testeuse rapporte que cela donne le sentiment “d’avoir gagné”.
  • Une remarque a été formulée concernant l’utilisation de ce type de dispositif sur toute une journée de cours. En effet, cela peut être répétitif si à chaque fois que l’on doit former des groupes, les participant.e.s doivent utiliser le dispositif. Il devrait apporter une certaine plus-value selon un des testeurs. L’idée d’ajouter un écran au dispositif a été proposée, où des consignes pourraient s’afficher ; cela donnerait un aspect utile en plus. Le dispositif pourrait ainsi faciliter les activités de groupes en plusieurs phases : les participants se regroupent selon la couleur reçue et ils reçoivent une première consigne. Puis le formateur envoie le temps restant et la suite des activités, jusqu’au retour en plénière.
  • Concernant le dispositif de réception, la “montre”, son utilité et son design ont été remis en question. Il pourrait être sous forme de patch ou pin’s plutôt qu’un objet au poignet selon les utilisateur.trice.s. En effet, des participant.e.s ont peut-être déjà des montres ou des bracelets au poignet ce qui pourrait être contraignant. De plus, à cette phase du prototypage, comme il ne s’agit que d’allumer une LED, il serait envisageable d’utiliser de la broderie numérique et d’y intégrer une micro-circuit avec une LED (i.e. Gemma, Flora)

6 Discussion

6.1 Design

Le design actuel est parti d'une idée d'utiliser la découpe laser pour la boîte émettrice et une forme de montre pour les récepteurs participants, avec un côté vintage et nostalgique des séries des années 80. Cela dit, nous avions tout de même recherché des produits plus petits et plus discrets, faciles à transporter et à manipuler. Cela s'est confirmé lors des tests, où en fin de compte, les participants ont apprécié avoir des objets légers et faciles à manipuler en main. Pour un prochain prototype, nous nous orienterions vers un Gemma ou Flora, sur un patch en broderie numérique pour les récepteurs participants.

Du côté émetteur, sont restés jusqu'à la fin, la difficulté de l'input du nombre de participants et du nombre de groupes attendus. Les potentiomètres se sont avérés trop complexes, autant pour comprendre ce qu'il fallait commander que pour programmer des niveaux de voltage correspondant à des seuils de chiffre. Pour pallier cette difficulté, nous avons tenté d'utiliser les éléments du CPB, soit les boutons et la slider. Cependant, cela nécessite des manipulations longues (par exemple : bouton A pour ajouter un participant, bouton B pour en enlever, slider pour valider) et rend l'opération fastidieuse.

Enfin, l'utilisation de la bande neopixel du CPB limite le nombre total de participants à 10. Pour une prochaine itération, nous utiliserions une bande externe permettant la gestion de groupes plus larges.

6.2 Résultats des tests utilisateurs

Une partie des retours utilisateurs ont été intégrés dans la section Design, car ils faisaient écho à nos propres envies, qui n'avaient pas été réalisables techniquement. Nous retenons les points clés suivants pour les prochaines itérations du projet, en avantages et faiblesses :

Les avantages sont :

  • un aspect ludique qui rend excitant le moment de passage à l'activité de sous-groupe et qui renforce l'engagement
  • un effet d'appartenance et de cohésion
  • une dimension pédagogique de rééquilibrage des postures : la personne qui forme peut choisir de contrôler la création des groupes ou de la rendre démocratique par sa délégation à un membre de la classe. Cela permet de garder une réelle impression de hasard

Du côté des faiblesses à améliorer :

  • Encore trop complexe et long par rapport à sa réelle plus-value. Il faudrait soit simplifier son utilisation (moins d'étapes intermédiaires (clic, slide) ou lui ajouter des fonctionnalités de communications avec les groupes (consignes, temps restants, etc.)
  • Le design actuel semble trop envahissant (boite, montre). Il faudrait le rendre plus facile à manipuler, porter et à oublier lorsqu'il n'est pas utilisé

7 Licence, fichiers et documentation

By-nc.png Cette œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale 4.0 International.

  • Fichiers :

Fichiers avec code émetteur et récepteur : Fichier:Code source.zip

  • Documentation :

Guide utilisateur : Fichier:Userguide.pdf

8 Bibliographie

  • Blair, C., Calkins, S., & Kopp, L. (2010). Self-regulation as the interface of emotional and cognitive development: Implications for education and academic achievement.
  • Pekrun, R., Goetz, T., Titz, W., & Perry, R. P. (2002). Academic emotions in students' self-regulated learning and achievement: A program of qualitative and quantitative research. Educational psychologist, 37(2), 91-105.