avr veel variabelen opslaan ?

Ja, bijna.

column-counter is 200,
dus
column-counter - 1 = 199

dus dan krijg je

ColumnData *MyColumn = &Columns[199]

Moet je lezen als:
MyColumn is een pointer (*) naar een data element van het type ColumnData, en die heeft de waarde (=) van het address (&) van element 199 in de array [] met de naam Columns.

En element nr 199 is de 200ste want nummer 0 is de eerste.

ja...ok dat met die -1 had ik wel begrepen, alleen niet verwerkt in mijn vraag . wil ik trouwens van af en ga dus 0-299 doen.

ik heb de schrijfwijze van henri62 gebruikt omdat ik graag alles C wil houden (i.p.v. C++), lijkt mij overzichtelijke voor mij.

{  MyColumn->Byte1 |= (PINB & BitMask);
    break;
}

die -> komt niet door de compiler:
request for member 'byte1' in something not a structure or union
en wat doet hij eigenlijk ?

ik wil zoals henri62 al voorstelde alles opslaan in 1 array van 900 byte's.
dit omdat ik dan in 1x alles over de uart (RS485) naar buiten kan brengen.

Dus dan declareer je een array van bytes;

unsigned char MyColumn[900];

en adresseer je de bytes met

  MyColumn[23] = ... ;

(met waarschijnlijk een index variabele "i" of iets dergelijks waar nu de "23" staat. )

dat gaat hem denk ik wel worden.

Even voor de andere kant van de zaak:

struct mystruct {
  unsigned char Byte1; 
  unsigned char Byte2; 
  unsigned char Byte3;
};

struct mystruct *MyColumn;

...

MyColumn = malloc (sizeof (struct mystruct));

Dan heb je wel:

 MyColumn->Byte1 |= ...

geldig is.

kan,... maar als ik alle 900 byte's in 1 array stop, heb ik denk ik geen struct nodig ?

Ik heb even geen overzicht over je project. Als je gewoon "900 bytes" nodig hebt dan is een array gewoon de juiste structuur. Als je zeg 5 bytes nodig hebt, maar die hebben allemaal een andere functie dan is een struct een veel duidelijkere manier van opschrijven.

Ik wilde alleen even uitleggen wanneer de -> constructie WEL voorkomt. En dat heb ik ook nog verkeerd gedaan. Ik ga het even verbeteren.

Ik gebruik voor dat soort zaken meestal een ringbuffer, dat kan veel kleiner zijn. (tijdens het zenden van de bytes kun je de buffer 'bijvullen'...)

Als het enkel om status van 300 bits gaat, heb je aan 38 bytes toch al genoeg?

Op 18 april 2020 14:13:16 schreef Arco:
Ik gebruik voor dat soort zaken meestal een ringbuffer, dat kan veel kleiner zijn. (tijdens het zenden van de bytes kun je de buffer 'bijvullen'...)

Als het enkel om status van 300 bits gaat, heb je aan 38 bytes toch al genoeg?

Dat was ook mijn idee (hiervoor aangekaart) vandaar mijn vraag "hoe synchroom moet dit verzonden worden" ?

edit: gekruisd met de post van bprosman.

nee: het is 3x300 = 900 bytes.

elke keer bij het doorlopen van de switch/case vult hij 3 bytes. en dat doet hij 300 keer.

@rew,dank voord e uitleg van ->, ik kon hem niet terug vinden in de documentatie.

verzenden van de bytes hoeft nergens synchroon mee. het gaat via de uart over een RS485 bus naar een andere atmega (2560).

maar de buffers worden eerst gevuld (900 bytes) en pas na seconden verstuurd

Op 18 april 2020 16:02:41 schreef trix:

elke keer bij het doorlopen van de switch/case vult hij 3 bytes. en dat doet hij 300 keer....

Dat zijn heel wat meer sensors dan oorspronkelijk opgegeven?

Want ik verstond die 900bytes ook niet met de opgave in gedachte maar wilde mij niet in de C discussie mengen.

maar de buffers worden eerst gevuld (900 bytes) en pas na seconden verstuurd

Misschien begrijp ik het niet maar waarom is dat ?

ik heb hier meerdere topics over lopen waar dit in voor komt, mischien "schiet" het je te binnen.

die 3 bytes = 24 x een lichtoog (IR zender en IR ontvanger) en staan 10 mm uit elkaar.
die bewegen over een werkstuk en elke 10 mm maken die 24x "lichtoog" een "scan". en dat 300x
dus elke 10mm word de data v/d scan opgeslagen, er is tussentijds geen tijd om die data alvast te verzenden. dat gebeurt dus pas als alle (300x) scans gedaan zijn.

Op 18 april 2020 16:15:19 schreef MGP:
[...]
Dat zijn heel wat meer sensors dan oorspronkelijk opgegeven?

blijven even veel sensors, nog steeds die 24.

