lecture d'un tsl201R

[Kondelec]

Bonjour à tous

Je travaille sur un petit projet utilisant un TSL201R. Je me suis inspiré du code de cette page :
https://arduining.com/2014/03/26/usi...-with-arduino/

Le code fonctionne très bien, mais reste assez lent en raison de algorithme utilisé : On balaye tous les bits d'horloge à chaque fois que l'on lit 1 pixel, pourtant la datasheet précise que la lecture s'effectue à la volée. Je ne comprend pas le choix de l'auteur du code, et effectivement quand je vais lire les pixels 1 à 1 sur un seul cycle les valeurs sont incohérentes (j'ai des valeurs d'intensité croissantes du début à la fin du capteur, même si il est illuminé de façon uniforme).

Est-ce que quelqu'un saurait me dire pourquoi ?
-----

[umfred]

j'ai l'impression qu'on pourrait faire mieux en utilisant le temps d'intégration dans le code de lecture, vu que ça serait la période d'horloge CLK et lire la valeur avant le front montant de la CLK déclenchant le bit suivant, si on regarde le chronogramme de la doc https://datasheet.octopart.com/TSL20...et-8327114.pdf

[jiherve]

bonjour,
D'abord il faudrait coder en assembleur avec interruptions et ensuite c'est assez simple il faut fournir le pulse de séquencement et son horloge à un rythme que l'ADC du µC puisse suivre. Chaque cycle complet donnera les 64 valeurs mesurées, bien sur il y aura une différence temporelle entre le premier pixel et le dernier, comme avec un rideau d'appareil photo argentique.
Avec un 328P @16MHz on doit pouvoir tenir 200Hz en capture donc 5 ms d’écart entre les deux extrêmes.
ne rien envoyer sur la liaison série pendant la capture, stocker les valeurs et ensuite les afficher si nécessaire, pour garder un temps d’intégration constant il faut maintenir un rythme stable d'où les interruptions.

JR

[jiherve]

ajout,
en y réfléchissant un peu plus il faut configurer l'ADC en "free running" et utiliser son interruption pour générer l'horloge du capteur et le pulse de contrôle ainsi que bien sur le stockage de la valeur lue, il faudra un buffer ad hoc (fifo, multipage ....). Ensuite une routine en tache de fond se chargera de l'affichage et du reste.
Le maintien d'un fonctionnement cyclique absolu est indispensable pour garantir un temps d’intégration fixe , donc une sensibilité constante pour chacun des pixels.
La plupart des soft donnés sur les forum sont pourris!
JR

[A voir en vidéo sur Futura]

[Kondelec]

Merci, grace à vos réponses je viens de comprendre pourquoi l'auteur du code l'a écrit de cette façon.
Si j'ai bien compris l’intégration continu pendant la lecture séquentielle des pixels

[jiherve]

bonsoir
oui l’intégration est contrôlée par le pulse de lecture c'est bien décrit dans la doc du composant; Il faut absolument maintenir un rythme constant pour celui ci.
JR

[Kondelec]

Ca j'ai bien compris, par contre je ne comprend pas la séquence de lecture.
Si on lit le diagramme on effectue un pulse sur SI, puis la valeur de chaque pixel est envoyée de façon séquentielle, à chaque pulse d'horloge : 1 pulse sur SI, 65 pulse sur clock et on recommence.
Pourtant plus bas page 7 il est dit qu'a chaque pulse sur SI on décale le pixel lu.
Comment est ajusté la durée d'intégration ?

[jiherve]

bonjour,
la durée d’intégration est l’écart entre les pulses de lecture.

The integration time is the interval between two consecutive output periods.

The integration time is the time from a specific pixel read to the next time that pixel
is read again. If either the clock speed or the time between successive SI pulses is changed, the integration time
will vary.

c'est pour çà que si l'on désire une réponse uniforme reproductible il faut que la lecture s'effectue avec une périodicité constante
JR

[Kondelec]

Merci pour l'explication.
Une solution serait peut être de gérer l'horloge en dehors du µc, par exemple avec un 555

[jiherve]

