Arduino functie met meerdere functies


Als je bij één begint met nummeren van leds en layers moet je wel bij beiden eentje optellen. Als je bij nul begint niet...

Arco - "Simplicity is a prerequisite for reliability" - hard en software ontwikkeling: www.arcovox.com

Zit er nog aan te denken om de sr poorten te switchen.
Als ik namelijk 7 pinnen per sr gebruik ipv 8.
Kom ik nooit aan de maximale 70mA
Ik gebruik 9.4mA per pin.

led op dat omdat je je leds in de layers scant je meer stroom door je leds moet/mag jagen om geen afbreuk op de helderheid te doen.
Dus stel een led is 20mA gespect, en je scant hem met een bepaalde dutycyle mag je er bijvoorbeeld 60mA doorheen sturen. Moet je wel in de datasheet kijken.
Nu vormt dat dan wel een probleem met je schuifregisters misschien?
gebruik je de 595?
Daar is anders ook een TPIC595 van.
Of je zet er een uln2803 achter

Ik heb een project waarbij ik drie zeven-segmenten displays aanstuur. Ik heb de stroom door de segmenten op net onder 20mA uitgemikt.

Als ik een reeds-geprogrammeerd bordje probeer te herprogrammeren, dan blijkt dat ie de boel niet compleet reset alvorens te gaan programmeren: er blijft een digit gewoon staan. En daar heb je dus de reden dat het eigenlijk fijn is dat je toch op die 20mA mikt, statisch. Doe je dat niet zou je eigenlijk hardware moeten maken om de boel uit te zetten als er niet geswitched wordt.

Bij moderne leds is het prima acceptabel als ze 1/3e van de tijd aanzijn. Voor 1/8e zal je misschien iets betere leds moeten kopen dan ik in mijn zeven segments displays heb zitten om dit voor mekaar te krijgen....

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

Ik had al een 3x3x3 cube gemaakt hier krijgen de leds ook 9,4mA.
Die zijn behoorlijk fel.

Ik gebruik nu npn transistor op de gnd de voor de 6x6x6.
Zou ik deze ook op de anodes kunnen gebruiken?
Weet niet hoeveel mA ik dan per pin gebruik. En of dat beter is
Ik gebruik 1kohm resistors op de base weet niet hoeveel dat moet zijn om 20mA naar de led te sturen.
Weet iemand dat

https://youtu.be/xxaDUhBjsiE

Handig om eindelijk te weten waar je mee bezig bent. Achteraf logisch met 36 leds en 6 layers.

Je gebruikt een arduino mega, toch? Je hebt nu de 36 kolommen gewoon met een weerstandje direct aan een output zitten?
Ah. Nu zie ik dat je een shiftregister gebruikt. Ik dacht dat andere mensen dat (fout) zaten te gokken. Gok of niet: ze hadden het goed. Dan zit je aan de max 70mA per '595 o.i.d. en dan is het een voordeel dat je iedere 8 leds toch naar een nieuwe chip moet. De per-chip limiet is zo veel minder heftig.

Ik zou dat zo houden. Het is geen lolletje om 36 weerstand-tor combinaties te moeten gaan solderen.

De arduino kan gewoon 20mA op iedere output leveren. Je zal vast tegen: 'officieel mag je maar zoveel mA totaal trekken' aanlopen. In de praktijk loopt het wel los. Als je maar weet dat je waarschijnlijk wel "buiten spec" gaat en dat je het netter op moet lossen als je "professioneel ontwerper" zou zijn.

Ik zou in dit stadium niet gaan lopen optimaliseren aan de weerstanden. Als ze "best wel fel" waren bij de 3x3, dan kan je nu gewoon de helft van het licht accepteren als je naar 6x6 gaat. Geen probleem.

Als je torren wilt gebruiken voor ook de led-lijnen dan is het 't makkelijst om dat met PNP te doen als de layers met NPN aangstuurd worden. Andersom kan natuurlijk ook. Maar ik vind het nu niet nodig. Gewoon nu iets werkends proberen te maken.

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

