Comment puis-je planifier mon logiciel pour éviter la réécriture excessive et interdépendances

Question

J'écris un contrôleur de moteur qui a deux interfaces (boutons, Bluetooth, boutons tactiles) qui est une tâche qui ne cesse de croître à un plus grand que je pensais. J'ai essayé d'aller juste à elle en commençant par les modules de bas niveau (par exemple le code d'écriture à parler sur le bus I2C), puis celles ci-dessus que (le code de parler à un dispositif particulier sur le I2C bus ...), mais tout ce que j'ai trop souvent plongée vers le bas à mes modules inférieurs à poignée bizarreries Je ne tenaient pas compte. Cela prend beaucoup de temps soit ou j'obtenir le code vraiment hack ish.

Mon objectif est donc ascendante MCU 8 bits semble que je peux mieux exploiter le matériel. Si je haut vers le bas, je n'ai pas la structure à construire ou test / debug.

J'ai essayé l'élaboration des schémas généraux et ceux des niveaux particuliers / pilotes, mais je ne suis pas sûr de savoir comment les structurer afin que je puisse être très systématique à ce sujet et éviter de manquer le signal étrange qui a besoin d'aller à travers 2-3 couches.

Je suppose que cela est la raison d'un degré CS? Je suis ingénieur électrique: P

Answer 1

On dirait que vous êtes sur la bonne voie. Parfois, aucun montant de la planification va vous empêcher d'avoir à redessiner ou parties de réusiner d'un système à une date ultérieure. Essayez quelques-uns des conseils suivants:

• Gardez votre code dans des modules séparés par des fonctions logiques.
• Ne pas coder en double, la conception à la place des méthodes réutilisables pour des fonctionnalités partagées.
• Essayez d'éviter la tentation d'ajouter hacks pour des cas particuliers. Finalement, cela deviendra ingérable. Au lieu de cela, ajuster et factoriser petites sections le plus tôt possible. Essayer de faire une grande nouvelle conception à la fin sera plus difficile.
• Ne pas essayer de trop concevoir le système dès le début, comme vous pourriez perdre votre temps quand vous arrivez à la mise en œuvre effective.
• Gardez les niveaux inférieurs aussi simple que possible, puis construire des capacités plus avancées sur le dessus.
• Documentez vos fonctions et écrire des tests unitaires, en particulier après l'ajout d'instructions complexes conditionnelles.
• Essayez d'erreurs de capture le plus haut de la pile possible. Par exemple faire la validation des entrées et vérifier les valeurs de retour. Cela rendra plus facile le débogage.

Answer 2

Lorsque vous travaillez dans le code à plusieurs niveaux, il est tentant de plonger dans un niveau inférieur lorsque l'API ne vous permet pas de faire exactement ce que vous voulez qu'il fasse. Cela est particulièrement difficile lors de l'écriture au niveaux mulitple même temps.

Voici quelques suggestions:

• Traiter tous les autres niveaux que celui que vous travaillez comme si elles sont scellées. Créé par une autre société, développeur, etc. Résistez à l'envie de modifier un autre niveau pour résoudre un problème dans votre niveau actuel.
• Créer un « niveau entre frères et soeurs » à celui que vous travaillez. Il est difficile de décrire dans le sens abstrait, mais permet de dire que votre niveau inférieur est une couche d'affaires, et le niveau supérieur est une interface utilisateur, créer une autre couche d'interface utilisateur pour une application différente. Maintenant, avec deux consommateurs du même point d'aide de l'API peut ce que devrait être dans chaque couche.
• essayez d'alterner l'ordre dans lequel vous travaillez sur les niveaux. Par exemple, dans certaines applications que je trouve plus utile de concevoir l'interface utilisateur, puis me frayer un chemin jusqu'à la couche d'affaires / base de données pour que le travail de l'interface utilisateur comme prévu. D'autres fois, il est plus logique de stat avec le modèle de données et le travail à une interface utilisateur. Mais le point est, vous « pensez » d'une API différente dans ces deux scénarios. Et après avoir regardé le code à plusieurs niveaux des deux angles aide.
• L'expérience compte. Parfois, juste faire l'erreur de code de trop couplé est la seule façon d'apprendre vraiment à éviter. Au lieu de planifier sur votre application étant parfaite, le plan sur qu'il soit imparfait. Je veux dire d'abord mis en place un cycle rapide développement / test / refactoring, de sorte que vous pouvez adapter rapidement aux erreurs que vous ne serez voir qu'après que vous avez faites. Ceci est aussi un domaine où « prototypage jetable » est très pratique. Faire simple brouillon, apprendre de lui et de le jeter. La partie de loin throw est important. Même si son incroyable, commencer à construire un autre à partir de zéro. Vous ferez mieux inévitable (et dans mon expirience, plus organisée) basé sur ce que vous avez appris du prototype.

Answer 3

Il est vraiment plus une question d'expérience que votre diplôme. Si vous êtes en train d'apprendre des choses sur la façon de contrôler le matériel, puis bien sûr votre code va changer. Je n'agoniser sur cela. Toutefois, étant donné ce que vous faites est vraiment le prototypage, vous devriez être prêt à factoriser le code une fois que vous l'avez travail. Supprimer les redondances, les données de compartimenter et de fonctionnalités, et d'organiser vos interfaces pour sens.

Mon expérience est que le code du pilote de périphérique a besoin de haut en bas et de bas en haut la conception / mise en œuvre, ce que j'appelle outside-in. Vous savez ce que l'utilisateur va vouloir le faire et vous pouvez écrire ces interfaces, et vous savez ce que le pilote de bas niveau doit faire et vous écrivez que. Si elles ne répondent pas bien au milieu, repenser votre mise en page du module.

