Modification de code remplacer attachInterrupt pour encoder

International Français
1

Bonjour,
je me présente en même temps que mon projet , Johann je suis mécanicien et touche à tout , j'ai fabriqué une imprimante type prusa i3 avec un plateau de 70cmX35cm en utilisant des vis mère donc grosse modif de code. Je m'amuse aussi avec solidworks et une cnc , enfin je suis un autodidacte et me défini comme assembleur.
je suis sur un projet de moniteur de température, avec affichage de l'heure de la date et des différentes températures relevées.
J'utilise une carte mega 2560 , une ramps 1.4 et un ecran 2004 avec lecteur sd et encoder rotatif.
Je suis donc dans une configuration sans entrés d'interruptions disponible car l'encodeur est relier aux pin 31 33 35 . J'ai écrit ,surtout modifié des codes et assemblés ceux ci , tout fonctionnait quand évidement j'ai voulu rajouter la ramps car le nombre de fils était source de faux contact.Donc les pin de mon encoder ont changés.
Y a t'il une solution simple sans changer complètement le code.
J'espère que mon poste respecte les règles c'est la première fois que je poste et je n'ai pas trouvé ou compris comment modifier la fonction attachinterrupt interne vers une autre fonction.
Merci pour votre aide

---------------------------------------------
`rotary_clock_quiet.ino

void setup() {
  setup_lcd();
  setup_rtc();
  setup_encoder();
 }

void loop( ) {
  check_switch_condition();
  long_push_timer();
  release_timer();
  event_dispatcher();
  display_clock();
  
}

#define ON  true
#define OFF false

---------------------------------------------
0_dispatcher.ino

// event dispatcher.

#define    EVENT _00,_01,_02,_03,_04,_05,_06,_07,_08,_09,_10,_11

#define   _BOOT        0       // _00() Initialize the adjustment mode
#define   _IDLE        1       // _01() idling
#define   _SELECT      2       // _02() select the commands
#define   _DISPATCH    3       // _03() carry out the selected commands
#define   _YEAR        4       // _04() adjust year
#define   _MONTH       5       // _05() adjust month
#define   _DATE        6       // _06() adjust date
#define   _HOUR        7       // _07() adjust hour
#define   _MINUTE      8       // _08() adjust minute
#define   _SECOND      9       // _09() adjust second
#define   _AMPMMT     10       // _10() change AM/PM MT mode
#define   _DUMMY      11       // _11() prevent long press

static uint8_t EventID;
void ( *event[] )() = { EVENT };
void event_dispatcher( void ) { (*event[ EventID ])(); }

static uint8_t TemporaryEventID;
void event_switcher( uint8_t e ) {
  TemporaryEventID = e;
  EventID = _DUMMY;
}
---------------------------------------------
1_setup.ino

#include <Wire.h>
#include <LiquidCrystal.h>


const int rs = 16, en = 17, d4 = 23, d5 = 25, d6 = 27, d7 = 29;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup_lcd( void ){

 lcd.begin(20, 4); }

// DS3231 Real Time Clock ( https://github.com/NorthernWidget/DS3231 )

#include <DS3231.h>
DS3231 clock; RTClib rtc;
void setup_rtc( void ) {  Wire.begin(); set_dow(); }

// KY-040 Rotary Encoder

#define CLK 31 //2
#define DT  33 //3
#define SW  35 //A0

void setup_encoder( void ) {
  pinMode( CLK, INPUT_PULLUP );
  pinMode( DT,  INPUT_PULLUP );
  pinMode( SW,  INPUT_PULLUP );

   
  attachInterrupt( 0, isr_0, RISING );
  attachInterrupt( 1, isr_1, RISING );
}

---------------------------------------------
2_encoder.ino

// rotary encoder

volatile uint8_t REGS1,REGS2;
volatile boolean CLK_PIN, DT_PIN;
volatile boolean Rotation = OFF;
volatile int16_t RotaryCounter;
volatile unsigned long ReleaseCounter;

void isr_0( void ) {
  
  REGS1  = PIND & 0b00001100;
  if ( ( REGS1 == 0b00001100 ) && CLK_PIN ) {
    RotaryCounter--; ReleaseCounter = 0;
    Rotation = ON; CLK_PIN = DT_PIN = LOW; sei();
  } else if ( REGS1 == _BV(2) ) DT_PIN = HIGH;
}

void isr_1( void ) {
  
  REGS2  = PIND & 0b00001100;
  if ( ( REGS2 == 0b00001100 ) && DT_PIN ) {
    RotaryCounter++; ReleaseCounter = 0;
    Rotation = ON; CLK_PIN = DT_PIN = LOW; sei();
  } else if ( REGS2 == _BV(3) ) CLK_PIN = HIGH;
}

#define RTMO 40  // Release time Maximum others.
#define RTMS 90  // Release time Maximum second.

static uint8_t ReleaseCounterMax = RTMO;

bool is_rotation( void ) {
  bool r = Rotation;
  if ( Rotation ) ReleaseCounter = ReleaseCounterMax;
  Rotation = OFF;
  return( r );
}

// builtin switch

static boolean DirectSwitch;
static boolean EdgeTriggerSwitch;
static boolean PreviousSwitch;

void check_switch_condition( void ) {
  DirectSwitch = !digitalRead( SW ); // convert to positive logic 
  EdgeTriggerSwitch = DirectSwitch ^ PreviousSwitch & DirectSwitch;   // rising
  PreviousSwitch = DirectSwitch;
}
--------------------------------------------------------------------
3_release.ino

// rotary encoder switching mechanism.

#define INTERVAL_MILLIS 100
#define LONG_PUSH_COUNTER_MAX 8
static uint16_t LongPushCounter;

void long_push_timer ( void )
{
  if ( !DirectSwitch ) { LongPushCounter = 0; return; }
  static unsigned long pms, cms; cms = millis();
  if ( cms - pms < INTERVAL_MILLIS ) return; else pms = cms;
  if ( LongPushCounter == LONG_PUSH_COUNTER_MAX - 1 ) EventID = _AMPMMT;
  if ( LongPushCounter < LONG_PUSH_COUNTER_MAX ) LongPushCounter++;
 }

void release_timer ( void )
{
  if ( DirectSwitch || Rotation ) { ReleaseCounter = ReleaseCounterMax; return; }
  static unsigned long pms, cms; cms = millis();
  if ( cms - pms < INTERVAL_MILLIS ) return; else pms = cms;
  if ( ReleaseCounter  > 0 ) ReleaseCounter--;
  if ( ReleaseCounter == 1 ) {
    EventID = _BOOT;
  }
}
---------------------------------------------------------------------------
4_display.ino

// LCD display.

// several abbreviations.
#define months_of_the_year "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
#define days_of_the_week   "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"

// for the purpose of correction a leap year.
#define days_of_the_month  00, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // ordinary year
//                         00, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // leap year

// days, weeks and months of the year
static const char   *moy[] = { months_of_the_year };
static const char   *dow[] = { days_of_the_week   };
static const uint8_t dom[] = { days_of_the_month  };

void display_clock ( void )
{
  static unsigned long pms, cms; cms = millis();
  if ( cms - pms < 50 ) return; else  pms = cms;
  static DateTime p;
  static DateTime t;
  t = rtc.now();
  print_sec();
  if ( t.minute() != p.minute() ) print_min();
  if ( t.hour() != p.hour() ) { print_hour(); print_apm_str(); }
  if ( t.day() != p.day() ) { print_date(); print_dow_str(); }
  if ( t.month() != p.month() ) print_mon_str();
  if ( t.year() != p.year() ) print_year();
  print_temperature();
  p = t;
}

bool Century = OFF;
bool h12;
bool PM;

void print_year( void ) {
  lcd.setCursor( 0, 0 );
  lcd.print( 2000 + clock.getYear(), DEC );
}
void print_mon_str( void ) {
  lcd.setCursor( 5, 0 );
  lcd.print( moy[clock.getMonth(Century) - 1 ] );
}
void print_date( void ) {
  lcd.setCursor( 9, 0 );
  add_zero( clock.getDate() );
}
void print_dow_str( void ) {
  lcd.setCursor( 12, 0 );
  set_dow();
  lcd.print( dow[ clock.getDoW( ) - 1 ] );
}

static boolean Military = OFF;

void print_apm_str( void ) {
  lcd.setCursor( 0, 1 );
  if ( Military == OFF ) {
    if ( clock.getHour(h12, PM) > 11 ) lcd.print( "PM ");
    else lcd.print( "AM " );
  } else lcd.print( "MT ");
}
void print_hour( void ) {
  uint8_t val = clock.getHour(h12, PM);
  if ( Military == OFF ) {
    if ( clock.getHour(h12, PM) > 12 ) val -= 12;
    if ( clock.getHour(h12, PM) == 0 ) val  = 12;
  }
  lcd.setCursor( 3, 1 );
  add_zero( val );
  lcd.print( ":" );
}
void print_min( void ) {
  lcd.setCursor( 6, 1 );
  add_zero( clock.getMinute() );
  lcd.print( ":" );
}

bool StopFlag;

void print_sec( void ) {
  if ( StopFlag ) return;
  lcd.setCursor( 9, 1 );
  add_zero( clock.getSecond() );
}

static int8_t PrevTemp;

void print_temperature( void )
{
  static int8_t currTemp;
  currTemp = ( int8_t )clock.getTemperature();
  if ( PrevTemp == currTemp ) return;
  PrevTemp = currTemp;
  lcd.setCursor( 11, 1 );
  if ( currTemp < 0 )  lcd.print("-");
  else lcd.print(" ");
  add_zero( abs(currTemp) );
  lcd.setCursor( 14, 1 );
  lcd.print( char(223) );
  lcd.print( "C" );
}
void clock_refresh( void )
{
  PrevTemp = 100;
  print_sec();
  print_min();
  print_hour();
  print_apm_str();
  print_dow_str();
  print_date();
  print_mon_str();
  print_year();
  print_temperature();
}
void set_dow( void )
{
  int dow;
  byte mArray[] = { 6, 2, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
  DateTime t = rtc.now();
  dow = ( t.year() % 100);
  dow = dow * 1.25;
  dow += t.day();
  dow += mArray[ t.month() - 1];
  if ((( t.year() % 4 ) == 0 ) && ( t.month() < 3 ) ) dow -= 1;
  while (dow > 7) dow -= 7;
  clock.setDoW( dow );
}
void add_zero( uint8_t val ) {
  if ( val < 10 ) lcd.print( "0" );
  lcd.print( val );
}
void select_active( void )
{
  lcd.blink();
  lcd.noCursor();
  lcd.setCursor( 15, 0 );
  lcd.print( "." );
}
void select_inactive( void )
{
  lcd.noCursor();
  lcd.noBlink();
  lcd.setCursor( 15, 0 );
  lcd.print( " " );
}

-------------------------------------------------
5_adjust.ino

// time settings.

/////////////////////////////////////////////////////////////////////////////////
//        BOOT          BOOT          BOOT          BOOT          BOOT
/////////////////////////////////////////////////////////////////////////////////
void _00( void ) // _BOOT
{
  StopFlag = OFF;
  ReleaseCounterMax = RTMO;  
  LongPushCounter = 0;
  ReleaseCounter = 0;
  select_inactive();
  clock_refresh();
  EventID++;
}
/////////////////////////////////////////////////////////////////////////////////
//        IDLE          IDLE          IDLE          IDLE          IDLE
/////////////////////////////////////////////////////////////////////////////////
void _01( void )  // _IDLE
{
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = _YEAR;
  select_active();
  EventID++;
}
/////////////////////////////////////////////////////////////////////////////////
//        SELECT        SELECT        SELECT        SELECT        SELECT
/////////////////////////////////////////////////////////////////////////////////
void _02( void )  // _SELECT
{
  if ( is_rotation() ) return;
  if ( RotaryCounter < _YEAR ) RotaryCounter = _SECOND;
  if ( RotaryCounter > _SECOND ) RotaryCounter = _YEAR;
  switch ( RotaryCounter ) {
    case _YEAR     : lcd.setCursor( 3, 0 ); break;
    case _MONTH    : lcd.setCursor( 7, 0 ); break;
    case _DATE     : lcd.setCursor( 10,0 ); break;
    case _HOUR     : lcd.setCursor( 4, 1 ); break;
    case _MINUTE   : lcd.setCursor( 7, 1 ); break;
    case _SECOND   : lcd.setCursor( 10,1 ); break;
  }
  if ( EdgeTriggerSwitch ) EventID++;
}
/////////////////////////////////////////////////////////////////////////////////
//        DISPATCH        DISPATCH        DISPATCH        DISPATCH
/////////////////////////////////////////////////////////////////////////////////
void _03( void ) // _DISPATCH
{
  EventID = RotaryCounter;
  switch ( EventID )
  {
    case _YEAR    : RotaryCounter = clock.getYear() + 2000 ; break;
    case _MONTH   : RotaryCounter = clock.getMonth( Century ); break;
    case _DATE    : RotaryCounter = clock.getDate(); break;
    case _HOUR    : RotaryCounter = clock.getHour( h12, PM ); break;
    case _MINUTE  : RotaryCounter = clock.getMinute(); break;
    case _SECOND  : RotaryCounter = clock.getSecond(); break;
    default       : break;
  }
  lcd.cursor();
  lcd.noBlink();
}
/////////////////////////////////////////////////////////////////////////////////
//        YEAR        YEAR        YEAR        YEAR        YEAR        YEAR
/////////////////////////////////////////////////////////////////////////////////
void _04( void )  // _YEAR
{
  if ( RotaryCounter < 2000 ) RotaryCounter = 2099;
  if ( RotaryCounter > 2099 ) RotaryCounter = 2000;
  if ( is_rotation() ) {
    clock.setYear( RotaryCounter - 2000 );
    lcd.setCursor( 0, 0 );
    lcd.print( RotaryCounter );
    print_dow_str();
  }
  lcd.setCursor( 3, 0 );
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = clock.getMonth( Century );
  event_switcher( _MONTH );
}
/////////////////////////////////////////////////////////////////////////////////
//        MONTH        MONTH        MONTH        MONTH        MONTH
/////////////////////////////////////////////////////////////////////////////////
void _05( void )  // _MONTH
{
  if ( RotaryCounter > 12 ) RotaryCounter =  1;
  if ( RotaryCounter < 1  ) RotaryCounter = 12;
  if ( is_rotation() ) {
    clock.setMonth( RotaryCounter );
    print_mon_str();
    print_dow_str();
  }
  lcd.setCursor( 7, 0 );
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = clock.getDate();
  event_switcher( _DATE );
}
/////////////////////////////////////////////////////////////////////////////////
//        DATE        DATE        DATE        DATE        DATE        DATE
/////////////////////////////////////////////////////////////////////////////////
void _06() // _DATE
{
  static uint8_t dom[] = { 00, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  if ( ( clock.getYear() % 4 ) == 0 ) dom[2] = 29; else dom[2] = 28;
  if ( RotaryCounter > dom[ clock.getMonth(Century) ] ) RotaryCounter = 1;
  if ( RotaryCounter <  1 ) RotaryCounter = dom[ clock.getMonth(Century) ];
  if ( is_rotation() ) {
    print_date();
    clock.setDate( RotaryCounter );
    print_dow_str();
  }
  lcd.setCursor( 10, 0 );
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = clock.getHour( h12, PM );
  event_switcher( _HOUR );
}
/////////////////////////////////////////////////////////////////////////////////
//        HOUR        HOUR        HOUR        HOUR        HOUR        HOUR
/////////////////////////////////////////////////////////////////////////////////
void _07( void ) // _HOUR
{
  if ( RotaryCounter > 23 ) RotaryCounter =  0;
  if ( RotaryCounter <  0 ) RotaryCounter =  23;
  if ( is_rotation() ) {
    print_hour();
    clock.setHour( RotaryCounter );
    print_apm_str();
  }
  lcd.setCursor( 4, 1 );
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = clock.getMinute();
  event_switcher( _MINUTE );
}
/////////////////////////////////////////////////////////////////////////////////
//        MINUTE        MINUTE        MINUTE        MINUTE        MINUTE
/////////////////////////////////////////////////////////////////////////////////
void _08( void ) // _MINUTE
{
  if ( RotaryCounter > 59 ) RotaryCounter =  0;
  if ( RotaryCounter <  0 ) RotaryCounter = 59;
  if ( is_rotation() ) {
    clock.setMinute( RotaryCounter );
    print_min();
  }
  lcd.setCursor( 7, 1 );
  if ( !EdgeTriggerSwitch ) return;
  RotaryCounter = clock.getSecond();
  event_switcher( _SECOND );
}
/////////////////////////////////////////////////////////////////////////////////
//        SECOND        SECOND        SECOND        SECOND        SECOND
/////////////////////////////////////////////////////////////////////////////////
void _09( void ) // _SECOND
{
  if ( Rotation ) StopFlag = ON;
  if ( RotaryCounter > 59 ) RotaryCounter =  0;
  if ( RotaryCounter <  0 ) RotaryCounter = 59;
  if ( is_rotation() ) {
    lcd.setCursor( 9, 1 );
    add_zero( RotaryCounter );
  }
  lcd.setCursor( 10, 1 );
  ReleaseCounterMax = RTMS;
  if ( !EdgeTriggerSwitch ) return;
  clock.setSecond( RotaryCounter );
  StopFlag = OFF;
  event_switcher( _BOOT );
}
/////////////////////////////////////////////////////////////////////////////////
//        AMPMMT        AMPMMT        AMPMMT        AMPMMT        AMPMMT
/////////////////////////////////////////////////////////////////////////////////
void _10( void )  // _AMPMMT
{
  Military = !Military;
  print_apm_str();
  print_hour();
  if ( EdgeTriggerSwitch ) return;
  event_switcher( _BOOT );
}
/////////////////////////////////////////////////////////////////////////////////
//        _DUMMY        _DUMMY        _DUMMY        _DUMMY        _DUMMY
/////////////////////////////////////////////////////////////////////////////////
void _11( void ) // _DUMMY
{
  if ( DirectSwitch ) { lcd.noCursor(); lcd.noBlink(); return; }
  EventID = TemporaryEventID;
  lcd.cursor();
}
2

Bonjour papsnet

Pour autant que ton encodeur ne sert que comme choix de menu, en utilisant la bibliothèque Encoder.h il n'est pas nécessaire d'avoir des pin avec interruption.

Cordialement
jpbbricole

3

hello
veux tu tester ce code en regardant sur le moniteur
une platine 2560, un cable dupont enfiché sur le GND et l'autre bout successivement sur D2, D3, D18, D19, D20, D21.
te voilà 6 interruptions sur une mega. sachant que 20 et 21 sont pour l'I2C

volatile int inter0 = 0;
volatile int inter1 = 0;
volatile int inter2 = 0;
volatile int inter3 = 0;
volatile int inter4 = 0;
volatile int inter5 = 0;
volatile int inter6 = 0;
volatile int inter7 = 0;
volatile unsigned long memo0 = 0;
volatile unsigned long memo1 = 0;
volatile unsigned long memo2 = 0;
volatile unsigned long memo3 = 0;
volatile unsigned long memo4 = 0;
volatile unsigned long memo5 = 0;
volatile unsigned long memo6 = 0;
volatile unsigned long memo7 = 0;
unsigned long tempo = 200;
void isr_0() {
  if (millis() > (memo0 + tempo))
    inter0++; memo0 = millis();
}
void isr_1() {
  if (millis() > (memo1 + tempo))
    inter1++; memo1 = millis();
}
void isr_2() {
  if (millis() > (memo2 + tempo))
    inter2++; memo2 = millis();
}
void isr_3() {
  if (millis() > (memo3 + tempo))
    inter3++; memo3 = millis();
}
void isr_4() {
  if (millis() > (memo4 + tempo))
    inter4++; memo4 = millis();
}
void isr_5() {
  if (millis() > (memo5 + tempo))
    inter5++; memo5 = millis();
}
void isr_6() {
  if (millis() > (memo6 + tempo))
    inter6++; memo6 = millis();
}
void isr_7() {
  if (millis() > (memo7 + tempo))
    inter7++; memo7 = millis();
}

void setup() {
  Serial.begin(115200);
  for (int f = 2; f < 45; f++) {
    pinMode(f, INPUT_PULLUP);
  }//int4 D2

  attachInterrupt(0, isr_0, FALLING);//2//ok
  attachInterrupt(1, isr_1, FALLING);//3//ok
  attachInterrupt(2, isr_2, FALLING);//21//ok
  attachInterrupt(3, isr_3, FALLING);//20//ok
  attachInterrupt(4, isr_4, FALLING);//19//ok
  attachInterrupt(5, isr_5, FALLING);//18//ok
  attachInterrupt(6, isr_6, FALLING);//NC
  attachInterrupt(7, isr_7, FALLING);//NC
  sei();
}

void loop()
{
  Serial.print(inter0); Serial.print('\t');
  Serial.print(inter1); Serial.print('\t');
  Serial.print(inter2); Serial.print('\t');
  Serial.print(inter3); Serial.print('\t');
  Serial.print(inter4); Serial.print('\t');
  Serial.print(inter5); Serial.print('\t');
  Serial.print(inter6); Serial.print('\t');
  Serial.println(inter7);
  delay(10);
}
4

une autre version que j'avais faite pour un gars qui faisait du midi, et qui voulait 4 encodeurs.
Le code traite 8 encoders
ici, ce sont des interruptions sur les ports
encodeur_mont_desc_portKB_mega_x8_ok.zip (6,0 Ko)

5

j'ai essayé cette bibliothèque mais il faut modifier ces lignes de code
attachInterrupt( 0, isr_0, RISING );
attachInterrupt( 1, isr_1, RISING );
J'ai essayé avec
if (digitalRead(DT)==HIGH && (digitalRead(CLK)=LOW) void isr_0 ();
if (digitalRead(DT)==LOW && (digitalRead(CLK)=HIGH) void isr_1 ();
Mais impossible de rediriger vers un des menu isr

6

je suis désolé je ne comprend pas comment convertir les entrées 31 33 en entrées d'interruption .
J'ai une ramps 1.4 sur ma carte arduino avec le connecteur écran 2004 avec son encodeur les pins d'entrées ne peuvent pas être interverti!

7

Bonsoir papsnet

L'usage de la bibliothèque n'est pas tout à fait ça :wink:
Tu n'as plus besoin de ces interruptions.

Tu devrai faire un des exercice pour en comprendre l'usage.

Cordialement
jpbbricole

8

Ce que dit la doc sur la mega:

The External Interrupts are triggered by the INT7:0 pin or any of the PCINT23:0 pins.

Cela correspond aux broches
PORTB0 à PORTB7 (PCINT0 à PCINT7), broches 53 à 50 (mais MOSI, MISO...) et 4 à 7
PORTD0 et PORTD3 (INT0 à INT3), broches 21 à 18
PORTE (PCINT8), broche 0 (mais utilisée pour RXD0)
PORTE4 à PORTE5 (INT4 à INT5), broches 2, 3
PORTJ0 à PORTJ1 (PCINT9 et PCINT10), broches 15, 14,
PORTK0 à PORTK7 (PCINT16 à PCINT23), broches A8 à A15
Cela fait plutôt 24 broches.

9

Bonjour vileroi

La doc du Mega dit 6:
External Interrupts: 2 (interrupt 0), 3 (interrupt 1), 18 (interrupt 5), 19 (interrupt 4), 20 (interrupt 3), and 21 (interrupt 2).

En parlant d'un usage des interruptions "normal", dans le langage Arduino, avec attachInterrupt().

Cordialement
jpbbricole

10

hello
**tu as raison, il n'y a pas 6 interruptions, mais 4 **

sur la datat sheet et dans le µ, il y a bien 8 interruptions INT0 à INT7

ce sont des interruptions que j'appellerai " directes"
mais les pins 20 et 21 sont aussi utilisées pour l'I2C, donc ce sera selon le programme et les périphériques utilisés ( I2C ou pas). (voir le 1er programme que j'ai donné en post #3)
et les bits 6 et 7 du port E qui n'ont pas été "routés" sur le PCB.
8 INT - (les 2 pour I2C) - (les 2 non routées) = 4 INT utilisables
et il y à 24 interruptions possibles sur les PORT B et K .
ce sont des interruptions que j'appellerai "indirectes", car il faut lire les bits du port en interruption pour savoir par ou est arrivée l'interruption.
PCINT0 à PCINT7 pour le port B (attention D50,51,52,53 concernés)
PCINT8 à PCINT15 pour les ports E sur le bit 0 et J mais seuls les bits 0 et 1 sont "routés" sur le PCB
PCINT16 à PCINT23 pour le port K
donc 24 PCINT-(D50àD53)-(PCINT11 à PCINT15 non routés)- PCINT0 qui est RX0)=14 PCINT utilisables

voir le programme que j'ai donné en post #4

le micro est une chose, la platine Arduino en est une autre.

tu peux me dire que ma puissante voiture équipée d'une boite 8 vitesse peut monter à 400Km par heure, si tu m'enlèves les 3 derniers pignons dans la boite...................

fin de la discussion.

11

Ce n'est pas la doc du Mega, c'est une pub simplifiée. D'après cette doc, il n'y aurait pas de timers ni de comparateur...

< :stuck_out_tongue_winking_eye:>à 20 près?</:stuck_out_tongue_winking_eye:>

< :stuck_out_tongue_winking_eye:>Ouais, c'est des ports de 12 bits!</:stuck_out_tongue_winking_eye:>

Pas forcément, si on n'en utilise qu'une seule, et qu'il y a une interruption, on sait laquelle c'est sans investigations.

Cela fait quand même 4+14 interruptions possibles! On est d'ailleurs d'accord, dans les 24 j'ai quand même compté D50 à 53 ainsi que les I2C.

12

Bonjour vileroi

Et ça?

Cordialement
jpbbricole

13

tu prends un malin plaisir à jouer sur les mots INT et PCINT
ports de 12 bits : j'ai oublié de citer le port J et et port E bit 0.

maintenant que c'est rectifié, je vous laisse.

14

Je te remercie pour le conseil , effectivement j'ai testé d'autres librairies et des exemples.
Je viens de comprendre effectivement ( dfgh) que la fonction attachinterrup était lié avec les menus type isr_ .
Donc il faut que je remplace cette partie du code aussi.
j'ai besoin d'utiliser une bibliothèque comme Encoder.h et un code qui gère les résultats (rebond) puis de les intégrer dans mon code ?
Ai je bien compris ou je suis encore à coté ?
Merci

15

Ce n'est pas nécessaire, la bibliothèque s'occupe des rebonds. Tu n'as qu'à t'occuper du compteur incrémenté ou décrémenté.

16

Il n’y a pas qu’ ”attachinteruption ” dans la vie d’un programmeur.
Les PCinterupt, sur port avr, existent même si elles ne sont pas gérées par Arduino.
Les micros peuvent faire plus ce qu’arduino en fait.
Arduino c’est la facilité, ce n’est pas l’utilisation maximale des micros.
Tous ces avr étaient déjà programmés en C, même pas en C++, que Wiring n’était pas encore un projet, et comme arduino n’est qu’une copie inamicale de Wiring.......

Quand arduino est limité, il faut savoir en sortir et lire les datasheets des composants.

La documentation arduino s’est améliorée par rapport au temps ou il était dit que l’on pouvait faire débiter 40 mA à toutes les sorties (ce qui était une triple, quadruple erreur) mais il reste a faire, notament avec des entrées qui sont présentées comme étant uniquement analogiques alors que leur état premier a la mise sous tension est d’etre complètement numérique.

1 Like
17

Bonjour 68tjs

Oui, c'est certain!

Mais c'est tellement plus simple avec attachInterrupt et du moment que cela suffit, pourquoi se prendre la tête.

Oui, c'est l'essence même du concept Arduino et de son langage, la facilité d'emploi.

Cordialement
jpbbricole
.

18

Je reviens vers vous apres avoir essayé moulte tentative et je n'arrive à rien.
J'ai fais des exemples avec mon montage , arduino mega , ramps 1.4 lcd 2004 avec smart controler .
j'arrive en effet à faire fonctionner l'encodeur mais impossible d'intégrer au code que j'ai posté.
Je manque de connaissances pour pouvoir recoder , je tente donc en branchant fil à fil la broche smart controler correspondant à ma ramps en récupérant les pins de l'encoder (31,33) et en les branchant sur la ramps en D2,D3 qui sont si je suis bien xd des pins d'interruptions int 4, int 5.
je remplace dans le code en corrigeant par
attachInterrupt( digitalPinToInterrupt(2), isr_0, RISING );
attachInterrupt( digitalPinToInterrupt(3), isr_1, RISING );
et évidemment ça fonctionne pas .
Si vous pouviez m'éclairer de vos lanternes lol
Merci

19

Voir en #3

20

Voir, également, en #2 :wink: