Development Kits (Arduino, FS, STM,ARM,TI)

Revivo este post, haber si algún compañero del foro me echa una mano, estoy controlando un linear array TCD1304AP de Toshiba con el STM32F103, ya pude controlar al CCD, mis intentos de usar Arduino fueron nulos pues no hay suficiente RAM (solo 2K) con el STM32 dispongo de 20K de RAM y es más rápido, para programar utilizo el IDE de Arduino 1.6 con el truco para el STM32, lo cierto es que cuando envío el buffer con 3648 valores hacia la PC a 115200 bauds, me toma 3 o 4 segundos, muy lento!, busco un ejemplo de código para transferencia masiva USB con el STM32F103, alguien tiene algo que me ayude?. Aquí el código de envio hacia la PC
Código:
 /*-----------------------------------------------------------
 Enviar datos del buffer hacia PC, por serial port, ¡es lento!
 ------------------------------------------------------------*/
void Enviar_buffer()
{
  digitalWrite(Led_testigo, HIGH); // Led testigo On
   // Ahora imprimimos al puerto serial
   for (int i=0;i<Num_Pixels;i++)
   {
    Serial.print(i);
    Serial.print(",");
    Serial.println(Pixel_array[i]);
   } 
  digitalWrite(Led_testigo, LOW); // Led testigo Off
}

Gracias
Americo

Yo mismo me respondo:LOL:, ya encontré la solución para hacer la comunicación más rápida::)
simplemente implemento una tasa de bauds muy alta; en el código del STM32, escribo algo así:
void setup()
{
//Serial.begin(115200); ésta es la máxima clásica en el IDE Arduino
Serial.begin(1500000); ésta es la que implementé
}
 
Aqui muestro un video de la aplicación VB para un espectroscopio PC con 3648 pixeles del TCD1304 controlado por un STM32F103, comentado lineas arriba
Americo8888
 
Hola amigos,

Les comparto algunas practicas que hice con la tarjeta de Frdm-KL25Z usando Keil Uvision 5,

El codigo es de ejemplo con el uso de una pantall OLED

Código:
#include <MKL25Z4.h>
#include "SPI0.h"
#include "oled_GXF.h"

const uint8_t _5a8dccb220de5c6775c873ead6ff2e43Bitmaps[] =
{
	0x20, 0x00, 0x01, 0x80, //   #                    ##  
	0x78, 0x0E, 0x03, 0xC0, //  ####       ###       #### 
	0xCC, 0x7F, 0xC7, 0x60, // ##  ##   #########   ### ##
	0xC7, 0xC0, 0xF0, 0x60, // ##   #####      ####     ##
	0xDB, 0x00, 0x1F, 0xE0, // ## ## ##           ########
	0xFC, 0x00, 0x06, 0x60, // ######               ##  ##
	0xD8, 0x00, 0x03, 0xC0, // ## ##                 #### 
	0xF0, 0x00, 0x01, 0xE0, // ####                   ####
	0xF0, 0x00, 0x01, 0xE0, // ####                   ####
	0x60, 0x00, 0x00, 0x40, //  ##                      # 
	0x40, 0x00, 0x00, 0xC0, //  #                      ## 
	0x60, 0x00, 0x00, 0xC0, //  ##                     ## 
	0x63, 0x80, 0x38, 0x80, //  ##   ###         ###   #  
	0x47, 0x80, 0x3C, 0xC0, //  #   ####         ####  ## 
	0x27, 0xB4, 0xFD, 0x80, //   #  #### ## #  ###### ##  
	0x33, 0x9F, 0x3C, 0x80, //   ##  ###  #####  ####  #  
	0x1E, 0x1E, 0x0F, 0x00, //    ####    ####     ####   
	0x0A, 0x06, 0x06, 0x00, //     # #      ##      ##    
	0x07, 0x00, 0x5C, 0x00, //      ###         # ###     
	0x01, 0xC8, 0xF0, 0x00, //        ###  #   ####       
	0x03, 0x3F, 0x88, 0x00, //       ##  #######   #      
	0x02, 0x3F, 0x98, 0x00, //       #   #######  ##      
	0x03, 0x1F, 0x18, 0x00, //       ##   #####   ##      
	0x05, 0xBF, 0xEC, 0x00, //      # ## ######### ##     
	0x04, 0xFD, 0xE4, 0x00, //      #  ###### ####  #     
	0x08, 0x79, 0xC6, 0x00, //     #    ####  ###   ##    
	0x0C, 0xF1, 0xE2, 0x00, //     ##  ####   ####   #    
	0x05, 0xFB, 0xF6, 0x00, //      # ###### ###### ##    
	0x06, 0x76, 0xCC, 0x00, //      ##  ### ## ##  ##     
	0x03, 0xEC, 0xF8, 0x00, //       ##### ##  #####      
	0x01, 0xFF, 0xB0, 0x00, //        ########## ##       
	0x00, 0x0F, 0x00, 0x00, //             ####           
};

