J'essaie de construire un contrôleur de type MIDI qui a un manche comme une guitare. Sur ce cou, il y a une énorme matrice de capteurs de pression. Le contrôleur émule 3 chaînes.

La façon dont cela fonctionne est: Il y a 3 longues bandes de ruban de cuivre double face (0,5 cm de largeur, aussi long que le cou) qui sont connectées à l'alimentation (3,3 V ou 5 V probablement, peu importe pour l'instant). Sur ces bandes se trouve une couche de Velostat, qui change la résistivité en fonction de la pression. Au sommet du vélostat se trouve une autre couche de rangées ou de cellules de ruban de cuivre, connectée à quelque chose, qui crache une lecture de la tension à travers la couche de vélostat. Comme le cou mesure environ 40 cm de long, il y aura au moins 80 rangées.

Si vous imaginez les 3 bandes inférieures de ruban de cuivre comme des colonnes d'un graphique le long du cou, les capteurs seront soit les cellules ou les rangées, selon la méthode de mesure (je pensais que l'on pourrait également multiplexer les colonnes, puis il peut y avoir des rangées.) Il y a quelques conditions spéciales qui pourraient faciliter cela cependant: comme il s'agit d'un contrôleur de type guitare, toutes les interactions ne doivent pas être mesurées! Seule la touche la plus proche du corps du contrôleur importe. Une résolution de 8 bits doit également être suffisamment précise. 255 niveaux de pression sont probablement plus que nécessaire de toute façon.

Maintenant, les morceaux difficiles:

La mesure doit être suffisamment en temps réel pour détecter les coups de bélier, etc. (aucune idée de la hauteur de la fréquence d'échantillonnage - estimée à plusieurs kHz pour une bonne mesure et jouabilité) et la sortie numérique du contrôleur doit être soit MIDI (sur 3 canaux séparés - un par chaîne) ou un signal numérique qui peut être traité avec un Raspberry Pi.

Maintenant que mes connaissances sont vraiment limitées, je ne pouvais pas penser aux bons outils pour le travail. Ce que je sais cependant, c'est que c'est possible. Il y a un contrôleur similaire mais différent qui utilise une technique très similaire (que j'ai pratiquement inversée jusqu'à ce que je remarque, qu'ils ont un brevet et que les informations sur la façon dont ils le font ne sont pas aussi obscures que je le pensais), on l'appelle le ROLI Côte.

TL; DR:

• environ 240 capteurs

• peut être séparé en groupes de 80 alimentés par la même ligne

• c'est une application en temps réel, j'ai besoin d'acquérir la pression de chaque capteur quand il est touché (certaines conditions s'appliquent, voir ci-dessus)

Merci d'avance, je sais que c'est beaucoup à lire. Je suis reconnaissant pour toute suggestion et serais très heureux si vous pouviez m'aider à accomplir le terrible gâchis que je me suis fixé pour objectif de produire!

Les choses auxquelles j'ai pensé jusqu'à présent:

Multiplexer des lignes et des colonnes, lire chaque cellule avec un ADC MCP3008 ou plus et chaîner des ATmegas (en guirlande ou en arbre) qui ne poussent que l'interaction la plus basse en termes de position jusqu'au signal final, mais d'après mes calculs, cela pourrait éventuellement être goulot d'étranglement par les frais généraux de communication. De plus, un modèle antérieur comprenait des potentiomètres à ruban, que j'ai rejetés, car la conception était mauvaise (plusieurs tentatives, pas assez cool).

MODIFIER / METTRE À JOUR:

Merci pour les bonnes suggestions jusqu'à présent! Grâce à eux, je peux maintenant exprimer mon problème beaucoup plus clairement:

J'ai une matrice de 80 lignes * 3 colonnes de capteurs de pression. Lorsqu'un humain interagit avec la matrice de capteurs, plusieurs capteurs à proximité captent le toucher, mais uniquement le long d'une colonne. Les colonnes sont séparées mécaniquement. Les capteurs ont une résistance entre 100 Ohm et 1 kOhm. Tous ces capteurs doivent être lus avec une profondeur de 8 bits, traités et les résultats doivent être envoyés avec une fréquence d'au moins 1 kHz. Ainsi, une seule lecture / traitement doit prendre moins d'une milliseconde. La sortie finale par colonne doit être: 4 octets pour un float32 et 1 octet pour un uint8. Le float32 indiquera la position moyenne de la première interaction le long de la colonne. Une interaction est définie comme un groupe consécutif de capteurs avec une pression supérieure à un certain seuil. C'est là que le traitement entre dans le mix: la colonne sera parcourue vers le bas jusqu'à ce qu'une lecture dépasse un seuil. Cela comptera alors comme le début d'une interaction. La pression et la position de chaque capteur sont mémorisées jusqu'au premier capteur, qui tombe en dessous du seuil avec un maximum de (probablement) 4 capteurs consécutifs. De tous les capteurs de l'interaction enregistrée, seuls deux capteurs seront traités - celui qui lit la pression la plus élevée (résistance la plus basse) et la plus élevée directement au-dessus ou en dessous. La position en virgule flottante est calculée en faisant la moyenne des deux positions de capteur pondérées par leurs pressions. La pression globale de l'interaction sera simplement l'addition des deux pressions serrées entre 0 et 255 (ajoutez les deux pressions de l'unité8 en uint16 et divisez par 2 sans arrondir, jetez les bits inutiles - cela devrait être rapide). Cela doit se produire pour chaque colonne. Le résultat de la taille de 15 octets sera ensuite envoyé via SPI à un petit ordinateur (Raspberry Pi B3) qui fait office de synthétiseur. Je ne suis pas fixé sur le mode de transmission. Si SPI n'est pas le bon outil pour le travail, je suis prêt à prendre n'importe quelle méthode de communication qu'un Raspberry Pi peut gérer. Puisqu'il s'agit d'une application musicale-interactive, la latence est cruciale.

