Contrôle d'un périphérique en I2C (PA, LPF, ...)

[F4HJH 43]

Bonjour,

Je dispose d'une "boite noire", il s'agit du module C25 (Charly 25) vendu chez RedPitaya dans le kit SDR de base.

[Edition : Ah j'oubliais... il n'existe à priori aucune documentation à peu près technique sur ce machin, ou bidule. Sauf une doc pour presse-bouton qui explique que le + doit être connecté au fil rouge....]

Ce module est un amplificateur HF, mais aussi un filtre commutable pour les bandes HF radioamateur.

Voici une vue du C25 :

 

Il est piloté en I2C depuis la version Charly 25 de Power SDR.

Connecté en SSH sur la RedPitaya, à l'aide des commandes I2Cdetect et I2Cget, j'ai pu récupérer les valeurs transmises en RX et TX par bande, voici ce que l'on a :

 

A noter que le filtrage vaut aussi pour la réception !

L'adresse du C25 est 0x20, j'ai remarqué des valeurs de registre différentes (0, 1 après les valeurs sont répétées pour 2, 3)

Pour piloter cette "boi-boite" et donc se défaire du "carcan" commercial, j'ai pour idée l'emploi d'un arduino.

Voici le bout de code que j'utilise :

Citation

// Test de pioltage du module C25 amp + LPF) en I2C

#include <Wire.h>

void setup() {
  Wire.begin(); // Déclaration du maitre sur le bus i2c
  Serial.begin(9600); // initialisation de la liaison série pour utilisation de la console
}

// Déclaration valeur par bande et par état du PTT
byte B80m_ptt_off = 2000; 
byte B80m_ptt_on = 2030;

void loop() {
  Wire.beginTransmission(32); // début de la transmission au périphérique d'adresse #32 (0x20)
  Wire.write(B80m_ptt_off);   // envoi d'une valeur au periphérique
  delay(4000);
  Wire.write(B80m_ptt_on);    // envoi d'une valeur au periphérique
  Wire.endTransmission();    // arrêt de la transmission I2C
  delay(2000);
}

 

Mais rien ne se passe.... (pour le moment 😊)

Quelqu'un aurait une idée de ce qui ne va pas ?

 

Modifié 9 juin 2019 par F4HJH

[F6FVY 32]

Bjr

Je n'y connais pas grand chose en I2C, mais initialiser un byte à 2000 (écrit en décimal et non en hexa comme dans le tableau !) pose déjà un problème...

73

Laurent - F6FVY

[F4HTQ 265]

il y a 42 minutes, F6FVY a dit :

Bjr

Je n'y connais pas grand chose en I2C, mais initialiser un byte à 2000 (écrit en décimal et non en hexa comme dans le tableau !) pose déjà un problème...

73

Laurent - F6FVY

Oui, il y a deux bêtises en une

le format d'écriture du nombre et la taille.

Avant de conseiller à Christophe  F4HJH une implémentation qui marche, je pose a mon tour une question.

Sur l'I2C, c'est du little endian ou du big endian ? 

Ou formulé autrement: On envoie quoi en premier ? l'octet de poids le plus faible ou l'octet de poids le plus fort ?

ça dépend du périphérique ou alors c'est fixé par une norme ?

David.

Edit: ici ils se posent la même question ==> https://www.raspberrypi.org/forums/viewtopic.php?t=122923

j'ai fouillé dans le document de la norme et rien n'est indiqué. la norme ne s’intéresse qu'aux octets. Il faut donc visiblement en déduire que c'est le constructeur du périphérique lui même qui décide si on lui parte en Little ou Big endian.

Modifié 9 juin 2019 par F4HTQ

[F6FVY 32]

Re

il y a 8 minutes, F4HTQ a dit :

ça dépend du périphérique ou alors c'est fixé par une norme ?

Selon ce que je lis c'est réglé par le périph. I2C.

Néanmoins, à voir la photo, les "I/O expanders" utilisés n'ont que 8 sorties. Je ne vois pas trop pourquoi on aurait à envoyer 16 bits de données ? Cela dit, la chose pourrait s'éclaircir avec un schéma ou la réf de ces circuits.

73

Laurent - F6FVY

[F4HJH 43]

@F4HTQ David & @F6FVY Laurent,

merci pour vos remarques, je vais modifier les valeurs et tester. Quant au code caractère, je n'ai pas d'avis sur la question.

[F4HJH 43]

Je viens de tester une variante

Citation

// Test de pioltage du module C25 amp + LPF) en I2C

