J'adore vraiment les didacticiels vidéo. Pour une raison quelconque, je perçois personnellement très mal les informations contenues dans le texte. Mais il y a des choses sur lesquelles il n'y a pas beaucoup d'informations sur papier. Prenez, par exemple, les leçons de la balalaïka: sur YouTube, il y a de merveilleuses discussions sur la façon de jouer telle ou telle mélodie (qui sont intéressés, nous recherchons "Sergey Vorontsov"), mais il est difficile de répéter et de mémoriser la séquence de la vidéo en streaming. Il faut soit écrire sur papier (à en juger par les commentaires sous les cours, certains le font), soit acheter du matériel supplémentaire (mais je ne suis pas gourmand, mais simple).

En général, dans mon cas de balalaïka, et avec beaucoup d'autres, je dois faire comme ceci: j'ai regardé le fragment, je l'ai mis en pause, je l'ai répété plusieurs fois derrière l'auteur et j'ai continué à regarder. Si quelque chose n'est pas clair - rembobiné, regardé de plus près. Mais comment remonter le tout si vos mains sont occupées? De plus, dans mon cas, ils sont occupés, sinon avec un énorme accordéon à boutons, mais encore certains, mais avec une balalaïka. Donc, vous devez travailler avec vos jambes.
Il y a de nombreuses années, lorsque toute l'humanité progressive utilisait des claviers PS / 2, ils nous ont apporté des dizaines de claviers USB pour le projet. Bien sûr, nous les avons connectés à une machine, avons appuyé sur Ctrl sur l'une d'elles, Alt sur la seconde et Del sur la troisième. L'effet est atteint. Depuis lors, je sais que les claviers USB fonctionnent complètement en parallèle, vous pouvez donc en connecter un autre pour aider le principal, qui enverra des codes à la place.
L'idée est donc née de faire une pédale qui se fait passer pour un clavier et envoie des codes de contrôle aux joueurs. En tant que joueur, j'ai d'abord choisi VLC Player, car il possède des boutons de contrôle bien documentés, mais il s'est avéré plus tard que les codes que j'avais sélectionnés avaient exactement le même objectif lorsque je regardais des vidéos sur YouTube en mode plein écran. C'est bien, car avec plusieurs vues en ligne, pour les impressions de la publicité, quelque chose semble tomber dans l'esprit de l'auteur. Regarder téléchargé ne serait pas aussi éthique.
Nous commençons donc à concevoir l'appareil.
Logique de travail
Au début, je voulais créer plusieurs pédales, chacune pour sa propre fonction. Au départ, je comptais 3-4 de ces fonctions: marche, arrêt, vent là-bas, retour en arrière. Mais alors j'ai compris combien de plastique cela prendrait, plus - comment je comprendrais les pédales au toucher, et j'étais triste. Par conséquent, il a été décidé de réviser radicalement toute la logique. Quelles fonctionnalités sont nécessaires du tout? Start-stop, mais il se bloque souvent sur la même clé, généralement sur un espace. Et rembobinage. VLC Player a "Shift + Left". YouTube, il s'est avéré également. Et, si vous le pensez, il n'y a plus de fonctions.
Super! Faisons en sorte que la pédale utilise brièvement la fonction "Start-Stop", et longtemps - par la fonction "Rewind".
À l'avenir, vous pourrez étendre la fonctionnalité. Vous pouvez entraîner la pédale à reconnaître le code morse. Ma femme, ayant appris l'idée, a suggéré de coder les impulsions de contrôle en utilisant des éléments de danses irlandaises ... En général, vous pouvez étendre les fonctionnalités à votre guise. Mais une chose est claire: une pédale suffit. Eh bien, nous allons maintenant reconnaître les presses longues et courtes.
La mécanique
Pour ceux qui marchent chez eux en pantoufles, il existe une solution très simple (je l'ai trouvée sur le site Thingiverse). On prend un bouton d'un diamètre de plus d'un centimètre, on le visse dans n'importe quel objet en forme de boîte, on obtient une pédale. Le problème est que je n'aime pas les chaussons, donc cette option ne me convient pas personnellement. J'ai besoin d'une surface plus grande pour que le pied ne fasse pas mal.
Des pédales en grandes quantités sont vendues sur Ali Express, vous devez rechercher le mot Foot Switch. Les prix commencent à 30 roubles, mais à ce prix, le coût de livraison peut être d'environ quatre cents roubles. Après avoir cherché, j'ai trouvé qu'il était tout à fait possible de trouver une pédale pour laquelle la somme «prix plus livraison» serait de 150 roubles. Mais vous devrez attendre en moyenne quelques mois (je suis ici récemment pour une carte SD depuis trois mois).
Je suis donc allé plus vite: j'ai fait une pédale sur une imprimante 3D. L'expérience personnelle (et toutes les options avec Thingiverse) montre que l'axe doit être en métal, sinon tout se cassera rapidement. J'ai pris le boulon de meuble M6x60 que j'avais avec l'écrou attaché, ainsi que le bouton (PSW-13), qui était dans les pièces radio voisines, et je les ai encerclés aussi plastique que possible. Voici à quoi ressemblaient les documents sources:

Les voici, insérés dans la moitié inférieure. Comme vous pouvez le voir, la principale caractéristique de conception est les murs, d'au moins quatre millimètres d'épaisseur. Avec ces paramètres, même un proto-typer doux devient assez durable. Le bouton est installé sans écrou, car tout vide en dessous entraînera la rupture du plastique et il se conserve assez bien.

Voici une version presque compilée:

Et voici le pédalier:

En principe, je vais joindre les fichiers STL, mais la solution n'était pas parfaite. Néanmoins, n'importe qui peut le répéter (s'il trouve le boulon M6x60 avec l'écrou correspondant et le bouton PSW-13). Assez pour la première fois, puis - vous pouvez tamponner la mécanique et commander avec ALI.
Périphérique USB
Bien que je fasse activement la promotion du PSoC ces derniers temps, son utilisation sur les pédales est un gaspillage sans précédent. Je considère que la meilleure solution est une planche à pain basée sur STM32F103C8T6, qui peut maintenant être commandée sur ALI Express pour environ 120 roubles (livraison incluse).

Bien sûr, nous pouvons spéculer qu'il existe des cartes moins chères basées sur AVR, mais la différence de prix n'est pas significative là-bas, et STM32 a beaucoup moins de temps de développement en raison du débogage via JTAG. Une heure de temps (même à la maison) - cela coûte aussi quelque chose. Ainsi, selon le critère total «prix de l'appareil + coûts de main-d'œuvre», STM32F103 est la meilleure option pour cette tâche. De plus, j'ai une douzaine et demie de telles maquettes en magasin pour un tel cas, donc le délai d'attente de livraison est désormais égal à zéro pour moi.
J'ai surfé sur le net pour des claviers USB prêts à l'emploi basés sur cette puce. J'ai trouvé un article sur Habr comment fabriquer une souris USB. Mais j'ai besoin d'un clavier. Sur le sujet des claviers, j'ai trouvé beaucoup de conseils intelligents sur les forums (mais je voulais quelque chose de prêt) et quelques projets prêts à l'emploi, mais complexes sur GitHub (mais je voulais quelque chose de clair). Mais celui qui cherche trouvera toujours. Voici un
merveilleux article dans lequel il y a tout ce qui est nécessaire (bien qu'il y en ait un dans le code, je n'ai pas peur de ce mot non russe, un DeadLock potentiel, mais j'écrirai mon propre code). L'essentiel est que toutes les étapes y soient clairement décrites, comment obtenir un clavier USB à partir d'un «poisson» fini fabriqué en Cube MX. La seule chose que l'auteur n'a pas faite, c'est de ne pas publier les codes clés. Ajoutez-les ici:

La mouche dans la pommade est que dans la version moderne de Cube MX, les noms des fichiers, des fonctions et même des constantes sont légèrement différents de ceux spécifiés dans cet article, mais par analogie, tout est rapidement trouvé. Je pourrais écrire une nouvelle version du texte, mais où est la garantie que les développeurs ne changeront plus tout? Ils aiment le faire. En général, vous pouvez voir les analogues dans mon exemple.
Alors. J'ai créé un projet de base dans Cube MX, effectué toutes les modifications recommandées par l'article mentionné ci-dessus. Et ensuite? Ensuite, ajoutez une description du port du bouton. J'ai choisi PB12 (uniquement parce que le contact correspondant est situé sur le coin de la planche à pain). Étant donné que je travaille toujours avec le fer via la bibliothèque mcucpp de Konstantin Chizhov, nous supprimons la définition de macro «-C99» dans les propriétés du projet,
renommons main.c en
main.cpp , puis ajoutons la déclaration:
typedef Mcucpp::IO::Pb12 pedal1;
Nous ajoutons l'initialisation du port à la fonction
main () (activation de la synchronisation du port, définition de la direction de la jambe, activation de la bretelle):
pedal1::ConfigPort::Enable(); pedal1::SetDirRead(); pedal1::SetPullUp (pedal1::Port::PullUp);
En fait, tout est initialisé. J'ai décidé de construire le corps principal à l'image du processus Verilog. Je ne sais pas pourquoi, je voulais juste. Le processus est généralement appelé sur des impulsions d'horloge. J'ai décidé que les ticks du système sont parfaitement pris comme des ticks. Par conséquent, la fonction régulière du gestionnaire de
ticks système dans le fichier
stm32f1xx_it.c a été ajoutée comme suit:

Même texte: void SysTick_Handler(void) { /* USER CODE BEGIN SysTick_IRQn 0 */ /* USER CODE END SysTick_IRQn 0 */ HAL_IncTick(); HAL_SYSTICK_IRQHandler(); /* USER CODE BEGIN SysTick_IRQn 1 */ TickProcess(); /* USER CODE END SysTick_IRQn 1 */ }
J'ai mis la fonction
TickProcess () elle-même en
principal. cpp . Considérez-le d'abord dans son intégralité, puis en partie.
Voici la fonction complète: uint8_t report [8] = {0,0,0,0,0,0,0,0}; uint32_t* pReport = (uint32_t*)report; extern "C" void TickProcess() { // 20!!! static const int shortTime = 700; // static const int longTime = 2000; // static int localTick = 0; static int tickDuringButton = 0; static bool bButtonStatePrev; bool bButtonState = pedal1::IsSet(); // if ((!bButtonState) && bButtonStatePrev) { tickDuringButton = 0; } // if (bButtonState && (!bButtonStatePrev)) { // // , 50 () if ((tickDuringButton >100)&&(tickDuringButton < shortTime)) { // report [2] = 0x2C; } } // if ((!bButtonState) && (!bButtonStatePrev)) { if ((tickDuringButton == shortTime)||(tickDuringButton > longTime)) { // Shift+ report [0] = 2; // Shift report [2] = 0x50; // } } // bButtonStatePrev = bButtonState; tickDuringButton += 1; if (localTick++ % 20 == 0) { USBD_HID_SendReport (&hUsbDeviceFS,report,sizeof(report)); pReport [0] = 0; pReport [1] = 0; } }
La première tâche implémentée dans ce gestionnaire est simple. Toutes les 20 millisecondes, nous envoyons un rapport contenant des informations sur les boutons enfoncés (s'il n'y a pas de boutons, nous envoyons quand même, juste avec des zéros). Étant donné que la fonction est appelée toutes les millisecondes, le rapport doit être envoyé à l'un de ses vingt appels. Pour ce faire, il existe une variable au début de la fonction:
static int localTick = 0;
et le code à la fin (nous envoyons les données, après quoi nous effaçons le tampon pour commencer à envoyer des zéros à la prochaine session):
if (localTick++ % 20 == 0) { USBD_HID_SendReport (&hUsbDeviceFS,report,sizeof(report)); pReport [0] = 0; pReport [1] = 0; }
La deuxième tâche est plus compliquée. Il suit la nature de la pression sur la pédale et remplit le rapport pour une soumission ultérieure. Pourquoi ai-je dit que l'idéologie est comme Verilog? Parce que j'attrape toujours des différences dans cette langue: j'ai une variable dans laquelle l'état actuel du bouton est placé:
bool bButtonState = pedal1::IsSet();
et il y a une variable dans laquelle son état précédent est stocké (comme nous nous en souvenons, l'état précédent est l'état du bouton lors du traitement d'interruption précédent du temporisateur de 1 ms):
static bool bButtonStatePrev;
Le bouton enfoncé donne la valeur
false , le bouton enfoncé -
vrai . Ainsi, nous pouvons toujours conclure sur l'état dynamique du bouton:
Nous introduisons deux constantes. On règle le temps de pressage court. Si la presse a duré moins de 700 ms, elle est de courte durée. La seconde définit l'heure à laquelle la répétition automatique est activée. Si, juste après sept cents millisecondes, vous commencez à envoyer le code clé, le lecteur commencera à tourner trop brusquement. Ceci est identifié empiriquement. Par conséquent, la logique de travail est la suivante: après 700 ms, un seul code "Shift + Left" est envoyé, après quoi l'utilisateur a la possibilité de relâcher la pédale. Si la pédale continue d'être maintenue, à partir de la seconde, l'envoi constant de ce code commence déjà jusqu'à ce que la pédale soit relâchée.
const int shortTime = 700; // const int longTime = 2000; //
Le temps pendant lequel le bouton est enfoncé est stocké dans une variable:
static int tickDuringButton = 0;
Si le bouton vient d'être pressé, on remet à zéro cette variable, en commençant à mesurer une nouvelle période:
// if ((!bButtonState) && bButtonStatePrev) { tickDuringButton = 0; }
Si le bouton vient d'être relâché, on vérifie alors combien de fois il a été enfoncé. Si juste un peu (maintenant il dit "moins de 100 ms") - c'est un bavardage. Cela ne compte pas. Ignorez ce clic. Si nous ne faisons rien de plus que la durée de la pression courte, les pressions longues sont traitées ci-dessous. Si, en quelques secondes, nous créons un rapport dans le buffer avec un espace (qui sera envoyé le moment venu):
// if (bButtonState && (!bButtonStatePrev)) { // // , 100 () if ((tickDuringButton >100)&&(tickDuringButton < shortTime)) { // report [2] = 0x2C; } }
Si le bouton est maintenu enfoncé depuis longtemps, alors nous envoyons «Maj + Gauche» dans deux cas:
- le bouton est maintenu exactement 700 ms (paquet unique);
- le bouton est maintenu enfoncé pendant plus de 2 secondes (envoi de chaque rapport suivant jusqu'à ce que le bouton soit relâché).
// if ((!bButtonState) && (!bButtonStatePrev)) { if ((tickDuringButton == shortTime)||(tickDuringButton > longTime)) { // Shift+ report [0] = 2; // Shift report [2] = 0x50; // } }
En fait, c'est tout. Ce code n'est pas plus différent du «poisson» que Cube MX nous a fait. Nous assemblons, flashons ... Non, c'est impossible sans erreurs (ici ils sont tous pris, mais je ne pourrais pas m'en passer au départ), nous les identifions en 10 minutes via le débogage JTAG (bonjour à AVR), nous cousons, nous sommes heureux ...
Conception alternative
En général, de telles choses sont utiles sans balalaïka (ou autre visualisation de didacticiels vidéo). En particulier, j'aime lire les nouvelles, allongé sur le lit, avec un ordinateur portable sur le ventre. Pour faire défiler le texte, vous devez toujours garder la main droite pliée, ce qui entraîne des douleurs au coude. Par conséquent, j'ai longtemps rêvé d'un gros bouton rouge qui pourrait faire défiler les pages sans plier le bras. En fait, il peut être fabriqué à partir des mêmes composants que la pédale, en remplaçant le boulon du meuble par une petite quantité de colle chaude. Total: bouton PSW13, plaque d'essai STM32F103C8T6, plastique pour imprimante 3D, adhésif thermofusible. Eh bien, dans le «firmware», j'ai remplacé les codes par «PgDn» par une courte pression et «Up» par une longue.


Conclusion
Vous pouvez utiliser vos jambes pour contrôler l'affichage des didacticiels vidéo lorsque vos mains sont occupées. Pour ce faire, une seule pédale simule le fonctionnement du clavier USB. Une pédale peut envoyer plusieurs codes clés, en les sélectionnant en fonction de différents types de frappes. L'article considère une pédale qui analyse deux types (appui court et appui long).
La mécanique se trouve sur Ali Express sous le mot Foot Switch ou peut être imprimée sur une imprimante 3D. En tant qu'électronique, la planche à pain STM32F103C8T6 peut être utilisée. Le "Firmware" se fait en moins d'une heure sur la base du "poisson" créé par Cube MX du fabricant des contrôleurs STM32. Le code supplémentaire occupe plusieurs écrans de texte (pour une résolution de 2K - un écran).
En général, l'ensemble du dispositif (mécanique + «firmware») a été entièrement conçu en une soirée, et il a fallu environ quatre heures pour imprimer la mécanique sur une imprimante 3D.
Les fichiers STL prêts pour l'impression à pédales peuvent être
téléchargés ici (il est souhaitable d'abaisser l'élément supérieur de 0,4 mm pour éviter un grand nombre de supports: la surface s'est avérée légèrement arrondie, en abaissant le modèle, nous rendrons la partie imprimée plate).
Les fichiers STL du "gros bouton rouge" peuvent être
téléchargés ici .
Les fichiers source prêts à l'emploi pour le projet et le fichier HEX pour le firmware peuvent être
téléchargés ici .
La date de publication de cet article n'a pas été choisie par hasard. Le conseil a décidé qu'il valait mieux publier un article sur de telles choses sur un site sérieux ce jour-là. Mais en fait, si vous regardez les vidéos trouvées sur les phrases "Alexey Arkhipovsky", "Dmitry Kalinin", "Cranberry Show", "Alexey Kodenko", il devient clair que la balalaïka académique est comme un assembleur. Là et là, se conjuguent simplicité absolue et puissance expressive frénétique. Et par la phrase "Sergey Vorontsov", vous pouvez comprendre comment apprendre à utiliser cet outil.
Addition
Après 8 mois de fonctionnement, le bouton PSW-13 a commencé à fonctionner une fois sur plusieurs, et seulement avec une très forte pression. En essayant de remplacer, il s'est avéré un détail très intéressant. Le nouveau bouton, acheté en même temps que le précédent, a une réserve de marche complètement différente et fonctionne dans une position complètement différente. En conséquence, elle était toujours enfoncée sur ma pédale. J'ai dû le broyer avec un dremel. Qui va répéter ma mécanique - gardez à l'esprit. Vous devrez peut-être modifier le bouton avec un fichier ou vice versa - sculptez un ruban électrique dessus pour l'augmenter. La répétabilité de la partie plastique de ce bouton n'était pas très grande. Mais en général - après une telle révision, tout fonctionne à nouveau.