Mes questions exactes sont les suivantes: cela peut-il être résolu avec un seul microcontrôleur sans casser la banque? Je ne peux pas me permettre d'acheter plusieurs centaines de dollars de circuits intégrés pour un projet de loisir. Quel matériel recommanderiez-vous? Y a-t-il des mises en garde non évidentes dont je dois me méfier?

L'approche que j'ai tirée des réponses jusqu'à présent consistait à alimenter chaque colonne individuellement, puis à lire les lignes avec 5 ADC à 16 canaux (ADS7961) connectés à un Arduino sur SPI. Je crains que ce ne soit pas l'approche la plus facile / la moins chère ou pas assez rapide pour atteindre un taux> 1 kHz.

Avertissement: je suis normalement un chimiste théoricien et un terrible amateur en matière de génie électrique, tout ce que je sais est autodidacte et sans aucune formation professionnelle (ce qui est à mon tour la raison pour laquelle je cherche de l'aide auprès de personnes plus compétentes). Mais je connais bien le logiciel. Tout ce qui concerne le logiciel, je le découvrirai avec assez de temps. De plus, je suis allemand, alors veuillez excuser les défauts de grammaire occasionnels.

En fonction de votre gamme de prix, vous voudrez peut-être envisager d'utiliser un FPGA entre votre Raspberry Pi et les ADC, tels que la carte DE0-Nano , qui a un bon support en tant que carte de développement FPGA d'introduction. Cette solution a l'avantage de vous permettre d'écrire du code qui cadencera plusieurs / plusieurs ADC en même temps et formatera vos données d'une manière qui sera présentable sur le Raspberry Pi.

Vous avez mentionné que vous envisagiez le MCP3008. Cette puce est SPI, vous pouvez donc connecter quelques appareils ensemble sur le même bus avec différentes broches CS. Supposons que vous ayez connecté trois puces à un bus, ce qui vous donne 24 canaux ADC par 6 broches (trois lignes de données et trois lignes CS). Cela signifie 240 canaux pour 60 broches, ce qui est facilement dans les capacités du FPGA.

Si vous exécutez la ligne d'horloge MCP3008 à sa fréquence maximale de 2 MHz, cela prendrait (15 horloges / canal) * (8 canaux / puce) * (3 puces / bus) * (1/2000000 secondes / horloge) = 0,18 ms pour lire les 240 capteurs, correspondant à un taux d'échantillonnage de 5,56 kHz.

La réponse évidente est le multiplexage, cela signifie que vous créez dynamiquement le chemin électrique. Il suffit donc de parcourir toute la matrice, une à la fois, ou autant d'entrées ADC (convertisseur analogique-numérique) que vous en avez.

Si vous avez 3 ADC, vous pouvez lire une ligne à la fois, puis vous changez les entrées en mux et voilla, vous lisez maintenant la deuxième ligne, puis vous continuez. Le problème avec cette configuration est que vous avez 80 lignes et qu'il n'y a pas de multiplexeur 80: 1 (quatre-vingts entrées pour une entrée) à ma connaissance. Mais il existe des multiplexeurs 16: 1 que vous pouvez assembler pour obtenir 16 * 5 = 80 entrées.

Cela ressemblerait à quelque chose comme ceci:

row  0-15 [16:1 mux]____________ 5 inputs in [8:1 mux]-ADC
row 16-31 [16:1 mux]_| | | |
row 32-47 [16:1 mux]___| | |
row 48-63 [16:1 mux]_____| |
row 64-79 [16:1 mux]_______|

Les 4 signaux d'entrée vers les multiplexeurs 16: 1 peuvent être connectés ensemble.

Donc, à la fin, vous avez un octet avec des signaux de contrôle dans ce modèle:

Grouped up:
0, 3 bits for the 8:1 mux, 4 bits for the 16:1 mux

Bit for bit:
0,8:1 MSB, 8:1 LSB+1, 8:1 LSB, 16:1 MSB, 16:1 LSB+3, 16:1 LSB+2, 16:1 LSB+1, 16:1 LSB

Cela signifie que vous aurez besoin de 5 × 16: 1 multiplexeurs et d'un multiplexeur 8: 1 = 6 CI,

Multipliez cela par 3, car vous voudrez peut-être lire une ligne à la fois.

Cela signifie que vous aurez 18 IC, 7 signaux de contrôle. Vous pouvez réduire le nombre de circuits intégrés si vous augmentez le nombre d'entrées analogiques. C'est 18 avec seulement 3 entrées analogiques.

Si vous avez plutôt utilisé 240/16 = 15 circuits intégrés, vous avez obtenu 15 sorties analogiques à partir des multiplexeurs 15 × 16: 1. Ensuite, vous pouvez le cascader avec un multiplexeur 16: 1 ou 16: 8. Au final, ce serait 16 circuits intégrés si vous "l'optimisiez" avec des multiplexeurs 16: 1. Mais cela signifierait que votre solution logicielle ne serait pas aussi ... élégante que ci-dessus, elle serait entrecroisée et module et d'autres choses, mais bon, vous enregistrez 2 IC.

$\frac{1}{0.8ms}=1.25 kHz$

C'est possible, mais ce n'est pas un bon design.

Résolvons cela d'une autre manière plus efficace et plus économique.

* 20 minutes plus tard * Hmmm ... toutes les solutions que j'ai trouvées sont trop difficiles à mettre en place et / ou nécessitent un étalonnage avancé ...

Eh bien, je suppose que votre conception est adaptée à votre tâche.

Bonne chance.

Je me demande quelles sont ces autres solutions. Se soucier de partager? - pandalion98

OP veut mesurer la position et la pression. Voilà deux paramètres. Cela signifie que nous devons regrouper ces informations à l'intérieur d'un signal de tension afin de pouvoir les lire et les déchiffrer. Ou nous devons l'emballer dans une autre unité, comme ohm, inductance, capacité.

Voici certaines de mes idées, où je ne pense qu'à une colonne. Multipliez simplement l'idée par 3 et vous avez toute la solution pour une guitare à 3 colonnes.

Première idée:

Utilisez deux fils parallèles (faible résistance) allant du bas de la guitare au manche de la guitare. Connectez la masse à l'un des fils au bas de la guitare. Faire un système de mesure LR et mesurer l'inductance et la résistance de l'autre fil, également en bas.

Lorsque vous touchez les deux fils avec un doigt, vous connectez les deux fils et il y aura certaine inductance ici. Plus vous touchez la guitare, plus le circuit sera long et plus vous mesurerez d'inductance. Plus vous appuyez fort, plus il y a de surface entre les deux fils et moins sa résistance est.

Il ne doit pas nécessairement s'agir de deux «fils», il peut s'agir de deux bandes conductrices ou autre chose.

Pourquoi je ne l'ai pas partagé auparavant: pour que cela soit fiable, vous devez calibrer les capteurs pour chaque individu, car tout le monde a une résistance différente dans sa peau. Chaque fois que vous jouez, vous transpirerez et réduirez ainsi la résistance, vous devrez donc compenser cela. Tout le monde transpire beaucoup, donc cela devra également être calibré par personne.

Donc l'inductance => positionnelle du doigt. La résistance => la force avec laquelle vous appuyiez.

L'écart des valeurs que vous mesurerez sera dans le nano Ω et le nano H, cela signifie que vous aurez besoin de connaissances appropriées concernant le CMRR et le SNR. Sinon, tout ce que vous verrez sera la tension du secteur, en supposant que cela se fasse à l'intérieur. Ou certaines autres fréquences du wifi ou des lampes ou d'autres sources de bruit. Il faudra donc peut-être un filtre numérique approprié. Et ... c'est probablement déjà en dehors de la portée des capacités de l'OP et de l'effort mental acceptable. Donc, cette idée est jetée.

Deuxième idée:

Faites une surface conductrice plate sur la guitare qui est connectée à la terre.

Utilisez un fil, du ruban conducteur ou simplement un conducteur plat. Mettez de la peinture non conductrice dessus, ou du ruban non conducteur ordinaire dessus.

Enroulez-le sur la guitare du bas vers le manche de la guitare. Connectez le fil au bas de la guitare aux hautes fréquences, dans la gamme des centaines de MHz. Vous allez maintenant commencer à obtenir des reflets visibles. Parce que techniquement, vous avez une ... mauvaise ligne de transmission où un seul côté est blindé.

Vous allez donc envoyer une courte impulsion d'onde carrée et mesurer le temps qu'il faut pour qu'elle revienne en raison de la réflexion due au fait que votre doigt est au-dessus du fil isolé. Et puis vous mesurez l'amplitude de la pointe réfléchie au bas de la guitare. Donc le temps de voyage => position du doigt. L'amplitude de la réflexion => la force avec laquelle vous appuyiez.

Ce n'est pas la chose la plus facile à mettre en place ... si vous ne savez pas ce que vous faites. Encore une fois, cela pourrait représenter un effort trop important pour OP. Donc, cette idée est jetée.

Cela ressemblerait à quelque chose comme ceci:

J'ai supposé que l'impédance caractéristique était de 150 Ω, c'est-à-dire une très mauvaise ligne de transmission. En réalité, cela pourrait être pire, je ne sais pas que je n'ai jamais fait ça.

Voici le lien au cas où quelqu'un voudrait déconner.

L'une des parties les plus difficiles sera de faire correspondre les points d'extrémité à une certaine résistance, pour cela, vous pourriez avoir besoin d'un oscilloscope ou d'un autre instrument coûteux.

L'autre partie difficile sera de mesurer réellement le TOF (temps de vol), il y a des circuits intégrés, mais ils ne sont pas bon marché .. mais vous pouvez toujours simplement créer une source de courant constant et remplir un petit condensateur, puis juste lire la tension.

L'idée ici est que lorsqu'un doigt s'approche du fil, votre doigt fera partie du circuit et agira comme un condensateur. Plus votre doigt est proche, plus il est capacitif. C'est pourquoi la résistance au point du doigt va baisser.

https://en.wikipedia.org/wiki/Transmission_line faites défiler vers le bas et vous verrez que le paramètre capacitif fait partie du dénominateur.

Chaque fois qu'un point sur le fil ne correspond pas, alors il y aura une réflexion, et vous pouvez le lire à la "sortie" d'où provient votre signal. S'il n'y a aucune réflexion nulle part, votre signal se terminera à l'un des points d'extrémité.

Plus vous poussez vers le bas, plus la surface de votre doigt sera plate => plus de capacité due à la zone. De plus, tout matériau non conducteur que vous avez entre le fil et votre doigt sera très légèrement comprimé pour augmenter encore la capacité.

Troisième idée:

Collez un theremin à l'intérieur de la guitare et mesurez la fréquence et l'amplitude. Je ne sais pas exactement ce qu'un theremin produira, mais sûrement quelque chose peut être utilisé.

À ce stade, je suis à court d'idées et je dis que j'ai passé 20 minutes. Quand en réalité j'ai peut-être passé 10. Oh bien. Maintenant, j'ai sûrement passé encore 10 minutes pour écrire ceci, donc tout s'additionne.

Trois idées:

1. Faites du multiplexage côté alimentation

En effet, le circuit que vous avez décrit est un grand nombre de résistances variables dont chacune a une extrémité commune à une tension d'alimentation. Vous voulez lire toutes les valeurs de résistance et les autres réponses jusqu'à présent ont principalement suggéré des approches pour multiplexer le signal du côté analogique.

Mais vous pouvez également faire tout ou partie de ce multiplexage du côté de l' offre , en divisant le «rail» d'alimentation en n sections. Connecter ensemble des ensembles de n pads de capteur qui ont chacun un rail d'alimentation différent. Maintenant, mettez sous tension un seul rail d'alimentation à la fois et utilisez une entrée ADC pour lire chaque jeu de pads. (C'est ainsi que le circuit qui lit un clavier d'ordinateur fonctionne généralement, et la façon dont les commutateurs sont câblés est souvent appelée un `` commutateur de point de connexion ''.) En fin de compte, vous pouvez simplement utiliser un seul ADC, connecté à tous les `` rails '', et faire tout le multiplexage en connectant tour à tour l'alimentation à chaque pad.

Le seul hic est que tous les autres pads doivent être isolés du rail d'alimentation, non connectés à la terre, ce qui serait le cas si vous utilisiez simplement une sortie numérique pour chacun. Il existe plusieurs façons de résoudre ce problème, y compris le câblage de chaque pad via une diode, un transistor bipolaire ou un FET, ou - je ne sais pas à quelle vitesse cela peut être fait dans la pratique, mais c'est possible en principe - en utilisant la broche d'entrée-sortie d'un microcontrôleur et en le réglant soit pour une sortie élevée, soit pour être une entrée, alors qu'il devrait avoir une impédance relativement élevée.

La précision de la mesure de vos capteurs par cette technique n'est peut-être pas parfaite par rapport à l'utilisation d'une seule source de tension fixe et de multiplexeurs analogiques de haute qualité, mais je pense que ce sera assez bon, d'autant plus que je suis sûr que les capteurs de pression auront une certaine tolérance sur leur résistance - vous devrez peut-être l'étalonner pour chaque capteur en utilisant une force de référence de toute façon.

2. Utilisez des microcontrôleurs avec beaucoup d'entrées ADC

Par exemple, le PICAXE 40X2 possède 27 broches qui peuvent être utilisées comme entrée analogique, vous pouvez donc couvrir vos besoins avec 9 d'entre elles. Il est programmé dans un langage BASIC simple et peut agir comme un esclave i2c - vous pouvez donc lire les 9 puces avec un autre microcontrôleur - ou vous pouvez probablement simplement envoyer la sortie de chaque puce en tant que données série et la lire sur l'ordinateur hôte via des convertisseurs série-USB. Je ne peux pas promettre exactement à quelle vitesse cela ira mais je pense que cela devrait fonctionner correctement si vous synchronisez le PICAXE à la vitesse maximale (de 64 MHz, en utilisant un résonateur externe de 16 MHz). Bien sûr, si vous êtes satisfait de la programmation du microcontrôleur en C, vous pouvez faire la même chose avec le PIC18F45K22 sur lequel le PICAXE est basé.

3. Utilisez des unités d'entrée analogiques standard

Enfin, si cela ne vous dérange pas de dépenser de l'argent pour gagner du temps et que la portabilité n'est pas une priorité élevée - par exemple, s'il est acceptable que l'instrument soit attaché à un rack d'équipement par des câbles épais - vous pouvez simplement acheter assez haut - dispositifs d'entrée analogique à comptage de canaux pour mesurer tous les capteurs à la fois. Par exemple, le Measurement Computing USB-2633 lit 64 entrées analogiques pour un peu plus de 1 000 $ US.

Cela pourrait valoir la peine d'envisager un conditionnement de signal par force brute (passif peut-être) suivi par de petits ADC ou MCU / ADC avec 16 entrées ADC MUX ou plus chacune. C'est seulement 40 jetons. Un exemple de puce qui pourrait fonctionner est l' ADS7961QDBTRQ1 , qui a un mode de canal à incrémentation automatique et 16 entrées.

Le débit de données global, même à un taux d'échantillonnage de 4 kHz et 240 octets par échantillon, est d'environ 1 Mo / s, ce qui n'est pas trop effrayant. Peut-être un CPU maître avec un bus SPI 10 MHz ou 20 MHz communiquant avec les esclaves. Utilisez 2 bus SPI si la bande passante n'est pas là. La partie mentionnée ci-dessus fonctionne à 20 MHz, donc un seul SPI fera l'affaire.

Ou peut-être que vous pouvez utiliser une seule puce TI - le DDC2256AZZF , qui a un échantillonnage simultané de 64 canaux et 256 entrées .. mais ce n'est pas particulièrement bon marché (environ 350 $ USD) et est livré dans une matrice LFBA 14x14mm 323 broches donc ça ne va pas travailler avec une planche à pain blanche.

Pour une application d'interface humaine en temps réel, un taux d'échantillonnage global de multi-khz semble élevé. 50 Hz est probablement suffisant ( https://en.wikipedia.org/wiki/Input_lag#Typical_overall_response_times ). Cela signifie que vous devez échantillonner tous les capteurs en <20 ms, donc 80us par capteur. Ce n'est pas trop difficile et peut être géré par pratiquement tous les microcontrôleurs 8 bits normaux (c.-à-d. Atmega88 peut le faire en <30us).

Vous pourriez aussi bien mesurer toutes les interactions, puis jeter celles dont vous n'avez pas besoin, car toutes les mesures ne sont pas difficiles sur le plan technologique. Le problème vient du multiplexage. Je suis un peu confus à votre poste, car il dit que les capteurs sont alimentés 80 à la fois? La chose habituelle à faire est, comme vous le dites, de multiplexer les colonnes et les lignes. Si vous ne le faites pas, vous devrez gérer plus de 80 fils sortant de votre appareil, ce qui n'est vraiment pas une bonne idée. Vous devez trouver un moyen de le diviser en une matrice, vous obtenez donc 30 fils (ce qui est encore beaucoup). Vous pouvez ensuite les multiplexer, etc., mais si j'étais vous, je n'aurais que plusieurs microcontrôleurs et les connecter à un maître. Vous pouvez utiliser un ADC dédié au lieu des MCU esclaves, mais personnellement, je m'en tiendrai aux MCU.

Vous avez correctement identifié que les communications pourraient être un problème, mais ce n'est pas un gros problème, au moins entre les MCU. Un Atmega à 8 MHz peut faire du SPI à 2 MHz, donc l'envoi de toutes les données du capteur prendra <1 ms. La question est alors de savoir ce que vous voulez faire de ces données une fois que le MCU maître les a.

Votre méthode la plus simple peut être de construire le tout sur un long circuit flexible avec une chaîne de 10 registres à collecteur ouvert de huit bits vers des registres parallèles répartis sur le câble pour alimenter chaque colonne de pads individuellement.

Vous pouvez les utiliser pour piloter chaque colonne de toutes les lignes simultanément et multiplexer les lignes de retour communes vers votre ADC. Les lignes de retour auraient besoin de tractions appropriées pour que vous obteniez une tension de diviseur de résistance avec la résistance du bouton.

^{simuler ce circuit - Schéma créé en utilisant CircuitLab}

Le micro de contrôle enverrait alors un bit zéro unique dans la chaîne de registres, de sorte qu'une seule colonne est alimentée en même temps. Les connexions restantes seraient flottantes.

la façon la plus évidente de le faire (car il vous suffit de voir une seule touche sur chaque chaîne) est de connecter les frettes à un diviseur de tension, puis de mesurer la tension sur chaque chaîne

qui vous dira de toucher l'emplacement.

pour obtenir une pression tactile, mettez un condensateur de la masse à chaque frette et mesurez la résistance AC sur chaque corde.

l'inconvénient de cette approche est que les cordes répondront aux touches plus élevées

Si vous pouvez obtenir un fil qui a une résistance par pouce raisonnablement uniforme qui se situe entre 100 ohms et 100K pour la longueur de la guitare, vous pouvez peut-être simplement fabriquer le manche avec un matériau modérément conducteur, avec une résistance de surface qui diminue avec la pression, puis mesurez la résistance entre le manche et chaque extrémité de chaque corde. La somme des résistances, moins la résistance d'une corde, indiquerait deux fois la résistance du point de contact. Après avoir soustrait la résistance du point de contact de chaque résistance mesurée, le rapport des résistances restantes indiquerait le point de contact sur le col.

Notez que cette approche serait capable de détecter les pressions simultanées sur les trois chaînes, mais ne fonctionnerait pas si une chaîne pouvait être pressée à plusieurs endroits. Sur une guitare, une telle conception empêcherait l'utilisation d'accords de barre - une limitation assez sévère - mais d'autres instruments peuvent ne pas nécessiter de toucher des cordes à plusieurs endroits.

J'ai vu ce post et je me disais, ça pourrait être possible avec une seule puce. Je suppose que vous prenez une sorte de carte microcontrôleur, comme la carte Bluepill bon marché. Il dispose d'un ARM M3, avec 10 canaux ADC gratuits à utiliser. Si vous placez les colonnes en 3 groupes de 3 chaînes, connectez-les à 9 canaux ADC gratuits. Utilisez les 21 autres broches pour basculer les rangées de broches, pour un total de 63 «frettes». Le microcontrôleur dispose de deux ADC 1 bit 12 bits qui peuvent être utilisés avec un retard de phase pour prendre en charge 2 Mps, ce qui devrait être suffisant pour ne jamais manquer un marteau ou remarquer une modulation. Je pense que vous pouvez utiliser la connexion USB et faire fonctionner la chose comme un contrôleur midi USB. Vous pouvez utiliser un microcontrôleur plus grand pour plus d'entrées, mais je ne vois pas comment vous allez gérer l'espacement des `` frettes '' avec plus de 30 frettes, ou cela ressemblera-t-il davantage à un écran tactile?

Je ne sais pas exactement comment fonctionnent ces feuilles de velostat, mais ne pouvez-vous pas mettre comme de petits points de terminaison au bas d'une plus grande feuille et corréler l'emplacement et la pression du doigt à la tension en plusieurs points? Ensuite, vous pouvez probablement vous en sortir avec beaucoup moins de détection et supporter des choses comme les virages et le vibrato.