re
ben non cela doit pouvoir se faire comme je l'ai indiqué en utilisant l'ADC et son interruption mais malheureusement je crains qu'il ne faille passer par de l'assembleur!
JR

[Kondelec]

merci pour ce complément d'info

[jiherve]

Bonsoir,
J'ai fait un bout de code assembleur et cela fonctionne correctement avec l'ADC configuré en Free Running.

  ADC_INT:
    xpush0123Y;
    lds rmp2,ADCH; msb only
    sbi PORTB,_CLK; next pixel
    nop;
    cbi PORTB,_SI;
    ldi YL,LOW(sAdcbuf0);
    ldi YH,HIGH(sAdcbuf0);
    lds rmp3,sIdxb;
    tst rmp3;
  breq store_adc;
    ldi YL,LOW(sAdcbuf1);
    ldi YH,HIGH(sAdcbuf1);
  store_adc:
    lds rmp0,sIdxd;
    clr rmp1;
    add Yl,rmp0;
    adc YH,rmp1; index value
    st Y,rmp2; store in buffer
    inc rmp0;
    cpi rmp0,64;
  brne end_adc_int;
    sbi PORTB,_SI; restart reading on next cycle
    sts sFlag,rmp0; flag to main task
    com rmp3; swap buffers
    clr rmp0;
  end_adc_int: 
    sts sIdxd,rmp0; 
    sts sIdxb,rmp3; 
    cbi PORTB,_CLK;
    xpop0123Y;
  reti;

à 8MHz la routine d'IT dure 3,5µS la lecture complète demande 3,3ms avec un ADC tournant à 250KHz.
JR

[Kondelec]

super, merci pour ce travail

[jiherve]

re
si cela t’intéresses je peux te donner le code complet.
JR

[Kondelec]

Puisque tu le propose si gentiment je en dis pas non, mes connaissances en assembleur sont très limitées

[jiherve]

bonjour,
j'ai cru l'avoir envoyé samedi soir mais c'est apparemment passé à la trappe car trop long!

; ***********************************
; * test_adc                        *
; * for ATmega 328 on internal clock*
; * Version 1.0 by JRV              *
; ***********************************
;
.INCLUDE "m328Pdef.inc"

;====================================
;   Hardware connections
;=====================================
;                                  ___   ___
;              (PCINT14/RESET) PC6|1  |_| 28| PC5 (ADC5/SCL/PCINT13)
; RX             (PCINT16/RXD) PD0|2   A  27| PC4 (ADC4/SDA/PCINT12)
; TX             (PCINT17/TXD) PD1|3   T  26| PC3 (ADC3/PCINT11)
;               (PCINT18/INT0) PD2|4   M  25| PC2 (ADC2/PCINT10)
;          (PCINT19/OC2B/INT1) PD3|5   E  24| PC1 (ADC1/PCINT9)
;             (PCINT20/XCK/T0) PD4|6   L  23| PC0 (ADC0/PCINT8)
;                              VCC|7      22| GND
;                              GND|8   A  21| AREF
;          PCINT6/XTAL1/TOSC1) PB6|9   T  20| AVCC
;         (PCINT7/XTAL2/TOSC2) PB7|10  m  19| PB5 (SCK/PCINT5)
;            (PCINT21/OC0B/T1) PD5|11  e  18| PB4 (MISO/PCINT4)
;          (PCINT22/OC0A/AIN0) PD6|12  g  17| PB3 (MOSI/OC2A/PCINT3)
;               (PCINT23/AIN1) PD7|13  a  16| PB2 (SS/OC1B/PCINT2)   SI
;           (PCINT0/CLKO/ICP1) PB0|14     15| PB1 (OC1A/PCINT1)      CLK
;                                 |_________|
;===================================
;  Constants definitions
;===================================
;define processing clock frequency
#define _FREQ_ACT  8.0;in MHz
#define _FREQ_REG  8.0;in MHz
;define usefull constant
.EQU _NULL          = 0;
.EQU _DEBUG         = 1;
.EQU _ESC           = 0X1B;


;port configuration
.EQU _SI            = 2;port B
.EQU _CLK           = 1;port B
.EQU _TEST          = 0;port B

.EQU _RESET         = 6;port C

.EQU _TX_PIN        = 1;port D
.EQU _RX_PIN        = 0;port D


.EQU _DDRC          = 0;
.EQU _PORTC         = 1<<_RESET;
.EQU _DDRB          = 1 <<_CLK |1 <<_SI |1 << _TEST;
.EQU _PORTB         = 0x00;
.EQU _DDRD          = 1 <<_TX_PIN;
.EQU _PORTD         = 1 <<_RX_PIN|1<<_TX_PIN;

;USART configuration
.EQU _BAUD          = (((_FREQ_ACT*1000000)/(16*19200))+0.5)-1;
.EQU _UCSR0A        = 1<<TXC0;
.EQU _UCSR0B        = 0<<RXCIE0|0<<RXEN0|0<<TXCIE0|1<<UDRIE0|1<<TXEN0|0<<UCSZ02|0<<TXB80;
.EQU _UCSR0C        = 1<<UCSZ01|1<<UCSZ00;8 bits,none, asynchronous
.EQU _UBRR0H        = HIGH(_BAUD);
.EQU _UBRR0L        = LOW(_BAUD);

;ADC configuration
.EQU _ADC_PC0        = 0x00;
.EQU _ADC_PC1        = 0x01;
.EQU _ADC_PC2        = 0x02;
.EQU _ADC_PC3        = 0x03;
.EQU _ADC_PC4        = 0x04;
.EQU _ADC_PC5        = 0x05;
.EQU _ADC_TMP        = 0x08;
.EQU _ADC_GND        = 0x0F;
.EQU _ADC_REF        = 0<<REFS1|1<<REFS0;Vcc cap on aref
.EQU _ADC_DIV        = 0x05;divide by 32
.EQU _ADMUX          = _ADC_REF|_ADC_PC0|(1<<ADLAR);left justified
.EQU _ADCSRA         = 1<<ADEN|0<<ADSC|1<ADIF|1<< ADIE|1<<ADATE|_ADC_DIV;
.EQU _ADCSRB         = 0<<ACME|0<<ADTS2|0<<ADTS1|0<<ADTS0; convert timer 1 ovf
.EQU _ACSR           = 1<<ACD; disable analog compator;
.EQU _DIDR0          = 1<<_ADC_PC0;

;==========================================
;  Register definitions
;=========================================
;
.DEF rmp0          = R16 ;  Multi-purpose register
.DEF rmp1          = R17 ;  Multi-purpose register
.DEF rmp2          = R18 ;  Multi-purpose register
.DEF rmp3          = R19 ;  Multi-purpose register
.DEF rmp4          = R20 ;  Multi-purpose register
.DEF rmp5          = R21;   Multi-purpose register
.DEF rmp6          = R22 ;  Multi-purpose register
.DEF rmp7          = R23 ;  Multi-purpose register
.DEF rDelL         = R24 ;  delay counter LSB
.DEF rDelH         = R25 ;  delay counter MSB

.DEF rcp0          = R0  ;  computation registers
.DEF rcp1          = R1  ;  computation registers
.DEF rcp2          = R2  ;  computation registers
.DEF rcp3          = R3  ;  computation registers
.DEF rcp4          = R4  ;  computation registers
.DEF rcp5          = R5  ;  computation registers
.DEF rcp6          = R6  ;  computation registers
.DEF rcp7          = R7  ;  computation registers
.DEF rcp8          = R8  ;  computation registers
.DEF rcp9          = R9  ;  computation registers
.DEF rcp10         = R10 ;  computation registers
.DEF rcp11         = R11 ;  computation registers
.DEF rcp12         = R12 ;  computation registers
.DEF rcp13         = R13 ;  computation registers
.DEF rcp14         = R14 ;  computation registers
.DEF rcp15         = R15 ;  computation registers

;==========================
;   Macro  definitions
;==========================
.MACRO xpush0123X
    push rmp0;
    in rmp0,SREG ; save SREG
    push rmp0;
    push rmp1;
    push rmp2;
    push rmp3;
    push XH;
    push XL;
.ENDMACRO

