Messages récents

Pages: 1 2 [3] 4 5 ... 10

Vos projets / Re : Les nouveaux AVR: coeur AVRx avec MEGACOREX, DXCORE, MEGATINYCORE

« Dernier message par laurentr le mai 02, 2024, 09:02:29 pm »

Poursuivons ici avec l'utilisation de la librairie LOGIC toujours avec les mêmes broches:



#include "Logic.h"

//PIN_PB0 PIN_PB1 and PIN_PB3 are mapped by default on LOGIC BLOCK CCL LUT2

void INIT_LOGIC_BLOCK2()
{
  Logic2.enable;                          //ENABLE LUT2
  Logic2.input0 = logic::in::input;       //input PIN_PB0
  Logic2.input1 = logic::in::input;       //input PIN_PB1 
  Logic2.input2 = logic::in::masked;      //masked = not used
  Logic2.output = logic::out::enable;     //use OUTPUT
  Logic2.output_swap = logic::out::no_swap; // use PIN_PB3 as OUTPUT
  Logic2.truth = 0x08;                    //AND OUT ON IF BOTH IN ARE HIGH

  Logic2.init();
  Logic2.start();
    
}

void setup() {

  INIT_LOGIC_BLOCK2();

}

void loop() {
  

}

Il n'y a plus de code dans la boucle principale, tout se fait en HARD et SANS aucune intervention du CPU!

Ltr

Vos projets / Re : Les nouveaux AVR: coeur AVRx avec MEGACOREX, DXCORE, MEGATINYCORE

« Dernier message par laurentr le mai 02, 2024, 08:49:16 pm »

Prenons un exemple simple pour illustrer:

Nous travaillons avec un ATTINY1626.

https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/ATtiny1624-26-27-DataSheet-DS40002234B.pdf

Voir la tableau page 18 qui reprend les attributions de broches.

CAS: AND à 2 entrées:

Dans un code habituel nous ferions la lecture de 2 entrées et nous ferions l'association de leur état pour produire une sortie selon la combinaison en entrée

Code: [Sélectionner]


/*
 * WE USE: 
 * PIN_PB0 PIN_PB1 as INPUT 
 * PIN_PB3 as OUTPUT
 */

#define ENTREE_1 PIN_PB0
#define ENTREE_2 PIN_PB1

#define SORTIE_1 PIN_PB3

void setup() {
  // put your setup code here, to run once:

  pinMode(ENTREE_1,INPUT);
  pinMode(ENTREE_2,INPUT);

  pinMode(SORTIE_1,OUTPUT);  

}

void loop() {

  bool IN1 = digitalRead(ENTREE_1);
  bool IN2 = digitalRead(ENTREE_2);

  bool OUT_STATE = IN1 & IN2;

  digitalWrite(SORTIE_1,OUT_STATE);

}