#include <Wire.h>

void setup() {
  Wire.begin(); // Déclaration du maitre sur le bus i2c
  Serial.begin(9600); // initialisation de la liaison série pour utilisation de la console
}

// Déclaration valeur par bande et par état du PTT
byte B80m_ptt_off = 8182; 
byte B80m_ptt_on = 8240;

void loop() {
  Wire.beginTransmission(32); // début de la transmission au périphérique d'adresse #32 (0x20)
  Wire.write(B80m_ptt_off);   // envoi d'une valeur au periphérique
  delay(4000);
  Wire.write(B80m_ptt_off);    // envoi d'une valeur au periphérique
  Wire.endTransmission();    // arrêt de la transmission I2C
  delay(2000);
}

J'ai donc converti l'Hexa en decimal. Il ne se passe toujours rien.

C'est un peu plus compliqué que je ne le pensait. Lorsque j'ai fait mes relevés, j'ai noté des valeurs Hexa différentes dans deux data address.

Vous savez comme cela est géré ? car lorsque j’écris en mémoire vi la bibliothèque Wire, on ne fais pas reference à ces registres...

 

Modifié 9 juin 2019 par F4HJH

[F4HTQ 265]

Christophe,

Il y avais eux erreurs, le décimal utilisé et la taille de stockage.

la vous utilisez un byte, ça plafonne à 0xFF.

Ce qu'il vous faut faire c'est ça:

 

byte B80m_ptt_off_Low = 0x00; 

byte B80m_ptt_off_High = 0x20; 

byte B80m_ptt_on_Low = 0x30;

byte B80m_ptt_on_High = 0x20;

void loop() {
  Wire.beginTransmission(32); // début de la transmission au périphérique d'adresse #32 (0x20)
  Wire.write(B80m_ptt_off_Low);   // envoi d'une valeur au periphérique
  Wire.write(B80m_ptt_off_High);   // envoi d'une valeur au periphérique

  delay(4000);
  Wire.write(B80m_ptt_on_Low);    // envoi d'une valeur au periphérique
  Wire.write(B80m_ptt_on_High);    // envoi d'une valeur au periphérique

  Wire.endTransmission();    // arrêt de la transmission I2C
  delay(2000);
}

David.

Et si ça ne fait  toujours rien, essayez en permutant les envois de Low et High ( au cas ou ça fonctionnerais en big endian)

Modifié 9 juin 2019 par F4HTQ

[F4HJH 43]

Merci David,

J'ai donc mis à jour le code en suivant vos conseils.

Citation

// Test de pilotage du module C25 amp + LPF) en I2C

#include <Wire.h>

void setup() {
  Wire.begin(); // Déclaration du maitre sur le bus i2c
  Serial.begin(9600); // initialisation de la liaison série pour utilisation de la console
}

// Déclaration valeur par bande et par état du PTT
byte B80m_ptt_off_Low = 0x00; 
byte B80m_ptt_off_High = 0x20; 
byte B80m_ptt_on_Low = 0x30;
byte B80m_ptt_on_High = 0x20;

void loop() {
  Wire.beginTransmission(32); // début de la transmission au périphérique d'adresse #32 (0x20)
  
  Wire.write(B80m_ptt_off_Low);   // envoi d'une valeur au periphérique
  Wire.write(B80m_ptt_off_High);   // envoi d'une valeur au periphérique

  delay(4000);
  Wire.write(B80m_ptt_on_Low);    // envoi d'une valeur au periphérique
  Wire.write(B80m_ptt_on_High);    // envoi d'une valeur au periphérique

  Wire.endTransmission();    // arrêt de la transmission I2C
  delay(2000);
}

Si j'ai compris, on écris dans le registre avec deux bits : un de poids faible "Low" et un de poids fort "High"

J'ai fait les inversions de valeurs au cas ou le fonctionnement se fait en Big Endian.

Pour le moment, toujours pas de réaction de la "boi-boite".... On va l'avoir 😋

 

[F4HTQ 265]

Alors ce n'est pas deux "bits" mais deux "bytes" ( octet).

Mais oui, le principe c'est ça, c'est décrire en deux envois de 8 bits un nombre de 16 bits.

[F4HJH 43]

il y a 3 minutes, F4HTQ a dit :

Alors ce n'est pas deux "bits" mais deux "bytes" ( octet).

Vous avez raison ! Les BYTES sont composés de 8 BITS 😊

[F4HJH 43]

J'ai testé plusieurs variantes, mais il ne se passe toujours rien... La "boi-boite" ne se laisse pas faire.

Donc, dans cette derniere version, les valeurs sont des byte, j'ai conservé la méthode proposée par @F4HTQ  David (On écris octet par octet)

 

Citation

#include <Wire.h>

void setup() {
  Wire.begin(); // Déclaration du maitre sur le bus i2c
}

// Déclaration valeur par bande et par état du PTT
byte B80m_ptt_off_Low = "0x00"; 
byte B80m_ptt_off_High = "0x20"; 
byte B80m_ptt_on_Low = "0x30";
byte B80m_ptt_on_High = "0x20";

void loop() {
  Wire.beginTransmission(32); // début de la transmission au périphérique d'adresse #32 (0x20)

  Wire.write( ((byte*)&B80m_ptt_off_Low)[0] ); // envoi d'une valeur au periphérique Premier octet
  Wire.write( ((byte*)&B80m_ptt_off_Low)[1] ); // envoi d'une valeur au periphérique Second octet

  delay(4000);

  Wire.write( ((byte*)&B80m_ptt_on_Low)[0] ); // envoi d'une valeur au periphérique Premier octet
  Wire.write( ((byte*)&B80m_ptt_on_Low)[1] ); // envoi d'une valeur au periphérique Second octet

  Wire.endTransmission();    // arrêt de la transmission I2C
  delay(4000);
}

Par contre, on ne tiens pas compte du registre mémoire... 

Par exemple sur 80m, lorsque l'on passe en émission, les valeurs dans les deux premiers registres sont différentes (data adresses dans mon tableau plus haut)

J'ai encore des progrès à faire 😋

 

Modifié 10 juin 2019 par F4HJH

[F6ITU 265]

bonjour

@F4HJR c'est bizarre, on dirait que toutes les tofs publiées sont interdites de lectures de mon côté… le tableau est lisible, mais pas le document situé au dessus.

Comme je ne suis pas du tout programmeur, et surtout un gros fainéant, et que le filtre C25 est piloté par un PCA9555, j'utiliserais la lib de nico Verduin qui m'éviterait de ramer de la même manière (ça va faire hurler David et tous les pros du code orthodoxe, et j'ai même pas honte)

voir sur  //https://github.com/nicoverduin/PCA9555 

reste à déclarer

#include "clsPCA9555.h"

PCA9555 ioport(0x20);

youpiii!

ne pas oublier de configurer les gpio du PCA en "sorties" (car ce biniou est bidirectionnel, il peut également "lire" un état et le renvoyer sur le bus I2C) 

for
	(uint8_t i = 0; i < 18; i++)
	{
	ioport.pinMode(i, OUTPUT); }

exemple de pilotage de 9555 avec un ArduiLoL 

https://github.com/F6ITU/MSA_Switching/blob/master/MSA_Switching.ino

qui me sert à commuter des relais coax 24V dans une sorte de super-séquenceur (frontend de mon analyseur de spectre) 

le bus I2C ne servant qu'à deux composants : le 9555 et l'afficheur LCD. Mais on pourrait cascader autant de 9555 (ou presque) car il est adressable sur 3 bits, de 0x20 à 0x27, soit 128 E/S... on peut piloter plein de filtres C25 :-) 

Marc

 

[F4HJH 43]

Bonjour Marc,

merci d'avoir signalé que la photo n'est pas visible. C'est un copié / collé depuis google photos, le tableau des valeurs proviens d'une image locale....

Voici donc la photo manquante en question :

 

il y a 8 minutes, F6ITU a dit :

et que le filtre C25 est piloté par un PCA9555

Ça y est ! Je suis sur une bonne piste je pense. 😊 A suivre donc... 

[F4HJH 43]

J'ai trouvé du code qui devrais me permettre de m'en sortir.

J'ai trouvé ceci : 

Citation

/*
	Charly 25LC pin assignment for PCA9555 port expander IC:
	Attenuator 12dB: I/O 0.0 -> Initial value = 0
	Attenuator 24dB: I/O 0.1 -> Initial value = 0
	VV 1 (preamp 1): I/O 0.2 -> Initial value = 0
	VV 2 (preamp 2): I/O 0.3 -> Initial value = 0
	unused: I/O 0.4 -> Initial value = 0
	unused: I/O 0.5 -> Initial value = 0
	unused: I/O 0.6 -> Initial value = 0
	unused: I/O 0.7 -> Initial value = 0
	10m: I/O 1.0 -> Initial value = 1
	20m: I/O 1.1 -> Initial value = 0
	40m: I/O 1.2 -> Initial value = 0
	80m: I/O 1.3 -> Initial value = 0
	Antenna relais: I/O 1.4 -> Initial value = 0
	PA switch: I/O 1.5 -> Initial value = 0
	unused: I/O 1.6 -> Initial value = 0
	unused: I/O 1.7 -> Initial value = 0
	*/

Source : Charly_25LC_Tester_V1_2.ino

Puis : Charly_25_RX_BPF_Board_Tester_V1_2.ino

Ce sont bien des PCA9555 qui permettent le pilotage de l'ensemble.

=> Il n'y a plus qu'à faire, je devrais pouvoir m'en sortir seul.

Je vais donc tester le pilotage de cette boite noire, et écrire un système à base d'arduino pour s'affranchir du logiciel PowerSDR édition Charly25.

Je rassemblerai tout dans Github avec un peu de doc une fois le système fonctionnel.

 

[F4HJH 43]

Le 09/06/2019 à 13:20, F6FVY a dit :

Néanmoins, à voir la photo, les "I/O expanders" utilisés n'ont que 8 sorties. Je ne vois pas trop pourquoi on aurait à envoyer 16 bits de données ? Cela dit, la chose pourrait s'éclaircir avec un schéma ou la réf de ces circuits.

Je vais en profiter pour démonter à nouveau le module et prendre quelques photos pour détailler les circuits cet apres-midi au radio club.

[F6EHJ 28]

il y a 15 minutes, F4HJH a dit :

Je vais en profiter pour démonter à nouveau le module et prendre quelques photos pour détailler les circuits cet apres-midi au radio club.

Bonjour;
Ce serait plutôt des PCF8574 (ou similaires) en 8 bits a priori..
73

Gérard

[F4HJH 43]

Voici une autre vue de la "boite noire" HamLab C25 du Kit SDR RedPitaya 14Bits

 

Puis un zoom sur les deux CI U3 & U4 :

 

Il s'agit de deux ULN2803A = Des transistors Darlington ....

Les CI en charge de l'I2C doivent être planqués en dessous du PCB. Mais il faut démonter et peut être dessouder...

J'ai fait de nouveaux tests avec des bouts de codes de j'ai récupéré sur Github (cités dans un message précédant), j'arrive à commuter les filtres, l’atténuateur : c'est un début ! 

Le principe :

Commutation du BPF sur 80m par exemple : 

Citation

I2CCommandString[2] |= 1 << 5;

 

