Trouvé chez des voisins ( 6bm8-lab.fr ) qui l'ont eux-mêmes trouvé chez d'autres voisins !

http://www.dos4ever.com/uTracer3/uTracer3.html

Intéressant car pas besoin de transfo, c'est alimenté par un bloc de pc portable (17 à 22V DC).

Maxi 300V et 200mA pour les HT et pour les filaments, au plus la tension de l'alim avec max 1,5A et un soft start.

Gestion de la tension de G2 ( je crois ).

Un kit existe pour 190 euros.

Salut Seb

L'idée et les infos sont très intéressante , un gros hic pour "nous" son logiciel ne tourne pas sous Linux
j'ai essayé avec Wine , message d'erreur à la connexion du port série ,

La tension négative se limite à -50 Volts et la conception du Biniou est telle que hors de question de tester
une 300B ou une 6S19P par exemple re

Ca fait 4 jours que je lis son blog V2 et V3, histoire de se renseigner et comprendre, j'ai envoyé son lien
à Yves

plein d'infos à glaner en tout cas

je lui ai écrit pour savoir si il pouvait donner ses sources Eagle pour graver le PCB et faire un essai
il ne vend que le kit
Ca me fait un peu cher pour faire joujou ces prochain mois

Perso , je partirai bien sur son µc et tenter d'écrire un GUI sous linux, mais c'est un peu costaud
surtout tout seul , et reste la tension négative qui me conviens pas
mais sur l'autre main tu as le code source complet du Pic 16F874 et le schéma complet de son µtracer
rerouter sous Kicad c'est faisable

Donc lecture et relecture , histoire de se faire une bonne idée

Et toi ton lampemètre à base d'Arduino tu en est ou
niveau hardware et software
j'ai lu que tu avait reçu un TA multi-tensions

Sinon avec un Pic tu as aussi dispo le code source du modèle Ducrocq
bien moins évoluer mais mérite une lecture aussi

A+

J'aime pas wine

Certes il a des limitation mais une conception novatrice.

Carrément ! J'ai vu dans un PDF le PCB nu recto et verso.

Cet été j'ai fait un boitier pour le kit trouvé sur ebay avec le transfo multi-tension vendu avec. Reste à finaliser le câblage et à tester le tunel port série de VirtualBox. Mais entre temps j'ai trouvé un nouveau boulot enfin dans l'électronique et je profite des ressources locales pour avancer mon 845. Il y a notamment un gars qui est costaud en alimentation à découpage et qui n'a pas eu peur quand j'ai parlé de faire un 1250V...

Connais pas.

@+

Séb

Le Ducrocq c'est le lampemètre que tu as monté et tester , tu as les source je suppose , celle du pic 16f876

Sinon , j'essaye en ce moment le port série sous ubuntu avec la doc dispo y adejà de quoi lire

A+

Oups

Je ne sais plus si j'ai des sources mais j'ai le protocole de communication. Ca suffit pour bricoler une IHM en Java...

Re

Tu arrive a communiquer avec le port série sous Java

une classe style Qextserialport

Tu as la source du fichier Hex du Pic dans le spost de René sur son site

Bon appétit

Bonjour Seb et Yves aussi

J'ai avancé dans la lecture du blog du µtracer 2 et 3

bref on y trouve un bon nombre d'infos et de fichiers , les sources pour le pic notamment
j'ai donc commencé par là pour chercher à comprendre les principes et fonctionnement

Ci-joint un fichier source propre du programme du pic en assembler avec les lignes commentaires
ces lignes permettent de comprendre le fonctionnement du biniou

ce fichier est utilisable sous MPLABX disponible pour Linux sur le site de Microchip

Je ai essayer de recompiler le fichier asm avec un pic16f877a , c'est le même brochage que le 16f874a
sauf qu'il a plus de mémoire et on trouve chez nos amis les "tongs" des "testboards" avec RS232 et ce pic
a faible prix
cela permettrai de faire un essai de communication sous linux

j'ai charger à cet effet Netbeans , je crois que c'est ce que vous utiliser non

reste a créer un petit IHM pour communiquer avec le Pic histoire de voire la faisabilité

