Répondre à la discussion
Affichage des résultats 1 à 23 sur 23

Projet : Mesurage d'angle



  1. #1
    jiherve

    Projet : Mesurage d'angle


    ------

    Bonjour,
    une petite bidouille utilisant un Atmega8A et un convertisseur synchro numérique pour acquérir et visualiser un angle capté par un resolver.
    C'est pour faire un diviseur sur un tour.
    Nom : angle_meter.jpg
Affichages : 243
Taille : 200,5 Ko

    le pont de Wien n'est pas de moi , je l'ai juste corrigé car le schéma original n'est pas fonctionnel.
    Beaucoup de fond de tiroirs.

    si cela interresse j'ai aussi le soft.
    JR

    -----
    Dernière modification par jiherve ; 09/08/2014 à 20h18.
    l'électronique c'est pas du vaudou!

  2. Publicité
  3. #2
    luc_1049

    Re : Projet : Mesurage d'angle

    bonjour

    Pourriez vous préciser quel capteur d'inclinaison vous utilisez ?
    Tout simplement un disque percé avec un capteur à photorésistance ?
    cdlt

  4. #3
    DAUDET78

    Re : Projet : Mesurage d'angle

    Sur le plan hard .... y a des choses pas trop légales !
    J'aime pas le Grec

  5. #4
    jiherve

    Re : Projet : Mesurage d'angle

    Bonjour
    Le capteur c'est un resolver :http://en.wikipedia.org/wiki/Resolver_%28electrical%29.
    @Daudet : tu veux sans doute parler des diodes qui assurent une forme de multiplexage sur le port D, rien de bien illégal compte tenu du VIL de l'Atmega à 1V (le 139 est un HC) et de la forte valeur du pull up, déjà classique sur ZX81 !
    Le soft inclue des délais pour tenir compte de la lenteur du bus.
    A moins que cela ne soit la capa (énergie stockée 1,25 µJ)sur le reset dont je sais que cela te donne des furoncles?
    JR
    l'électronique c'est pas du vaudou!

  6. A voir en vidéo sur Futura
  7. #5
    DAUDET78

    Re : Projet : Mesurage d'angle

    Y a pas que ça ....
    PS : Il y a des valeurs illisibles :
    R12= ?
    C'est quoi le chip en bas à gauche ?
    J'aime pas le Grec

  8. #6
    jiherve

    Re : Projet : Mesurage d'angle

    Bonsoir,
    Le composant en bas à gauche est un convertisseur synchro numérique DDC serie HSDC8915, là un 8920, composant obsolète mais efficace pour cette application.
    Pour le valeurs illisibles je n'y peux pas grand chose car le format. SCH n'est pas admis ici.
    R12 comme ses petites sœurs fait 18K , pourquoi , et bien par ce que c’était la valeur que j'avais en quantité suffisante sous la main, accessoirement les transistors ne sont pas des BC237 mais deux réseaux de transistors Texas ayant vieilli 40 ans en fut de chêne, et dont bien sur il n'existe pas de symbole kicad.
    Ceci dit qu'est ce qui te chagrines?
    JR
    l'électronique c'est pas du vaudou!

  9. Publicité
  10. #7
    DAUDET78

    Re : Projet : Mesurage d'angle

    Le 741, si c'est un schéma de 1980 ... OK
    Par contre le BC237 en sortie du 741, Il manque une diode en inverse pour éviter de faire passer la jonction BE en avalanche

    18K pour saturer les BC237 , c'est un peu juste . Il a un gain de 20 en saturation. Le 4511 peut sortir , alimenté en 5V, une vingtaine de mA au niveau haut
    J'aime pas le Grec

  11. #8
    jiherve

    Re : Projet : Mesurage d'angle

    bonjour,
    741 fond de tiroirs pour amplifier du sinus à 400Hz c'est suffisant et comme précisé ce ne sont pas des 237 mais des BF93N, il passe moins de 10 ma par segment mais avec des 237 cela serait un peu juste effectivement , le 511 ne peut pas driver des afficheurs anodes communes seulement des cathodes communes d'où toute cette glue.
    Le seul composant récent c'est le µC, tout le reste date du siècle dernier, j'ai rapatrié, avec l'accord écrit de mon employeur of course(bien content de s'en débarrasser), mes vieux composants lorsque j'ai pris ma retraite début avril (il y en avait deux armoires basses pleines, j'ai beaucoup donné à un IUT) , il y a donc des pièces datant fin 60's et toujours fonctionnelles, et je m'occupe.
    JR
    Dernière modification par jiherve ; 14/08/2014 à 15h50.
    l'électronique c'est pas du vaudou!

  12. #9
    luc_1049

    Re : Projet : Mesurage d'angle

    Bonjour

    Je ne connaissais pas ce type de capteur plutôt électrotechnique et analagique que pure électronique numérique.

    Soit mais à qu'elle précision vous attendez vous ?
    Physiquement qu'elle taille a-t-il en terme de diamètre, autrement dit les bobines sont grandes ou pas, même si je pense qu'elle doivent être proches pour le couplage.

    Un codeur optique nécessite s'il est fait maison un disque de grand diamètre pour s'affranchir de l'erreur de perçage sur la circonférence du disque. Ici votre résolveur est il un produit encore d'actualité facilement approvisionnable ou un composant de votre stock ou mieux fait maison DIY ?
    S'il est acheté est un modèle à transformateur tournant pour s'affranchir des balais (cf wikipédia) ?

    cdlt luc_1049

  13. #10
    jiherve

    Re : Projet : Mesurage d'angle

    Bonsoir
    C'est un resolver taille 8 (diamètre 19mm,longueur 31,5mm) TH-CSF DEM, issu de mes stocks, la précision 5 minutes d'angle soit un peu plus que 12 bits sur un tour, le convertisseur fournit 14 bits.
    Pour information c'est toujours utilisé , on n'a jamais fait mieux dans ce volume, c'est inusable il n'y a pas de balais,et très robuste,par contre c'est assez cher car difficile à fabriquer, c'est hors de portée du DIY, sur le modèle utilisé, de mémoire, le fil fait aux alentours de 9/100.
    JR
    l'électronique c'est pas du vaudou!

  14. #11
    Yvan_Delaserge

    Re : Projet : Mesurage d'angle

    Bonjour,

    J'avais zappé ce fil lorsqu'il est paru début août.

    Le montage m'intéresse, parce que je possède des synchro/resolvers que j'avais récupéré sur un radar météo il y a une vingtaine d'années.

    Dans ce matériel, l'affichage de l'angle se fait sur des 7 segments à LED, mais le module qui réalise la lecture des resolvers et l'affichage est moulé dans de la résine. Même la doc du radar ne montre pas le schéma. Donc à l'époque j'avais pas mal réfléchi pour savoir comment cela pouvait bien fonctionner. Ce qui est exclu, c'est la présence d'un microcontrôleur, car le radar datait des années 70.

    Merci de partager ce montage avec nous, jiherve.

    De mémoire, un synchro/resolver est basé sur le principe suivant:
    On a une bobine émettrice, dans laquelle circule du 400 Hz (ou autre) d'amplitude constante.
    On a 3 bobines réceptrices autour de l'émettrice, décalées de 120 degrés.
    En fonction de l'angle avec l'émettrice, chaque réceptrice verra apparaître à ses bornes un signal d'amplitude différente. Maximal si elle se trouve alignée avec l'émettrice. Minimal si l'angle entre émettrice et réceptrice est de 90 degrés.
    La bobine émettrice est reliée à un axe qui peut pivoter sur 360 degrés. Elle est alimentée via un slipring. Les 3 réceptrices sont fixes.
    A chaque position angulaire de l'axe, va correspondre une constellation de valeurs unique, aux bornes des 3 réceptrices.

    Ce dispositif de conception très simple permet une lecture absolue de la position angulaire de l'axe mobile, avec une précision étonnante. Le seul contact électrique est utilisé pour l'alimentation de l'émettrice. En cas de contact électrique imparfait du slipring, la précision est préservée, car l'erreur de lecture est la même sur les 3 réceptrices.

    Comment fonctionne ton montage Jhervé?

    J'imagine que tu pratiques un redressement sans seuil du signal des 3 réceptrices et que tu compares les 3 résultats avec une table de valeurs dans le microcontrôleur? Ou bien est-ce que ce dernier réalise un calcul, suivi d'une interpolation et d'une conversion puis de l'affichage sur les 7-segments?

    L'image est un peu à la limite du lisible, pour des raisons de résolution. Peux-tu nous en dire plus?

    Merci d'avance.

    Amicalement,

    Yvan
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  15. #12
    jiherve

    Re : Projet : Mesurage d'angle

    Bonjour,
    Comme déja dit ce montage utilise un composant dédié HSDC-8920 dont le principe n'est pas un redressement des signaux , c'est grosso modo un resolver numérique asservi par les signaux d'entrée, il fourni directement la valeur angulaire codée sur 14 bits 359,999° = 0x3FFF.
    Ce composant n'est pas très courant, c'est un hybride DDC obsolet, il en existe cependant des équivalents monolithique chez AD :http://www.analog.com/en/analog-to-d...cts/index.html.
    On peut faire autrement avec une démodulation synchrone des signaux sinus et cosinus issus du resolver (si synchro l'idéal est de disposer d'un transfo de Scott pour effectuer le passage triphasé vers diphasé).
    Les résultats, filtrés, de la démodulation sont codés en numériques il suffit ensuite d'effectuer une conversion rectangulaire vers polaire pour récupérer l'angle et le module. Cela se faisait assez facilement avec des petites UC séries utilisant l'algorithme CORDIC (conçu à cet effet), aujourd'hui n'importe quel petit µC peut le faire, l'algorithme n'utilisant que des additions, soustraction , décalages avec bien sur des compteurs de boucle.
    L'ensemble peut donc être réalisé au moyen de quelques AOP et switch analogique et d'un petit ATMEL ou PIC.
    JR
    l'électronique c'est pas du vaudou!

  16. Publicité
  17. #13
    Yvan_Delaserge

    Re : Projet : Mesurage d'angle

    Merci pour la référence Analog Devices. S'ils ont pris la peine de commercialiser des IC et même un circuit de référence pour une famille de convertisseurs synchro/resolver vers digital, c'est que ces composants doivent être encore largement utilisés de nos jours et n'ont pas été supplantés par des codeurs optiques.

    OK pour l'algorithme CORDIC, je me demandais à l'époque comment Hewlett-Packard avait fait pour produire des calculettes avec les fonctions trigonométriques.

    Le délai que mettait le résultat à s'afficher était dû à la série d'itérations.
    Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)

  18. #14
    jiherve

    Re : Projet : Mesurage d'angle

    Bonsoir,
    en effet les machines tournantes sont encore largement utilisées, car c'est à la fois trés robuste et précis.
    JR
    l'électronique c'est pas du vaudou!

  19. #15
    jiherve

    Re : Projet : Mesurage d'angle

    Bonsoir,
    j'exhume un de mes vieux sujet pour proposer un petit convertisseur Resolver vers Digital de mon cru.
    J'ai cherché à faire le plus simple et le plus petit possible en n'employant que des composants courants, ce qui n’était pas le cas du montage en #1.
    Bien sur la précision ne sera pas la même car la conversion Resolver vers Digital repose sur une mesure des tensions crête des signaux sinus et cosinus, ensuite on effectue par logiciel un changement de coordonnée cartésiennes (X,Y)=> (Theta,Rho).
    La référence 400Hz est produite par une PWM à 14400 Hz issue du TIMER1, il y a donc 36 échantillon par période, ils sont filtrés par un passe bas structure S&K coupant à 400Hz et ayant un gain d'environ 2.
    Les signaux d'entrée sont adaptés par des étages inverseurs (gain environ 1) polarisés à mi tension; le codage est bien sur fait de façon alternée par l'ADC interne de l'Atiny45 l'instant d'échantillonnage est déterminé par le TIMER0 qui est calé sur 400Hz .Si cela intéresse je fournirai plus de détails par la suite.
    La sortie digitale est effectuée par un pseudo UART @14400kBds et transmet en série des groupe de 5 octets qui sont les valeurs hexadécimales codées ASCCII de l'angle et du module, la trame est :
    Angle,Module,Angle,Module,.... ..., CR au bout de 8 doublets ; C'est pour afficher proprement sur Teraterm
    donc le schéma:
    Nom : Reolver to digital.jpg