void GPIO_Init(void){

	SIM->SCGC5 |= SIM_SCGC5_PORTD(1);		// Open Clock to PORTD
	PORTD->PCR[1] = PORT_PCR_MUX(2);		// PIN 1 AS CLK
	PORTD->PCR[2] = PORT_PCR_MUX(2);		// PIN 2 AS MOSI
	//PORTD->PCR[3] = PORT_PCR_MUX(2);	// PIN 3 AS MISO
	PORTD->PCR[0] = PORT_PCR_MUX(1);		// PIN 0 AS SS
	PORTD->PCR[5] = PORT_PCR_MUX(1);		// PIN 5 AS RST
	PORTD->PCR[6] = PORT_PCR_MUX(1);		// PIN 6 AS DC
 	
	GPIOD->PDDR	|= (1 << 1);						// PIN 1 AS OUTPUT / CLK
	GPIOD->PDDR	|= (1 << 2);						// PIN 2 AS OUTPUT / MOSI
	//GPIOD->PDDR	&= ~(1 << 3);					// PIN 3 AS INPUT  / MISO
	GPIOD->PDDR	|= (1 << 0);						// PIN 0 AS OUTPUT / SS

	GPIOD->PDDR |= (1 << 5);						//PIN 5 AS RST
	GPIOD->PDDR |= (1 << 6);						//PIN 6 AS DC


}

int main(void){
	
	GPIO_Init();
	SPI0_Init();
	
	init_screen();

	while(1){
	
			Screen_invertDisplay(1);
			Screen_display();
			delay_ms(250);
			Screen_invertDisplay(0);
			Screen_display();
			delay_ms(250);
			Screen_clearDisplay();
			drawBitmap1(0,0,_5a8dccb220de5c6775c873ead6ff2e43Bitmaps,32,32,WHITE);
			Screen_display();
			
			startscrolldiagright(0x00,0x07);
		
			while(1);	
	
	}


}



¡Saludos!
 

Adjuntos

  • KL25.zip
    4.7 MB · Visitas: 3
Hola a todos,

Les comparto mas vídeos de tutoriales de la placa FRDM-KL25Z.



He estado haciendo mas ejemplos, solo teniendo tiempo las subire, por ahora me gustaria preguntarles , ¿Que placas de desarrollo o fabricadas por ustedes tienen actualmente? yo tengo las siguientes:

-FRDM-KL25Z
FRDM-KL25Z_BD.jpg

-MSP432
msp432-1_orig.jpg

-OpenLPC1114
Open1114-intro.jpg

-OpenLPC1768
Open1768-intro.jpg

-STM32
STM32Mini-300x300.jpg

-DiscoveryF0
stm32f0308-disco-kit-discovery-stm32-f0-series.jpg

-OpenLPC4537
4-3inch-LCD-Ethernet-speaker-ARM-LPC4357-LPC43-Cortex-M4-M0-dual-core-Development-Board-Open4357.jpg


El único IDE que he estado usando es KEIL UVISION 5 modo lite (aunque hay medicina para activarlo) me parece una herramienta muy buena, por la simple razón es que puedo programar cualquier microcontrolador ARM CORTEX Mx.
Tuve una experiencia programando con MCUxpresso, y la verdad creo que es una buena herramienta de desarrollo muy intuitivo, pero a la hora de realizar proyectos empiezas a ver complejidades tales como direccionar el UART con la función printf, y no existe mucha información respecto a eso, entre otras complejidades que tuve (tal ves porque no estuve 100% usando MCUxpresso). Creo que hay ciertas personas que si conocen al 99% el IDE de MCUXpresso y todas sus funciones, pero usando Keil vi que disminuyo la curva de aprendizaje ya que como ya había usado keil para otro micro, al empezar a programar un LPC fue demasiado sencillo por la razón que al importar librerías y definir símbolos fue casi igual que otro microcontrolador de otra compañia.

¡Saludos!
 
Hola a todos,

En este tutorial vamos a usar una tarjeta de MicroSD con un microcontrolador LPC1114 de la compañia de NXP, ya habiamos realizado algunas practicas halla por los años 2014 :D, pero ahora hemos de regresar en algo muy bueno ya que con esto podemos realizar DATA LOGGER, donde puede monitorear y siempre estar granado datos en la tarjeta.