Sur le site du µtracer , on trouve un programme écrit en quickbasic qui est assez facile à comprendre

Donc il faut pour cet IHM 4 box pour rentré la valeur des tensions ( anode,écran,grille 1 et filament )
convertir ces tensions en hexadécimal pour être exploitable par le pic
le calcul est basé sur la résolution des A/D converter soit (1024*(tension entrée/tension maxi)) qui donne un integer
et convertir cet integer en Hex
une box ou on peut modifier les paramètres du PCB ( calibration ini ) ou on peut modifier les tensions maxi dispo
sur le PCB pour chaque section
Concatener les valeurs hex dans une chaîne (string) selon le format indiqué sur le blog du µrtracer
( dans l'archive , le fichier txt du programme en qbasic pour lire )


Ceci devrait permettre de tester l'envoi et la réception via RS232 sous linux en suivant les indications du blog

et si ça marche continuer a creuser

au pire on peut faire tourner le logiciel "windows" sous virtualbox

Bon je vais essayer de lire quelques tutos de Netbeans et lire "Javaenfants.pdf" plus sérieusement

A+

Pour tester la com tu peux faire ça depuis le shell (console Linux) qui te permettra de choisir le port série, de le configurer, d'y écrire des données et de récupérer les réponses.
Si ça te parait abscon, dis toi que tu devras de toutes façons y passer et que tu n'auras pas perdu ton temps à comprendre les méthodes Linuxiennnes d'accés aux ports série.
Généralement, il faut être superviseur pour avoir les droits d'accés au hardware en général.

Yves.
J'explore Python, c'est simple, original, puissant, et bien plus léger que Java Je suis loin d'avoir tout compris !
Mais ça ne gére pas non plus directement les ports série, pas plus que ne le faisait VB6. J'utilisais WinIO (demande à google ! )

Salut Yves

Pour les port série sous ubuntu , j'ai déjà fait des essai avec ma carte proto AVR en RS232
et je peut envoyer et recevoir grâce a cutecom en root , il gère le hex en plus
selon le site des développeur il est écrit avec les bibliothèque Qt
j'ai aussi Qt créator comme IDE , chercher toujours chercher

A+

Bonjour,

J'ai écrit un bout de code en C pour communiquer par RS232 avec mon ATMega32.

Je travaille sous Linux et il faut être root pour exécuter le programme.

La liaison est fixée en asynchrone, c'est à dire qu'un émetteur n'attend pas d'accusé
de réception. L'avantage est de ne pas bloquer le programme émetteur si le programme récepteur
n'est pas démarré. L'inconvénient est que les deux horloges qui cadencent chaque bout
de la ligne doivent être voisines. Chez moi, j'arrive à transmettre à 115200 bps, ce qui
est déjà bien rapide. De même, il faut mettre en place un protocole de dialogue
émetteur / récepteur pour réceptionner en phase les trames émises.

J'ai écrit quelques moulinettes pour transmettre des paquets de 1,2 ou 4 octets.
Il est toujours possible de faire des routines adaptées à chaque cas.





//-----------------------------------------------------------------------
// main.cpp
//-----------------------------------------------------------------------

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<termios.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<math.h>

//-----------------------------------------------------------------------

using namespace std;

//-----------------------------------------------------------------------

//emission 8 bits
bool rs232_tx_8(int fd,unsigned char c);

//reception 8 bits
bool rs232_rx_8(int fd,unsigned char *c);

//emission 16 bits
bool rs232_tx_16(int fd,int c);

//reception 16 bits
bool rs232_rx_16(int fd,int *c);

//emission 32 bits
bool rs232_tx_32(int fd,float c);

//reception 32 bits
bool rs232_rx_32(int fd,float *c);

//emission chaine
bool rs232_tx_chaine(int fd,char chaine[100]);

//-----------------------------------------------------------------------

int main(void)
{

int fd;
struct termios options;


// ouverture port serie:

// ttys0 pour le port com0
// fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);


// ttys1 pour le port com1
// fd = open("/dev/ttyS1", O_RDWR | O_NOCTTY | O_NDELAY);

// ttyUSB0 pour un adaptateur USB RS232
fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY | O_NDELAY);

tcgetattr(fd, &options);

cfmakeraw(&options);

// debit de la com en input
cfsetispeed(&options, B115200);

// debit de la com en output
cfsetospeed(&options, B115200);

tcsetattr(fd, TCSANOW, &options);

if (fd==-1)
{
cout<<"ouverture port serie impossible"<<endl;
}
else
{
fcntl(fd, F_SETFL, 0);
}



unsigned char vout;
unsigned char vin;

...
...
...
...

//pour ecrire
rs232_tx_8(fd,vout);

//pour lire
rs232_rx_8(fd,&vin);

...
...
...
...


close(fd);

}
//-----------------------------------------------------------------------
bool rs232_tx_8(int fd,unsigned char c)
{
bool res;
int ntx;

res=true;

//envoi de la valeur
ntx=write(fd,&c,1);

if (ntx<0)
{
res=false;
}

return res;
}
//-----------------------------------------------------------------------
bool rs232_rx_8(int fd,unsigned char *c)
{
bool res;
int nrx;

res=true;

//lecture de la valeur
nrx=read(fd,c,1);

if (nrx<0)
{
res=0;
}

return res;
}
//-----------------------------------------------------------------------
//emission 16
bool rs232_tx_16(int fd,int c)
{
bool res;
unsigned char msb;
unsigned char lsb;

//decomposition msb lsb
msb=c/256;
lsb=c-msb*256;

res=true;

//transmission
res=res & rs232_tx_8(fd,msb);
res=res & rs232_tx_8(fd,lsb);

return res;
}
//-----------------------------------------------------------------------
//reception 16
bool rs232_rx_16(int fd,int *c)
{
bool res;
unsigned char msb;
unsigned char lsb;

res=true;

//transmission
res=res & rs232_rx_8(fd,&msb);
res=res & rs232_rx_8(fd,&lsb);

//recomposition msb lsb
*c=256*msb+lsb;

return res;
}
//-----------------------------------------------------------------------
//emission 32
bool rs232_tx_32(int fd,float c)
{
unsigned char *val;
int i;

val=(unsigned char*)&c;

for (i=0;i<4;i++)
{
rs232_tx_8(fd,*val);
val++;
}
}
//-----------------------------------------------------------------------
//reception 32
bool rs232_rx_32(int fd,float *c)
{
unsigned char val;
unsigned char *ptr;
int i;

ptr=(unsigned char*)c;

for (i=0;i<4;i++)
{
rs232_rx_8(fd,&val);
*ptr=val;
ptr++;
}
}
//-----------------------------------------------------------------------
//emission chaine
bool rs232_tx_chaine(int fd,char chaine[100])
{
int i,clen;

clen=strlen(chaine);

for (i=0;i<clen;i++)
{
rs232_tx_8(fd,chaine[i]);
}
}