O, ik dacht dat je meerdere printen van 24 sensors 'boven' en 'onder' ging plaatsen zodat je een vierkant of rechthoek ging maken van 300 sensors.

Je gaat dus maar 1 rij van 24 sensor hebben, dat is een meevaller voor uw IR probleem

in dit topic vroeg ik specifiek naar het opslaan van veel data. gewoon 900 bytes. in 1 atmega16 (word waarschijnlijk een 32). hier heb ik bewust het klein gehouden om dat dat voldoende was voor mijn vraag, en het voorkomt veel "ruis" op de lijn.

maar het zijn inderdaad 300 (in werkelijkheid 288) "lichtsluisen" boven elkaar.
op gebouwd uit 12x PCB met elk 24 "IR zenders" (12x24 = 288)
en 12x PCB met elk 24 "IR ontvangers"
en elke PCB heeft een atmega, maar bij 12 daarvan (alleen de ontvangers) moet ik data opslaan en verzenden.

Op 18 april 2020 17:15:50 schreef trix:

op gebouwd uit 12x PCB met elk 24 "IR zenders" (12x24 = 288)

Dat zijn toch maar 288 bits ofte 36 bytes?
Nu, het heeft geen belang voor de wijze van datatransport maar wel van de te verzenden hoeveelheid bytes.

Door het verspreiden van dit probleem over meerdere topics is er bijna geen touw meer aan vast te knopen.
Maar de 'oplossing' kan bijna zeker veel eenvoudiger als dat het nu is. Zoals eerder gezegd: opnieuw alles nog eens doordenken vanaf start...

het is niet het verspreiden van dit probleem over meerdere topics.
dit probleem kom je alleen in dit topic tegen.
het is een groot project, met vele disciplines en van meerdere disciplines vind je een topic.