Para empear necesitamos tener KEIL ya que es mi pan de cada dia, aunque muchos diran que no es bueno, yo digo todo lo contrario, creo que es un excelente IDE para programar microcontroladores de todas las compañias que utilicen ARM CORTEX.

Pic%2B1.jpg


Actualmente esta la version 5.24a con su Pack Installer que nos permite actualizar las librerias de cada microcontrolador de diferentes compañias. Cuando bajas el software de Keil Uvision 5 te pedira registrarte solo es para llevar una contabilizacion de donde y cuales son tus metas al usar la herramienta, al terminar de regitrarte, te enviara a otra pagina donde ya podras instalar el software.
Al instalarse se podra usar por 60 dias en modo profesional, donde no tendras limite de codigo, apaso del los 60 dias se cambiara a modo de evalucion sin limite de tiempo solo que podras debuggear o compilar hasta 32 Kb de ROM (Mas que suficiente para algunos).

Cuando abrimos Keil, nos dirigimos a presionar el boton de Pack Installer para agregar las librerias de los microntroladores LPC11xx.

Pack%2BInstaller.png


El codigo mostrado es para poder manejar las tarjetas microSD, se utiliza la libreria de FATfs Junto con la lirebria de perifericos que ya NXP nos proporciona lo puedes bajar aqui.(Baja la version de LPC11U24 para su correcto funconamiento).

Código:
#include "chip.h"
#include <stdio.h>
#include <string.h>
#include "SPI_MSD_Driver.h"
#include "diskio.h"
#include "ff.h"

FATFS fs;         /* Work area (file system object) for logical drive */
FIL fsrc;         /* file objects */   
FRESULT res;
UINT br;


char path[512]="0:";
char textFileBuffer[50];   
uint16_t data[2];

void __delay_ms(uint32_t time){

	for(uint32_t t=time*500000;t>0;t--);

}
int SD_TotalSize(void){
    FATFS *fs;
    DWORD fre_clust;        

    res = f_getfree("0:", &fre_clust, &fs);  /* ±ØÐëÊǸùĿ¼£¬Ñ¡Ôñ´ÅÅÌ0 */
    if ( res==FR_OK ) 
    {
	  /* Print free space in unit of MB (assuming 512 bytes/sector) */
      printf("\r\n%d MB total drive space.\r\n"
             "%d MB available.\r\n",
           ( (fs->n_fatent - 2) * fs->csize ) / 2 /1024 , (fre_clust * fs->csize) / 2 /1024 );
		
	  return 1;
	}
	else 
	  return 0;   
}

void Open_Periphericals(void){
	
	Chip_GPIO_Init(LPC_GPIO);
	
	/*Funciones para configurar PINs*/

	/*Configuracion de Pines del USART*/
	
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO1_6, FUNC1);
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO1_7,FUNC1);
	
	/*Configuracion de Pines del ADC*/
	
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO0_11,FUNC2);
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO1_0,FUNC2);

	/*Configuracion de Pines del SSP0*/
	
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO0_9,FUNC1);
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO0_8,FUNC1);
	Chip_IOCON_PinLocSel(LPC_IOCON,IOCON_SCKLOC_PIO2_11);
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO2_11,FUNC1);

	/*Configuracion de Pines de GPIO*/
	
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO1_10,FUNC0);
	Chip_GPIO_SetPinDIROutput(LPC_GPIO,1,10);
	
	Chip_IOCON_PinMuxSet(LPC_IOCON,IOCON_PIO1_11,FUNC0);
	Chip_GPIO_SetPinDIRInput(LPC_GPIO,1,11);
	
	/*
	 * Inicializa UART0  a 115200 bps
	 *
	 *
	 * 
	 */


	Chip_UART_Init(LPC_USART);
	Chip_UART_SetBaud(LPC_USART,115200);
	
	/*
	 * Inicializa ADC  a 400KSPS
	 *
	 *
	 * 
	 */
	
	ADC_CLOCK_SETUP_T AdcSetup;
	
	Chip_ADC_Init(LPC_ADC,&AdcSetup);
	

	Chip_SSP_Disable(LPC_SSP0);
	Chip_SSP_Init(LPC_SSP0);
	Chip_SSP_Enable(LPC_SSP0);
	
	
}

