ademhalingstechniek project 4 7 8

[brederode Profiel Privébericht]

Hallo allemaal,
Mijn zoon kampt met ernstige ADHD, waarvoor zware medicatie wordt voorgeschreven om het onder controle te houden. Persoonlijk ben ik terughoudend wat betreft medicatie, vanwege mogelijke gezondheidsproblemen op latere leeftijd.
Ik ben echter op zoek naar alternatieven, en heb ontdekt dat een ademhalingstechniek erg effectief kan zijn. De 4/7/8 methode lijkt veelbelovend: 4 seconden inademen, 7 seconden de adem vasthouden, en 8 seconden uitademen.
Nu zou ik iets willen maken met 19 leds waarvan 4 gele leds (inademen) 7 rode leds (adem vasthouden) en 8 groene leds (uitademen),

Het idee is dat de leds per seconde aftellen, en na elke cyclus van 19 seconden het proces vier keer opnieuw begint. Bij het opstarten van het apparaat zouden alle leds aan moeten staan, en dan beginnen af te tellen.
Als iemand suggesties heeft voor de benodigde componenten en de programmeerlogica, zou ik dat zeer waarderen.
Met vriendelijke groet,

[shooter Profiel Privébericht]

dat kan met een Uno prima want de analoge pinnen kun je ook digitaal gebruiken echter 19 leds tegelijk is een beetje veel voor een UNO dus er moet een omzetter tussen.
kijk eens naar een microbit daar zit een klein display direct aan dan hoef je alleen nog maar de software te maken en is ook nog leuker voor hem want die kan hij helemaal zelfstandig programmeren.

[ThHe Profiel Privébericht]

Ik ga erover nadenken hoe ik de juiste informatie aan je kan overbrengen want ik wil je hiermee wel helpen.
Groetjes Theo.

[ThHe Profiel Privébericht]

Normaal kunnen 24 leds niet direct worden aangestuurd door een UNO maar door ze als een matix
te verbinden en een eigen library functie te gebruiken is dat wel mogelijk.
De programma's staan hieronder gepresenteerd.
Hoe de leds moeten worden aangesloten staat in de het led478.ino bestand.

De drie bestanden namelijk led478.ino, TheLeds.h en Theleds.cpp moeten in een map worden geplaatst.

De code led478.ino

Code: Alles selecteren

/**
 *    Maken van een proef opstelling voor 19 Leds.
 *
 *   Onderdelen:
 *       - Arduino UNO
 *       - Breadboard
 *       - 19 Leds
 *       - 19 Weerstanden (220 of 1K)
 *       - Verbinding snoertjes.
 *   
 *   Voor 19 leds in een matrix maken we 4 groepjes van 5 Leds.
 *   Door de matrix opstelling gebruiken we GEEN Pin 5V en Pin GND.
 *   
 *   MinPins zijn  [2,3,4,5]
 *   PlusPins zijn [6,7,8,9,10]
 *
 *   Bedrading aanbrengen voor het eerste groepje van 5 Leds.
 *       - Begin bij het breadboard links boven.
 *       - Plaats 5 Leds (4 gele + 1 rode) op een rij
 *            A1  B1  C1  D1  E1
 *            -+  -+  -+  -+  -+
 *       - De - van het led naar 1 weerstand. (220 of 1K)
 *       - Verbind alle 5 de weerstanden de andere kant aan elkaar en
 *        een verbinding naar Pin 2 van de UNO.
 *       - De + van de led(A1) gaat naar Pin 6.
 *       - De + van de led(B1) gaat naar Pin 7.
 *           .......
 *       - De + van de led(E1) gaat naar Pin 10.
 *
 *     De werking kan nu getest worden door NLEDS = 5 in deze ino file tijdelijk op tenemen.
 *
 *     Nu kan het tweede groepje van 5 Leds worden geplaatst.
 *       - Plaats 5 Leds (5 rode) op een rij
 *                A2  B2  C2  D2  E2
 *                -+  -+  -+  -+  -+
 *       - De - van het led naar 1 weerstand. (220 of 1K)
 *       - Verbind alle 5 de weerstanden de andere kant aan elkaar en
 *         een verbinding naar Pin 3 van de UNO.
 *       - De + van de led(A2) verbinden met + van led(A1). (en dus ook naar Pin 6)
 *       - De + van de led(B2) verbinden met + van led(B1). (en dus ook naar Pin 7).
 *           .......
 *       - De + van de led(E2) verbinden met + van led(E1). (en dus ook naar Pin 10).
 *
 *       Vervolgens groep 3 de 5 leds (1 rode + 4 groene) indien groep2. (weerstanden naar Pin 4)
 *      Vervolgens groep 4 de 4 leds (4 groene) indien groep2. (weerstanden naar Pin5).
 *
 * @author Theo Heeren
**/
#include "TheLeds.h"

