Arduino functie met meerdere functies

Omdat de leds niet achtereenvolgend op de pinnen zitten.
Ik heb elke Q7 pin vrijgelaten.
Dan zes kolommen en een Layer.
Om te voorkomen dat er teveel spanning doorgaat.
Ik schakel niet per led maar per 36 1 laag als het nodig is.
Ik ben pas in maart begonnen met code schrijven ik ben er dus niet gedreven in.
Van daar ook dat ik shift.h gebruik.
Ik heb codes opgezocht van een 6x6x6 cube maar daar kom ik niet uit.

Ik heb mijn setup nu zo gemaakt dat ik per led aan kan zetten.
Per x of y as.
Of hele layers.
Tevens heb ik het zo dat wanneer ik leds aanzet automatisch de Layer mee aan gaat en de andere Layers uitzet.
Zo gaat er dus maar 1 Layer tegelijk aan.

Er is mij ook geadviseerd iets met b01100101 te doen maar goed zoals ik zeg kende c code tot een maand geleden nog niet dit zijn mijn eerste stapjes

je hebt per schuif register dus 6 leds en 1 layer en Q7 vrij?
Als je de aansluitingen even vermeld, kunnen we misschien wat effectievere code bedenken.

Ik weet niet precies hoe je je code in gedachte had, of misschien had je daar gezien je net begonnen bent nog helemaal geen gedachte over :)
Er valt nog veel te leren, maar dat geeft niet.

Ik zou het als volgt opzetten:

Je hebt 6 lagen van 36 leds.
continu worden er dus 36 bitjes ingeklokt van 0 of 1 naar gelang de desbetreffende led aan moet zijn in een laag.
Vervolgens wordt die laag actief gemaakt en dat voor elke laag.

Je moet dus een buffer maken waarin je hele kubus staat.
Die kan 36*6 bits = 216 bits = 27 bytes zijn.
Of misschien voor het gemak een 2 dimensionaal array van 5x 6 (5*8 = 40 bits en 6 lagen).
Je kan je array ook zo inrichten dat je precies 1 byte hebt voor elk shift register en dat je vul functie dan bepaalde bits overslaat.
Dan kun je makkelijk in 1x een hele byte lezen en uitklokken. Scheelt weer een hoop bit manipulaties

De inhoud van dat array laat je met een interrupt continu naar je leds schrijven.
Als dat werkt dan maak je functies om die buffer te vullen met patronen.

Hier raak ik de weg al kwijt sorry.
Ik snap dat dat als ik 6 shift registers van heb ik 48 bits moet versturen.
Stel ik moet 6 pinnen hoog hebben moet ik er ook 42 laag maken.
Omdat hij ze op schuift.
Maar dat heb ik dus niet omdat ik shifty gebruik.
Ik voer gewoon shift.writeBit(6pinnen, HIGH) en de libary doet de rest.
Die maakt alle andere pinnen laag.
De libary doet ook zelf de latch de clock en de data.
Dus stel ik wil pin 1 hoog hebben.
En ik heb 1 sr
Doe ik shift.writeBit(1, HIGH);

Doet de libary. B01000000;

Doe ik shift.writeBit(2 high)
Doet de libary de B01100000

Ik moet de pinnen die ik hoog heb gehad zelf omlaag zetten.
Werkt hetzelfde als digitalWrite

Hieronder is mijn setup.
En 1 loop als voorbeeld.
Getest op mijn 3x3x3 cube en werkend.

c code:

 
#include <Shifty.h>

// Declare the shift register
Shifty shift; 

