Bonjour, J'ai fai un programme en C pour une modulation FSK mais cette année il faut le faire en assembleur (.asm) quelqu'un pourrai me dire ou trouver un logiciel de conversion ou quelqu'un qui connais bien l'assembleur et le C qui pourrai me le retranscrire
Merci d'avance
ouch a pas de logiciel de transformation
faut experer que c est juste 10 ligne de c
Salut!
Pour creer l'éxécutable, le compilateur passe par une version assembleur de ton code.
Il suffit de compiler avec l'option -S pour qu'il s'arrete a la version assembleur.
Donc :
> gcc -S fichier.c -o fichier.s (ou .asm si tu preferes)
Attention : c'est un grand S pour l'option.
Attention 2 : tu vas effectivement souffrir si le programme fait plus de 10 lignes...
sub nbLignes A
JNS souffrance
courage : )
Quel est le but ?
Si c'est pour accélérer la procédure, pas d'autre solution que le réécrire à la main.
Si c'est parceque c'est un exercice à rendre, sache qu'au premier coup d'oeil il est facile de différencier de l'assembleur écrit par un humain de l'assembleur écrit par un compilateur.
fait nous voir le c deja
On peut le faire traduire en asm, puis modifier les endroits où c'est lent. Mais c'est plus simple de mettre asm{.........................} .Envoyé par Garion
10 lignes c'est déjà (un peu)long à traduire.
20 lignes, faut pas espérer le faire en une journée.
100 lignes, mieux vaut laisser le compilateur le faire.
Bonne programmation.
avec sse2 facile de travaille en double (reel flotant)
c est pas super dur mais faut tester bout par bout
asser facile de faire une dll assembleur
Alors la je comprend pas trop ce que vous me dite a la fin
mais bon voici mon prog en C
a oui dans ce cas un simple NOP suffira
Si tu as voulu l'uploader, c'est que pour les images que ça marche.
Fait un copier coller.
Pole.
Re bonjour DSL, je n'est pas réussi a le faire avant alors voici le prog:
/*********************/
/* Modulation F.S.K. */
/*********************/
#include <std.h>
#include <c6x.h>
#include "c6211dsk.h"
#include "Def_Timer_Regs.h"
#include "Def_IMLH_Regs.h"
#include "Switch_Led.h"
/* Variable en RAM pour mémoriser l'état des LEDs. */
typ_LED_REG LED_REG_MEM;
/**/
/* Registre de commande des LEDs à l'adresse 0x90080000. */
#pragma DATA_SECTION(LED_REG, "LED_sect")
typ_LED_REG LED_REG;
/* Fréquence des interruptions = 24kHz. */
/* Fréquence des échantillons de sortie = 8kHz. */
/* Nombre d'échantillons de la table des sinus = 240. */
/* Table des sinus. */
short int sinus[ ] = { 0, 857, 1714, 2570, 3425, 4276, 5125, 5971,
6812, 7649, 8480, 9306, 10125, 10937, 11742, 12539,
13327, 14106, 14875, 15635, 16383, 17120, 17846, 18559,
19259, 19947, 20620, 21280, 21925, 22555, 23169, 23768,
24350, 24916, 25464, 25995, 26509, 27004, 27480, 27938,
28377, 28796, 29195, 29575, 29934, 30272, 30590, 30887,
31163, 31417, 31650, 31861, 32050, 32218, 32363, 32486,
32587, 32665, 32722, 32755, 32767, 32755, 32722, 32665,
32587, 32486, 32363, 32218, 32050, 31861, 31650, 31417,
31163, 30887, 30590, 30272, 29934, 29575, 29195, 28796,
28377, 27938, 27480, 27004, 26509, 25995, 25464, 24916,
24350, 23768, 23169, 22555, 21925, 21280, 20620, 19947,
19259, 18559, 17846, 17120, 16383, 15635, 14875, 14106,
13327, 12539, 11742, 10937, 10125, 9306, 8480, 7649,
6812, 5971, 5125, 4276, 3425, 2570, 1714, 857,
0, -857, -1714, -2570, -3425, -4276, -5125, -5971,
-6812, -7649, -8480, -9306, -10125, -10937, -11742, -12539,
-13327, -14106, -14875, -15635, -16383, -17120, -17846, -18559,
-19259, -19947, -20620, -21280, -21925, -22555, -23169, -23768,
-24350, -24916, -25464, -25995, -26509, -27004, -27480, -27938,
-28377, -28796, -29195, -29575, -29934, -30272, -30590, -30887,
-31163, -31417, -31650, -31861, -32050, -32218, -32363, -32486,
-32587, -32665, -32722, -32755, -32767, -32755, -32722, -32665,
-32587, -32486, -32363, -32218, -32050, -31861, -31650, -31417,
-31163, -30887, -30590, -30272, -29934, -29575, -29195, -28796,
-28377, -27938, -27480, -27004, -26509, -25995, -25464, -24916,
-24350, -23768, -23169, -22555, -21925, -21280, -20620, -19947,
-19259, -18559, -17846, -17120, -16383, -15635, -14875, -14106,
-13327, -12539, -11742, -10937, -10125, -9306, -8480, -7649,
-6812, -5971, -5125, -4276, -3425, -2570, -1714, -857 };
/* Valeur des deux coefficients pour générer les deux fréquences F0 = 2100Hz et F1 = 1300Hz .*/
short kcoeff[] = { 21, 13 };
short nte_mod3; /* division par 3 de la fréquence d'échantillonnage 24kHz. */
short i_phase; /* Indice de la phase instantanée. */
short i_coeff; /* Incrément de l'indice de phase. */
short nte; /* Nombre de périodes d'échantillonnage pour réaliser la durée d'un moment. */
short nb_bit; /* Compteur de bits. */
short nb_int; /* Compteur de mots de 32 bits. */
short int preamb; /* Drapeau préambule. */
short int toggle;
unsigned int *pt_buff; /* Pointeur de mots de 32 bits. */
unsigned int mot32_transmis;
extern void DSS_init(Void); /* Initialize codec and serial port, cf dss_dsk6211.c */
extern void mcbsp0_write_data(int out_data); /* Envoi d'un "int" sur MCBSP0, cf dss_dsk6211.c. */
/****************************** ****/
/* Fonctions de gestion des LEDs. */
/****************************** ****/
/* Modifier le registre CE1_SCR pour accéder à la commande des LEDs. */
void acces_switch_led()
{ int *pt_register;
pt_register = (int *)EMIF_CE1;
*pt_register = 0xffffff23;
}
/* Commande LED1. */
void LED1(int valbit)
{
b_LED1 = valbit;
LED_REG = LED_REG_MEM;
}
/* Commande LED2. */
void LED2(valbit)
{
b_LED2 = valbit;
LED_REG = LED_REG_MEM;
}
/* Commande LED3. */
void LED3(int valbit)
{
b_LED3 = valbit;
LED_REG = LED_REG_MEM;
}
/****************************** *******/
/* Initialisation des interruptions. */
/****************************** *******/
void Interrupt_init()
{
/* Disable all maskable interrupts, bit GIE = 0, spru189d.pdf, p 362. */
CSR &= 0xfffffffe;
/* Interrupt Enable Register, spru189d.pdf, p 364. */
IER=0; /* Disable all maskable interrupts. */
/* INT4 vecteur de l'interruption Timer0, spru190c.pdf, p 420. */
INTSEL4 = Num_TINT0;
/* ISTP : Interrupt Service Table Pointer register , spru189d.pdf, p 359. */
asm ( " .ref RESET_RST");
asm ( " ZERO.S2 B0");
asm ( " MVKH RESET_RST,B0");
asm ( " MVC.S2 B0,ISTP");
/* Interrupt Clear Register, clear all pending interrupts. */
ICR=0xffff;
}
/* Valider, globalement les interruptions masquables,
GIE = 1, cf spru189d.pdf page 362.*/
void Enable_Interrupt()
{
CSR |= 1;
}
/* Valider NMI nécessaire après un RESET.*/
void Enable_NMI_Interrupt()
{
ICR = IFR | 0x0002;
IER |= 0x0002;
}
/* Enable Timer0 interrupt */
void Enable_Timer0_Interrupt()
{
ICR = IFR | MASK_INTR_TIMER0_BIT;
IER |= MASK_INTR_TIMER0_BIT;
nte_mod3 = 0;
}
/* Disable Timer0 interrupt */
void Disable_Timer0_Interrupt()
{
IER &= !MASK_INTR_TIMER0_BIT;
}
/**********************/
/* Initialiser TIMER0 */
/**********************/
/* Period exprimée en secondes. */
void TIMER0_init(float Period)
{
_TIMER0_CTRL = 0; /* Timer0 control reg. */
_TIMER0_PERIOD = (unsigned int)(150E6*Period/4); /* Timer0 period reg. */
_TIMER0_CLKSRC = 1; /* Horloge interne : 150MHz/4. */
_TIMER0_PWID = 1; /* Pulse width = 2 impulsions d'horloge.*/
_TIMER0_HLDB = 1; /* Mode comptage, non maintien. */
_TIMER0_GO = 1; /* Valider fonctionnement Timer0. */
}
/****************************** *******/
/* Fonctions liées aux interruptions */
/****************************** *******/
/* fonction liée à l'interruption du TIMER0. */
interrupt void TIMER0_isr()
{
ICR = IFR | MASK_INTR_TIMER0_BIT; /* Effacer la requête d'interruption INT4. */
nte_mod3++;
nte_mod3 %= 3;
i_phase = (i_phase + i_coeff)%240; /* Mise à jour de l'indice de phase. */
if (nte_mod3 == 0)
{
mcbsp0_write_data(sinus[i_phase]); /* Envoi de la valeur du sinus sur l'AIC. */
};
nte--;
LED1(0);
/* Fin de l'envoi de la porteuse 1300Hz. */
if (( nte == 0) & (preamb == 0))
{
preamb += 1;
nb_bit = 256;
nte = 20;
LED2(0);
};
/* Envoi des 256 bits de préambule. */
if ((nte == 0) & (preamb == 1))
{
i_coeff = kcoeff[toggle];
nb_bit--;
toggle ^= 0x0001;
nte = 20; /* Remise à jour du compteur de période. */
if (nb_bit == 0)
{
nb_bit = 32; /* Remise à jour du compteur de bits. */
preamb += 1;
LED3(0);
mot32_transmis = *pt_buff;
};
};
if ((nte == 0) & (preamb == 2))
{
if ( (mot32_transmis & 0x80000000) == 0 ) { i_coeff = kcoeff[0]; }
else { i_coeff = kcoeff[1]; };
mot32_transmis <<= 1;
nb_bit--;
nte = 20; /* Remise à jour du compteur de période. */
if ( nb_bit == 0)
{
nb_int--;
pt_buff++;
mot32_transmis = *pt_buff;
nb_bit = 32; /* Remise à jour du compteur de bits. */
};
};
if (nb_int == 0)
Disable_Timer0_Interrupt();
}
/********************/
/* Initialisations. */
/********************/
void init_timer_codec_interrupt()
{
/* Pour accéder au registre de commande des LEDs. */
acces_switch_led();
/* Initialiser les registres d'interruption. */
Interrupt_init();
/* Initialize codec and serial port */
DSS_init();
/* Initialisation TIMER0, Period en secondes. */
TIMER0_init(41.6667E-6); /* Fréquence d'échantillonnage 24kHz. */
/* Valider interruptions. */
Enable_Interrupt();
Enable_NMI_Interrupt();
}
/****************************** ***************/
/* Envoi des trames 32 bits, modulation FSK. */
/****************************** ***************/
void transfert_mots_code_32b_mod_FS K(short nb_mots, unsigned int *pmots_codes)
{
/* Eteindre les 3 LEDs. */
LED1(1);
LED2(1);
LED3(1);
/* Initialiser les différents compteurs. */
i_phase = 0;
/* Fréquence des interruptions 24kHz, 1200 Bauds => nte = 20 pour un moment. */
nte = 12000; /* 12000 périodes d'échantillonnage pour réaliser la durée de 500ms. */
preamb = 0;
toggle = 1;
nb_int = nb_mots;
pt_buff = pmots_codes;
i_coeff = kcoeff[1]; /* Initialiser i_coeff pour la porteuse 1300Hz. */
/* Valider interruptions TIMER0. */
Enable_Timer0_Interrupt();
wait_end:
/* Attente d'une interruption. */
if (nb_int != 0) goto wait_end;
LED1(1);
LED2(1);
LED3(1);
}
/* END. */
et voila c fini merci de votre aide
Ca risque d'être long. Surtout si ce qu'il y a dans les includes est long.
Rien de ce qu'il n'y a là-dedans ne me semble très subtil. Copies mémoire, applications de masques binaires ou appels de fonction... il sera difficile de faire mieux que n'importe quel compilateur. En plus d'être longue et pénible, l'opération risque de s'avérer bien inutile.
Bonjour,
Il ne me semble pas que tu ais répondu à la question: l'exercice consiste-t-il à écrire ce programme (l'algo qui y correspond du moins) en assembleur?
Si oui, oublie l'utilisation du code asm produit par le compilateur C. Tu ne pourrais pas t'en servir avec un assembleur.
Au fait, qu'utilises-tu comme assembleur? c'est pour quel processeur?
Ton algo ne me semble pas très compliqué. Si tu manipules un peu Asm, ce qui devrait être le cas puisque tu as un exo à faire, tu devrais y passer deux ou trois jours. L'important est de disposer d'un organigramme précis. Et oui, en asm, on fait encore des organigrammes... Attention à la manipulation mémoire et à l'adressage: c'est le plus piégeant en asm (80x86 du moins, parce que en Motorola, c'est plus cool...)
Mon projet en fait c'est de faire une modulation FSK pour le cours de DSP et on utilise l'assembleur
Merci de m'aider
Dois-tu écrire le programme entièrement en assembleur?
(Parce que si c'est non, ça va être beaucoup plus simple à faire)
Peux-tu aussi mettre les fichiers #include et les fonctions extern?
Pole.
arf du c mechant desteste le c
essaye deja de reecrire le c en supprimant 80% des lignes
1 seul procedure qui n appele aucune autre
exemple
i_phase = (i_phase + i_coeff)%240; /* Mise à jour de l'indice de phase. */
mov eax, i_phase
Add eax, i_coef
mov ebx, 240
mov edx, 0
div ebx
mov i_phase, edx
nte_mod3++; inc nte_mod3
nte_mod3 %= 3; cmp nte_mod3,3
jnz s1
mov nte_mod3, 0
if (nte_mod3 == 0)
{
mcbsp0_write_data(sinus[i_phase]); /* Envoi de la valeur du sinus sur l'AIC. */
};
s1: dec nte
nte--;
Bonsoir,
En fait la gestion des led je n'ai pas besoin car il y en a pas ce ke j'ai surtout besoin c la modulation FSK c tout car en fait je rentre a l'aide d'un GBF une sinusoide et le DSP (donc le programme que je met de dedans) fait une modulation de ce signal c cela que j'ai besoin.
Merci d'avance