#define NPLUS_PINS  5
#define NMIN_PINS   4

#define NLEDS       19
#define START_TIJD  1000   // 1 sec voordat het begint.
#define NLOOPS      4      // aantal loops

int pinsPlus[] = {6, 7, 8, 9, 10};
int pinsMin[]  = {2, 3, 4, 5};

int loops      = NLOOPS;
int iLed       = 0;
long timer     = 0;     

void setup()
{
    theLeds.begin(pinsPlus, NPLUS_PINS, pinsMin, NMIN_PINS);
    timer = millis() + START_TIJD;
}

void loop()
{
    if (timer < millis())                       // Actie ondernemen want de timer is verlopen
    {
        if (iLed == 0)                          // iLed = 0 dan alle Leds HIGH
        {
            for (int i = 0; i < NLEDS; i++)
            {
                theLeds.setLed(i, HIGH);        // Alle leds gaan aan.       
            }
            loops--;                            // Start een loop
        }
        else
        {
            theLeds.setLed(iLed - 1, LOW);      // Vorige iLed gaat LOW 0 t/m NLEDS - 1
        }
        iLed = (iLed + 1) % (NLEDS + 1);        // iled met 1 ophogen. iLed van 0 t/m NLEDS.
        timer = millis() + 1000;                // Volgende timer op 1 sec
    }

    if (loops >= 0)                             // Indien de loop teller < 0 dan stoppen.
    {
        theLeds.refresh();                      // refresh Leds
    }
}


De code TheLeds.h

Code: Alles selecteren

/* TheLeds Library
 *
 * Library voor arduino aansturen van leds in een matrix aangesloten.
 *
 * Voorbeeld:  5 PlusPins en 2 MinPins. Totaal 10 leds.
 * Aansluiten:
 *      MinPin[0] --- ohm --- led(0) --- PlusPin[0] -----
 *        |                                             |
 *      MinPin[0] --- ohm --- led(1) --- PlusPin[1] ----+----
 *        |                                             |   |
 *      .........                                       |   |
 *        |                                             |   |
 *      MinPin[0] --- ohm --- led(4) --- PlusPin[4] ----+---+----
 *                                                      |   |   |
 *      MinPin[1] --- ohm --- led(5) --- PlusPin[0] ----|   |   |
 *        |                                             |   |   |
 *      MinPin[1] --- ohm --- led(6) --- PlusPin[1] ----+---|   |
 *      .........                                       .....   |
 *      MinPin[1] --- ohm --- led(9) --- PlusPin[4] -------------
 *
 * Normaal is de volgorde binnen 1 MinPin van 0 t/m <aantal plusPins - 1>
 * Indien de minPin negatief is de volgorde <aantal plusPins -1> t/m 0.
 * Voorbeeld:
 *       #define NPLUS_PINS  5
 *       #define NMIN_PINS   2
 *       int pinsPlus[] = {4, 5, 6, 7, 8};
 *       int pinsMin[]  = {2,-3};
 *
 *    led      plusPin      minPin
 *  ---      -------      ------
 *  0      4         2
 *   1      5         2
 *  2      6         2
 *  3      7         2
 *  4      8         2
 *  5      8         3   (-3 daarom plusPin 8 ipv 4)
 *  6      7         3
 *  7      6         3
 *  8      5         3
 *  9       4         3
 *
 * Functies:
 *       setLed(led, HIGH / LOW);   De <led 0 t/m 9> wordt aan/uit gezet tot de volgende set.
 *
 *       setCode(uint64_t code)      Set alle led via een bit patroon op ON(1) of Off.
 *                                  0xb<64bits>  1111100000  MinPins
 *                                               4321043210  PlusPins index
 *                                     9876543210  Led nummers.
 *
 *      refresh()               Refresh de led deze functie opnemen in de loop.
 *
 * De instance <theLeds> is aanwezig om direct te gebruiken.
 *
 * @author Theo Heeren
 */
#ifndef TheLeds_h
#define TheLeds_h

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#define MAX_PINS 8

class TheLeds
{
public:
   TheLeds();
   
    void begin(int plusPins[], uint8_t nPlusPins, int minPins[], uint8_t nMinPins);
   
   void setCode(uint64_t code);                                // set een nieuwe code voor de Leds bv 5 Plus & 2 Min
                                                                // 0xb<32bits>  1111100000  MinPins
                                                                //              4321043210  PlusPins
                                                //              9876543210  Led
   void setLed(uint8_t led, bool high);                  // set led 0..n naar HIGH / LOW

   void refresh();                                               // refresh de leds (Continu in de loop)                                                

private:
   void refreshPlus(int iMin, uint8_t code);                   // Refresh 1 minPin code = 11111 (5 bits bij groep van 5 leds behorede bij pin)
   
   uint8_t _nPlusPins;
   uint8_t _nMinPins;
   uint8_t _maxPins;
   uint8_t _plusPins[MAX_PINS];
   uint8_t _minPins[MAX_PINS];
   bool    _negPins[MAX_PINS];                            // _plusPins richting.

   uint64_t _code;                                             // Huidige code <64 bits> voor leds
};

#ifndef TheLeds_cpp
// TheLeds Object.
TheLeds theLeds;
#endif // TheLeds_cpp
#endif // TheLeds_h


De code TheLeds.cpp

Code: Alles selecteren

/* TheLeds Library
 *
 * Library voor arduino aansturen van leds in een matrix aangesloten.
 * Zie beschrijving in TheLeds.h
 *
 * @author Theo Heeren
 */
#define TheLeds_cpp
#include "TheLeds.h"

 /*
  * Constructor
  */
TheLeds::TheLeds()
 {
 }
  /*
  * begin informatie.
  * plusPins
  * nPlusPins
  * minPins             * Indien negatief dan wordt de volgorde binnen deze groep reverse aangeroepen.
  * nMinPins
  * Voorwaarde nPlusPins * nMinPins maimaal 64.
  */
 void TheLeds::begin(int plusPins[], uint8_t nPlusPins, int minPins[], uint8_t nMinPins)
 {
    // Size van Plus & Min pins
    _nPlusPins = nPlusPins;
    _nMinPins  = nMinPins;
    _maxPins   = nPlusPins * nMinPins;
    _code      = 0;

   for (int i = 0; i < _nPlusPins; i++)
   {
      _plusPins[i] = plusPins[i];
      pinMode(_plusPins[i], OUTPUT);
      digitalWrite(_plusPins[i], HIGH);
   }
   for (int i = 0; i < _nMinPins; i++)
   {
      _minPins[i] = abs(minPins[i]);
      _negPins[i] = minPins[i] >= 0;
      pinMode(_minPins[i], OUTPUT);
      // minPins staan altijd op HIGH
      digitalWrite(_minPins[i], HIGH);
   }
}

/*
 * Aan / uit van de lampjes volgens de Code
 * deze routine in de loop aanroepen.
 */
void TheLeds::refresh()
{
   uint64_t code = _code;
   for (int i = 0; i < _nMinPins; i++)
   {
      refreshPlus(i, code);
      code >>= _nPlusPins;
   }
}

/*
 * refresh alle leds behorende bij de minPin
 */
void TheLeds::refreshPlus(int iMin, uint8_t code)
{
   uint8_t c = code;
   for (int i = 0; i < _nPlusPins; i++)
   {
      int index = _negPins[iMin] ? i : _nPlusPins - i - 1;
      digitalWrite(_plusPins[index], c & 1 ? HIGH : LOW);
      c >>= 1;
   }
   digitalWrite(_minPins[iMin], LOW);
   delay(1);
    digitalWrite(_minPins[iMin], HIGH);
}

/*
 * set led nummer van 0..(n-1) naar HIGH / LOW
 * Indien buiten de grens dan geen setting.
 */
void TheLeds::setLed(uint8_t led, bool high)
{
   if (led >= 0 && led < _maxPins)
   {
      uint64_t bit = ((uint64_t) 1) << led;
      _code        = high ? (_code | bit) : (_code ^ bit);
   }
}   

/*
 * set code bestaande uit 64 bits voor de plus(5) en min(2) pins
 * 0b<32bits>  1111100000  MinPins
 *             4321043210  PlusPins
 *             9876543210  Led
 */
void TheLeds::setCode(uint64_t code)
{
   _code = code;
}


Ik hoop dat je hier als start iets mee kan en vervolg vragen zijn altijd welkom.
Succes met je project.
Groetjes Theo