Ce code est optimisable car les utilisations des fonctions digitalRead(), digitalWrite() sont gourmandes en temps.
Nous utiliserions pour cela de mode de manipulation direct des ports (et donc l'écriture dans les registres)

Explications ici par exemple:
https://github.com/SpenceKonde/DxCore/blob/master/megaavr/extras/DirectPortManipulation.md

On utilise aussi 3 des 4 registres internes pouvant stoker chacun 1 byte.
Leur accès est ce qui est le plus rapide

Code optimisé:

Code: [Sélectionner]


#define SORTIE1_ON  PORTB.OUTSET = PIN3_bm
#define SORTIE1_OFF PORTB.OUTCLR = PIN3_bm

#define IN1 GPIOR0
#define IN2 GPIOR1
#define OUT_STATE GPIOR3


void setup() {
  // put your setup code here, to run once:

  //PIN_PB0 AS INPUT:
  PORTB.DIRSET = PIN0_bm;

  //PIN_PB1 AS INPUT:
  PORTB.DIRSET = PIN1_bm;

  //PIN_PB3 AS OUTPUT
  PORTB.DIRCLR = PIN3_bm;

}

void loop() {
  // put your main code here, to run repeatedly:

  IN1 = PORTB.IN & PIN0_bm;
  IN2 = PORTB.IN & PIN1_bm;

  OUTSTATE = IN1 & IN2;

  if(OUTSTATE)
  {
    SORTIE1_ON;
  }
  else
  {
    SORTIE1_OFF;
  }
}

En revanche nous avons perdu ici la "portabilité" du code d'un hardware vers un autre au bénéfice d'une performance accrue sur le hardware dédié.

Vos projets / Re : centrale DCC / analogique modulaire

« Dernier message par laurentr le mai 02, 2024, 08:21:49 pm »

Historiquement le rapport du cout pour passer de 2 vs 4 couches était d un rapport de 1 à 4

C'est restait plutôt stable, voir même le cout du 4 couches a baissé

A noter que le format 100mmx100mm ( 10x10cm) est moins pénalisant coté cout qu'autrefois.

En revanche les prix du port ont "explosé"!

Pour le montage c est selon... mais il y a quelques astuces pour optimiser:
respecter la taille mini du 70mmx70mm y compris avec des bords "edges" additionnels pour y parvenir.
choix de composants en évitant si possible les "extended"
garder tout ce qui est traversant à implanter soit même.( connecteurs notamment, relais,...)

en cas de petites séries rester sur des couleurs et épaisseurs "ordinaires" type 1.6mm/vert
équiper 2/5 des pcb fabriqués.

garder un oeil entre les multiples de couts des pièces et leur nombre à implanter.
enfin rester sous les 150€ pour ne pas avoir de taxes supplémentaires à devoir acquitter...

Ltr

Ltr

Vos projets / Re : centrale DCC / analogique modulaire

« Dernier message par lebelge2 le mai 02, 2024, 07:29:48 pm »

Bonjour.

Assemblage PCB:

Juste pour vous informer que je viens de faire une simulation pour un double face et les prix ont fortement augmenté chez JLCPCB.
Pour ma part, je ne ferai plus que des simples faces....
Alors pour un quatre couches……

Vos projets / Re : Les nouveaux AVR: coeur AVRx avec MEGACOREX, DXCORE, MEGATINYCORE

« Dernier message par laurentr le mai 02, 2024, 06:22:57 pm »

Dans l'exemple donné vous remarquerez qu'il n'est pas nécessaire de déclarer en INPUT et OUTPUT les broches.

La librairie du framework va s'en occuper tt seule comme une grande.

Il peut en être différemment lorsque l'on combine des éléments plus complexes entre eux!

Voir l'exemple de code plus complet donné dans le post: https://forum.locoduino.org/index.php?topic=1707.0 pages 4 et 5.

Ltr

Vos projets / Re : Les nouveaux AVR: coeur AVRx avec MEGACOREX, DXCORE, MEGATINYCORE

« Dernier message par laurentr le mai 02, 2024, 06:10:52 pm »

On retrouve dans ces framworks des librairies qui vont piloter des couches hardware de ces processeurs.

On peut naturellement se passer de leur apport mais il faudra dans ce cas re écrire une bonne partie de code pour piloter ces éléments hardware.

Autant bénéficier des solutions "universelles" déjà testées et approuvées par une large communauté.
Ces framework étant à présent "matures" et continue d'évoluer pour prendre en comptes des correctifs ou de nouveaux CPU.

Nous avons évoqué précédemment des composants additionnel sur ces nouvelles puces.

Nous allons en traiter 3 ici:
le "GLU LOGIC"
le "COMPARATOR"
l "EVENT"

Chacun dispose de sa bibliothèque et pour l utiliser nous ajouterons en tête de programme:

Code: [Sélectionner]

#include "nom_de_la_librairie;h"
Maintenant de quoi retourne t il:
GLU LOGIC:
C est en fait un ensemble de portes logiques configurables à la demande.
On peut disposer sur chaque bloc logique appelé LUT de 3 entrées et d'une sortie.
Ces entrées et sorties peuvent être de différentes natures: entrée de pins, event, état d'un composant interne,...
De nombreuses combinaisons sont offertes et il est même possible dans certaines conditions de chainer ces portes logiques.

L intérêt de cette logique programmée est qu'elle est INDEPENDANTE des ressources du coeur du CPU. = elles n'utilisent pas de ressources du cœur du CPU pour fonctionner.
C est l'équivalant de composants externes placés dans la puce comme "bonus" en étant en plus très rapides, moins encombrant et donc globalement plus performant.

A titre d exemple voici un paramétrage du 3eme LUT ( 3eme bloc logique):

sur un ATTINY1626: (MEGATINY1626)

Code: [Sélectionner]

  //LOGIC LUT3:
    Logic3.enable;                                //ENABLE LUT3
    Logic3.input0 = logic::in::ac;           //AC0 level OUT : sortie du comparateur
    Logic3.input1 = logic::in::input;       //PC1 input : correspond ici à la broche PC1
    Logic3.input2 = logic::in::event_a;   //evenement_a
    Logic3.output = logic::out::enable;  //output on PIN PA5 
    Logic3.truth = 0x0a;                       //table de vérité de combinaison des 3 entrées input0, 1 ,2: =10 = 0x0a ==> la sortie est a 1 quand uniquement l'entrée input2 est à 1. sinon 0

    Logic3.init();
    Logic3.start();

Cette exemple, non le plus simple, montre surtout la diversité des éléments combinables et il sera surement plus simple dans vos premières mises en œuvre de test de réaliser les exemples fournis par ces frameworks. ( NAND, AND, NOR, XOR, OR,...)

N'hésitez pas à commenter ces premiers éléments de présentation pour que nous l'enrichissions collectivement.

Ltr

Vos projets / Nouveaux AVR:coeur AVRx avec MEGACOREX, DXCORE, MEGATINYCORE: utiliser le HARD:

« Dernier message par laurentr le mai 02, 2024, 05:42:17 pm »

On voit ici que des chiffres apparaissent et il vont avoir un rôle pour identifier les générations de processeurs et ou leur ressources.
Sur le ATTINY85 on retrouve 8K de mémoire contre 4K seulement pour le 45 et seulement 2 pour le 25.
Le chiffre 5 étant l'indice de la série de ces processeurs.

Apparus il y a plus de 10 ans ces processeurs ont vu leur descendance s'étendre en apportant leur lot d'innovations et d'apports.

A titre d exemple de nouveaux processeurs sont aussi devenus "compatibles ARDUINO", c'est à dire programmables via l'interface IDE ARDUINO.
Les plus connus sont le LESP8266 et l'ESP32 (dans leur différentes déclinaisons)

Dans la lignée de leur ainés chez ATMEL MICROCHIP les AVR on vu la gamme complétée des AVRx:
On distingue 2 groupes de façon générale: (avec qq exceptions):
les TINY dont le nombre de broches est <=24
les "MEGA" qui ont dont un nombre de broches >24

Dans ces 2 groupes plusieurs générations se sont suivies: série 0, série 1, série 2.

On se reportera aux datasheets de chaque item pour leur caractéristiques propres.

Toutefois ces CPU disposent d'organes communs, souvent méconnus dont nous allons présenter quelques éléments utiles:
TIMER
EVENT
GLU LOGIC
COMPARATOR

Pour assurer la portabilité entre le code et le soft on a recours a des frameworks qui vont faire "en sous marin" des opérations complexes avec une mise en œuvre simplifiée.
Pour les AVRx on dispose de 3 framework selon les CPU:

AVRX MEGA série 0 : les célèbres ATMEGAx08 et X09 dont le ATMEGA4809 qui équipe les ARDUINO NANOEVERY ==>framework MEGACOREX
https://github.com/MCUdude/MegaCoreX

AVRX "TINY" pour les "petits CPU" serie 0, 1 et 2: ==>framework MEGATINYCORE
https://github.com/SpenceKonde/megaTinyCore

AVRX "MEGA" serie 0, 1, 2 avec : ==>framework DXCORE
https://github.com/SpenceKonde/DxCore

Ltr

Vos projets / Re : RailCom: Générateur de CutOut

« Dernier message par laurentr le mai 02, 2024, 05:09:45 pm »

Hello Marc

Tu as raison la facilitera "l'adoption" et montrera la plus value de ces processeurs sur leur ainés dans le cas présent.

Je vais ouvrir un post dédié car cela sera utile en dehors de ce projet.

Je vais préparer ce qu'il faut pour mieux comprendre de quoi il retourne

J'ai profité de mes essais pour implémenter la commande externe avec gestion ad hoc de la led d'indication.
J ai du pour cela très légèrement revoir le mapping et ajouter quelques variables pour que "cela passe crème" sans voir besoin de ressources supplémentaires.

Ltr

Vos projets / Re : RailCom: Générateur de CutOut

« Dernier message par trimarco232 le mai 02, 2024, 03:37:01 pm »

Laurent ,
les gens sont peu familiers avec la valorisation de tels hardwares , notamment les programmateurs , qui ont du mal avec l'électronique , et qui ont une culture de portabilité de leurs codes
si tu as du temps , tu peux faire une description didactique du projet , avec des dessins décrivant le principe général , et le rôle de chaque hardware particulier : cela permettra aux gens de voir les avantages des nouveaux microcontrôleurs , et de les comprendre , et de les approuver

Vos projets / Re : RailCom: Générateur de CutOut

« Dernier message par laurentr le mai 02, 2024, 06:02:49 am »

CODE PART 4:

Code: [Sélectionner]


void setup()
{
  INIT_PINS(); //init first PINS

  //SIMPLE_AMPLIFICATOR = digitalRead(SIMPLE_AMPLIFICATOR_MODE_INPUT_PIN);
  AMPLIFICATOR_MODE = PORTC.IN & PIN4_bm; //faster

  if(AMPLIFICATOR_MODE == false)
  {    
    LED_SIMPLE_AMPLIFICATOR_MODE_PIN_OFF;

    INIT_TCB();

    INIT_ADDITIONNAL_PINS();

    //RAILCOM = digitalRead(RAILCOM_MODE_SELECTOR_INPUT_PIN);
    RAILCOM = PORTC.IN & PIN3_bm; //faster

    INIT_SYSTEM_WITH_RAILCOM();

    if (RAILCOM == false) //NO RAILCOM
    {
      //force these states out:
      LOGIC_ENABLE_OUT_PIN_ON;
      LOGIC_CUTOUT_OUT_PIN_ON;

      LED_RAILCOM_ENABLE_PIN_OFF;
    }
    else
    {
      LED_RAILCOM_ENABLE_PIN_ON;
    }
  }
  else
  {
    LED_RAILCOM_ENABLE_PIN_OFF;
    RAILCOM = false;
    LED_SIMPLE_AMPLIFICATOR_MODE_PIN_ON;
    
    INIT_SYSTEM_SIMPLE_AMPLIFICATOR();
  }

}


void loop(){

  //NOTHING TO DO! ALL IS AUTOMATIC :)

}

Plus qu'a se pencher sur un dessin de PCB pour donner vie à ce dispositif!

Ltr

Pages: 1 2 [3] 4 5 ... 10

Nouvelles: