MPLAB X IDE lent ?

[UDAR]

Vă salut .

Am încercat azi să testez trecerea de la MikroC PRO for PIC la MPLAB X IDE din motive de ”Demo Limit ”.

Întrucât lucrez pe un PC cu Win7 32 biți am instalat MPLAB X IDE v. 3.65 cu XC8 v1.42 . 

Un program extrem de mic - practic o bibliotecă LCD copiată de pe net și adaptată de la avr-gcc la PIC-C îl compilează și îl build-uiește ( iertare ! ) în 6-7 minute !!!

Am fost avertizat că va merge încet pe 32 de biți dar chiar așa ? MikroC ar fi lucrat câteva secunde cel mult la același job. 

Oare îmi scapă ceva ? 

Vă mulțumesc pentru orice informație - azi a fost spargerea gheții, cu siguranță nu știu multe despe acest MPLAB dar viteza asta parcă mă descurajează din start .... 

Până depanez un program de 1-2k normal recompilez de câteva zeci de ori , deci .... 

[Liviu M]

Merge la fel de greu și la recompilare? 

Ca dacă ar fi doar prima dată, poate ar fi suportabil, la fiecare compilare e nasol. 

Mă gândesc desigur că folosește make (sau ceva similar) și nu compileză decât fișierele modificate, deci eventualele biblioteci nu le mai. 

 

PS La mine mergea bine, dar sistemul e complet diferit (64 de biți, linux, versiune mai veche de compilator...). De curiozitate, dacă postezi codul încerc mâine să fac niște teste. 

[UDAR]

/*
 * File:   newmain.c
 * Author: radu_p
 *
 * Created on April 2, 2021, 10:05 PM
 */

#pragma config FOSC = INTRCCLK  // Oscillator Selection bits (INTOSC oscillator: CLKOUT function on RA4/OSC2/CLKOUT pin, I/O function on RA5/OSC1/CLKIN)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled and can be enabled by SWDTEN bit of the WDTCON register)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config MCLRE = ON       // MCLR Pin Function Select bit (MCLR pin function is MCLR)
#pragma config CP = OFF         // Code Protection bit (Program memory code protection is disabled)
#pragma config CPD = OFF        // Data Code Protection bit (Data memory code protection is disabled)
#pragma config BOREN = ON       // Brown-out Reset Selection bits (BOR enabled)
#pragma config IESO = OFF       // Internal External Switchover bit (Internal External Switchover mode is disabled)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enabled bit (Fail-Safe Clock Monitor is disabled)

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

#include <xc.h>

#define _XTAL_FREQ 8000000

#define LCD_DATA_PORT PORTC
#define LCD_DATA_DDR  TRISC
#define LCD_CTRL_PORT PORTC
#define LCD_CTRL_DDR  TRISC
#define LCD_RS        0
#define LCD_RW        1
#define LCD_E         2



/* Here are some defines for the LCD instructions we'll use.
 */
#define LCD_FUNCTION_SET      0x38 // 0b00110000
#define LCD_FUNCTION_SET_4BIT 0x28 // 0b00101000
#define LCD_DISPLAY_OFF       0x08 // 0b00001000
#define LCD_DISPLAY_ON        0x0F // 0b00001111
#define LCD_DISPLAY_CLEAR     0x01 // 0b00000001
#define LCD_ENTRY_MODE_SET    0x06 // 0b00000110
#define LCD_CURSOR_HOME       0x02 // 0b00000010


/* LcdSendNibble
 * 
 * Sends a 4-bit nibble to the display.
 *
 * Parameters:
 *	uint8_t nibble	The high nibble of of this byte
 *					is sent to the display.
 * Returns:
 *	nothing
 */
void LcdSendNibble( char nibble )
{
   __delay_ms(5);

   // Output upper nibble on the data ports upper bits
   LCD_DATA_PORT = (nibble & 0xF0) | (LCD_DATA_PORT & 0x0F);

   // Toggle the E line
   LCD_CTRL_PORT |= (1<<LCD_E);   // Going up..
   LCD_CTRL_PORT &= ~(1<<LCD_E);  // ..and down.
}

/* LcdSendByte
 * 
 * Sends a 8-bit byte to the display.
 *
 * Parameters:
 *	uint8_t theByte	The byte to send to the display
 *
 * Returns:
 *	nothing
 */
void LcdSendByte(char theByte)
{
   // Send the high nibble
   LcdSendNibble(theByte);

   // Shift theByte to get lower nibble in upper part...
   theByte = theByte << 4;
   // ...and send it
   LcdSendNibble(theByte);
}

/* LcdSendInstruction
 * 
 * Sends an instruction to the display.
 *
 * Parameters:
 *	uint8_t command	This byte is sent to the display as 
 *					an instruction (RS low).
 * Returns:
 *	nothing
 */
void LcdSendInstruction( char theInstruction )
{
   // RS low for instructions
   LCD_CTRL_PORT &= ~(1<<LCD_RS);

   // Send the instruction
   LcdSendByte(theInstruction);
}

/* LcdSendCharacter
 * 
 * Sends a character to the display.
 *
 * Parameters:
 *	uint8_t nibble	This byte is sent to the display as 
 *					a character (RS high).
 * Returns:
 *	nothing
 */
void LcdSendCharacter(char theChar)
{
   // RS high for characters to display
   LCD_CTRL_PORT |= (1<<LCD_RS);

   // Send the command
   LcdSendByte(theChar);
}

/* LcdInitialize
 * 
 * Initialize the display.
 *
 * Parameters:
 *	none
 *
 * Returns:
 *	nothing
 */
void LcdInitialize(void)
{
   // initialize LCD control lines
   LCD_CTRL_PORT &= ~(1<<LCD_RS);	// RS low
   LCD_CTRL_PORT &= ~(1<<LCD_RW);	// R/W low
   LCD_CTRL_PORT &= ~(1<<LCD_E);	// E low

   // initialize LCD control lines to output
   LCD_CTRL_DDR |= (1<<LCD_RS);
   LCD_CTRL_DDR |= (1<<LCD_RW);
   LCD_CTRL_DDR |= (1<<LCD_E);

   // initialize LCD data port to input
   LCD_DATA_DDR |= 0xF0;      // Data on high four bits of port for now...

   // First part of init sequence is 3 x Function Set with
   // stipulated waits. Note that the display is in 8-bit mode
   // initially, but although the four low data lines are not connected
   // this does not matter as the instructions low nibble is zero anyway.
   __delay_ms(15);
   LcdSendNibble( LCD_FUNCTION_SET );
   __delay_ms(5);
   LcdSendNibble( LCD_FUNCTION_SET );
   __delay_us(100);
   LcdSendNibble( LCD_FUNCTION_SET );

   // Now, still in 8-bit mode, set the display to 4-bit mode
   LcdSendNibble( LCD_FUNCTION_SET_4BIT );

   // We are now in 4-bit mode.
   // Do the rest of the init sequence.
   LcdSendInstruction( LCD_FUNCTION_SET_4BIT );
   LcdSendInstruction( LCD_DISPLAY_OFF );
   LcdSendInstruction( LCD_DISPLAY_CLEAR );
   LcdSendInstruction( LCD_ENTRY_MODE_SET );
   LcdSendInstruction( LCD_DISPLAY_ON );
}

char message[] = "4-bit avr-gcc";


void main(void)
{
   OPTION_REG = 0b10000000;
   OSCCON = 0b01110001;
   ANSEL = 0;
   ANSELH = 0;
   TRISA = 0b111100;
   TRISB = 0;
   TRISC = 0;
   PORTB = 0;
   PORTC = 0;
   
   LcdInitialize();

   volatile int i = 0;
   while (message[i] != 0)
	{
	   LcdSendCharacter(message[i]);
		i++;
   }

   while(1);
   return ;
}

Este un singur fișier - acesta , newmain.c .  Era doar un test. ( Mă îngrijora înainte de încercare lipsa bibliotecilor cu care mă obișnuisem la MikroC de aceea am început cu asta .)

PS Comentariile au rămas din codul original pe care l-am copiat de pe Net de aici :  https://www.avrfreaks.net/sites/default/files/avr-gcc4bit.c

Și da , a avut o oarecare îmbunătățire - 7minute și ..., 7 minute și ceva, 6 minute 30 . 

 

Mulțumesc pentru interes.

Editat Aprilie 2, 2021 de UDAR

[Liviu M]

Pentru ce controller e?

[UDAR]

PIC16F677, scuze !  Ăsta era cel mai mic pe care l-am avut la îndemână . Pregătisem deja breadboardul cu LCD-ul și uC-ul pe el ! 

[Liviu M]

Ce pot sa-ti zic e ca n-are legatura cu codul tau. La mine nu face nici o problema.

MPLABX 4.01, xc8 1.30. Cateva secunde (3? 4?), nici n-apuc sa apsa bine butonul clean & build (ciocanul cu matura) si e gata.

 

[UDAR]

Mulțumesc mult pentru efort. O să mai fac mâine niște teste , o să opresc toate celelalte aplicații eventual și antivirusul pentru niște teste . Oricum mi se pare infernal de mult . Am mai văsut plângeri pe Net dar nu dădeau cifre concrete ca să fac o comparație .

Mulțumesc încă odată, noapte bună !

[Liviu M]

Am pornit acum windowsul (win8, pe 64 de biti) si am testat codul tau si de aici (MPLabX v5.30, xc8 v1.45) si compileaza intr-o secunda. Din cate vad eu, softul uChip e oricum pe 32 de biti, nu stiu daca arhitectura face diferenta mare.

Ca sa vezi daca problema e la compilator sau la ide, sugestia mea e sa pornesti compilarea din linia de comanda, dupa ce ai compilat o data din mplabx (ca sa genereze Makefile-ul).

Deschizi o consola, cd in directorul cu Makefile-ul, si apelezi make.exe din Mplabx (la mine e in C:\Program Files (x86)\Microchip\MPLABX\v5.30\gnuBins\GnuWin32\bin).

Prima data cu make clean, ca sa activezi compilarea "full", a doua oara doar make:

-- make clean
C:\Users\liviu\MPLABXProjects\testCompiler\testcomp.X>"c:\Program Files (x86)\Microchip\MPLABX\v5.30\gnuBins\GnuWin32\bi
n\make.exe" clean
-- urmat de make
C:\Users\liviu\MPLABXProjects\testCompiler\testcomp.X>"c:\Program Files (x86)\Microchip\MPLABX\v5.30\gnuBins\GnuWin32\bi
n\make.exe"

 

[UDAR]

Mulțumesc, o să încerc. Ce pot să zic acum e că el raporta Clean ca realizat în sub 1 secundă, pe urmă stătea ceva până parcurgea codul - imi dădea niște warning-uri , apoi stătea și stătea .... 

O să scriu aici ce-am obținut . 

[Liviu M]

Lucrezi cu compilatorul in mod free, sau esti in perioada de test pentru PRO? Ca daca testezi pro, poate se chinuie cu optimizarile, eu stiu?

[UDAR]

In mod Free. Mi-a și zis-o pe aia că dacă aș trece la Pro ar fi cu nu-știu-cât-la-sută mai compact și mai rapid !

Cu siguranță e ceva legat de PC-ul meu care - probabil- amplifică niște probleme existente ale MPLAB x-ului. 

Eventual am să ”retrogradez” la MPLAB IDE v8.nn ( fără X ) .

[Liviu M]

Ai incercat direct din consola si merge bine, sau de ce dai vina pe MPLABx?

Oricum, nu sunt sigur ca MPLAB IDE (fara x) merge cu xc8. Nici nu mai stiu cum il foloseam cu picc de la HighTec...

Se pare ca merge totusi... https://www.microchip.com/forums/m984758.aspx

[UDAR]

Am încercat acum . Face în câteva secunde . Prima, cea cu ”clean” mai repede (2-3 sec) a doua sub 10 secunde.

 

În concluzie, după primul ”build” aș putea să lucrez așa , din linia de comandă ? Nu mă pricep foarte bine la ce face exact în fiecare etapă - la ”make” mai recompilează dacă am corectat ceva în sursă ?

 

Editat Aprilie 3, 2021 de UDAR

[Liviu M]

OK, in cazul asta e clar ca de vina e ide-ul. Da' tot nu-s convins c-as folosi MPLAB 8.nn, as compila (make) de mana. Da' eu sunt mai maso, asa.

Am mai citit si eu intre timp si ai dreptate, se pare ca depinde de arhitectura, de fapt de cata memorie poate folosi - http://microchip.wikidot.com/mplabx:jvm-configuration-options . Cat RAM ai in calculator?

Cum nu prea ma pricep la fineturi de-astea, cred ca te las singur mai departe. Succes. Iar daca reusesti sa-l faci sa mearga omeneste, poate completezi topicul, pe post de referinta.

 

Vad c-ai editat, asa ca incerc sa raspund.

Make e un utilitar care se uita ce ai modificat de la ultima compilare si recompileaza numai fisierele modificate. Asa ca da, daca modifici un fisier in ide si dai de mana make, ar trebui sa recompileze modificarile din ide. Trebuie sa nu uiti sa salvezi in ide (butonul de compilare din ide salveaza automat).

De fapt IDE-ul asta si face - apeleaza make.

[UDAR]

RAM am 4G dar se pare că pe 32 biți nu poate aloca mai mult de 512M zonă contiguă - de aia ziceam că e de la PC-ul meu .

Oricum nu mă dau în lături de la a face make manual. Căci erorile de sintaxă am văzut că le evidențiază ”on line” ( nu lucrez des deci mai uit să pun punct și virgulă la final, mai pun virgulă în loc de punct și virgulă în for, etc. ) și atunci nu ar fi chiar tragic. 

Oricum muțumesc foarte mult pentru soluția asta dar și pentru răbdare și timpul alocat . O să mai postez aici când o să am noutăți.

Editat Aprilie 3, 2021 de UDAR