.MACRO xpop0123X
    pop XL;
    pop XH;
    pop rmp3;
    pop rmp2;
    pop rmp1;
    pop rmp0;
    out SREG,rmp0; restore SREG
    pop rmp0;
.ENDMACRO

.MACRO xpush0123Y
    push rmp0;
    in rmp0,SREG ; save SREG
    push rmp0;
    push rmp1;
    push rmp2;
    push rmp3;
    push YH;
    push YL;
.ENDMACRO

.MACRO xpop0123Y
    pop YL;
    pop YH;
    pop rmp3;
    pop rmp2;
    pop rmp1;
    pop rmp0;
    out SREG,rmp0; restore SREG
    pop rmp0;
.ENDMACRO

.MACRO xdelay ;max is 65536µs*FREQ_REG/FREQ_ACT
    ldi rDelH,HIGH((@0*_FREQ_ACT)/_FREQ_REG)
    ldi rDelL,LOW((@0*_FREQ_ACT)/_FREQ_REG)
  rcall DelayZ
.ENDMACRO

.MACRO xprint_const ;
    ldi ZH,HIGH(2*@0); message address
    ldi ZL,LOW(2*@0);
  rcall print_const;
.ENDMACRO

.MACRO xprint_byte ;
    ldi YH,HIGH(@0); variable address
    ldi YL,LOW(@0);
    ldi rmp7,1;number of byte
  rcall print_uart;
.ENDMACRO

.MACRO xprint_word ;
    ldi YH,HIGH(@0); variable address
    ldi YL,LOW(@0);
    ldi rmp7,2;number of byte
  rcall print_uart;
.ENDMACRO

.MACRO xprint_triple ;
    ldi YH,HIGH(@0); variable address
    ldi YL,LOW(@0);
    ldi rmp7,3;number of byte
  rcall print_uart;
.ENDMACRO

.MACRO xprint_quad ;
    ldi YH,HIGH(@0); variable address
    ldi YL,LOW(@0);
    ldi rmp7,4; number of byte
  rcall print_uart;
.ENDMACRO



;============================================
; SRAM definitions
;============================================

.DSEG
.ORG Sram_Start
sCycle:       .BYTE 1;
sFlag:        .BYTE 1;
sIdxd:        .BYTE 1;
sIdxb:        .BYTE 1;
sAdcbuf0:     .BYTE 64;
sAdcbuf1:     .BYTE 64;

;USART
sBuf_uart:    .BYTE 32;
sByte_index:  .BYTE 1;
sBuf_flag:    .BYTE 1;



;=============================================
;  Reset and Interrupt Vectors starting here
;=============================================
;
.CSEG
.ORG $0000
;
; Reset/Intvectors
;
  jmp RESET ; Reset
    ;nop;
  reti ; EXT_INT0 ; IRQ0 Handler
    nop;
  reti ; EXT_INT1 ; IRQ1 Handler
    nop;
  reti ; PCINT0 ; PCINT0 Handler
    nop;
  reti ; PCINT1 ; PCINT1 Handler
    nop;
  reti ; PCINT2 ; PCINT2 Handler
    nop;
  reti ; WDT ; Watchdog Timer Handler
    nop;
  reti ; TIM2_COMPA ; Timer2 Compare A Handler
    nop;
  reti ; TIM2_COMPB ; Timer2 Compare B Handler
    nop;
  reti ; TIM2_OVF ; Timer2 Overflow Handler
    nop;
  reti ; TIM1_CAPT ; Timer1 Capture Handler
    nop;
  reti ; TIM1_COMPA ; Timer1 Compare A Handler
    nop;
  reti ; TIM1_COMPB ; Timer1 Compare B Handler
    nop;
  reti ; TIM1_OVF ; Timer1 Overflow Handler
    nop;
  reti ; TIM0_COMPA ; Timer0 Compare A Handler
    nop;
  reti ; TIM0_COMPB ; Timer0 Compare B Handler
    nop;
  reti ; TIM0_OVF ; Timer0 Overflow Handler
    nop;
  reti ; SPI_STC ; SPI Transfer Complete Handler
    nop;
  reti ; USART_RXC ; USART, RX Complete Handler
    nop;
  jmp USART_UDRE ;reti ; USART_UDRE ; USART, UDR Empty Handler
    ;nop;
  reti ; USART_TXC ; USART, TX Complete Handler
    nop;
  jmp ADC_INT;reti ; ADC ; ADC Conversion Complete Handler
    ;nop;
  reti ; EE_RDY ; EEPROM Ready Handler
    nop;
  reti ; ANA_COMP ; Analog Comparator Handler
    nop;
  reti ; TWI ; 2-wire Serial Interface Handler
    nop;
  reti ; SPM_RDY ; Store Program Memory Ready Handler
    nop;