Pour l'amélioration, sous réserve votre conception et le code d'examiner par des personnes ayant plus d'expérience. Laissez moi sortir et juste obtenir leur point de vue sur le problème. Vous pouvez également lire un livre sur l'analyse orientée objet et design (je faisais comme les livres de Peter Coad. Je ne sais pas qui les en train d'écrire). Une bonne montrera des exemples de la façon de diviser un problème en objets avec des rôles et des responsabilités claires.

L'autre pièce, une fois que vous avez terminé le prototypage et les pilotes savent comment contrôler le matériel, est de vous assurer que vous avez des exigences détaillées. Rien tord code plus que de découvrir les exigences lors de votre écriture. Vous pouvez également essayer UML l'apprentissage et la conception des diagrammes avant l'écriture de code. Cela ne fonctionne pas pour tout le monde. Notez également que vous n'avez pas besoin d'être de codage dans une langue que les supports des constructions orientées objet à l'utilisation OOD.

Answer 4

Si votre problème est de savoir comment construire des abstractions appropriées, ce qui semble être le cas, je pense que la chose la plus importante que vous pouvez faire pour apprendre (en plus de demander des revues de conception de code / lire des livres / lire le code) est PENSER dur avant d'écrire un traitement .

Il arrive souvent que vous commencez avec une idée approximative de ce que vous voulez et comment il devrait être fait et ensuite à écrire du code. Plus tard, vous découvrirez que vous ne pensez pas que les choses à travers et vous avez plusieurs trous béants qui maintenant, parce que vous avez investi du temps par écrit le code, sont difficiles à patch, ce qui conduit à deux temps perdu ou un code aki.

Pensez sérieusement à la façon de créer un design qui peut facilement gérer les changements. Par exemple, les données encapsuler qui a besoin de Voyage entre les couches, donc si vous découvrez plus tard vous avez manqué un paramètre crucial, vous pouvez facilement l'ajouter à la structure sans avoir à modifier le code partout.

Essayez de « lancer la conception dans votre tête », plusieurs fois, jusqu'à ce que vous êtes reasoanly sûr que vous avez examiné les détails les plus importants et vous pouvez dire (ce qui est la partie la plus importante, parce que vous serez toujours manquer des choses ou des exigences changera) que si vous avez manqué quelque chose que vous pouvez modifier les modules avec une relative facilité.

UML peut vous aider à structurer notre façon de penser à la conception. Il est certainement pas une panacée, mais elle montre les différents critères à considérer lors de la création d'une conception logicielle.

Il est un peu comme les conseils des enseignants d'échecs classique: " assis sur vos mains ": -)

Answer 5

Les conducteurs se prêtent à une approche de la couche.

Vos pilotes pourraient avoir plusieurs "classes":

• Entrée uniquement
• Sortie uniquement
• moi-même et O.

Ils devraient avoir une interface standardisée, par exemple .:

GetKnobLevel()
GetNextKeyboardButton

Ou, est d'avoir quelque chose comme une autre approche

syscall(DRIVERNUMBER, command)

mettant paramètres / résultats dans des registres spécifiés.

Il est une approche simple et utilisable. Une variante plus complexe pourrait être d'avoir des files d'attente circulaires entre votre code de communication de matériel et votre code de communication logiciel, au lieu de registres.

Voici le modèle mental que je utilise:

---
Application
---
OS
---
Driver communicators
---
drivers
---
hardware

Il est étroitement définie, l'interface sans écart entre chaque couche (je continue à imaginer un gâteau de couche épaisse avec un glaçage entre les couches ...). Le système d'exploitation ne peut exister pour vous, bien sûr.

Si votre MCU prend en charge les interruptions logicielles et matérielles comme le CPU x86, vous pouvez les utiliser pour isoler les conducteurs des communicateurs du pilote.

est un peu d'une solution « overengineery », pour être honnête. Mais, dans une situation où votre complexité devient importante, il est plus facile d'avoir le génie serré que d'avoir l'ingénierie libre.

Si vous communiquez entre les couches, vous pouvez utiliser une variable globale pour chaque communication « canal », et d'y accéder de façon disciplinée, en utilisant uniquement les fonctions pour y accéder.

En général, vous voulez faire des dessins de papier à un certain niveau, des travaux d'exploration, et redessiner avant de vraiment partiras au code de votre projet. Et les diagrammes de transition bus fonctionnent bien ici.

Ceci est l'approche que j'ai favorisé dans mon travail de systèmes embarqués et il fonctionne bien pour moi.

En outre - cet espace de problème n'est pas bien exploré par les programmes de sciences informatiques traditionnels. Il est beaucoup moins indulgent que les systèmes d'exploitation Web ou moderne.

Answer 6

A mon avis, les aspects les plus importants du code bien architecturé sont faible degré de couplage et séparation des effets secondaires de l'état .

En outre - le code est un métier. Ne pensez pas que vous pouvez faire la solution parfaite depuis le début. Préparez-vous à changer votre code que vous apprenez des choses nouvelles. En fait - Assurez-vous que vous embrassez changer auto dans le cadre de votre travail

.

Answer 7

Pour ne pas être trop simple, mais une citation de Le Mythical Man-Month vient à l'esprit: "Plan de jeter un loin, vous aurez de toute façon"

Le corollaire qui est « le faire fonctionner. Faites-droite. Faites vite. »

Je suppose que cela me fait un avocat de faire une conception à l'avance, mais pas se paralysé par elle. Il ne doit pas être parfait la première fois. Prévoyez de refactoring. Nous espérons que vous avez écrit des choses de manière à ce que vous n'êtes pas vraiment jeter beaucoup de code loin, mais les choses réarranger de manière plus agréable.