int main(void){
	
	SystemCoreClockUpdate();
	
	Open_Periphericals();
	/*Main Code Here*/
	if( _card_insert() == 0 ){
		
		printf("-- SD card detected OK \r\n");
		
	}
	else
	{
		printf("-- Please connect a SD card \r\n"     );
		while( _card_insert() != 0 );
		printf("-- SD card connection detected \r\n");
		__delay_ms(10);
	}
    
	f_mount(&fs,"",0);	
  
	res = f_open( &fsrc , "Simple20.csv" , FA_CREATE_NEW | FA_WRITE | FA_OPEN_APPEND);		

	if ( res == FR_OK )
	{ 
		/* Write buffer to file */
		
		for(uint32_t cont = 0; cont<50; cont++){
			
			for(uint8_t ADC_Cont = 0; ADC_Cont<2;ADC_Cont++){
				
				Chip_ADC_EnableChannel(LPC_ADC,ADC_Cont,ENABLE);
				Chip_ADC_SetStartMode(LPC_ADC,ADC_START_NOW,ADC_TRIGGERMODE_RISING);
				
				while(Chip_ADC_ReadStatus(LPC_ADC,ADC_Cont,ADC_DR_DONE_STAT)==RESET);
				
				if(Chip_ADC_ReadValue(LPC_ADC,ADC_Cont,&data[ADC_Cont]) == ERROR){
					
					printf("Error\r\n");
				
				}

				
				Chip_ADC_EnableChannel(LPC_ADC,ADC_Cont,DISABLE);
				
			}
			
			sprintf(textFileBuffer,"%u,%u\r\n",data[0],data[1]);
			
			
			res = f_write(&fsrc, textFileBuffer,(unsigned) strlen(textFileBuffer), &br);     

			if(res == FR_OK){
			
				printf("Simple20.csv successfully created        %u,%u\r\n",br,cont);
				
			}else{
			
				printf("Simple20.csv successfully created with some Error        %u\r\n",res);
			
			
			}
			
			__delay_ms(10);
			
		}
			 
	}
	else if ( res == FR_EXIST )
	{
		
		printf("Demo.TXT created in the disk      \r\n");
		
	}
	
	f_close(&fsrc);
	SD_TotalSize();
	
	f_mount(0,"",0);
	

	for(;;){
	
		
	
	}

	return 1;
	
}

El diagrama es el siguiente:

Diagrama.png


Se ha adherido algunos ejemplos para que el usuario pueda implementarlos en sus proyectos

https://drive.google.com/drive/folders/0B5PHuBzaImxfbktlVU9wTzJjYkk?usp=sharing

¡Saludos!
 
Última edición:
Hola a todos.

Les comparto un tutorial del Microcontrolador PIC16F18877
Actualmente aún sigue en proceso de explicar algunas partes, pero por ahora les comparto el avance.

R1446573-01.jpg

Google Drive Tutorial

¡Saludos!
 

Adjuntos

  • Libro Curso Basico.part01.rar
    5 MB · Visitas: 5
  • Libro Curso Basico.part02.rar
    5 MB · Visitas: 6
  • Libro Curso Basico.part03.rar
    1.4 MB · Visitas: 5
Última edición por un moderador:
Hola. ¿Qué tal?

Les comparto un curso que estaré actualizando cuando tenga tiempo, por ahora subo un avance.
El curso está enfocado más que nada al microcontrolador de NXP, el tal LPC4357 que utiliza dos procesadores M4 y M0.
Cuando vayamos avanzado podremos realizar un proceso con los dos núcleos.

MCUXpresso-TN.jpg


s-l500.jpg


Bajar aquí

¡Saludos!
 

Adjuntos

  • CORTEX M4.part1.rar
    5 MB · Visitas: 0
  • CORTEX M4.part2.rar
    5 MB · Visitas: 0
  • CORTEX M4.part3.rar
    2.4 MB · Visitas: 0
Última edición por un moderador:
Hola a todos,

Les comparto algunos manuales que estoy desarrollando, no los subo a la pagina porque aun les falta mucho para avanzar,

El manual de PIC32 es una pequeña introducción a la programación de microcontroladores de 32 bits de microchip, aunque si termine algunos capítulos no le he seguido porque he visto que podrían ya no ser tan populares la tecnología MIPS. Por otro lado tenemos el manual del PIC18F27K42 que son lo nuevo de microchip, aun no le avanzado lo suficiente ya que estoy en desarrollo de un robot balacing con este micro ya que sera el capitulo final de este manual, y por ultimo tenemos el LPC54114 que es totalmente diferente a los micros de 32 bits de microchip ya es la arquitectura ARM CORTEX con doble nucleo a este es el que le estoy invirtiendo mas tiempo por lo complicado que es.

PIC32
PIC18F27K42
LPC54114

¡Saludos!
 
Atrás
Arriba