void setup() {
  // Set the number of bits you have (multiples of 8)
  shift.setBitCount(48);

  // Set the ds, sh, and st pins you are using
  // This also sets the pinMode for these pins
  shift.setPins(11, 8, 12); 
}
void Layer(int K)
{
  if    (  K >0 && K <37 ) {              ///Layer gaat automatisch aan als je 1 van de 216 Led's aan zet)///
       shift.writeBit(40, 0);             ///de andere Layers gaan automatisch uit////
       shift.writeBit(32, 0);             /// let wel op deze layer geld niet voor de X en Y as/////////
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(0, 1);
 }
  else if  ( K >36 && K < 73 ) { 
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(0, 0);
       shift.writeBit(8, 1);
 }
  else if  ( K >72 && K < 109 ) {       
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(0, 0);
       shift.writeBit(8, 0);
       shift.writeBit(16, 1);
 }
  else if  ( K >108 && K < 145 ) {      
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(0, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(24, 1);
 }
  else if  ( K >144 && K < 181 ) {    
       shift.writeBit(40, 0);
       shift.writeBit(0, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(32, 1);
 }
  else  if ( K >180 && K < 217 ) {         
       shift.writeBit(0, 1);
       shift.writeBit(32, 1);
       shift.writeBit(24, 1);
       shift.writeBit(16, 1);
       shift.writeBit(8, 1);
       shift.writeBit(40, 0);
 }
  else{         
       shift.writeBit(0, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(40, 0);
 }
 }
 void LayerXy(int X)
{
  if    (  X >0 && X <7 ) {
       shift.writeBit(40, 0);              ///LayerXy word automatisch aangezet bij het aanzetten van de X of Y as//////
       shift.writeBit(32, 0);              ///de andere Layers worden automatisch uitgezet//////
       shift.writeBit(24, 0);              ///er kan dus maar 1 layer tegelijk aan/////
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(0, 1);
 }
  else if  ( X >6 && X < 13 ) { 
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(0, 0);
       shift.writeBit(8, 1);
 }
  else if  ( X >12 && X < 19 ) {       
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(0, 0);
       shift.writeBit(8, 0);
       shift.writeBit(16, 1);
 }
  else if  ( X >18 && X < 25 ) {      
       shift.writeBit(40, 0);
       shift.writeBit(32, 0);
       shift.writeBit(0, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(24, 1);
 }
  else if  ( X >24 && X < 31 ) {    
       shift.writeBit(40, 0);
       shift.writeBit(0, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(32, 1);
 }
  else  if ( X >30 && X < 37 ) {         
       shift.writeBit(0, 1);
       shift.writeBit(32, 1);
       shift.writeBit(24, 1);
       shift.writeBit(16, 1);
       shift.writeBit(8, 1);
       shift.writeBit(40, 0);
 }
  else{         
       shift.writeBit(0, 0);
       shift.writeBit(32, 0);
       shift.writeBit(24, 0);
       shift.writeBit(16, 0);
       shift.writeBit(8, 0);
       shift.writeBit(40, 0);
 }
 }
void Col(int range)
{
  
  switch (range) {
    case 1:    
       shift.writeBit(1, HIGH);                     ///void Col is er om de juiste pins aan de juiste Led's toe te wijzen///           
      break;                                        /// deze functie niet in de void loop gebruiken////
    case 2:
       shift.writeBit(2, HIGH);
     break;
    case 3:    
       shift.writeBit(3, HIGH);
      break;
    case 4:
       shift.writeBit(5, HIGH);
     break;
    case 5:    
       shift.writeBit(6, HIGH);
      break;
    case 6:
       shift.writeBit(9, HIGH);
     break;
    case 7:    
       shift.writeBit(10, HIGH);
      break;
    case 8:
       shift.writeBit(11, HIGH);
     break;
    case 9:    
       shift.writeBit(12, HIGH);
      break;
    case 10:
       shift.writeBit(13, HIGH);
     break;
    case 11:    
       shift.writeBit(14, HIGH);
      break;
    case 12:
       shift.writeBit(17, HIGH);
     break;
    case 13:    
       shift.writeBit(18, HIGH);
      break;
    case 14:
       shift.writeBit(19, HIGH);
     break;
    case 15:    
       shift.writeBit(20, HIGH);
      break;
    case 16:
       shift.writeBit(21, HIGH);
     break;
    case 17:    
       shift.writeBit(22, HIGH);
      break;
    case 18:
       shift.writeBit(25, HIGH);
     break;
    case 19:    
       shift.writeBit(26, HIGH);
      break;
    case 20:
       shift.writeBit(27, HIGH);
     break;
    case 22:    
       shift.writeBit(28, HIGH);
      break;
    case 23:
       shift.writeBit(29, HIGH);
     break;
    case 24:    
       shift.writeBit(30, HIGH);
      break;
    case 25:
       shift.writeBit(33, HIGH);
     break;
    case 26:    
       shift.writeBit(34, HIGH);
      break;
    case 27:
       shift.writeBit(35, HIGH);
     break;
    case 28:    
       shift.writeBit(36, HIGH);
      break;
    case 29:
       shift.writeBit(37, HIGH);
     break;
    case 30:
       shift.writeBit(38, HIGH);
     break;
    case 31:    
       shift.writeBit(41, HIGH);
      break;
    case 32:
       shift.writeBit(42, HIGH);
     break;
    case 33:
       shift.writeBit(37, HIGH);
     break;
    case 34:
       shift.writeBit(38, HIGH);
     break;
    case 35:    
       shift.writeBit(41, HIGH);
      break;
    case 36:
       shift.writeBit(42, HIGH);
     break;
  }
}
void Led(int L)
{
  if      (  L >0 && L <37 )                       ///void Led zet de desbetreffende Led aan inclusief de kathode laag///
               {Col(L);
               Layer(L);}                          /// Led's zitten op 1 t/m 216 selecteer je een ander nummer (bijv 0)///
   else if (  L >36 && L <73 )             
              {Col(L -36);                         /// dan zet je alles uit inclusief de layers//////
               Layer(L);}
   else if (  L >72 && L <109 ) 
              {Col(L -72);
               Layer(L);}
   else if (  L >108 && L <145 )  
              {Col(L -108);
               Layer(L);}  
   else if (  L >144 && L <181 ) 
              {Col(L -144);
               Layer(L);} 
   else if (  L >180 && L <217 ) 
              {Col(L -180);
               Layer(L);} 
   else if (  L >108 && L <145 ) 
              {Col(L /2);
               Layer(L);} 
   else{ 
          for (int i = 0; i <= 216; i++)
            {shift.writeBit(i, LOW);}
 }
}            
void Yas(int Y)
{
  LayerXy(X);                                           ////Xas(); Zet de Xas aan 1 t/m 36 op laag 1 37 t/m 72 laag 2 ENZ ENZ///
  Led(Y);
  Led(Y +6);
  Led(Y +12);
  Led(Y +18);
  Led(Y +24);
  Led(Y +30);
}


void loop()
{
  for (int i = 0; i <= 216; i++)
 {
            Led(i, HIGH);
            delay(200);                                ///Led 1 gaat aan na 20 ms gaat Led 1 weer uit en Led 2 aan///
            Led(i, LOW);
 }
}

[Bericht gewijzigd door Henry S. op 18 april 2019 22:00:22 (0%)]

ik heb ven die library bekeken.
Leuk voor wat je nu doet, maar zoals je het nu gemaakt hebt kun je volgens mij steeds maar 1 led tegelijk aanzetten.

De onderstaande code kan echter niet werken want daar zitten nog wat foutjes in.

Ik heb 2 van je functies sterk vereenvoudigd, met een manier die rew en ik al hadden aangegeven. Bekijk dat eens en leer het nut daarvan. Dat scheelt je eindeloze switch cases en if else constructies.

Zolang er een verband zit in je nummeringen kun je op deze manier altijd efficienter uit de voeten.

c code:


void Layer(int K)
{
	int layerIndex = K - 1; //je telt vanaf 1, maar 0 is makkelijker, daarom maar -1
	layerIndex /= 36;		//we willen weten welke van de 6 layers, daarvoor delen door 36
	layerIndex *= 8;		//de layer lijnen zitten op elke veelvoud van 8e pin op je schuifregister dus vermenigvuldigen met 8
	
	shift.batchWriteBegin();
	//eerst alles default uitzetten
	shift.writeBit(40, 0);             ///de andere Layers gaan automatisch uit////
    shift.writeBit(32, 0);             /// let wel op deze layer geld niet voor de X en Y as/////////
    shift.writeBit(24, 0);
    shift.writeBit(16, 0);
    shift.writeBit(8, 0);
    shift.writeBit(0, 0);
	
	//nu enkel de berekende layerIndex aanzetten
	shift.writeBit(layerIndex, 1);
    
	//nu pas in 1x alles wegschrijven
	shift.batchWriteEnd();	
 }

die

c code:

shift.batchWriteBegin

en

c code:

shift.batchWriteEnd()

zorgen ervoor dat je eerst al je bit manipulaties kan doen en dat dan alles pas in 1x naar je schuifregister wordt geklokt en niet bij elke shift.writeBit

en

c code:


void Col(int range, bool on)
{
	int ledIndexInsideLayer = range - 1;
	int shiftRegBitIndex = 0;
	int shiftRegisterIndex = 0;
	
	ledIndexInsideLayer %= 36; //o houden we altijd 0-36 over en hoef je niet steeds bij de functie call de 36 eraf te trekken
	
	shiftRegisterIndex = ledIndexInsideLayer / 6; //dit berekend op welke van de 6 shiftregisters de led zit
	shiftRegBitIndex = ledIndexInsideLayer % 6;	  //dit berekend op welke index van het desbetreffende shiftreg die led zit
	
	ledIndexInsideLayer = (shiftRegisterIndex * 8) + 1 + shiftRegBitIndex;
  
	shift.writeBit(ledIndexInsideLayer, on);  
 
}

ik denk dat je beter per byte kan schrijven, al doet die shifty lib dat onderwater nu voor je.
als je per byte wil schrijven kun je naar deze lib kijken:
https://playground.arduino.cc/Code/ShiftRegister595/

daarnaast zou ik je adviseren om je functies en variabele zinvol en betekenisvolle namen te geven.

Nou heb nu een ander issue heb de sr, 's aangesloten maar alle pinnen staan hoog. Volgens mij heb ik het boeltje kapot

als je nou eens een schemaatje post...

Precies!

Wat je wilt is dat je een "framebuffer" hebt met welke leds aan en uit zijn. En je wilt de leds denk ik addresseren met xyz coordinaten.

Als je dan 6 schuifregisters van 6 bits gebruikt, de bovenste 2 bits niet, dan kan je optimaliseren door je framebuffer ook zo te organiseren.

code:


uint8_t framebuffer[6*6]; // * 6 bits in iedere byte. 

static void setled (uint8_t x, uint8_t y, uint8_t z)
{
 framebuffer[z*6+y] |= 1 << x;
}

static void clrled (uint8_t x, uint8_t y, uint8_t z)
{
 framebuffer[z*6+y] &= ~(1 << x);
}

static void writeled (uint8_t x, uint8_t y, uint8_t z, uint8_t v)
{
  if (v) setled (x, y, z);
  else   clrled (x, y, z);
}

static void nextlayer ()
{
  static uint8_t fbp;
  uint8_t i, j, t, layer;

  layer = fbp/6; // 0...5
  // hier je huidige layer uitzetten. 

  for (i=0;i<6;i++) {
    t = buf[fbp++];
    for (j=0;j<8;j++) {
      digitalwrite (DATAPIN,  t&1);
      digitalwrite (CLOCKPIN, 1);
      t = t >> 1; 
      digitalwrite (CLOCKPIN, 0);
    }
  }
  if (fbp >= 36) fbp = 0;

  digitalwrite (LATCHPIN, 1);
  digitalwrite (LATCHPIN, 0);

  layer = fbp/6; // 0...5
  // hier je layer aanzetten. 
}

Als je nu 1000x per seconde, bijvoorbeeld in een timer interrupt die "nextlayer aanroept. dan scant ie netjes alle leds naar de juiste waardes. Je hoofdprogramma kan dan alle patronen bedenken.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

idd, maar ik denk dat de ts dat een stapje te ver gaat wellicht

De pinnen zijn hier nog niet juist aangesloten.

Ik krijg de sr niet brandend.
Als ik nu de sh_cp uit de arduino haal en tussen de vingers houd doet hij het wel.

Heb er 1 werkend.
Ik heb nu de code getest.
Als ik 1 hoog zet.

Dan een delay en dan 2 hoog
Blijft 1 ook hoog
Werkt dus exact hetzelfde als digitalWrite

[Bericht gewijzigd door Henry S. op 18 april 2019 22:00:59 (31%)]

Hier trouwens nog het schema zoals ik hem nu aan het bakken ben

Op 17 april 2019 10:12:52 schreef rew:
Precies!

Wat je wilt is dat je een "framebuffer" hebt met welke leds aan en uit zijn. En je wilt de leds denk ik addresseren met xyz coordinaten.

Als je dan 6 schuifregisters van 6 bits gebruikt, de bovenste 2 bits niet, dan kan je optimaliseren door je framebuffer ook zo te organiseren.

code:


uint8_t framebuffer[6*6]; // * 6 bits in iedere byte. 

static void setled (uint8_t x, uint8_t y, uint8_t z)
{
 framebuffer[z*6+y] |= 1 << x;
}

static void clrled (uint8_t x, uint8_t y, uint8_t z)
{
 framebuffer[z*6+y] &= ~(1 << x);
}

static void writeled (uint8_t x, uint8_t y, uint8_t z, uint8_t v)
{
  if (v) setled (x, y, z);
  else   clrled (x, y, z);
}

static void nextlayer ()
{
  static uint8_t fbp;
  uint8_t i, j, t, layer;

  layer = fbp/6; // 0...5
  // hier je huidige layer uitzetten. 

  for (i=0;i<6;i++) {
    t = buf[fbp++];
    for (j=0;j<8;j++) {
      digitalwrite (DATAPIN,  t&1);
      digitalwrite (CLOCKPIN, 1);
      t = t >> 1; 
      digitalwrite (CLOCKPIN, 0);
    }
  }
  if (fbp >= 36) fbp = 0;

  digitalwrite (LATCHPIN, 1);
  digitalwrite (LATCHPIN, 0);

  layer = fbp/6; // 0...5
  // hier je layer aanzetten. 
}

Als je nu 1000x per seconde, bijvoorbeeld in een timer interrupt die "nextlayer aanroept. dan scant ie netjes alle leds naar de juiste waardes. Je hoofdprogramma kan dan alle patronen bedenken.

Daar snap ik dus helemaal niks van ;)
Snap wat je bedoeld maat hoe ik dan de boel juist moet aansturen.
Latch clock en data hoef ik niet iet te gebruiken dat gaat vanzelf door de libary die ik gebruik.

Op 15 april 2019 13:59:15 schreef Jeroen vrij:
Wil een functie void Led(int X)

Als Led=(1) (37) (73) (109) (145) (181)
Maak 1 high (pin 13)
Als Led = (2) (38) enz
Maak 2 high(pin 14)
Tot aan als led =(36) (72)...... (216).
Maak 36 high. (pin 48)

En daarnaast moet hij bij:
1 tot 36 Layer1 hoog maken.
37 tot 72 Layer1 enz.
Heb hiervoor een void Layer aangemaakt.
Hij moet dus bij Led(1);
Layer1 hoogmaken is pin 1 sr6/6
En pin 13 sr5/6

Ik heb dat nu als een if statement.
Maar zou hem graag korter hebben als in een for loop met een formule erin.

Ik heb geen idee waarom je een for loop wilt, want het klinkt nu als een enkel statement. Daarom neem ik even aan dat alle LEDs behalve degene die je noemt en alle layers behalve die je noemt uit moeten gaan.

Meep! Meep!

Je reageert op een bericht van 2 dagen geleden.
Ik heb dat stukje inmiddels al ingekort naar 7 regels.

Verwijderd is opgelost

[Bericht gewijzigd door Jeroen vrij op 19 april 2019 12:42:51 (96%)]