Bonsoir Philbob

C'est vrai que tu est callé en µc toi

et en plus en AVR , pourrait tu nous donner un petit coup de main
Une question est ce possible de transcrire le fichier ASM que j'ai joint avec
un AVR quite à prendre un modèle qui est déjà a liaison USB
pour les test RS232 port série j'ai une testboard avec un AT90s2313 pour servir de cobaye

Là je bûche une petite IHM en Gambas ( langage proche du basic ) car j'ai vu dans les exemple
2,3 truc pour le port série et le port Usb avec Arduino ( AVR )
J'ai déjà trouver le moyen de convertir en hexdecimal les tensions que je rentre
pour Va Ve Vg et Vf et et une petite sous-fenêtre pour rentré les paramètres des
tensions maxi du PCB qui permettent de calculer les valeur Hex
j'ai crée pour ce faire un fichier ini que je lis pour découper en tableau
et rentrer les entrées (tension d'anode maxi etc ) dans des textbox de saisie
me reste a apprendre a modifier ces valeurs et les sauvegarder dans ce fichier
ini pour être utile et fermer cette initialisation

Bref j'ai mon idée qui mûri avec ce que j'ai déjà un peu pratiquer, je suis un very very newbie
en programmation , autant commencer bas

Je me souviens que tu m'avait dépanné avec la conversion analogique sur mon Atmega8535
pour mon potar ALPS motorisé

Le structurel du fichier pour le Pic est assez facile à lire

Bon dodo maintenant , je continuerai les jours qui viennent

Bonjour,

Je me demande si la seule raison pour laquelle il est nécessaire que vous soyez en root pour exécuter ces programmes n'est pas que les droits sur le fichier d'accès aux ports série (/dev/ttyS0 et /dev/ttyS1) ne sont attribués qu'à root. Chez moi (ubuntu) ça donne ça:



Ce qui signifie que seuls root et les membres du groupe "dialout" peuvent accéder à ce périphérique. Si vous ajoutez votre utilisateur non privilégié au groupe dialout, ce dernier pourra enfin y accéder. Pour cela, en tant que root, utilisez le script suivant (debian, ubuntu) :



Amicalement,
Grégoire

Hello Chanmix

Bien vu

un petit sudo adduser mon-user dialout suivi d'un redémarrage et plus besoin de rootr
pour lancer cutecom

a retenir car du coup en ajoutant son user au groupe plus besoin de lancer l'IMH en root
pour ce connecter au Pic, c'est ça j'ai bien compris

Du coup j'ai reessayer le logiciel µtracer avec wine et paf le chien
la connexion port com1 semble prise en compte
le debug du programme indique le retour d'un mauvais caractère car j'ai shunté la
pin 2 et 3 soit Rx et Tx
reste à continuer à chercher , un petit prog à uploader dans mon AT90s2313 ou l'Atmega8535
qui traîne dans mon tiroir pour leurer le programme et tester l'envoi d'une trame et le retour
du mot attendu par le µc pour voir si ce programme peut tourner sous wine
si oui on peut penser raisonnablement à construire ce PCB et voir une IHM purement Linux

ce sera mon projet 2013 , c'est décidé

trop fort ce Greg

Bonjour,

pour répondre à Totof

1) Conversion ASM de PIC --> AVR

