[PROJET]Modulateur,Demodulateur PPM

[jiherve]

Bonsoir,
Comme il faut que je m'occupe depuis que je suis en retraite je vous propose une réalisation duale d'un modulateur et d'un démodulateur PPM utilisables en RC avec 3 voies proportionnelles et une discrète utilisant des Attiny45(un dans l’émetteur et un dans le récepteur).
Le codeur offre une possibilité de calibration des manches (pour obtenir l'excursion max) et sa mémorisation, le décodeur assure une fonction de fail safe en cas de perte de liaison, retour au neutre ou autre c'est configurable.
rien de bien génial mais c'est très compact, un DIL 8 et quelques composants annexes, pour la HF c'est open.
la suite , schéma, code (assembleur) plus tard.
Cela fonctionne bien sur.

JR
-----

[jiherve]

Bonjour,
le schéma du codeur.

Le switch possède plusieurs fonctions:
Si maintenu pressé pendant quelques secondes après la mise sous tension il annule la calibration mémorisée et au relâchement la LED clignote.
la fin de calibration, qui demande à ce que les 3 manches soient maneuvrés du min au max, est validée par un appui sur ce switch, cela autorise également la sauvegarde en EEPROM.
ensuite un appui sur le switch modulera la longueur de trame , 20ms/18ms .
A noter que le flashage du soft efface l'EEPROM et induit une demande de calibration.
Pour un fonctionnement avec moins de 6V il faut un LDO à la place du LM317, la consomation est de l'ordre de 17Ma, le µC tourne avec la PLL activée donc à 16MHz.
JR

[jiherve]

Bonsoir
Comme je suis de nature bienveillante et malgré le peu d’intérêt manifesté je vous joins le code.
PPM_encoder.txt
explications si quelqu'un intéressé.
JR

[Yvan_Delaserge]

Hello Jiherve, beau travail!

Sur ton schéma, on reconnaît l'ATTINY à 8 pattes au centre, le LM317 à gauche, les 3 potentiomètres des joysticks.

J'aurais quelques questions:

Quel est l'IC à 6 pattes en haut du schéma? et quelle est sa fonction?

La sortie du signal PPM se fait où?

Quelle est la fonction du PLL à 16 MHz?

De mon côté, je viens de réaliser un montage me permettant de contrôler une plate-forme azimut/élévation au moyen d'un joystick et de moteurs pas à pas. Mais le montage utilise des LM324, des 4046 pour les VCO et des comparateurs. Un microcontrôleur aurait permis de réaliser un circuit bien plus simple, mais il faut savoir le programmer

Quel est le langage que tu utilises? du C? Personnellement je ne suis jamais allé plus loin que le Basic. Ou alors le FORTRAN, mais ça ne nous rajeunit pas!

Amicalement,

Yvan

[A voir en vidéo sur Futura]

[DAUDET78]

Quel est l'IC à 6 pattes en haut du schéma? et quelle est sa fonction?

Comme jiherve fait la sieste ... je répond à sa place. C'est le connecteur de programmation

[jiherve]

Bonsoir,
Merci Daudet, je m’étais absenté.
C'est programmé en assembleur, un truc d'homme, car je suis un vrai hardeux!
JR

[DAUDET78]

car je suis un vrai hardeux!

Comme moi ! Et je n'étais pas sûr de ma réponse ... tu sais bien, sorti des transistors, résistances et condensateurs, j'y connais pas grand chose !

[jiherve]

RE
Ben voyons
JR

[Yvan_Delaserge]

OK donc pour le connecteur. J'imagine que le signal PPM aboutit là aussi (le schéma est peu lisible) Et les autres signaux présents sur le connecteur, c'est quoi?

Et pour ce qui est du PLL 16 MHz? C'est pour l'horloge?

Je vois aussi qu'il n'y a pas de quartz externe pour l'horloge du microcontrôleur. Est-ce une propriété des AtTiny? Ou alors, c'est le condensateur qui se trouve au-dessus de l'AtTiny qui est utilisé pour l'oscillateur d'horloge?

[jiherve]

Bonsoir
Les µC Atmel comme les µC Microchip comportent un oscillateur interne avec dans certains cas une PLL qui permet d'augmenter la fréquence de fonctionnement de la bête.
JR

[jiherve]

Bonjour,
La suite le décodeur, un peu particulier car il pilote à la fois un servo classique (direction) et fourni 2 PWM pour les moteurs de propulsion, il y a interaction entre direction et propulsion.
Le schéma est en PDF (généré directement à partir de Kicad en utilisant l'imprimante virtuelle de Foxit par impression dans un fichier)j'espère qu'il sera tout de même validé car le GIF/JPEG etc à partir d'une capture d’écran c'est pourri.
Printing PPM_decoder-sch.pdf.
Le schema est simplissime je ne pense pas qu'il faille le commenter plus avant.
Le code suit.
JR

[jiherve]

Re
Le code:

; *********************************************************
; * PPM decoder for three analog channels and one discrete*
; * for ATtiny45 on internal clock with PLL               *
; * Version 2.0 by JRV                                    *
; *********************************************************
;
.INCLUDE "tn45def.inc"
.EQU FREQ_ACT = 400;in tens of Khz
.EQU FREQ_REG = 8;in MHZ
.EQU COEFF = FREQ_ACT/FREQ_REG;coefficient to ajust delay if CPU frequency different from 8MHz
.EQU INT0_LEV = 0x00;
.EQU INT0_CHG = 0x01;
.EQU INT0_NEG = 0x02;
.EQU INT0_POS = 0x03;


; ================================================
;           Hardware connections
; ================================================
;                ___   ___
;      RESET/B5 |1  |_| 28| VCC
;      CHAN0/B3 |2   A  27| B2/SCK/INT0
; OC1B/CHAN1/B4 |3   T  26| B1/MISO/CHAN2/OC1A
;           GND |4   M  25| B0/MOSI/DISCRETE
;               |_________|
;
;
; ================================================
;            Register definitions
; ================================================
;
.DEF rTim0  = R0  ;  counter lsb
.DEF rTim1  = R1  ;  counter lsb
.DEF rLim0  = R2  ;  limit lsb
.DEF rLim1  = R3  ;  limit msb
.DEF rDen0  = R4  ;  denominator byte 0 
.DEF rDen1  = R5  ;  denominator byte 1 
.DEF rQuo0  = R6  ;  quotient byte 0
.DEF rQuo1  = R7  ;  quotient byte 1
.DEF rmp1   = R16 ;  Multi-purpose register outside interrupts
.DEF rmp2   = R17 ;  Multi-purpose register outside interrupts
.DEF rmp3   = R18 ;  Multi-purpose register outside interrupts
.DEF rmp4   = R19 ;  Multi-purpose register outside interrupts
.DEF Irmp1  = R20 ;  Multi-purpose register inside interrupts
.DEF Irmp2  = R21;   Multi-purpose register inside interrupts
.DEF Irmp3  = R22 ;  Multi-purpose register inside interrupts
.DEF rSreg  = R23 ;  ISave status register inside interrupts
.DEF rDelL  = R24 ;  delay counter LSB 
.DEF rDelH  = R25 ;  delay counter MSB
; ================================================
;             SRAM definitions
; ================================================
;
.DSEG
.ORG Sram_Start
;
;channel
sNumchan: ; channel number
.BYTE 1
sCatch_3:
.BYTE 1
sCatch_0:
.BYTE 1
sCatch_1:
.BYTE 1
sCatch_2:
.BYTE 1
sReinit: ; flag to synchronise channel counter in interrupt
.BYTE 1
sDiscrete:
.BYTE 1
sFail_flag: ; set to 0x1 by main reseted by INTO
.BYTE 1
sMean_flag: ; set to 0x1 by average capture
.BYTE 1
.BYTE 1
sMean_0:
.BYTE 1
sMean_1:
.BYTE 1
sMean_2:
.BYTE 1
sCycle:
.BYTE 1
sFilter:

tabchan:
.BYTE 4;



; ==============================================
;   Reset and Interrupt Vectors starting here
; ==============================================
;
.CSEG
.ORG $0000
;
; Reset/Intvectors
;
  rjmp Main ; Reset
  rjmp  Int0_prog;
  reti ; PCINT0_;
  reti ; TIMER1_COMPA Comp
  reti ; TIMER1_OVF;
  reti ; TIMER0_OVF
  reti ; EE_RDY EEPROM Ready
  reti ; ANA_COMP Analog Comparator
  reti ; ADC ADC Conversion Complete
  reti ; TIMER1_COMPB Timer/Counter1 Compare Match B
  reti ; TIMER0_COMPA;Timer/Counter0 Compare Match A
  reti ; TIMER0_COMPB; Timer/Counter0 Compare Match B
  reti ; WDT Watchdog Time-out
  reti ; USI_START USI START
  reti ; USI_OVF
  
;
; =============================================
;
;     Interrupt Service Routines
;
; =============================================
Int0_prog:

    in rSreg,SREG ; save SREG
    push ZH;save Z registers
    push ZL;
    clr Irmp3;
    sts sFail_flag,Irmp3;reset fail flag
    ldi rDelH,HIGH(25*COEFF);reset main counters
    ldi rDelL,LOW(25*COEFF);
    lds Irmp2,sReinit;
    sts sReinit,Irmp3;clear Sreinit in any case
    lds Irmp1,sNumchan;
    tst Irmp2;check old Sreinit value, set to one by main 
  breq int0_prog_1;skip if not start of frame
    ldi Irmp1,3;will force reset of counter here |
  int0_prog_1:;                                  |
    inc Irmp1;inc channel counter                | 
    sbrc Irmp1,2;                                | 
      clr Irmp1;<---------------------------------
    sts sNumchan,Irmp1;
    in Irmp2,TCNT0;read timer 0 counter value 16uS per LSB
    ldi ZH,HIGH(sCatch_3); point to chan timing values
    ldi ZL,LOW(sCatch_3);
    add ZL,Irmp1;
    adc ZH,Irmp3;
    st Z,Irmp2; store measured time value of previous channel
    in Irmp2,GTCCR;
    ori Irmp2,1<< PSR0|1<<TSM;|1<< PSR1; Prescaler Reset Timer/Counter Synchronization Mode
    out GTCCR,Irmp2;reset prescaler
    out TCNT0,Irmp3;reset counter
    andi Irmp2,0x7F;
    out GTCCR,Irmp2;restart prescaler and counter for next measurement
    ldi ZH,HIGH(tabchan); point to chan bit table values to configure PORTB output
    ldi ZL,LOW(tabchan);
    add ZL,Irmp1;
    adc ZH,Irmp3;
    ld Irmp2,Z; 
    lds Irmp1,sDiscrete;get discrete output value, this controls the relays
    or Irmp2,Irmp1;
    out PORTB,Irmp2;update PORTB
    pop ZL; restore Z registers
    pop ZH;
    out SREG,rSreg; restore SREG
reti;


;=================================================
;             Delay routines
;=================================================
;
Delay20ms:
  ldi rDelH,HIGH(200*COEFF)
  ldi rDelL,LOW(200*COEFF)
  rjmp DelayZ
Delay7_5ms:
  ldi rDelH,HIGH(75*COEFF)
  ldi rDelL,LOW(75*COEFF)
  rjmp DelayZ
Delay5ms:
  ldi rDelH,HIGH(50*COEFF)
  ldi rDelL,LOW(50*COEFF)
  rjmp DelayZ
Delay3_0ms:
  ldi rDelH,HIGH(30*COEFF)
  ldi rDelL,LOW(30*COEFF)
  rjmp DelayZ
Delay2_5ms:
  ldi rDelH,HIGH(25*COEFF)
  ldi rDelL,LOW(25*COEFF)
  rjmp DelayZ
Delay2_0ms:
  ldi rDelH,HIGH(20*COEFF)
  ldi rDelL,LOW(20*COEFF)
  rjmp DelayZ
Delay1_5ms:
  ldi rDelH,HIGH(15*COEFF)
  ldi rDelL,LOW(15*COEFF)
  rjmp DelayZ
; =========================================
; Delays execution for (rDelH,rDelL) microseconds @ 8MHz
; =========================================
DelayZ:
  nop
  nop
  nop
  nop
  sbiw rDelL,1 ; 2
  brne DelayZ ; 2
  ret
   
; =========================================
; Main Program Start
; =========================================

main:
  ; 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;
  ;init non zero variables
  ldi rmp1,0x2C;
  sts tabchan+0,rmp1;
  ldi rmp1,0x34;
  sts tabchan+1,rmp1;
  ldi rmp1,0x26;
  sts tabchan+2,rmp1;
  ldi rmp1,0x24;
  sts tabchan+3,rmp1;
  ldi rmp1,1;
  sts sFail_flag,rmp1;
  ldi rmp1,100; regular average value for channel
  sts sMean_0,rmp1;
  sts sMean_1,rmp1;
  sts sMean_2,rmp1;

  ;init clock divider to two
  ldi rmp1,0x80;
  ldi rmp2,1;
  out CLKPR,rmp1;
  out CLKPR,rmp2; 
  
  ;calibrate clock
  ldi rmp1,0x98;
  ;out OSCCAL,rmp1;
  
  ;init PLL
  ldi rmp1,1<<PLLE|1<<LSM|1<<PCKE;
  out PLLCSR,rmp1;
  
  ; init ports
  ldi rmp1,0x3F;
  out PORTB,rmp1;
  ldi rmp1,0x1B;
  out DDRB,rmp1; port B 5,2 input 0,1,3,4 output
  
  ; init interrupts
  ldi rmp1,INT0_NEG;
  out MCUCR,rmp1;
  ldi rmp1,1<<INT0;
  out GIMSK,rmp1;
  
  ;init Timer0
  ldi rmp1,0x02; fast pwm
  out TCCR0A,rmp1;
  ldi rmp1,0x03;divide by 64
  out TCCR0B,rmp1;
  ldi rmp1,0xFF;max
  out OCR0A,rmp1;
  ldi rmp1,0xFF;max
  out OCR0B,rmp1;
  
  ;init Timer1
  ldi rmp1,0x05|1<<CTC1|1<<PWM1A|1<<COM1A1;|1<<COM1A0;
  out TCCR1,rmp1;divide by 8 ctc mode
  ldi rmp1,255;max value for timer1 counter
  out OCR1C,rmp1;
  ldi rmp1,0; set PWM to zero, motors are then stopped
  out OCR1A,rmp1;
  out OCR1B,rmp1;
  ldi rmp1,1<<PWM1B|1<<COM1B1;
  out GTCCR,rmp1;

  ;init interrupts
  ldi rmp1,0x80;
  out SREG,rmp1; enable interrupt
  ; wait loop after power up so that RF receiver set up
  ldi rmp2,50;
  loop_wait:
    rcall Delay20ms;
    dec rmp2;
  brne loop_wait;

  ; Here is the infinite loop
  loop_main:
  ;discrete channel and fail safe routines
    ;cbi PORTB,0;for debug
    sts sCycle,rmp2; update cycle counter 
    ldi rmp1,1;
    sts sFail_flag,rmp1; set flag to interrupt
  rcall Delay2_5ms;timing , counter is reloaded at each falling edge of input signal by interrupt routine, return from function after last input pulse
    lds rmp1,sFail_flag;
    tst rmp1;check to be sure that interrupt as occured
  breq sync_cycle;this point reached after last channel ,used to synchronize INTO process
    lds rmp2,sCycle;
    inc rmp2;increment cycle counter
    cpi rmp2,7;max cycle number this control fail safe frame
  brlo loop_main;
  ; no more RF link ,force neutral on channels
    lds rmp1,tabchan+0;
    out PORTB,rmp1;
  rcall Delay1_5ms;
    lds rmp1,tabchan+1;
    out PORTB,rmp1;
  rcall Delay1_5ms;
    lds rmp1,tabchan+2;
    out PORTB,rmp1;
  rcall Delay1_5ms;
    lds rmp1,tabchan+3;
    out PORTB,rmp1;
    ; stop motors
    ldi rmp1,0;
    out OCR1A,rmp1;
    out OCR1B,rmp1;
    ;reinit variable including cycle counter
    clr rmp2;to reset cycle counter
    sts sFilter,rmp2;
    sts sMean_flag,rmp2;
rjmp loop_main;

  sync_cycle :
    ldi rmp1,1;
    sts sReinit,rmp1;synchronise Int0 routine on frame cycle this occurs 2,5ms after last pulse
    ;sbi PORTB,0;debug
    lds rmp1,sMean_flag;check calibration flag
    cpi rmp1,0;
  brne regular_cycle;calibration done
    cpi rmp2,4;test for short frame 17ms
  brsh end_sync;jump if regular frame 20ms
    cpi rmp2,2;detect false frame noise reject
  brlo end_sync;jump if false frame
    ; check that there are 10 contiguous short frames
    lds rmp1,sFilter;
    inc rmp1;
    sts sFilter,rmp1;
    cpi rmp1,10;
  brlo end_sync; jump if less than 10
    ; capture measured timing of each channel, values are supposed to be neutral
    sts sMean_flag,rmp1;
    lds rmp1,sCatch_0;
    sts sMean_0,rmp1;    
    lds rmp1,sCatch_1;
    sts sMean_1,rmp1;    
    lds rmp1,sCatch_2;
    sts sMean_2,rmp1;
  regular_cycle:    
    ;cbi PORTB,0;debug
    ldi rmp2,1;command for ahead
    ; substract from current value of channel one (ahead/astern) the channel's neutral value
    lds rmp1,sCatch_1;
    lds rmp4,sMean_1;
    sub rmp1,rmp4;
  brsh ahead; result is positive
    neg rmp1; result was negative make it positive
    ldi rmp2,0;command for reverse
  ahead:
    sts sDiscrete,rmp2;set relay control
    cpi rmp1,8;create dead zone around neutral
  brsh test_max1;
    clr rmp1;
  test_max1:
    cpi rmp1,43;check max value 
  brlo in_range;
    ldi rmp1,42;saturate
  in_range:
    ;expand value from 42 max to 210 max
    mov rmp3,rmp1;
    lsl rmp1;
    lsl rmp1;
    add rmp1,rmp3;x5
    mov rmp2,rmp1;save for computation of second channel
    ; substract from current value of channel zero (direction) the channel's neutral value
    lds rmp3,sCatch_0;
    lds rmp4,sMean_0;
    sub rmp3,rmp4;
    ;create dead zone around neutral
    cpi rmp3,-7;
  brlt mix;
    cpi rmp3,8;
  brsh mix;
    clr rmp3;
  mix:
    ; combine motor control and direction values
    add rmp1,rmp3;
    sub rmp2,rmp3;
    ; output to timer 1 PWM
    out OCR1A,rmp1;
    out OCR1B,rmp2;
    ldi rmp1,sFilter;
  end_sync:
    sts sFilter,rmp1;
    clr rmp2;to reset cycle counter
    
  rjmp loop_main;
  


; End of source code

L'entrée attendue sur INTO est la sortie d'un récepteur RC 3 canaux , pulses actifs à zéro, la durée trame est supposée variable entre 17ms et 20ms , le passage à 17ms induit une calibration du neutre des canaux .
En sortie le canal 0 est destiné à piloter un servo normal qui contrôle la direction du modèle, le canal 1 porte le contrôle des moteurs de propulsion, il y a un mélange avec la direction avant de piloter 2PWM, l'inversion de marche des moteurs ne dépends que du canal propulsion et est effectuée par des relais .
Si le récepteur est assez ancien alors il faut rajouter un schmitt en entrée:
Pièce jointe 261558
JR

[Yvan_Delaserge]

; * PPM decoder for three analog channels and one discrete*
; * for ATtiny45 on internal clock with PLL *

L'entrée attendue sur INTO est la sortie d'un récepteur RC 3 canaux , pulses actifs à zéro, la durée trame est supposée variable entre 17ms et 20ms , le passage à 17ms induit une calibration du neutre des canaux .
En sortie le canal 0 est destiné à piloter un servo normal qui contrôle la direction du modèle, le canal 1 porte le contrôle des moteurs de propulsion, il y a un mélange avec la direction avant de piloter 2PWM, l'inversion de marche des moteurs ne dépends que du canal propulsion et est effectuée par des relais .
Si le récepteur est assez ancien alors il faut rajouter un schmitt en entrée:
Pièce jointe 261558
JR

Donc si j'ai bien compris, tu as 3 canaux analogiques qui viennent du récepteur, connectés aux pattes 2,3 et 6 ( chan 0, chan 1, chan2) de l'AtTiny
Plus une entrée discrete sur la patte 5
et en plus une entrée sur INTO, patte 7?

Mais la sortie se fait par où alors?

[Yvan_Delaserge]

Non, ça y est, l'entrée du signal PPM se fait par INTO et il y a les 3 sorties analogiques sur chan 0, chan 1, chan2.
Et discrete, c'est quoi?

Donc on a la direction sur chan 0 (joystick G ou D) et les gaz sur chan1 en positif ou négatif (joystick vers l'avant ou l'arrière). Plus une zone morte centrale, avec arrêt des moteurs. Et on alimente les 2 moteurs avec un PWM dépendant de que l'on trouve sur chan0.

C'est bien ça?

Donc on n'utilise pas chan2?

[jiherve]

Re
la direction est sur le channel 0, à l’émission le contrôle des moteurs est sur le channel 1, il y a un auxiliaire sur le channel 2 et la modulation de la durée trame (17ms,20ms,23ms) permet normalement de piloter un discret.
Dans l'usage qui est fait ici de cet émetteur je n'utilise pas le channel 2 et la durée trame est utilisée pour faire autre chose qui est la calibration des neutres car comme les PWM sont obtenues par mesure des largeurs d'impulsions des canaux 0 et 1 et que la mesure est faite en utilisant la base de temps interne il faut prévoir un moyen de compenser les dérives tant coté émetteur que récepteur.

Donc le µc demultiplexe le signal PPM, l'impulsion du channel 0 est envoyée sur la sortie B3 ,les deux autres aussi(B4,B1) mais cela est sans effet car c'est le timer 1 qui à en fait la main sur les I/O.Le timer 0 est utiliser pour mesurer la durée de chacun des canaux (0,1,2) ensuite les valeurs issues des canaux 0,1 sont touillées pour piloter 2 PWM realisées par le timer 1:
on a sans tenir compte des zones mortes:
PWM0 = 5*ABS(valeur channel 1 - neutre channel 1) + (valeur channel 0 - neutre channel 0)
PWM1 = 5*ABS(valeur channel 1 - neutre channel 1) - (valeur channel 0 - neutre channel 0)
les coefficients de mise à l’échelle provienent du fait que (valeur channel 1 - neutre channel 1) varie entre 0 et 42 sur mon montage(l'émetteur qui est ancien excursionne beaucoup plus que 1ms,2ms) c'est la même chose pour (valeur channel 0 - neutre channel 0), comme la dynamique du registre de controle des PWM est 8 bits j'ai donc pris 5 et 1 car 6*42 = 252 (pile poil non ?)

La sortie discrète est en fait le signe de (valeur channel 1 - neutre channel 1).

une remarque sur le câblage : câblage étoile indispensable des alimentations des moteurs et du reste de l’électronique.
JR

[Yvan_Delaserge]

Ben mon vieux!

On sent que c'est pas la première fois que tu fais ça!
En tout cas, c'est magistral. Tout ça dans un IC à 8 pattes. ça serait très intéressant à utiliser sur une maquette volante. 4 sorties qui pilotent chacune un rotor de quadricoptère. On pourrait prendre un engin volant de petite taille, le poids d'un microcontrôleur comme l'AtTiny le permettrait. Pas besoin de relais. Encore un gain en poids. Ou alors quelque chose de plus gros, mais moins de poids= davantage d'autonomie.

Il faudrait encore un autre AtTiny pour interfacer des MEMS trois axes pour accéléromètre, gyroscope, magnétomètre. Et hop! une plate-forme à inertie!
Tu as déjà tenté le coup?


A part ça, est-ce que tu pourrais m'expliquer dans la première partie du code (message #3) comment tu procèdes pour étalonner le joystick au départ? C'est pas évident à comprendre d'après la source en assembleur.

Personnellement, je procéderais comme ça: Tu pousses le joystick en avant et tu appuies sur un bouton pour dire au microcontrôleur de prendre note.
Pareil pour les autres positions du joystick (nord-sud-est-ouest) et pour le point central.

Mais toi, tu n'as pas de bouton connecté à l'Attiny.

Donc, tu fais comment?
Tu tournes le joystick dans tous les sens et le uC ne prend en considération que les valeurs les plus élevées? Mais pour ça, il faut qu'il stocke en mémoire de nombreuses valeurs avant de les trier. Est-ce qu'on a assez ce place en mémoire?
Et comment déterminer le point de repos du joystick? Par interpolation? Mais est-ce assez précis?

Amicalement,

Yvan

[jiherve]

Re
Le joystick est calibré sur l’émetteur , c'est l'autre code, en fait c'est très simple deux détecteurs crête l'un détecte le min l'autre le max, il n'y a besoin que de deux variables par canal, la fin de la séquence est validée par un appui sur un bouton, ensuite c'est du calcul, déjà détaillé au début de ce fil.
On pourrait faire la même chose sur le récepteur, il suffit d'une commande pour indiquer la fin de la séquence. Ici je n'ai choisi que de calibrer le neutre car les min et max on s'en fout un peu en réception tant qu'ils sont suffisamment distincts .
JR