;=================================
;  adc interrupt
;=================================


  ADC_INT:
    xpush0123Y;
    lds rmp2,ADCH; msb only
    sbi PORTB,_CLK; next pixel
    nop;
    cbi PORTB,_SI;
    ldi YL,LOW(sAdcbuf0);
    ldi YH,HIGH(sAdcbuf0);
    lds rmp3,sIdxb;
    tst rmp3;
  breq store_adc;
    ldi YL,LOW(sAdcbuf1);
    ldi YH,HIGH(sAdcbuf1);
  store_adc:
    lds rmp0,sIdxd;
    clr rmp1;
    add Yl,rmp0;
    adc YH,rmp1; index value
    st Y,rmp2; store in buffer
    inc rmp0;
    cpi rmp0,64;
  brne end_adc_int;
    sbi PORTB,_SI; restart reading on next cycle
    sts sFlag,rmp0; flag to main task
    com rmp3; swap buffers
    clr rmp0;
  end_adc_int:
    sts sIdxd,rmp0;
    sts sIdxb,rmp3;
    cbi PORTB,_CLK;
    xpop0123Y;
  reti;
;===============================================
;  Delays execution for 1 microseconds @ 8MHz
;===============================================
  DelayZ:
    nop;1
    nop;1
    nop;1
    nop;1
    sbiw rDelL,1 ; 2
  brne DelayZ ; 1/2
  ret;



;======================================
; UART transmit interrupt
;======================================

  USART_UDRE :
    xpush0123X
    ldi XH,HIGH(sBuf_uart);
    ldi XL,LOW(sBuf_uart);
    lds rmp0,sByte_index;
    sbrc rmp0,7;
  rjmp end_usart_txc;ignore while loading
    clr rmp1;
    add XL,rmp0;
    adc XH,rmp1;
    inc rmp0;
    sts sByte_index,rmp0;
    ld rmp0,X;
    tst rmp0;
  breq end_transmit;
    sts UDR0,rmp0;
  rjmp end_usart_txc;
  end_transmit:
    ldi rmp0,0x20;send space
    sts UDR0,rmp0;
    lds rmp0,UCSR0B;
    andi rmp0,~(1<<UDRIE0);
    sts UCSR0B,rmp0;
    clr rmp0;
    sts sBuf_flag,rmp0;done
    com rmp0;
    sts sByte_index,rmp0;
  end_usart_txc:
    xpop0123X;
  reti;
;===========================
; Uart xmit sub routine
;===========================

  put_char:
    ; Wait for empty transmit buffer
    lds rmp6,UCSR0A;
    sbrs rmp6,UDRE0;
  jmp put_char;
    ; Put data (r16) into buffer, sends the data
    sts UDR0,rmp4;
  ret;


  hex_to_asc:
    ldi rmp5,0x30;
    andi rmp4,0x0F;get nibble
    cpi rmp4,0x0A;
  brlo decimal
    ldi rmp5,0x37;
  decimal:
    add rmp4,rmp5;
  ret;

  print_uart:
    push XL;
    push XH;
  print_uart0:
    lds rmp4,sBuf_flag;
    tst rmp4;
  brne print_uart0;wait for xmit end
    ldi XH,HIGH(sBuf_uart);
    ldi XL,LOW(sBuf_uart);
  copy_buffer:
    ld rmp4,Y;
    swap rmp4;get upper nibble
  call hex_to_asc;
    st X+,rmp4;
    ld rmp4,Y+;
  call hex_to_asc;
    st X+,rmp4;
    dec rmp7;
  brne copy_buffer;
  close_buff:
    ldi rmp4,0x00;
    st X+,rmp4;
    sts sByte_index,rmp4;
    ldi rmp4,1;
    sts sBuf_flag,rmp4;
    lds rmp4,UCSR0B;
    ori rmp4,1<<UDRIE0;
    sts UCSR0B,rmp4;
    pop XH;
    pop XL;
  ret;

  print_const:
    push XL;
    push XH;
  print_const0:
    lds rmp4,sBuf_flag;
    tst rmp4;
  brne print_const0;wait for previous buffer empty
    ldi XH,HIGH(sBuf_uart);
    ldi XL,LOW(sBuf_uart);
  copy:
    lpm rmp4,Z+;
    st X+,rmp4;
    tst rmp4;
  brne copy;
  jmp close_buff;