Je pense que ce n'est pas possible. Les deux µC ont des archis différentes.
Et quand bien même, le travail d'adaptation est plus que largement
supérieur à la génération du code "from scratch".

Meme en partant d'un code C, la transplantation n'est pas évidente (ports IO,
interruptions, etc...)

2) Un coup de main pour développer en AVR

Oui, dans la mesure ou c'est sur un ATMega et bien sur dans la mesure de mes moyens....

3) Root

adduser mon_user dialout

Oui, c'est la bonne solution.

Bonsoir Philbob

Bon pour l'instant , je vais rester sur le Pic pour faciliter la tâche et vu que le logiciel
répond avec wine , c'est une épine du pied en moins

Mon IHM avec Gambas avance et pour tester Utracer sous wine , faudrait un "leur"
je m'explique , j'ai a dispo une petite carte avec un AT90s2313 et une liaison RS232 via un max

Ce qui serait bien c'est un petit .hex qui simulerait le hardware du utracer pour mon AT90s2313

En gros le utracer envoi des chaînes composés d'un byte de commande suivi de 8 byte de config
voir détails ici http://dos4ever.com/uTracerlog/tubetester2.html#more22


La réponse retournée par le utracer est formatée comme suit


Ce qui me serait vraiment utile c'est un bout de code qui lirait la chaîne entrante et retournerait une réponse
fictive sous le format du protocole pour mon AT93S2313

Perso j'en suis au stade de créer les "string" pour envois vers le µc sous gambas
dès que c'est finalisé , je pourrais créer une routine de mesure complète pour envoyer vers le µc
pour l'instant j'ai créer des routines 01 xxxxxx , 02 xxxxx etc , donc reste à faire une boucle

Pour l'AVR je ne me suis pas encore plonger dessus mais ça doit être faisable non

Avec ce leur , je pourrais ensuite voir ce que le programme utracer envoi au µc
pour une mesure disons par exemple va de 0 à 250V par pas de 50V, ve 250V vg, de -10V à -2v par pas de 2v, vf 6.3 pour une El84

Voilà j'en demande peut être beaucoup , mais mon idée est là

A+