Affichages : 121
Taille : 90,0 Ko
    J'ai bidouillé avec ce que j'avais sous la main et les AOP qui sont des MCP6021 et MCP6022 sont luxueux pour du 400Hz(et un peu instables en gain unité), n'importe quel Rail to Rail IN/OUT mono tension peut être utilisé.
    Pour prévenir une question je précise qu'il est possible d'utiliser un redressement synchrone, cela sera moins sensible au bruit mais c'est plus encombrant, 2 AOP supplémentaires + résistances ad hoc et un switch analogique DPDT.
    JR
    l'électronique c'est pas du vaudou!

  20. #16
    jiherve

    Re : Projet : Mesurage d'angle

    Bonsoir,
    Voila le code en assembleur, les commentaires sont en anglais car il est difficile de se défaire d'habitudes vieilles de 40ans .
    il est coupé en 5 pour que le forum l'accepte.
    les declarations diverses
    Code:
    ; *******************************************************************************************************************
    ; * SYNCHRO/RESOLVER controler                                                                                      *
    ; * for ATiny85 on internal clock                                                                                   *
    ; * Version 1.0 by JRV                                                                                              *
    ; *******************************************************************************************************************
    .INCLUDE "tn45def.inc"
    
    
    ; ====================================================================================================================
    ;           Hardware connections
    ; ====================================================================================================================
    ;                                                                    ___   ___
    ;                   (PCINT5/RESET/ADC0/dW) PB5   |1  |_|  8| VCC
    ; SIN (PCINT3/XTAL1/CLKI/#OC1B/ADC3) PB3 |2   A   7| PB2 (SCK/USCK/SCL/ADC1/T0/INT0/PCINT2)        TX    
    ; COS  (PCINT4/XTAL2/CLKO/OC1B/ADC2) PB4 |3   T   6| PB1 (MISO/DO/AIN1/OC0B/OC1A/PCINT1)           PWM   
    ;                                                            GND |4   M   5| PB0 (MOSI/DI/SDA/AIN0/OC0A/#OC1A/AREF/PCINT0) SPL    
    ;                                                                   |______ |
    ;
    ;
    ; ===================================================================================================================
    ;define processing clock frequency
    #define FREQ_ACT  7.3728;in MHz
    #define FREQ_REG  8.0;in MHz
    ;define usefull constants
    .EQU _KCORDIC                  = 65536.0*0.6072; scale factor for modulus
    ; define ports
    .EQU _RESET                   = 5; port B
    .EQU _COS                     = 4; port B Cosine input
    .EQU _SIN                     = 3; port B Sine input or potentiometer for frequency calibration
    .EQU _TX                      = 2; port B as ouput 14400 Bds Digital output Theta,Rho,... CR after 8 pairs; as input frequency calibration request
    .EQU _PWM                     = 1; port B PWM for 400Hz reference generation goes to 2nd order S&K low pass filter
    .EQU _SPL                     = 0; port B Debug signal leading edge is cos sampling , falling edge is end of calculation
    
    
    ;port configuration
    .EQU _PORTB_DIR               = 1<<_PWM|1<<_SPL; 
    .EQU _PORTB_DAT               = 1<<_RESET|1<<_TX|1<<_SPL; pull up 
    
    ;Timer0 configuration
    .EQU _CLK0                     = 0x4;divide by 256
    .EQU _MODE0                    = 7; fast PWM mode
    .EQU _TCCR0A                   = 0<<COM0A1|0<<COM0A0|0<<COM0B1|0<<COM0B0|(_MODE0 & 0x3); 
    .EQU _TCCR0B                   = 0<<FOC0A|0<<FOC0B|((_MODE0 & 0x4)>>2)<<WGM02|_CLK0 ; 
    .EQU _OCR0A                    = 71; Period is 400Hz
    .EQU _OCR0B                    = 27;
    
    ;Timer1 configuration
    .EQU _CLK1                     = 0x2;divide by 2
    .EQU _MODE1                    = 0;
    .EQU _TCCR1                    = _MODE1<<CTC1|1<<PWM1A|1<<COM1A1|0<<COM1A0|_CLK1; PWM activated
    .EQU _OCR1A                    = 128;
    .EQU _OCR1B                    = 128;
    .EQU _OCR1C                    = 255; 14,4khz
    
    ;common
    .EQU _TIMSK                    = 0<<OCIE1A|0<<OCIE1B|0<<OCIE0A|0<<OCIE0B|1<<TOIE1|1<<TOIE0; 
    .EQU _TIFR                     = 0<<OCF1A|0<<OCF1B|0<<OCF0A|0<<OCF0B|1<<TOV1|1<<TOV0 ;
    .EQU _GTCCR                    = 0<<TSM|0<<PWM1B|0<<COM1B1|0<<COM1B0|0<<FOC1B|0<<FOC1A|0<<PSR1|0<<PSR0;
        
    ;ADC configuration
    
    .EQU _ADCSRA                   = 1<< ADEN|0<< ADSC|1<< ADATE|1<< ADIF|1<< ADIE |1<< ADPS2|1<< ADPS1|0<< ADPS0;115.2kHz 
    .EQU _ADCSRB                   = 0<<BIN|0<<ACME|0<<IPR|1<<ADTS2|0<<ADTS1|1<<ADTS0; compb  
    .EQU _ADMUXSIN                 = 0<<REFS1|0<<REFS0|0<<ADLAR|0<<REFS2|0<<MUX3|0<<MUX2|1<<MUX1|1<<MUX0;VCC input SIN right justified
    .EQU _ADMUXCOS                 = 0<<REFS1|0<<REFS0|0<<ADLAR|0<<REFS2|0<<MUX3|0<<MUX2|1<<MUX1|0<<MUX0;VCC input COS right justified
    .EQU _ADMUXGND                 = 0<<REFS1|0<<REFS0|0<<ADLAR|0<<REFS2|1<<MUX3|1<<MUX2|0<<MUX1|0<<MUX0;VCC input GND right justified
    .EQU _ADMUXREF                 = 0<<REFS1|0<<REFS0|0<<ADLAR|0<<REFS2|1<<MUX3|0<<MUX2|0<<MUX1|0<<MUX0;VCC input REF right justified
    .EQU _DIDR0                    = 0<<ADC0D|1<<ADC2D|1<<ADC3D|0<<ADC1D|0<<AIN1D|0<<AIN0D ; 
    
    ;comparator configuration
    .EQU _DIDR1                    = 0; 
    .EQU _ACSR                     = 1<< ACD; disabled
    ;====================================================================================================================
    ;                                          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 for put_hex
    .DEF rmp5          = R21;   Multi-purpose register for put_hex
    .DEF rmp6          = R22 ;  Multi-purpose register for put_hex
    .DEF rmp7          = R23 ;  Multi-purpose register 
    .DEF rDelL         = R24 ;  delay counter LSB
    .DEF rDelH         = R25 ;  delay counter MSB
    
    
    
    ;====================================================================================================================
    ;                                           Macro  definitions
    ;====================================================================================================================
    .MACRO xpush0123
        push rmp0;2 cycles
        push rmp1;2 cycles
        push rmp2;2 cycles
        push rmp3;2 cycles
        in rmp0,SREG ; save SREG 1 cycle
        push rmp0;2cycles
    .ENDMACRO
    
    .MACRO xpop0123
        pop rmp0;
        out SREG,rmp0; restore SREG
        pop rmp3;
        pop rmp2;
        pop rmp1;
        pop rmp0;
    .ENDMACRO
    
    .MACRO xpush01Z
        push rmp0;
        push rmp1;
        push ZL;
        push ZH;
        in rmp0,SREG ; save SREG
        push rmp0;
    .ENDMACRO
    
    .MACRO xpop01Z
        pop rmp0;
        out SREG,rmp0; restore SREG
        pop ZH;
        pop ZL;
        pop rmp1;
        pop rmp0;
    .ENDMACRO
    
    .MACRO xpush0
        push rmp0;
        in rmp0,SREG ; save SREG
        push rmp0;
    .ENDMACRO
    
    .MACRO xpop0
        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
    
    
    ; ===================================================================================================================
    ;                                              SRAM definitions
    ; ===================================================================================================================
    ;
    .DSEG
    .ORG Sram_Start
      sPhasecal:      .BYTE 1;Phase calibration counters
      sPhase:         .BYTE 1;Current phase
      sOsccal:        .BYTE 2;Frequency calibration counters
      sMid_sin:       .BYTE 2;Offset value for sine
      sMid_cos:       .BYTE 2;Offset value for cosine
      sAdc_gnd:       .BYTE 2;Ground value , unused
      
      sTab_idx:       .BYTE 2; pointer to sin value 
      sSin_cos:       .BYTE 1; selection bit 
      sAdc_sin:       .BYTE 2; Measured sine value
      sAdc_cos:       .BYTE 2; Measured cosine value
      sAdc_flag:      .BYTE 1; Handshake flag :main => ADC interrupt
      sXmit_flag:     .BYTE 1; Handshake flag :main => TIMER1 OVF interrupt
      sTheta:         .BYTE 2; Obvious
      sRho:           .BYTE 2;   ""
      sCrho:          .BYTE 2*(_OCR0A+1)/3;Phase search buffer
      sAff:           .BYTE 5; Scrath pad for ASCII string
      sNum:           .BYTE 1; messages counter
    .ESEG
    .ORG $0000
    eValidity:        .BYTE 1; Validity for frequency 
    eOsc_val:         .BYTE 1; Value of frequency
    
    ; ===================================================================================================================
    ;                           Reset and Interrupt Vectors starting here
    ; ===================================================================================================================
    ;
    .CSEG
    .ORG $0000
    ;
    ;
    ; Reset/Intvectors
    ;
      rjmp RESET ; reti; rjmp RESET ; Reset Handler
      reti; rjmp EXT_INT0 ; IRQ0 Handler
      reti; rjmp PCINT0 ; PCINT0 Handler
      reti; rjmp TIM1_COMPA ; Timer1 CompareA Handler
      rjmp TIM1_OVF ;reti; rjmp TIM1_OVF ; Timer1 Overflow Handler
      rjmp TIM0_OVF ;reti; rjmp TIM0_OVF ; Timer0 Overflow Handler
      reti; rjmp EE_RDY ; EEPROM Ready Handler
      reti; rjmp ANA_COMP ; Analog Comparator Handler
      rjmp ADC_INT ;reti; rjmp ADC_INT ; ADC Conversion Handler
      reti; rjmp TIM1_COMPB ; Timer1 CompareB Handler  
      reti; rjmp TIM0_COMPA ;
      reti; rjmp TIM0_COMPB ;
      reti; rjmp WDT ;
      reti; rjmp USI_START ;
      reti; rjmp USI_OVF ;
    l'électronique c'est pas du vaudou!

  21. #17
    jiherve

    Re : Projet : Mesurage d'angle

    Re
    les sous programmes d'interruptions:
    Code:
    ;===================================================================================================================
    ;                                  Interrupt Service Routines
    ;===================================================================================================================
    TIM0_OVF:
        xpush0;
        ldi rmp0,0;
        sts sTab_idx+1,rmp0; synchronize sin generator
        xpop0;
      reti;
    
    TIM1_OVF:
        xpush01Z;
        lds ZH,sTab_idx;
        lds Zl,sTab_idx+1;
        lpm rmp0,Z+; pwm value
        out OCR1A,rmp0;update register
        cpi ZL,36;max index value
      brlo store_z;
        clr ZL;
      store_z:;
        sts sTab_idx,ZH;update index
        sts sTab_idx+1,Zl;
        lds rmp0,sOsccal+1;check for frequency calibration
        cpi rmp0,0xFF;
      brlo test_pin ; calibration running
        lds rmp0,sXmit_flag;
        tst rmp0;
      breq end_tim1_ovf; nothing to send
        mov rmp1,rmp0;
        andi rmp1,0x0F; lsb are bits counter
        cpi rmp1,9;
      brlo bit_shift;
        cbi PORTB,_TX;start bit
      rjmp dec_bits;
      bit_shift:
        tst rmp1;
      breq stop_bit; counter is zero send stop bit
        mov rmp1,rmp0;
        swap rmp1;
        andi rmp1,0x0F;get address of ASCII byte
        subi rmp1,1;
        ldi ZH,HIGH(sAff);
        ldi ZL,LOW(sAff);
        add ZL,rmp1;
        ldi rmp1,0;
        adc ZH,rmp1;
        ld rmp1,Z;read ASCII byte
        sbrc rmp1,0;
        sbi PORTB,_TX; lsb is one set _TX pin
        sbrs rmp1,0;
        cbi PORTB,_TX; lsb is zero clear _TX pin
        lsr rmp1;shift data
        st Z,rmp1; store 
      dec_bits:;
        dec rmp0;update counter
      end_tim1_ovf:;
       sts sXmit_flag,rmp0; store counter
        xpop01Z;
      reti;
      
      stop_bit:
        sbi PORTB,_TX;
        subi rmp0,0x10;
      brne next_byte;not finished
      test_pin:
        cbi DDRB,_TX; deactivate output;
        nop;
        nop;
        in rmp1,PINB;get input value, if zero then calibrate clock
        sbrc rmp1,_TX;
        sec;
        sbrs rmp1,_TX;
        clc;
        lds rmp1,sOsccal+1;
        rol rmp1;filtering of pin state
        sts sOsccal+1,rmp1;
      rjmp end_tim1_ovf;finished
      next_byte:;
        ori rmp0,9; reload bit counter
      rjmp end_tim1_ovf; 
      
      
      
    ADC_INT:
        xpush0123;
        lds rmp0,sAdc_flag;
        tst rmp0;
      brne end_adc_int;if not read ignore new values
        in rmp2,ADCL;
        in rmp3,ADCH;
        lds rmp0,sSin_cos;test sin cos flag
        tst rmp0;
      brne store_cos;
        sts sAdc_sin+0,rmp3;
        sts sAdc_sin+1,rmp2;
        ldi rmp1,_ADMUXCOS;prepare for next conversion
      rjmp adc_int0;
      store_cos: 
        sts sAdc_cos+0,rmp3;
        sts sAdc_cos+1,rmp2;
        sts sAdc_flag,rmp0; set flag for angle calculation
        sbi PORTB,_SPL
        ldi rmp1,_ADMUXSIN;prepare for next conversion
      adc_int0:;   
        out ADMUX,rmp1;update mux
        com rmp0;
        sts sSin_cos,rmp0; toggle sin/cos
      end_adc_int:
        in rmp1,TIFR;
        ori rmp1,1<<OCF0B;
        out TIFR,rmp1; erase OCF0B flag
        xpop0123;
      reti;
    l'électronique c'est pas du vaudou!

  22. #18
    jiherve

    Re : Projet : Mesurage d'angle

    Re
    les sous programmes mathématiques et autres:
    ATAN est l'equivalent d'ATAN2 c'est l'algo Cordic canonique.La multiplication est la méthode basique
    Code:
    ; ===================================================================================================================
    ; 16 bits ATAN ,entry in rmp0,rmp1=x/rmp2,rmp3=y/rmp4 output in rmp0,rmp1=theta/rmp2,rmp3=rho
    ; ===================================================================================================================
      .DEF regx0  = R0  ;  cordic reg x lsb
      .DEF regx1  = R1  ;  cordic reg x 
      .DEF regy0  = R2  ;  cordic reg y lsb
      .DEF regy1  = R3  ;  cordic reg y
      .DEF regz0  = R4  ;  cordic reg z lsb
      .DEF regz1  = R5  ;  cordic reg z  
      .DEF regc0  = R6  ;  cordic reg z lsb
      .DEF regc1  = R7  ;  cordic reg z  
      .DEF rquad  = R8  ;  angle quadrant
     
      ashift_right_y:
        movw regc0,regy0;
      rcall ashift_right;
      ret;
      
      ashift_right_x:
        movw regc0,rmp0;
      rcall ashift_right;
      ret;
      
      ashift_right:
        mov rmp7,rmp6;
        tst rmp7;
      loop_shift:
      brne shift_one_place
      ret;
      
      shift_one_place:
        asr regc1;
        ror regc0;
        dec rmp7;
      rjmp loop_shift; 
      
      load_constant:
        mov rmp0,rmp6;copy index
        lsl rmp0;
        clr rmp1;
        ldi ZH,HIGH(2*tab_cordic); 
        ldi ZL,LOW(2*tab_cordic);
        add ZL,rmp0;
        adc ZH,rmp1;
        lpm regc0,Z+;load constant
        lpm regc1,Z;
      ret;
      
      atan:
        push rmp4;
        push rmp5;
        push rmp6;
        push rmp7;
        ;reduce to first quadrant
        movw regx0,rmp0; copy in arithmetic register
        clr rquad;
        tst regx1;
      brpl good_x;
        com regx0;
        com regx1;
        ldi rmp0,1;
        or rquad,rmp0;flag for output
        clr rmp1;
        add regx0,rmp0;
        adc regx1,rmp1;-x
      brpl good_x; value was not 0x8000
        ldi rmp0,0xFF;
        ldi rmp1,0x7F;
        movw regx0,rmp0;
      good_x:  
        movw regy0,rmp2; 
        tst regy1;
      brpl good_y;
        com regy0;
        com regy1;
        ldi rmp0,2;
        or rquad,rmp0;flag for output
        ldi rmp0,1;
        clr rmp1;
        add regy0,rmp0;
        adc regy1,rmp1;-y
      brpl good_y; value was not 0x8000
        ldi rmp0,0xFF;
        ldi rmp1,0x7F;
        movw regy0,rmp0;
      good_y: 
       clr regz0; 
       clr regz1; 
       clr rmp6; step
      atan_loop:
        tst regy1;
      brmi negative;
        movw rmp0,regx0; save x
        ;x <= x + asr(y,step)
      rcall ashift_right_y;
        add regx0,regc0;
        adc regx1,regc1;
        ;y <= y - asr(x,step);
      rcall ashift_right_x;
        sub regy0,regc0;
        sbc regy1,regc1;
        ;z <= z + tab_cordic(step);
      rcall load_constant;
        add regz0,regc0;
        adc regz1,regc1;
        inc rmp6;
        cpi rmp6,16;
      brlo atan_loop;
      rjmp atan_adjust;
      negative:
        movw rmp0,regx0;save x
        ;x <= x - asr(y,step);
      rcall ashift_right_y;
        sub regx0,regc0;
        sbc regx1,regc1;
       ;y <= y + asr(x,step);
      rcall ashift_right_x;
        add regy0,regc0;
        adc regy1,regc1;
        ;z <= z - tab_cordic(step));
      rcall load_constant;
        sub regz0,regc0;
        sbc regz1,regc1;
        inc rmp6;
        cpi rmp6,16;
      brlo atan_loop;
      atan_adjust:
        ;restore correct quadrant
        movw rmp2,regz0;
        mov rmp4,rquad;
        clr rmp0;
        clr rmp1;
        lsr rmp4;
        eor rmp4,rquad;
        sbrc rquad,0; first and fourth quadrant
        ldi rmp1,0x80;
        sbrc rmp4,0; first and third quadrant
        sub rmp0,rmp2;
        sbrc rmp4,0;first and third quadrant
        sbc rmp1,rmp3;
        sbrs rmp4,0; second and fourth
        add rmp0,rmp2;
        sbrs rmp4,0;second and fourth
        adc rmp1,rmp3;
        movw rmp2,regx0;
        pop rmp7;
        pop rmp6;
        pop rmp5;
        pop rmp4;
      ret;
    
      tab_cordic:
      .DW 8192,4836,2555,1297,651,326,163,81,41,20,10,5,3,1,1,0
    .UNDEF regx0 ;
    .UNDEF regx1 ;
    .UNDEF regy0 ;
    .UNDEF regy1 ;
    .UNDEF regz0 ;
    .UNDEF regz1 ;
    .UNDEF regc0 ;
    .UNDEF regc1 ;
    .UNDEF rquad ;
    
    ;====================================================================================================================
    ;                                   Delays execution for 1 microseconds @ 8MHz
    ;====================================================================================================================
      DelayZ:
        nop;1
        nop;1
        nop;1
        nop;1
        sbiw rDelL,1 ; 2
        brne DelayZ ; 1/2
      ret;
    ;====================================================================================================================
    ;                                           EEPROM read and write
    ;====================================================================================================================
    
      EEPROM_read:
      ; Wait for completion of previous write
      sbic EECR,EEPE
      rjmp EEPROM_read
      ; Set up address (XH:XL) in address register
      out EEARH, XH;
      out EEARL, XL;
      ; Start eeprom read by writing EERE
      sbi EECR,EERE;
      ; Read data from data register
      in rmp2,EEDR;
      ret;
      
    EEPROM_write:
      ; Wait for completion of previous write
      sbic EECR,EEPE;
      rjmp EEPROM_write;
      ; Set Programming mode
      ldi rmp1, (0<<EEPM1)|(0<<EEPM0);
      out EECR, rmp1;
      ; Set up address (XH:XL) in address register
      out EEARH, XH;
      out EEARL, XL;
      ; Write data (rmp2) to data register
      out EEDR, rmp2;
      ; Write logical one to EEMPE
      sbi EECR,EEMPE;
      ; Start eeprom write by setting EEPE
      sbi EECR,EEPE;
      ret;
      
    ; ===============================================================================================================
    ; 16x16 bits Multiplication 16 bits unsigned multiplicand  in rcp3..rcp2 16 bits unsigned multiplier in rcp1..rcp0 
    ;                  result in rcp9..rcp6 scratch pad in rcp5..rcp4
    ; ===============================================================================================================
    .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
      multiply:
        push rmp0;
        ldi rmp0,16;
        clr rcp4;
        clr rcp5;
        movw rcp6,rcp4;
        movw rcp8,rcp4;
      mult0: ;shift multiplier right
        lsr rcp1;
        ror rcp0;
      brcc mult1; test of multiplier lsb
        add rcp6,rcp2; add if set
        adc rcp7,rcp3;
        adc rcp8,rcp4;
        adc rcp9,rcp5;
      mult1:    ;shift multipicand left
        lsl rcp2;
        rol rcp3;
        rol rcp4;
        rol rcp5;
        dec rmp0;
      brne mult0;
        pop rmp0;
      ret;
    l'électronique c'est pas du vaudou!

  23. Publicité
  24. #19
    jiherve

    Re : Projet : Mesurage d'angle

    Re
    et pour finir le corps du programme qui assure la gestion de l'application.
    Code:
    ;===================================================================================================================
    ; Main Program Start
    ; ===================================================================================================================
    
      RESET:
        ; set stack pointer
        ldi ZH,HIGH(RAMEND);
        out SPH,ZH;
        ldi ZL,LOW(RAMEND);
        out SPL,ZL;
    
        ; init whole memory to zero
        ldi YH,HIGH(SRAM_START);        Y point ram location
        ldi YL,LOW(SRAM_START);
        ldi rmp1,0;
      init_ram:
        st Y+,rmp1
        cp YL,ZL;
        cpc YH,ZH;
      brne init_ram;
        ldi ZH, HIGH(tab_sin*2); init sinus table pointer
        ldi ZL, LOW(tab_sin*2);
        sts sTab_idx,ZH;
        sts sTab_idx+1,ZL;
        ldi rmp0,(_OCR0A+1)*2/6;
        sts sPhase,rmp0;Default Phase
        ldi rmp0,0xFF;Default :no frequency calibration 
        sts sOsccal+1,rmp0;
        sts sOsccal+0,rmp0;
     
        ;init clock divider to one
        ldi rmp0,0x80;
        ldi rmp1,0;
        sts CLKPR,rmp0;
        sts CLKPR,rmp1;
        ;calibrate clock
        ldi XL,LOW(eValidity);
        ldi XH,HIGH(eValidity);X point EEPROM location of validity byte
      rcall EEPROM_read;
        ldi rmp0,50; default value
        cpi rmp2,0xA5;
      brne not_initialized;
        adiw XL,1;
      rcall EEPROM_read; get OSCCAL value
        mov rmp0,rmp2;
      not_initialized:;
        out OSCCAL,rmp0;
        ; init ports
        ;port B
        ldi rmp0,_PORTB_DAT
        out PORTB,rmp0;
        ldi rmp0,_PORTB_DIR;
        out DDRB,rmp0;
        
        ;init Timer0 
        ldi rmp0,_TCCR0A; 
        out TCCR0A,rmp0;
        ldi rmp0,_TCCR0B;
        out TCCR0B,rmp0;
        ldi rmp0,_OCR0A;
        out OCR0A,rmp0;
        lds rmp0,sPhase;
        out OCR0B,rmp0;
        
        ;init Timer1
        ldi rmp0,_TCCR1;
        out TCCR1,rmp0;
        ldi rmp0,_OCR1A;
        out OCR1A,rmp0;
        ldi rmp0,_OCR1B;
        out OCR1B,rmp0;
        ldi rmp0,_OCR1C;
        out OCR1C,rmp0;
    
       
        ;init ADC
        ldi rmp0,_ADMUXGND;
        out ADMUX,rmp0;
        ldi rmp0,_ADCSRA;
        out ADCSRA,rmp0;
        ldi rmp0,_ADCSRB;
        out ADCSRB,rmp0;
        ldi rmp0,_DIDR0 ;inactivate digital inputs
        out DIDR0,rmp0; 
        
        ; calibrate ADC mid values , sine generator still stopped
      rcall get_val;
        sts sAdc_gnd+0,rmp1;
        sts sAdc_gnd+1,rmp0;
        ldi rmp0,_ADMUXCOS;
        out ADMUX,rmp0;
        xdelay 10000; 
      rcall get_val;
        sts sMid_cos+0,rmp1;
        sts sMid_cos+1,rmp0;
        ldi rmp0,_ADMUXSIN;
        out ADMUX,rmp0;
        xdelay 10000; 
      rcall get_val;
        sts sMid_sin+0,rmp1;
        sts sMid_sin+1,rmp0;
       
        ;activate timer 0,1 IT
        ldi rmp0,_TIFR;
        out TIFR,rmp0;
        ldi rmp0,_TIMSK;
        out TIMSK,rmp0;
        ldi rmp0,_GTCCR;
        out GTCCR,rmp0;
        
        ;enable interrupt
        ldi rmp0,1<<SREG_I;
        out SREG,rmp0;  
        ; give time to sine generator
        ldi rmp0,100;
      loop_init:;
        xdelay 10000; 
        dec rmp0;
      brne loop_init;
        sts sAdc_flag,rmp0;
        
      ; Here is the infinite loop
      loop_main:
        lds rmp0,sAdc_flag;
        tst rmp0;
      breq loop_main;
        lds rmp0,sOsccal+1;
        tst rmp0;
      breq cal_osc_hook; calibration running
        lds rmp1,sOsccal+0;
        cpse rmp0,rmp1; calibration done
      cal_osc_hook:;  
      rjmp cal_osc;
        ; process cosine value Adc_cos = Adc_cos-Mid cos
        lds rmp0,sAdc_cos+1;
        lds rmp1,sAdc_cos+0;
        lds rmp4,sMid_cos+1;
        lds rmp5,sMid_cos+0;
        sub rmp0,rmp4;
        sbc rmp1,rmp5;
        ; process sine value Adc_cos = Adc_sin-Mid sin
        lds rmp2,sAdc_sin+1;
        lds rmp3,sAdc_sin+0;
        lds rmp4,sMid_sin+1;
        lds rmp5,sMid_sin+0;
        sub rmp2,rmp4;
        sbc rmp3,rmp5;
      rcall atan;
        sts sTheta+1,rmp0;
        sts sTheta+0,rmp1;
        sts sRho+1,rmp2;
        sts sRho+0,rmp3;
        lds rmp4,sPhasecal; check for phase calibration
        cpi rmp4,(1+(_OCR0A+1)/6)<<4;13<<4
      brsh cal_done;
      rcall cal_phase;
      cal_done:
        ; Scale Rho
        ldi rmp0,LOW(_KCORDIC);
        ldi rmp1,HIGH(_KCORDIC);
        movw rcp0,rmp0;
        movw rcp2,rmp2;
      rcall multiply;
        lds rmp0,sNum;test messages counter odd = send Rho, even=send Theta
        sbrc rmp0,0;
      rcall disp_rho;
        lds rmp0,sNum;
        sbrs rmp0,0;
      rcall disp_theta;
        clr rmp0;
        sts sAdc_flag,rmp0;acknowledge to ADC interrupt
        sbi DDRB,_TX; activate output;
        ldi rmp0,0x59;
        sts sXmit_flag,rmp0; update flag 4 words with 9 bits
        lds rmp0,sNum;update messages counter
        inc rmp0;
        andi rmp0,0x0F;
        sts sNum,rmp0;
        cbi PORTB,_SPL
      rjmp loop_main;
      
      cal_osc:; value of sin is potentiometer
        cpi rmp0,0;
      brne ignore; wait a little on entering calibration (8xTIMER1 period), stop earlier before quiting
        lds rmp2,sAdc_sin+1;
        lds rmp3,sAdc_sin+0;
        lsr rmp3;
        rol rmp2;
        lsr rmp3;
        rol rmp2;
        lsr rmp3;
        rol rmp2; get only 7bits to match with Attiny OSCCAL behaviour
        in rmp3,OSCCAL;
        add rmp2,rmp3;
        lsr rmp2;
        out OSCCAL,rmp2;
      ignore:
        in rmp2,OSCCAL;
        sts sOsccal+0,rmp0;memorize Oscal
        cpi rmp0,0xFF;
      brne not_done;
        in rmp0,SREG;
        cbr rmp0,SREG_I;
        out SREG,rmp0; disable interrupt
        ldi XL,LOW(eValidity+1);copy in EEPROM
        ldi XH,HIGH(eValidity+1);X point EEPROM location
      rcall EEPROM_write;
        sbiw XL,1;
        ldi rmp2,0xA5;
      rcall EEPROM_write;
        in rmp0,SREG;
        sbr rmp0,SREG_I;
        out SREG,rmp0; enable interrupt
        ldi rmp0,(_OCR0A+1)*2/6; request phase calibration
        sts sPhase,rmp0;
        xdelay 2000; wait for calibration switch release
      not_done:;
        clr rmp0;
        sts sAdc_flag,rmp0;Aknowledge for ADC interrupt
        cbi PORTB,_SPL; maintain activity 
      rjmp loop_main;
      
      get_val:; Produre to measure mid value on Sin and Cos inputs
        ldi rmp4,32; 32 measures to do
        clr rmp0;
        clr rmp1;
      loop_adc:
      rcall get_adc;
        add rmp0,rmp2;
        adc rmp1,rmp3;
        dec rmp4;
      brne loop_adc;
        ldi rmp4,5; 1/32 scaling down 
      loop_shift_adc:
        lsr rmp1;
        ror rmp0;
        dec rmp4;
      brne loop_shift_adc;
      ret;
      
      get_adc:
        ldi rmp2,_ADCSRA | 1<<ADSC;
        out ADCSRA,rmp2; start conv
      loop_wait:; Wait for ADC conversion done
        in rmp2,ADCSRA;
        sbrc rmp2,ADSC;
      rjmp loop_wait;
        in rmp2,ADCL;read values
        in rmp3,ADCH;
      ret;
      
      cal_phase:;Measure for 12 phase value with filtering of 16 measures
        cpi rmp4,((_OCR0A+1)/6)<<4;12<<4
      breq sel_phase;
        mov rmp5,rmp4;
        inc rmp4;
        sts sPhasecal,rmp4;
        andi rmp4,0x0F;
      brne no_change; maintain same phase as there are still some values to acquire
        lds rmp4,sPhase; add 360°/(_OCR0A+1) to phase
        inc rmp4;
        sts sPhase,rmp4;
        out OCR0B,rmp4; update timer register
      no_change:;
        mov rmp4,rmp5;
        swap rmp4;
        andi rmp4,0x0F; get MSB of calibration counter i.e Phase number and so address of variable
        lsl rmp4;word address
        clr rmp5;
        ldi YH,HIGH(sCrho);
        ldi YL,LOW(sCrho);
        add YL,rmp4; 
        adc YH,rmp5;
        ld  rmp1,Y;
        ldd rmp0,Y+1; last value
        add rmp0,rmp2;
        adc rmp1,rmp3; will cumulate 16 values
        st Y,rmp1;
        std Y+1,rmp0;
      ret;
      
      sel_phase: ;scan rho values and select te biggest one
        ldi rmp5,(_OCR0A+1)/6;
        mov rmp4,rmp5;
        clr rmp2;
        clr rmp3;
        ldi YH,HIGH(sCrho);
        ldi YL,LOW(sCrho);
      loop_comp:;
        ld rmp1,Y+
        ld rmp0,Y+;
        swap rmp0; divide by 16
        andi rmp0,0x0F;get msb 
        mov rmp7,rmp1;
        swap rmp7;
        andi rmp7,0xF0;get lsb 
        or rmp0,rmp7;
        swap rmp1;
        andi rmp1,0x0F;
        cp rmp0,rmp2;
        cpc rmp1,rmp3;
      brlo smaller;
        mov rmp2,rmp0;
        mov rmp3,rmp1;
        mov rmp4,rmp5;
      smaller:
        dec rmp5;
      brne loop_comp;
        ldi rmp5,(_OCR0A+1)/2;
        sub rmp5,rmp4;adjust value
        sts sPhase,rmp5;
        out OCR0B,rmp5;
        sts sRho+0,rmp3;
        sts sRho+1,rmp2;
        ldi rmp4,(1+(_OCR0A+1)/6)<<4 ;
        sts sPhasecal,rmp4;
      ret;
     
      disp_rho:;Convert Rho to ASCCI string
        clr rmp3;
        mov rmp2,rcp9;
        swap rmp2;
      rcall to_asc;
        sts sAff+4,rmp2;
        mov rmp2,rcp9;
      rcall to_asc;
        sts sAff+3,rmp2;
        mov rmp2,rcp8;
        swap rmp2;
      rcall to_asc;
        sts sAff+2,rmp2;
        mov rmp2,rcp8;
      rcall to_asc;
        sts sAff+1,rmp2;
        ldi rmp0,',';
        lds rmp2,sNum;
        inc rmp2;
        sbrc rmp2,4; send Cr every 16 bytes
        ldi rmp0,0x0D;
        sts sAff+0,rmp0;
      ret;
      
       disp_Theta:; Convert Theta to ASCCI string
        clr rmp3;
        lds rmp2,sTheta+0;
        swap rmp2;
      rcall to_asc;
        sts sAff+4,rmp2;
        lds rmp2,sTheta+0;
      rcall to_asc;
        sts sAff+3,rmp2;
        lds rmp2,sTheta+1;
        swap rmp2;
      rcall to_asc;
        sts sAff+2,rmp2;
        lds rmp2,sTheta+1;
      rcall to_asc;
        sts sAff+1,rmp2;
        ldi rmp0,',';
        lds rmp2,sNum;
        inc rmp2;
        sbrc rmp2,4;
        ldi rmp0,0x0D;send Cr every 16 bytes
        sts sAff+0,rmp0;
      ret;
    
      to_asc: ;convert Hex nibble to ASCCI
        andi rmp2,0x0F;
        ldi ZH,HIGH(2*tab_asc)
        ldi ZL,LOW(2*tab_asc)
        add ZL,rmp2;
        adc ZH,rmp3;
        lpm rmp2,Z;
      ret;
      tab_asc:
        .DB 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,0x45,0x46
        
      
     .CSEG
     .ORG $0700
    
      tab_sin: ;ARRONDI(127,5*SIN(i*2*PI()/36)+127,5) 0<=i<=35
      .DB 128,150,171,191,209,225,238,247,253,255,253,247,238,225,209,191,171,150,128,105,84,64,46,30,17,8,2,0,2,8,17,30,46,64,84,105
    
    
    ; End of source code
    au total cela fait mois de 1000 ligne de code mais c'est tres loin de remplir la memoire du µC.
    En fait il y a plus de soft que de hard mais c'etait un peu le but.
    JR
    Dernière modification par jiherve ; 11/08/2020 à 17h35.
    l'électronique c'est pas du vaudou!

  25. #20
    Vincent PETIT
    Animateur Électronique

    Re : Projet : Mesurage d'angle

    Salut JR
    Merci pour cette contribution !

    Aurais tu un schéma de meilleur qualité que celui du #15 à tout hasard ?
    Je ne sais pas s'il t'est encore possible d'ajouter les références de U5, U4 et D1 sur le schéma ? J'ai vu que tu avais tout noté dans ton message mais je me suis dit que serait bien aussi sur le schéma, si tu peux bien sur.


    Pour le reste je crois que tout y est. Encore merci de partager ton expérience ici avec nous.

    Bien à toi.
    Vincent
    Là où il n'y a pas de solution, il n'y a pas de problème.

  26. #21
    jiherve

    Re : Projet : Mesurage d'angle

    Bonjour Vincent,
    le site n'acceptant pas les .dch je passe par une capture d’écran c'est donc limite pour la lisibilité.
    Nom : Reolver to digital.jpg
Affichages : 57
Taille : 142,1 Ko
    Bon là cela semble mieux.
    JR
    l'électronique c'est pas du vaudou!

  27. #22
    Vincent PETIT
    Animateur Électronique

    Re : Projet : Mesurage d'angle

    Parfait !
    Merci.
    Là où il n'y a pas de solution, il n'y a pas de problème.

  28. #23
    jiherve

    Re : Projet : Mesurage d'angle

    bonsoir,
    s'il y a des questions je suis à l’écoute.
    JR
    l'électronique c'est pas du vaudou!

Discussions similaires

  1. Idées de systèmes de mesurage des dimensions de camions
    Par Drazzen dans le forum Technologies
    Réponses: 3
    Dernier message: 29/01/2014, 12h52
  2. Réponses: 10
    Dernier message: 08/02/2010, 21h58
  3. calcul de l'angle entre 2 vecteurs en respectant le signe de l'angle?
    Par hamoudasafira dans le forum Mathématiques du supérieur
    Réponses: 18
    Dernier message: 01/11/2009, 23h38
  4. les méthodes de contrôles et de mesurage
    Par bigoude13 dans le forum Technologies
    Réponses: 0
    Dernier message: 09/04/2009, 17h07
  5. calcul de l'angle entre 2 vecteurs en respectant le signe de l'angle?
    Par hamoudasafira dans le forum Logiciel - Software - Open Source
    Réponses: 1
    Dernier message: 26/04/2007, 19h31
Découvrez nos comparatifs produits sur l'informatique et les technologies.