[Bericht gewijzigd door trix op 18 april 2020 18:23:23 (13%)

Op 18 april 2020 17:28:52 schreef MGP:
[...]
Dat zijn toch maar 288 bits ofte 36 bytes?
Nu, het heeft geen belang voor de wijze van datatransport maar wel van de te verzenden hoeveelheid bytes.

klopt in het begin heb ik ergens 300 genoemd, en dat vaak zo gehouden om eenheid te houden. maar het maakt voor de oorspronkelijke vraag niet uit.
komt ook doordat ik in 1e instantie 16 IR zenders/ontvanger per PCB had, en dan kom je op 304 (19x PCB) later is dat veranderd naar 24 per PCB.

[Bericht gewijzigd door trix op 18 april 2020 17:57:27 (15%)

ik probeer dus een code te schrijven die dus 900 bytes in 1 array stopt.
nou heb ik gebaseerd op de code van dekees een aanzet gemaakt met behulp van pointers.
ik maak een array van 900 bytes (char):

char columns [899]

met een pointer (mycolumn) kan ik elk v/d 900 plekken aan wijzen:

char *MyColumn = &Columns [column_counter];

hoe kan ik nou een byte op die plek die ik aanwijs krijgen ?

char columns [899]

Dit geeft een array van 899 bytes. Niet genoeg denk ik.

   uint16_t column_counter = 355;

   uint8_t  NewData = 12;
 
   char *MyColumn = &columns [column_counter];
 
 * MyColumn = NewData;

moet natuurlijk: char columns [900] zijn.

ik ga het hiermee eens proberen, ik zal de code nog wel posten. tnx.

zou dit kunnen werken ?
ik krijg v/d main PCB een start puls.
dan moet ik 3x een byte in de array plaatsen (met ieder een eigen adres natuurlijk).
dan krijg ik v/d main PCB weer een start pulse..enz. enz.

ik zou graag in de array met 0 willen beginnen, maar ik hoog hem al meteen op en word dus meteen 1. hoe doe je dit het beste ?

if (start_scan == 1) // komt van main PCB whit UART
{
	column_counter = column_counter + 1;
}

ISR(TIMER1_COMPA_vect)
{
	static uint8_t PulseCounter = 150;
	static uint8_t BitCounter   = 0;	
	
if(PulseCounter == 0)
{
	PulseCounter = 150;		
	char columns [900]
		
	char *MyColumn = &Columns [column_counter];

	switch(BitCounter++)
	{
			
		case 0 : { byte_1 |= (PINC & 0x80);  break; }
		case 1 : { byte_1 |= (PINC & 0x40);  break; }
		case 2 : { byte_1 |= (PINC & 0x20);  break; }
		case 3 : { byte_1 |= (PINC & 0x10);  break; }
		case 4 : { byte_1 |= (PINC & 0x08);  break; }
		case 5 : { byte_1 |= (PINC & 0x04);  break; }
		case 6 : { byte_1 |= (PINC & 0x02);  break; }
		case 7 : { byte_1 |= (PINC & 0x01);  				
		*MyColumn = byte1;
		column_counter = column_counter + 1; break; }
			
		case 8 : { byte_2 |= (PINA & 0x80);  break; }
		case 9 : { byte_2 |= (PINA & 0x40);  break; }
		case 10: { byte_2 |= (PINA & 0x20);  break; }
		case 11: { byte_2 |= (PINA & 0x10);  break; }
		case 12: { byte_2 |= (PINA & 0x08);  break; }
		case 13: { byte_2 |= (PINA & 0x04);  break; }
		case 14: { byte_2 |= (PINA & 0x02);  break; }
		case 15: { byte_2 |= (PINA & 0x01);  				
		*MyColumn = byte2;
		column_counter = column_counter + 1; break; } 
			
		case 16: { byte_3 |= (PINB & 0x80);  break; }
		case 17: { byte_3 |= (PINB & 0x40);  break; }
		case 18: { byte_3 |= (PINB & 0x20);  break; }
		case 19: { byte_3 |= (PINB & 0x10);  break; }
		case 20: { byte_3 |= (PINB & 0x08);  break; }
		case 21: { byte_3 |= (PINB & 0x04);  break; }
		case 22: { byte_3 |= (PINB & 0x02);  break; }
		case 23: { byte_3 |= (PINB & 0x01);  				
		*MyColumn = byte3;
		column_counter = column_counter + 1; break; }
		
// below: pulse counter = 0; needed so that TSAL & TSOP number 1 start on the same time.			
case 24: {  BitCounter = 0; PulseCounter = 0; start_pulse_train = 0; PORTD &= ~(1 << PIND4);  break; }			
	}
}
else
{
	PulseCounter -= 1;
}
}

Zo hoef je helemaal niet met pointers te werken,
Dan kun je gewoon direkt in de array indexen.

if (start_scan == 1) // komt van main PCB whit UART
{
   // Niet ophogen hier.
   // Geberut al in the ISR
   column_counter = 0;
}

ISR(TIMER1_COMPA_vect)
{
   static uint8_t PulseCounter = 150;
   static uint8_t BitCounter   = 0;
   
   if(PulseCounter == 0)
   {
      PulseCounter = 150;     

      // Geen lange array hier. 
      // - Lokale variabelen zijn weer weg als de ISR is afgelopen
      // - Of je moet ze static declareren zoals de PulseCounter hierboven  
      // char columns [900]
      
      // Pointer kan wel maar is hier niet nodig. 
      // char *MyColumn = &Columns [column_counter];

      switch(BitCounter++)
      {
         case 0 : { byte_1 |= (PINC & 0x80);  break; }
         case 1 : { byte_1 |= (PINC & 0x40);  break; }
         case 2 : { byte_1 |= (PINC & 0x20);  break; }
         case 3 : { byte_1 |= (PINC & 0x10);  break; }
         case 4 : { byte_1 |= (PINC & 0x08);  break; }
         case 5 : { byte_1 |= (PINC & 0x04);  break; }
         case 6 : { byte_1 |= (PINC & 0x02);  break; }
         case 7 : { byte_1 |= (PINC & 0x01);             
         {  Columns [column_counter] = byte1;
            column_counter += 1; 
            break; 
         }

         case 8 : { byte_2 |= (PINA & 0x80);  break; }
         case 9 : { byte_2 |= (PINA & 0x40);  break; }
         case 10: { byte_2 |= (PINA & 0x20);  break; }
         case 11: { byte_2 |= (PINA & 0x10);  break; }
         case 12: { byte_2 |= (PINA & 0x08);  break; }
         case 13: { byte_2 |= (PINA & 0x04);  break; }
         case 14: { byte_2 |= (PINA & 0x02);  break; }
         case 15: { byte_2 |= (PINA & 0x01);             
         {  Columns [column_counter] = byte2;
            column_counter += 1; 
            break; 
         }

         case 16: { byte_3 |= (PINB & 0x80);  break; }
         case 17: { byte_3 |= (PINB & 0x40);  break; }
         case 18: { byte_3 |= (PINB & 0x20);  break; }
         case 19: { byte_3 |= (PINB & 0x10);  break; }
         case 20: { byte_3 |= (PINB & 0x08);  break; }
         case 21: { byte_3 |= (PINB & 0x04);  break; }
         case 22: { byte_3 |= (PINB & 0x02);  break; }
         case 23: { byte_3 |= (PINB & 0x01);             
         {  Columns [column_counter] = byte3;
            column_counter += 1;
            break; 
         }

         // below: pulse counter = 0; needed so that TSAL & TSOP number 1 start on the same time.        
         case 24: 
         {  BitCounter = 0; 
            PulseCounter = 0; 
            start_pulse_train = 0; 
            PORTD &= ~(1 << PIND4);  
            break; 
         }         
      }
   }
   else
   {
      PulseCounter -= 1;
   }
}