Comment vous résoudriez pour \ $V_x \ $ suivre la méthode de tension de noeud. Je peut résoudre ceci utilisant \ $Q_ {initial} =Q_ {final} \ $, mais je ne peux pas la résoudre utilisant la tension de noeud.
Utilisant noeud tension j'obtiennent \ $v (t) - v (0) = \ frac {k} {} de 170 \ mbox {aF} \ $. Je ne suis pas sûr comment résoudre pour le k constant ou si c'est même correct.
Je cherche très un petit, bon marché, assez le processeur bas-Spéc. qui devrait avoir RS232, RJ45, et peut-être WiFi. Je veux lire des mesures utilisant la porte série d'oner de sondes (de ModBus), en fais qui traite et passe les résultats au-dessus de RJ45 (TCP/IP) ou peut-être de WiFi.
Comme vous avez pu avoir deviné de ma description, je suis un type de logiciel, pas matériel, ainsi sentez-vous libre pour poser des questions.
Bon marché et gai est ce que je veux.
Je travaille avec le contrôleur micro Mega-32 (SMD). Je recherche un module sans fil pour transférer et recevoir les données que j'ai créées avec le micro.
Pourriez-vous svp me guider ?
salut mon circuit a une charge énorme et ainsi volts laisse tomber considérablement par conséquent chaque composant n'obtient pas beaucoup de potentiel. Je me demandais combien difficile est il pour construire un bloc alim. multi de rail ? Pourriez vous signaler un exemple pour que j'ait un aller à.
Peut quelqu'un me proposer toutes les plates-formes incluses qui seraient capables de couler la vidéo d'un webcam d'USB (de préférence. HD) au-dessus de wlan et couru une certaine saveur de Linux ? La plate-forme devrait être aussi petite comme possible. Je sais déjà le gumstix et le beagleboard, mais le gumstix sont un peu cher et le beagleboard est un peu grand.
Je veux convertir un nombre de virgule flottante en nombre de nombre entier. Fondamentalement j'ai un nombre de virgule flottante entre 1 et 0, avec trois décimales, et moi veulent le passer à un nombre de nombre entier comme si multiplié d'ici 1000. Je suspecte qu'il devrait y a une manière plus optimale de la faire qu'utilisant l'arithmétique multipliez l'opération x1000. Je recherche un bout de code de préférence.
J'ai construit un compteur mod16, et le résultat de production est un NOMBRE ENTIER (tous les exemples j'ai vu le NOMBRE ENTIER utilisé).
J'ai construit un décodeur de hex-to-7-segment-display, et son entrée est un STD_LOGIC_VECTOR (lui a écrit de cette façon parce qu'il était facile de tracer la table de vérité).
Je voudrais relier la production du à l'opposé de l'entrée du décodeur, mais j'obtiens des erreurs de « type disparité » en essayant de compiler dans QuartusII.
Est-ce qu'y a-t-il il une manière de convertir d'un type de NOMBRE ENTIER en STD_LOGIC_VECTOR saisissent une liste de VHDL ?
Quand concevant un dispositif basé sur bras qui devrait montrer les graphiques simples sur un affichage à cristaux liquides de couleur, comment un meilleur devrait-il se répandre concevoir des choses pour permettre les mises à jour rapides, de préférence sans être attaché à un vendeur particulier de BRAS ou d'affichage à cristaux liquides ? Mon projet en cours emploie un affichage noir et blanc qui peut être rapide comme l'éclair conduit par le port de SPI sur une PIC (refaisant un affichage complexe dans 1/60 seconde). Il semble que les affichages communs d'affichage à cristaux liquides de couleur ont un port de SPI, mais remplir même affichage à cristaux liquides 160x120 de couleur solide prendrait 30ms, et un 320x240 prendrait le meilleur-cas 120ms (horloge de décalage 10MHz).
Si on pourrait épargner les goupilles de contrôleur, le mode parallèle pourrait être meilleur, mais je ne sais d'aucun moyen famille-indépendant de connecter l'interface parallèle sans exiger trois instructions distinctes de mémoire-magasin pour chaque pixel (un pour placer les données, un pour placer la production d'horloge haute, et un pour la synchroniser le bas). Quelques puces de BRAS ont des interfaces de mémoire-autobus, mais ceux veulent souvent faire des choses comme l'adresse et les données multiplex, ou commettent beaucoup de goupilles à produire le peu inutile d'adresse (l'affichage à cristaux liquides aurait besoin juste d'une adresse mordue).
Regarder l'ILI9320 par ILITEK, ou le HD66789 par Renesas, une approche qui semblerait intéressante serait d'employer un CPLD pour convertir SPI en données parallèles, et incluent un mode qui produirait un pixel par peu. Regardant la fiche technique de Renesas, il pourrait être possible d'obtenir le pixel-par-peu écrit avec le matériel minimal (aucun CPLD requis) en faisant à toute la voie de bits d'informations de parallèle-port la goupille de périodique-données, utilisant le mode ligne pour tout mais le pixel écrit, et en utilisant les fonctions de comparer/masque de sorte que les pixels de tout-zéros soient transparents et tout-ceux les pixels placent le peu choisi dans le GRAMME, ou tout-ceux les pixels seraient transparents et les pixels de tout-zéros dégageraient le peu choisi. « Comporte » la section de la fiche technique d'IKITEK suggère qu'elle ait la fonctionnalité semblable, mais les cartes de registre ne semblent pas inclure les registres appropriés (la plupart des adresses appropriées de registre n'apparaissez pas dans l'IKITEK, mais l'un d'entre eux--le registre 4, est utilisé pour un but différent).
Assumer le code montrera principalement le texte et les graphiques de solide-couleur, l'approche idéale semblerait être d'employer un CPLD pour connecter le port de SPI du BRAS au port parallèle de l'affichage, et permet au CPLD d'être chargé avec des couleurs de premier plan/fond. Ce serait particulièrement gentil si on avait des moyens des pixels « transparents » d'écriture. Donné une police comme couleur deux à mémoire d'image, on a pu simplement charger les données de police directement dans le port de SPI ; ceci permettrait à des données de police d'être montrées à un taux d'un pixel des horloges de chaque deux BRAS. D'autre part, un CPLD suffisamment pour gérer une tâche si affichage-commande coûterait environ $2.
What's the best way to interface an ARM with a color LCD, if the objective is to mainly to show solid-color text or simple (e.g. 16-color or 64-color) graphics?
Edit
I've done many LCD display projects, with many types of LCDs, including character-mode LCDs, custom 3:1 multiplexed segment-based using my own drive method, black and white graphic LCDs with built-in controllers, and black-and-white LCDs for which I designed my own CPLD-based controller to interface with a microcontroller's general-purpose DMA (providing four-level grayscale even). I pride myself on making displays zippy. One of the graphic controllers was a bit of a dog that required about 1/10 second for a full screen refresh even when writing constant data, but most of my displays can render even a fairly complex image in under 1/50 second.
Many of the projects I do are battery-powered, so current draw is an issue. The DMA-based display controller I did worked nicely, but it was for a line-powered project. I believe the only way to get reasonable current draw from a graphics LCD is to use a controller which combines the display buffer and the column drivers. Sending lots of display between chips every frame would waste a lot of energy even on a single bit-per-pixel display; on a color display with sixteen bits per pixel, it would be far worse.
I've only started looking at color LCD data sheets; many displays seem to use a controller similar to the ILITEK ILI9320, though all of the data sheets I've found for controllers based on that general design have been marked "preliminary". Some like the ILITEK one claim to have masking and transparency features but don't list any registers for them; I don't know whether the real chips have such features but the "preliminary" data sheets neglected to include them, or whether they omitted the features but forgot to strike the mention of them. If in practice all such chips have transparency features, it would seem reasonable to design for them; if not, not.
I would expect that for most projects a typical screen would consist of arbitrarily-placed text in moderate number of arbitrarily-sized solid-color fonts. Fonts would most likely be stored as bit-per-pixel data. Using a Cortex-M3, if I wanted to write the display with parallel data, the code's "inner loop" to write two pixels would probably end up something like:
rol r0,r0,#2 ; Get one bit in C, the other in N itcs strhcs r1,[r3,#DATA_OFS] ; Write data strhcc r2,[r3,#DATA_OFS] ; Write data strb r4,[r3,#CLOCK_SET_OFS] ; Set clock high strb r4,[r3,#CLOCK_CLR_OFS] ; Set clock low itmi strhmi r1,[r3,#DATA_OFS] ; Write data strhpl r2,[r3,#DATA_OFS] ; Write data strb r4,[r3,#CLOCK_SET_OFS] ; Set clock high strb r4,[r3,#CLOCK_CLR_OFS] ; Set clock low
Not exactly the fastest thing in the world. Eliminating the writes to the set/clear clock instructions would help. My guess would be that there's no nice architecture-independent way to eliminate both clock writes, but there may be a pretty common way that would allow for eliminating one (e.g. many chips may have a counter/PWM that could be made to pulse an output briefly in response to a single memory store operation).
Using the SPI port and adding hardware to clock one pixel per bit would greatly speed up display access. If using a display without masking and transparency, the CPLD would have to include an address counter, and for each pixel either clock a word of pixel data or else a set-address command for the following pixel's position (for which it would need a counter). By contrast, if a display had masking and transparency, all I would need to do would be to have the CPLD support a mode where after it had clocked in 16 bits, each additional bit would clock a word of data out to the display with the LSB tracking the SDI pin (it might not even be necessary to use a CPLD--just a few normal logic chips). I would set the transparency color to the be color I want to write but with the LSB flipped.
I don't want to come up with a beautiful design that relies upon masking and transparency and then discover that the only displays with such features have a 30-week lead time. On the other hand, if such displays are apt to be and remain widely available from many vendors, I don't want to let paranoia about availability drive me to use an inferior design.
J'ai un circuit simple :
L'estimation maximum (actuelle) de la LED est 30mA.
Comment est-ce que je peux établir de ce que la résistance de la résistance a besoin pour être ? À l'aide de la loi d'ohm je l'ai trouvée pour être de 3/0.03 = 100 ohms. Cependant utilisant le logiciel a appelé Yenka, et test et erreur que j'ai obtenu la résistance possible minimum d'être 36 Ω. Cependant, si j'utilise une résistance de 35 Ω, puis la LED se casse. Le logiciel est-il suis erroné, est-ce qu'ou (plus probable) je faisant quelque chose mal ?
Je voudrais pouvoir daisy chain les dispositifs multiples utilisant juste les fils d'alimentation d'énergie et puis injecter un signal de communications au-dessus des lignes électriques pour le transformer en réseau semi-duplex.
Y a-t-il des méthodes communes de réaliser ceci ? Plus le meilleur et lui serait simples grand s'il a employé UART sur le microcontrôleur.
Éditez : Il y a réellement de deux projette que je travaille à cela que je pense tirerais bénéfice de ceci - on est un réseau de sonde de puissance faible. L'autre est un projet d'éclairage de LED. Dans les deux cas l'objectif est de simplifier le câblage, mais si la solution est trop complexe puis il semble probablement plus de raisonnable d'employer trois fils (PWR, terre, comms).