;==========================
; Main Program Start
;==========================

  RESET:
  ; init ports
  ;port B
    ldi rmp0,_PORTB;
    out PORTB,rmp0;
    ldi rmp0,_DDRB;
    out DDRB,rmp0;
  ;port C
    ldi rmp0,_PORTC;
    out PORTC,rmp0;
    ldi rmp0,_DDRC;
    out DDRC,rmp0;
  ;port D
    ldi rmp0,_PORTD;
    out PORTD,rmp0;
    ldi rmp0,_DDRD;
    out DDRD,rmp0;
  ; set stack pointer
    ldi ZH,HIGH(RAMEND);
    ldi ZL,LOW(RAMEND);
    out SPL,ZL;
    out SPH,ZH;
    adiw ZL,1;
  ; init whole memory to zero
    ldi YH,HIGH(SRAM_START); Y point ram location
    ldi YL,LOW(SRAM_START);
    ldi rmp0,0;
  init_ram:
    st Y+,rmp0
    cp YL,ZL;
    cpc YH,ZH;
  brne init_ram;
  ;init clock divider
    ldi rmp0,0x9D;
    sts OSCCAL,rmp0;


;init ADC and Comparator
    ldi rmp0,_ADMUX;
    sts ADMUX,rmp0;
    ldi rmp0,_ADCSRA;
    sts ADCSRA,rmp0;
    ldi rmp0,_ADCSRB;
    sts ADCSRB,rmp0;
    ldi rmp0,_ACSR;
    sts ACSR,rmp0;
    ldi rmp0,_DIDR0;
    sts DIDR0,rmp0;



  ;init USART for _DEBUG
  .IF _DEBUG == 1;
    ldi rmp0,_UCSR0A;
    sts UCSR0A,rmp0;
    ldi rmp0,_UCSR0B;
    sts UCSR0B,rmp0;
    ldi rmp0,_UCSR0C;
    sts UCSR0C,rmp0;
    ldi rmp0,_UBRR0H;
    sts UBRR0H,rmp0;
    ldi rmp0,_UBRR0L;
    sts UBRR0L,rmp0;
  .ENDIF
  ;enable interrupt
    sei;

 .IF _DEBUG == 1;
    ldi rmp0,0x23;activate UART
    sts UDR0,rmp0;
    xprint_const home;
    xprint_const clear_screen;
    xprint_const crlf;
    xprint_const prompt;
    xprint_const prompt1;
    xprint_const crlf;
 .ENDIF
;============================
;      Main
;============================
    ldi rmp0,_ADCSRA |1 << ADSC; start adc
    sts ADCSRA,rmp0;

  Main:
    lds rmp0,sFlag;
    tst rmp0;
  breq main;
    xprint_byte sFlag;
  jmp main;
  Prompt:
  .DB "  JRV me fecit",_NULL;
  Prompt1:
  .DB "   annus MMXXIII",_NULL;
  crlf:
  .DB '\r','\n',_NULL;
  home :
  .DB _ESC,"[1,1H",_NULL;
  clear_screen:
  .DB _ESC,"[2J",_NULL;

malgré les balise c'est déformaté par endroits , c'est du brut de fonderie mais fonctionnel.
cela se compile avec AVRstudio.
JR

[Kondelec]

Un grand merci pour ce travail