Kan het niet alleen met npn?
Op mijn breadboards kan ik met npn zowel de gnd als de vcc schakelen
Pnp moet ik bestellen Namenlijk.
Ik wil de transistors gebruiken uit veiligheid om de max 70ma te vermijden.
En wou voor de gnd 2 npn parallel zetten omdat 1 laag alle leds bijna 360ma moet sinken

Twee torren parallel is "tricky". Van twee weerstanden parallel weet je dat ze in princiepe de stroom zullen delen: De spanningen zijn gelijk dus ook de stroom.

Van twee torren parallel die je als schakelaar gebruikt kan het zomaar zijn dat de verzadigingsspanning van de ene lager is dan die van de andere. Het gevolg is dan dat je een enorm scheve verhouding kan krijgen in de stroom die de twee torren krijgen.

Stuur je dan 150mA door twee torren die ieder max 100mA mogen, dan kan het al zijn dat de ene minder dan 50 pakt en de andere meer dan 100. Poef!

In jou opstelling ZOU je dit probleem kunnen omzeilen door 18 leds op de ene en 18 op de andere tor aan te sluiten.

Als je 74HC595 chips gebruikt: Die 70mA is met 10mA per ledje een vrij "zachte" limiet: De chip kan het officieel niet aan, maar in de praktijk heeft ie nog behoorlijk wat marge.

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

Kan dus beter 6 leds op 1 sr zetten en een gnd
Dan weet ik zeker dat het een nooit mis gaat.
Moet ik alleen even uitzoeken hoe ik dan de leds toch makkelijk kan nummeren op volgorde.
Dan moet ik maar een case aan maken met 32 cases

Ik heb nu een case aangemaakt.
Met Col(int range,int state)
Range staat voor case nummer.
Dus de leds hebben nu nr 1-36.
State is voor high of LOW.

Zo nu kan ik col(1,1) kolom1 aan.
Kan iemand mij helpen hier een pin array voor te maken
Zodat ik op ee de makkelijke manier er 6 aan kan zetten 30 uit.
Het zijn altijd 6 op1 volgend.
Dus gaat 1-6 aan rest uit.
7-12 aan rest uit.

Kan iemand mij hier vertellen wat er mis is met onderstaande codes.

code:

 
void Layer(int i)
{
  if (int i = 1; i <= 5; i++) {
       digitalWrite(12,HIGH);
       digitalWrite(13,HIGH);
       digitalWrite(11,LOW);
  } else if(int i = 6; i <= 10; i++) {
       digitalWrite(11,HIGH);
       digitalWrite(13,HIGH);
       digitalWrite(12, LOW);
  } else (int i = 1; i <= 15; i++) {
       digitalWrite(12,HIGH);
       digitalWrite(11,HIGH);
       digitalWrite(13,LOW);   
  } 
}  

Deze noob is een echte noob haha

Heb onderstaande ook geprobeerd maar die laat alleen de derde if branden.

code:

 
void Layer(int K)
{
  
 if ( K >= 0 &&  K < 6 ) {
    digitalWrite(12, HIGH);
    digitalWrite(13, HIGH);
    digitalWrite(11, LOW);
  } else if ( K >= 5 &&  K < 11 ) {
    digitalWrite(11, HIGH);
    digitalWrite(13, HIGH);
    digitalWrite(12, LOW);
  } else  (K >= 10 &&  K < 16 );{
    digitalWrite(12, HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(13, LOW);
  }
}

En heb hem opgelost
Heb nu if k<6
Else if k<11
En de laatse else leeg

Begin layers en leds met nul te tellen. Is echt handiger.

Als je int s = led/6; doet, dan heb je direct het schuifregisternummer. Vermenigvuldig dat met 8 en dan heb je het eerste ledje op dat schuifregister.

c code:

int n;
n = 8*(led/6) + led %6;

voila! je n heeft het lednummer van als je de laatste twee posities van ieder schuifregister leeg laat.

Maar ik snap niet waarom je moeilijk doet. Gewoon de stroom iets lager afstellen of gewoon weten dat je zelden patronen hebt waarbij alles tegelijk aan is.

Daarnaast snap ik niet waarom je alle leds 1 voor 1 lijkt te willen aansturen. Dan krijg je een 1:216 multiplexing terwijl je de hardware lijkt te maken zodat een 1:6 multiplexing mogelijk is.

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

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%)]