Commande du PA : (synthaxe différente... C'est un autre bout de code...)

Citation

I2CCommandString[1] = I2CCommandString[1] ^ B00100000;

Pour le moment, je ne maitrise absolument rien, mais j'arrive à transmettre des commandes depuis l'arduino vers cette "boite noire"

Je progresse (pas vite, mais je progresse et j'apprend des choses 😊)

Modifié 15 juin 2019 par F4HJH

[F6EHJ 28]

Bonjour,

Oui, les 2803 ce sont les drivers de puissance pour les relais. Il doit donc effectivement  y avoir 16 sorties d’ou la nécessité de transmettre 2 octets successifs à destination du PCF via l’I2C..

A suivre

73

Gerard 

[F6EHJ 28]

Il y a 12 heures, F4HJH a dit :

Il y a 12 heures, F4HJH a dit :

Charly 25LC pin assignment for PCA9555 port expander IC:   Attenuator 12dB: I/O 0.0 -> Initial value = 0   Attenuator 24dB: I/O 0.1 -> Initial value = 0   VV 1 (preamp 1): I/O 0.2 -> Initial value = 0   VV 2 (preamp 2): I/O 0.3 -> Initial value = 0   unused: I/O 0.4 -> Initial value = 0   unused: I/O 0.5 -> Initial value = 0   unused: I/O 0.6 -> Initial value = 0   unused: I/O 0.7 -> Initial value = 0       10m: I/O 1.0 -> Initial value = 1   20m: I/O 1.1 -> Initial value = 0   40m: I/O 1.2 -> Initial value = 0   80m: I/O 1.3 -> Initial value = 0   Antenna relais: I/O 1.4 -> Initial value = 0   PA switch: I/O 1.5 -> Initial value = 0   unused: I/O 1.6 -> Initial value = 0   unused: I/O 1.7 -> Initial value = 0   */

 

Vous avez Le descriptif des 16 sorties..

Il’y a bien deux I/O correspondant aux deux 2803 : I/0 0.0 a 0.7 et I/O 1.0 à 1.7

Il suffit d’écrire Les deux octets en fonctions de la configuration atténuateurs/ relais et autres.(0=inactif, 1=actif)

Un masque pourra être nécessaire pour modifier uniquement la sortie désirée sans modifier les autres..

A suivre

Gérard 

 

[F4HJH 43]

Il y a 13 heures, F6EHJ a dit :

Il’y a bien deux I/O correspondant aux deux 2803 : I/0 0.0 a 0.7 et I/O 1.0 à 1.7

Il suffit d’écrire Les deux octets en fonctions de la configuration atténuateurs/ relais et autres.(0=inactif, 1=actif)

Un masque pourra être nécessaire pour modifier uniquement la sortie désirée sans modifier les autres..

Bonjour Gérard,

Oui, c'est une bonne idée de me rappeler les valeurs. C'est une seconde piste pour arriver à piloter ce module.

En fonction de la bande et de l'état du PTT, je pourrais utiliser un tableau pour écrire l'état pour chaque octet.

Cette voie me paraît aussi plus simple.

A suivre...

 

[F4HJH 43]

Ca y est ! Youpi !! 😊 Cela fonctionne

Pour le test, j'utilise ce code :

Citation

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "clsPCA9555.h"
#include "Wire.h"

PCA9555 ioport(0x20);

void setup()
{
//
// Configuration des IOports (0 à 15) en sortie
//
for (uint8_t i = 0; i < 15; i++)  {
    ioport.pinMode(i, OUTPUT);
                                  }

//
// On initialise tous les IOports (0 à 14) à l'état bas
//
for (uint8_t i = 0; i < 15; i++)  {
      ioport.digitalWrite(i, LOW);
      delay(50);
                                  }
Serial.begin(9600); // initialisation de la liaison série pour utilisation de la console
}

void loop()
{
// Attenuator 12dB
uint8_t i = 0; // Valeur de l'IOport

ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("Attenuator 12 dB / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("Attenuator 12 dB / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// Attenuator 24dB
i = 1; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("Attenuator 24 dB / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("Attenuator 24 dB / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// VV 1 (preamp 1)
i = 2; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("VV 1 (preamp 1) / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("VV 1 (preamp 1) / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// VV 2 (preamp 2)
i = 3; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("VV 2 (preamp 2) / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("VV 2 (preamp 2) / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// LPF 10m
i = 8; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("LPF 10m / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");  // La valeur initiale pour le LPF 10m est à HIGH
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("LPF 10m / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

// BPF 20m
i = 9; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("BPF 20m / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("BPF 20m / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// BPF 40m
i = 10; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("BPF 40m / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("BPF 40m / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// BPF 80m
i = 11; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("BPF 80m / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("BPF 80m / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// Antenna relay
i = 12; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("Antenna relay / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("Antenna relay / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);

// PA switch
i = 13; // Valeur de l'IOport
ioport.digitalWrite(i, HIGH);
Serial.print("_______________________________________________");
Serial.println( );
Serial.print("PA switch / IOport = ");
Serial.print(i);
Serial.print("    IOport : HIGH ");
Serial.println( );
Serial.println( );
delay(2000);

ioport.digitalWrite(i, LOW);
Serial.print("PA switch / IOport = ");
Serial.print(i);
Serial.print("    IOport : LOW ");
Serial.println( );
Serial.println( );
delay(2000);
     
}

Le pilotage de l’atténuateur, du pre ampli fonctionne bien. 

Par contre, tout ce qui est au dessus de I/O 1.0 jusqu'à I/O 1.5 (LPF, BPF, Ant Relay, PA) : j'entend bien un ou des relais, mais il ne se passe rien d'autre.

J'ai l'impression qu'il y a un problème d'adressage du second PCA955...

A suivre...

 

 

 

[F6EHJ 28]

il y a 51 minutes, F4HJH a dit :

Ca y est ! Youpi !! 😊 Cela fonctionne

Pour le test, j'utilise ce code :

Le pilotage de l’atténuateur, du pre ampli fonctionne bien. 

Par contre, tout ce qui est au dessus de I/O 1.0 jusqu'à I/O 1.5 (LPF, BPF, Ant Relay, PA) : j'entend bien un ou des relais, mais il ne se passe rien d'autre.

J'ai l'impression qu'il y a un problème d'adressage du second PCA955...

A suivre...

 

 

 

Bonjour,
Ca progresse...!
Si vous entendez les relais c'est que ça commute normalement...
Que voulez-vous dire par " il ne se passe rien  d'autre ?"
Actuellement vous arrivez à commander les sorties 1 à 3 et 8 à 13. Il y en a d'autres ?
J'avais cru comprendre qu'il n'y avait qu'un seul PCA...16 sorties ne suffisent pas ?
Gérard

[F6ITU 265]

Ah que ce digitalwrite est agréable comparativement aux émissions sérielles en big endian... 🙂 

Il n'y a a priori qu'un seul 9555 et deux ULN (celui qui est en 0x20) pour le lpf, mais rien n'est clair dans la doc de C25

Voir le schéma du modèle "entrée de gamme"...

... et la photo du filtre de malade de la version "haut de gamme" qui n'est prévu que pour la réceptions semble-t-il, et photographié l

https://charly25-sdr.github.io/hardware/rx-filters/

12 bandes tout de même, et 12 bandes en lame de couteau. 

et enfin ce qui semble correspondre, mais sans schéma d'ensemble, à savoir le modèle 20 W 

https://smartradioconcepts.com/WebRoot/Store22/Shops/e9b48953-6f5a-4d0c-be47-c3b4790d80ea/5BDD/F5C7/101E/63EE/6628/0A48/355E/1601/Charly_25_TRX_Mainboard_en_002.pdf

qui semble comporter une carte de format comparable à celle du pcb "ampli", et truffé de commutations (j'imagine atténuateurs, préamps, sélection des ADC... mais pas le moindre plan dispo)

@ christophe : est-il certain que tous les esclaves I2C on bien été découverts ? je ne cesse d'utiliser le petit scanner de bus du playground Arduino qui est très pratique 

https://playground.arduino.cc/Main/I2cScanner/

Ca aiderait à lever certains doutes je pense

Bon courage ! le bout du tunnel n'est plus très loin (pensait vil coyote en poursuivant bip-bip) 

Marc 

Modifié 16 juin 2019 par F6ITU

[F6EHJ 28]

Ca se confirme..
Les sorties I/O_0  0 à 4 sont utilisées
Les sorties I/O_1  0 à 5 sont utilisées.

On peut aussi se passer le la librairie du 9555 si difficulté. Il suffit d'envoyer l'adresse, l'octet de commande et les deux octets de données.

https://smartradioconcepts.com/WebRoot/Store22/Shops/e9b48953-6f5a-4d0c-be47-c3b4790d80ea/5BDD/F5C7/101E/63EE/6628/0A48/355E/1601/Charly_25_TRX_Mainboard_en_002.pdf
Jolie carte mais à quoi servent les 23 SMA ?

Gérard

 

[F6ITU 265]

"Jolie carte mais à quoi servent les 23 SMA ?" 

a justifier le prix, dirais-je sarcastiquement...

non, en fait, tout dépend de ce que l'on souhaite faire avec un ddc/duc/ Les commutations du frontend telles que prévues par l'OpenHPSDR sont assez complexes, et la ré-interprétation du C25  n'a pas arrangé les choses . Il y a les sorties pour transverter, celles pour récupérer l'échantillonnage en sortie d'ampli pour générer la pré-distorsion, un commutateur d'antennes intégré (a priori, 3 par récepteur, il y a deux ADC), des préamplis et atténuateurs avec probablement des circuits de bouclage, j'imagine également les commutations pour utiliser la carte Red Pitaya en analyseur vectoriel, géné HF etc .... et surtout la volonté de coller les mêmes specs sur les deux ADC, ce qui est imho totalement injustifié (OpenHPSDR ne filtre qu'un seul des deux ADC, le second est laissé "pieds nus"). 

C25 est, à l'origine, un club Allemand fortement versé dans les contests, et qui a pensé son filtre en mode contest -donc stations à fortes puissance, risques d'accroissement du bruit de bande etc).

Pour ma part, je me suis simplement limité à reproduire la version "orthodoxe" de la commutation OpenHPSDR, et j'ai à la louche 18 SMA, donc certaines ne sont que des prises de liaison d'étage à étage, et seulement 8 ( dont un commutateur 3 antennes), sont susceptibles de ressortir en façade. (et sur ce total, une seule réellement utilisée en  conditions conventionnelle)

Ca fait beaucoup de trous dans le boitier si l'on souhaite exploiter toutes les possibilités 🙂 

https://f6itu.files.wordpress.com/2018/07/rig-small.jpg

Marc (perceur de trous à ses moments perdus)