Esempio n. 1
0
/*
 * Send AT command to SIMCOM module and check response immediately.
 */
static int SendCmd_Check(char *cmd, char *check)
{
    int result = 1;
    char recv_str[32];

    dbg_puts("Send: ");
    dbg_puts(cmd);
    dbg_puts("\n\r");
    TM_USART_Puts(USART1, cmd);
    TM_USART_Puts(USART1, "\r\n");

    if(check) {
        RecvResponse(recv_str);

        if(strlen(recv_str) > 0) {
            dbg_puts("Recv: ");
            dbg_puts(recv_str);
            dbg_puts("\n\r");
        }

        if(!strstr(recv_str, check)) {
            result = 0;
        }
    }

    return result;
}
Esempio n. 2
0
int main(void) {
	char str[15];
	//Initialize system
	SystemInit();
	//Initialize Delay library
	TM_DELAY_Init();
	
	//Initialize USART1-> TX: PA9, RX: PA10
	TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600);
	
	TM_USART_Puts(USART1, "ADC example");
	
	//Initialize ADC1 on channel 0, this is pin PA0
	TM_ADC_Init(ADC1, ADC_Channel_0);
	//Initialize ADC1 on channel 3, this is pin PA3
	TM_ADC_Init(ADC1, ADC_Channel_3);
	
	while (1) {
		//							Read ADC1 Channel0					Read ADC1 Channel3
		sprintf(str, "%d: %d\n\r", TM_ADC_Read(ADC1, ADC_Channel_0), TM_ADC_Read(ADC1, ADC_Channel_3));
		TM_USART_Puts(USART1, str);
		
		Delayms(100);
	}
}
Esempio n. 3
0
/**
  * Read the configuration file
  * Name: SDCard_readConfig
  *
  * Description: Mounts the SD card and opens the configuration file
  *              The data in the file is extracted and placed in a buffer
  *              The file is then closed and the SD card unmounted
  *
  * Arguments: void
  *
  * Returns: void  
  */
void SDCard_readConfig() {
  char str[512];
  uint32_t count;

  fres = f_mount(&fatFs, "SD:", 0);
	
  if (fres != FR_OK) {
    sprintf(str, "Error Message @%d\n\r", fres);
    /* Put to USART */
    TM_USART_Puts(USART1, str);
  }
  if ((fres = f_open(&file, "SD:config.txt", FA_READ | FA_WRITE)) != FR_OK){
    if (fres == FR_NO_FILE) {
      sprintf(str, "NO CONFIG FILE AVAILABLE\n\r");
      TM_USART_Puts(USART1, str);
	}
    else {
      sprintf(str, "Failed to open file. Error: %d\n\r", fres);
      TM_USART_Puts(USART1, str);
	}
  }
  else {
    f_read(&file, SD_Buffer, sizeof(SD_Buffer), &count);
    sprintf(str, "Reading is done. Read %d bytes\n\r", count);
    TM_USART_Puts(USART1, str);
    f_close(&file);
    f_mount(NULL, "SD:", 1);
    sprintf(str, "File Contents:\n\r%s", SD_Buffer);
    /* Put to USART */
    TM_USART_Puts(USART1, str);
  }
}
Esempio n. 4
0
/*
 * Send AT command.
 */
static void SendCmd(char *cmd)
{
    dbg_puts("Send: ");
    dbg_puts(cmd);
    dbg_puts("\n\r");

    TM_USART_Puts(USART1, cmd);
    TM_USART_Puts(USART1, "\r\n");
}
Esempio n. 5
0
int main(void){
	SystemInit();
	TM_DELAY_Init();
	TM_ILI9341_Init();
	TM_ILI9341_SetLayer1();

	/* Initialize USART2 at 115200 baud, TX: PD5, RX: PD6 */
	TM_USART_Init(USART2, TM_USART_PinsPack_2, 115200);
	
	uint8_t wacc = 0x3A; // 0xA6
	uint8_t racc = 0x3B; // 0xA7

	// 0x2D POWER_CTL: Power-saving features control
	TM_I2C_Write(I2C2, wacc, 0x2D, 0x08);
	// 0x31 DATA_FORMAT: Data format control
	//TM_I2C_Write(I2C1, wacc, 0x31, 0x0B); // FULL_RES and +- 16g
	TM_I2C_Write(I2C2, wacc, 0x31, 0x01); // fixed resolution and +- 4g
	// 0x2C BW_RATE: Data rate and power mode control
	TM_I2C_Write(I2C2, wacc, 0x2C, 0x0A);
	
	char str[16] = {0};
	sprintf(str, "delay = 100");
	TM_USART_Puts(USART2, str); 
	while(1){

		TM_ILI9341_Fill(ILI9341_COLOR_WHITE);
		TM_ILI9341_Puts(30, 30, str, &TM_Font_11x18, ILI9341_COLOR_WHITE, ILI9341_COLOR_BLUE2);
		uint8_t buff[6] = {0};
		int16_t tri[3] = {0};
		TM_I2C_ReadMulti(I2C2, racc, 0x32, buff, 6);
		
		// original read digit
		tri[0] = (int16_t) ((uint16_t)buff[1] << 8 | (uint16_t)buff[0]);	
		tri[1] = (int16_t) ((uint16_t)buff[3] << 8 | (uint16_t)buff[2]);	
		tri[2] = (int16_t) ((uint16_t)buff[5] << 8 | (uint16_t)buff[4]);	
		
		float ftri[3] = {0}, divisor = 128.0f;
		ftri[0] = (float) tri[0] / divisor;
		ftri[1] = (float) tri[1] / divisor;
		ftri[2] = (float) tri[2] / divisor;
	
		sprintf(str, "%.3f,%.3f,%.3f\n\r", ftri[0], ftri[1], ftri[2]);
		TM_USART_Puts(USART2, str); 
		TM_ILI9341_Puts(30, 50, str, &TM_Font_11x18, ILI9341_COLOR_BLACK, ILI9341_COLOR_WHITE);
		
		Delayms(100);
	}

}
Esempio n. 6
0
/* Called on alarm B interrupt */
void TM_RTC_AlarmBHandler(void) {
	/* Show user to USART */
	TM_USART_Puts(USART3, "Alarm B triggered\n");
	
	/* Disable Alarm so it will not trigger next month at the same date and time */
	//TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
}
Esempio n. 7
0
/* Called on alarm A interrupt */
void TM_RTC_AlarmAHandler(void) {
	/* Show user to USART */
	TM_USART_Puts(USART3, "Alarm A triggered\n");
	
	/* Disable Alarm so it will not trigger next week at the same time */
	//TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
}
Esempio n. 8
0
/**
  * Receive Handler for USART1
  * Name: TM_USART1_ReceiveHandler
  *
  * Description: Gives functionality when a character is received over the USART serial communication channel
  *              Stores data received into a buffer for use in other functions 
  *              Control available for use of the backspace key, functions called when enter key pressed (carriage return)
  *              Used to set the RTC time
  *
  * Arguments: uint8_t c - character received
  *
  * Returns: void  
  */  
void TM_USART1_ReceiveHandler(uint8_t c){
  char str[256];
  TM_USART_Putc(USART1, c);
  buffer[i] = c;
  i++;
  /* Backspace */
  if (c == 0x7F){
    i--;
    buffer[i] = 0;
    i--;
    buffer[i] = 0;
  }
  /* Carriage Return */
  if (c == 13){
    if (buffer[0] == 'R' && buffer[1] == 'T' && buffer[2] == 'C'){
    if (isdigit(buffer[4]) && isdigit(buffer[5]) && !isdigit(buffer[6]) && isdigit(buffer[22])){
      strncpy(RTC_time, (char *) buffer + 4, sizeof(buffer) - 4);
	  /* Set RTC time */
      TM_RTC_SetDateTimeString(RTC_time);
    }
  }
  sprintf(str, "\n\rRTC %s\n\r", RTC_time);
  /* Put to USART */
  TM_USART_Puts(USART1, str);
  memset(buffer, 0, sizeof(buffer));
  i = 0;
  }
}
Esempio n. 9
0
void set_GPS(void) {
  TM_GPS_Data_t position;
  FloatOrUInt tmp;
  uint32_t timeout = 60000;
  sprintf(buffer,"Trying to update GPS position with %ld seconds timeout\n\r",timeout/1000);
  TM_USART_Puts(MENU_USART, buffer);

  GC_CheckPosition(&position, timeout);
  sprintf(buffer,"GPS Position:\n\r             Longitude: %3.6f\n\r             Latitude:  %3.6f\n\r", position.Longitude, position.Latitude);
  TM_USART_Puts(MENU_USART,buffer);
  
  tmp.f=position.Latitude;
  config(GC_SAVE,tmp.fInt,GC_LATITUDE);
  tmp.f=position.Longitude;
  config(GC_SAVE,tmp.fInt,GC_LONGITUDE);
}
Esempio n. 10
0
int main(void) {
	/* Init system clock for maximum system speed */
	TM_RCC_InitSystem();
	
	/* Init HAL layer */
	HAL_Init();
	
	/* Init leds */
	TM_DISCO_LedInit();
	
	/* Init button */
	TM_DISCO_ButtonInit();
	
	/* Init USART, Pins not initialized yet, 921600 bauds */
	TM_USART_Init(USART6, TM_USART_PinsPack_Custom, 921600);
	
	/* Put test string */
	TM_USART_Puts(USART6, "Hello world\n");
	
	while (1) {
		/* Check if anything received */
		while (!TM_USART_BufferEmpty(USART6)) {
			/* Send data back from buffer */
			TM_USART_Putc(USART6, TM_USART_Getc(USART6));
		}
	}
}
Esempio n. 11
0
int main(void) {
	/* Init system clock for maximum system speed */
	TM_RCC_InitSystem();
	
	/* Init HAL layer */
	HAL_Init();
	
	/* Init leds */
	TM_DISCO_LedInit();
	
	/* Init USART, TX: PC6, RX: PC7, 921600 bauds */
	TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200);
	
	/* Put test string */
	TM_USART_Puts(USART2, "Hello world\n");
	
	while (1) {
		/* Check if we have string "OK" in USART6 buffer */
		if (TM_USART_FindString(USART2, "OK")) {
			/* Send data back from buffer */
			while (!TM_USART_BufferEmpty(USART2)) {
				/* Send to computer */
				TM_USART_Putc(USART2, TM_USART_Getc(USART6));
			}
		}
	}
}
Esempio n. 12
0
int main(void) {
	/* Initialize system */
	SystemInit();
	
	/* Init USART2 on pins TX = PA2, RX = PA3 */
	/* This pins are used on Nucleo boards for USB to UART via ST-Link */
	TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200);
	
	/* Say string without DMA */
	TM_USART_Puts(USART2, "Hello via USART2 without DMA\n");
	
	/* Init TX DMA for USART2 */
	TM_USART_DMA_Init(USART2);
	
	/* Send data with DMA */
	TM_USART_DMA_Send(USART2, (uint8_t *)USART_Buffer, strlen(USART_Buffer));
	
	/* Wait till DMA works */
	/* You can do other stuff here instead of waiting for DMA to end */
	while (TM_USART_DMA_Sending(USART2));
	
	while (1) {
		/* If any string arrived over USART */
		/* Expecting "\n" at the end of string from USART terminal or any other source */
		if (TM_USART_Gets(USART2, USART_Buffer, sizeof(USART_Buffer))) {
			/* Send it back over DMA */
			TM_USART_DMA_Send(USART2, (uint8_t *)USART_Buffer, strlen(USART_Buffer));

			/* Wait till DMA works */
			/* You can do other stuff here instead of waiting for DMA to end */
			while (TM_USART_DMA_Sending(USART2));
		}
	}
}
Esempio n. 13
0
int main(void) {
	char buf[30];
	uint8_t devices, i, j, count, device[2][8];
	
	/* Initialize system */
	SystemInit();
	
	/* Initialize delay */
	TM_DELAY_Init();
	
	/* Initialize One Wire on pin PD0 */
	TM_OneWire_Init();
	
	/* Initialize USART, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200);
	
	/* Checks for any device on 1-wire */
	devices = TM_OneWire_First();
	count = 0;
	while (devices) {
		count++;
		for (i = 0; i < 8; i++) {
			device[count - 1][i] = TM_OneWire_GetROM(i);
		}
		/* Check for new device */
		devices = TM_OneWire_Next();
	}
	/* If any devices on 1-wire */
	if (count > 0) {
		sprintf(buf, "Devices found on 1-wire: %d\n\r", count);
		TM_USART_Puts(USART1, buf);
		/* Display 64bit rom code */
		for (j = 0; j < count; j++) {
			for (i = 0; i < 8; i++) {
				sprintf(buf, "0x%02X ", device[j][i]);
				TM_USART_Puts(USART1, buf);
			}
			TM_USART_Puts(USART1, "\n\r");
		}
	} else {
		TM_USART_Puts(USART1, "No devices on OneWire.\n\r");
	}
	
	while (1) {

	}
}
Esempio n. 14
0
/* Send message to PC */
void SendString(char* message) {
#ifdef ENABLE_USART
	TM_USART_Puts(USART1, message);
#endif
#ifdef ENABLE_VCP
	TM_USB_VCP_Puts(message);
#endif
}
Esempio n. 15
0
void getTime(void) {
  TM_RTC_Time_t datatime;
  TM_RTC_GetDateTime(&datatime, TM_RTC_Format_BIN);
  sprintf(buffer,"Current time: %02d:%02d:%02d, %02d.%02d.%02dr.\n\r",
          datatime.hours, datatime.minutes, datatime.seconds,
          datatime.date, datatime.month, datatime.year);
  TM_USART_Puts(MENU_USART,buffer);
}
Esempio n. 16
0
/**
  * Extract data from buffer
  * Name: SDCard_extractConfig
  *
  * Description: Separates the buffer array filled by reading the configuration file using delimiters
  *              Values extracted for each expected parameter
  *              Configuration structure was populated with the extracted values
  *
  * Arguments: void
  *
  * Returns: void  
  */
void SDCard_extractConfig(){
  char str[512];
  char *str1, *str2, *param, *value;
  char *saveptr1, *saveptr2;
  int j;

  for (j=1, str1 = (char *) SD_Buffer; ; j++, str1 = NULL) {
    param = strtok_r(str1, ";", &saveptr1);
    if (param == NULL){
      break;
    }
    for (str2 = param; ; str2 = NULL) {
      value = strtok_r(str2, " = ", &saveptr2);
      if (value == NULL) {
        break;
      }
	  /* Extract Cutoff Frequency */
      if (strstr(value, "Cutoff") != NULL){
        str2 = NULL;
        value = strtok_r(str2, " = ", &saveptr2);
        config.LPF_cutOffFrequency = atoi(value);
      }
	  /* Extract Sampling Frequency */
      else if (strstr(value, "Adc_sampling") != NULL){
        str2 = NULL;
        value = strtok_r(str2, " = ", &saveptr2);
        config.ADC_samplingRate = atoi(value);
      }
	  /* Extract Classification Time */
      else if (strstr(value, "Time") != NULL){
        str2 = NULL;
        value = strtok_r(str2, " = ", &saveptr2);
        config.classificationTime = atoi(value) * config.ADC_samplingRate;
      }
      sprintf(str, "--> %s\n\r", value);
      /* Put to USART */
      TM_USART_Puts(USART1, str);
    }
  }
  sprintf(str, "cut = %u, adc = %u, time = %u\n\r", config.LPF_cutOffFrequency, config.ADC_samplingRate, config.classificationTime);
  /* Put to USART */
  TM_USART_Puts(USART1, str);
}
Esempio n. 17
0
/* DMA transfer complete callback */
void TM_DMA_TransferCompleteHandler(DMA_Stream_TypeDef* DMA_Stream) {
	/* Check for which stream we were successful */
	if (DMA_Stream == TM_USART_DMA_GetStreamTX(USART)) {
		/* DMA transfer has finished */
		/* We also have to wait for USART to finish transmitting last byte from DMA */
		while (TM_USART_DMA_Transmitting(USART));
		
		/* Send notification to the same USART port with polling mode */
		TM_USART_Puts(USART, "DMA has sent data!\n");
	}
}
Esempio n. 18
0
/**
  * Handle PC7 interrupt
  * Name: EXTI9_5_IRQHandler
  *
  * Description: Handles the interrupt generated by the card detect pin
  *              This sends a debug message with the new status of the SD card
  *              If no SD card is detected, the Error LED function is called
  *              If it is detected then the LED is cleared 
  *
  * Arguments: void
  *
  * Returns: void  
  */
void EXTI9_5_IRQHandler(void) {
  char str[20];
  /* Make sure that interrupt flag is set */
  if (EXTI_GetITStatus(EXTI_Line7) != RESET) {
    if ((((FATFS_USE_DETECT_PIN_PORT)->IDR & (FATFS_USE_DETECT_PIN_PIN)) == 0 ? 0 : 1) != 0 && SDCardInserted == 1) {
      sprintf(str, "NO SD CARD INSERTED\n\r");
      TM_USART_Puts(USART1, str);
      SDCardInserted = 0;
      LED_error();
    }
    if ((((FATFS_USE_DETECT_PIN_PORT)->IDR & (FATFS_USE_DETECT_PIN_PIN)) == 0 ? 0 : 1) == 0 && SDCardInserted == 0) {
      SDCardInserted = 1;
      sprintf(str, "SD CARD INSERTED\n\r");
      TM_USART_Puts(USART1, str);
      LED_clearError();
    }
    /* Clear interrupt flag */
    EXTI_ClearITPendingBit(EXTI_Line7);
  }
}
Esempio n. 19
0
int8_t	SIM300SendMsg(const char *num, const char *msg,uint8_t *msg_ref)
{
	TM_USART_ClearBuffer(USART1);
	
	char cmd[25];
	
	sprintf(cmd,"AT+CMGS= %s",num);
	
	cmd[8]=0x22; //"
	
	uint8_t n=strlen(cmd);
	
	cmd[n]=0x22; //"
	cmd[n+1]='\0';
	
	//Send Command
	SIM300Cmd(cmd);
	
	Delayms(100);
	
	TM_USART_Puts(USART1,msg);
	
	TM_USART_Putc(USART1,0x1A);
	
	while(   TM_USART_Available(USART1)<(strlen(msg)+5)   );
	
	//Remove Echo
	TM_USART_Gets(USART1,sim300_buffer,strlen(msg)+5);
	
	uint8_t len=SIM300WaitForResponse(6000);
	
	if(len==0)
		return SIM300_TIMEOUT;
	
	sim300_buffer[len-1]='\0';
	
	if(strncasecmp(sim300_buffer+2,"CMGS:",5)==0)
	{
		
		*msg_ref=atoi(sim300_buffer+8);
		
		TM_USART_ClearBuffer(USART1);
		
		return SIM300_OK;
	}
	else
	{
		TM_USART_ClearBuffer(USART1);
		return SIM300_FAIL;	
	}		
}
Esempio n. 20
0
int8_t SIM300Cmd(const char *cmd)
{
	TM_USART_ClearBuffer(USART1);
	TM_USART_Puts(USART1,cmd);	//Send Command
	TM_USART_Puts(USART1,"\r\n");	//CR
	//TM_USART_FlushBuffer(USART1);
	TM_USART_ClearBuffer(USART1);
	uint8_t len=strlen(cmd);
	
	len++;	//Add 1 for trailing CR added to all commands
	
	uint16_t i=0;
	
	//Wait for echo
	while(i<10*len)
	{
		if(TM_USART_Available(USART1)<len)
		{
			i++;
			
			Delayms(10);
			
			continue;
		}
		else
		{
			//We got an echo
			//Now check it
			TM_USART_Gets(USART1,sim300_buffer,len);	//Read serial Data
			
			return SIM300_OK;
			
		}
	}
	
	return SIM300_TIMEOUT;
			
}
Esempio n. 21
0
void goSleep(void) {
  TM_RTC_Interrupts(TM_RTC_Int_Disable);
  TM_USART_Puts(MENU_USART,"Going to sleep state now!\n\r");
  USART_DeInit(MENU_USART);
  USART_DeInit(GSM_USART);
  USART_DeInit(GPS_USART);
  I2C_DeInit(I2C3);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE, DISABLE);
  TM_RTC_Interrupts(TM_RTC_Int_1s); // 500ms;1,2,5,10,15,30,60 seconds to choose from
  TM_LOWPOWER_Standby();
  //TM_LOWPOWER_StopUntilInterrupt();
  //TM_LOWPOWER_SleepUntilInterrupt(1);
  //TM_LOWPOWER_EnableWakeUpPin();
}
Esempio n. 22
0
void setTime(void) {
  TM_RTC_Time_t time;
  int tmp=0;
  TM_RTC_GetDateTime(&time, TM_RTC_Format_BIN);
  tmp = cmdlineGetArgInt(1);
  if (tmp > 0 && tmp < 25) 
  time.hours=tmp;
  tmp = cmdlineGetArgInt(2);
  if (tmp > 0 && tmp < 61)   
  time.minutes=tmp;
  tmp = cmdlineGetArgInt(3);
  if (tmp > 0 && tmp < 61) 
  time.seconds=tmp;
  TM_RTC_SetDateTime(&time, TM_RTC_Format_BIN);
  conf_bit(SET,SETTINGS_1,TIME_SET);
  TM_USART_Puts(MENU_USART,"Time has been sucessfully set!\n\r");
}
Esempio n. 23
0
void setDate(void) {
  TM_RTC_Time_t time;
  int tmp=0;
  TM_RTC_GetDateTime(&time, TM_RTC_Format_BIN);
  tmp = cmdlineGetArgInt(1);
  if (tmp > 0 && tmp < 32) 
    time.date=tmp;
  tmp = cmdlineGetArgInt(2);
  if (tmp > 0 && tmp < 13) 
    time.month=tmp;
  tmp = cmdlineGetArgInt(3);
  if (tmp >= 0 && tmp <= 99) 
    time.year=tmp;
  TM_RTC_SetDateTime(&time, TM_RTC_Format_BIN);
  conf_bit(SET,SETTINGS_1,DATE_SET);
  TM_USART_Puts(MENU_USART,"Date has been sucessfully set!\n\r");
}
Esempio n. 24
0
/* Called on wakeup interrupt */
void TM_RTC_RequestHandler() {
	/* Get time */
	TM_RTC_GetDateTime(&datatime, TM_RTC_Format_BIN);
	
	/* Format time */
	sprintf(buf, "%02d.%02d.%04d %02d:%02d:%02d  Unix: %u\n",
				datatime.date,
				datatime.month,
				datatime.year + 2000,
				datatime.hours,
				datatime.minutes,
				datatime.seconds,
				datatime.unix
	);
	/* Send to USART */
	TM_USART_Puts(USART3, buf);
	/* Toggle LED */
	TM_DISCO_LedToggle(LED_RED | LED_GREEN);
}
Esempio n. 25
0
int main(void) {
	/* Init system clock for maximum system speed */
	TM_RCC_InitSystem();
	
	/* Init HAL layer */
	HAL_Init();
	
	/* Init USART, check USART lib description for pinout */
	TM_USART_Init(USART, TM_USART_PinsPack_1, 921600);
	
	/* Say string without DMA */
	TM_USART_Puts(USART, "Hello via USART without DMA\n");
	
	/* Init TX DMA for USART */
	TM_USART_DMA_Init(USART);
	
	/* Enable interrupts for TX DMA */
	TM_USART_DMA_EnableInterrupts(USART);
	
	/* Send data with DMA */
	TM_USART_DMA_Send(USART, (uint8_t *)USART_Buffer, strlen(USART_Buffer));
	
	/* Wait till DMA works */
	/* You can do other stuff here instead of waiting for DMA to end */
	while (TM_USART_DMA_Transmitting(USART));
	
	while (1) {
		/* If any string arrived over USART */
		/* Expecting "\n" at the end of string from USART terminal or any other source */
		if (TM_USART_Gets(USART, USART_Buffer, sizeof(USART_Buffer))) {
			/* Send it back over DMA */
			TM_USART_DMA_Send(USART, (uint8_t *)USART_Buffer, strlen(USART_Buffer));

			/* Wait till DMA works */
			/* You can do other stuff here instead of waiting for DMA to end */
			while (TM_USART_DMA_Transmitting(USART));
		}
	}
}
Esempio n. 26
0
int main(void) {
	uint8_t c;
	
	//Initialize system
	SystemInit();

	TM_DELAY_Init();

	//Initialize USART1 at 9600 baud, TX: PA9, RX: PA10
	TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600);
	//Put string to terminal
	TM_USART_Puts(USART1, "Hello world\n\r");

	while (1) {
		//Get character from internal buffer
		c = TM_USART_Getc(USART1);
		if (c) {
			//If anything received, put it back to terminal
			TM_USART_Putc(USART1, c);
		}
	}
}
Esempio n. 27
0
void zspmStat (void) {
//TM_I2C_Init(ZSPM_I2C, ZSPM_I2C_PINSPACK, ZSPM_I2C_SPEED); 
  if (!TM_I2C_IsDeviceConnected(ZSPM_I2C, ZSPM_I2C_ADDRESS)) {
    TM_USART_Puts(MENU_USART,"ZMDI charger is not available\r\n");
  }
else {
    uint8_t test=0;
    uint8_t tmp=0;
    TM_I2C_Write(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG_ENABLE, BIT_EN_CFG);
    printf("Register 0: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_STATUS));
    printf("Register 2: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG1));
    printf("Register 3: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG2));
    printf("Register 4: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG3));
    printf("Register 5: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG4));
    printf("Register 6: %x\n\r",TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG5));
    test=TM_I2C_Read(ZSPM_I2C, ZSPM_I2C_ADDRESS, ZSPM_CONFIG1);
    tmp=(test&BIT_PRE_CHRG)>>6;
    if(tmp==0x00) printf("Precharge current 50mA\n\r");
    else if (tmp==0x01) printf("Precharge current 100mA\n\r");
    else if (tmp==0x02) printf("Precharge current 185mA\n\r");
    else if (tmp==0x03) printf("Precharge current 370mA\n\r");
  }
}
Esempio n. 28
0
int main(void) {
    char buffer[20];

    /* Initialize system */
    SystemInit();

    /* Initialize delay */
    TM_DELAY_Init();

    /* Initialize USART1, TX: PB6 */
    TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200);

    /* Initialize random number generator */
    TM_RNG_Init();

    while (1) {
        /* Get number */
        sprintf(buffer, "Number: %u\n", TM_RNG_Get());
        /* Put to USART */
        TM_USART_Puts(USART1, buffer);
        Delayms(1000);
    }
}
Esempio n. 29
0
/**
  * Write data to SD card
  * Name: SDCard_writeData
  *
  * Description: If the SD card is detected, it is mounted and the correct file is opened
  *              The string is created using the time from the RTC, the classification Value and the data 
  *              The file is then appended to include the new line of text
  *
  * Arguments: data_type type - enumerated type to determine what type of data is to be written
  *            uint32_t data[] - data array
  *	           const char * classificationValue - String of classification result
  *
  * Returns: void  
  */
void SDCard_writeData(data_type type, uint32_t data [], const char *classificationValue) {
  char str[codebookSize * codebookSize * 3] = {0}, fileName[14], time[25];
  char contents[codebookSize * codebookSize * 3] = {0};
  uint32_t count;
  uint32_t cnt;
  int i;
  /* Only attempt the write function if SD card is inserted */
  if (SDCardInserted){
    /* Get time and date */ 
    TM_RTC_GetDateTime(&datatime, TM_RTC_Format_BIN);
    sprintf(time, "%02d.%02d.%04d %02d:%02d:%02d    ",
            datatime.date,
            datatime.month,
            datatime.year + 2000,
            datatime.hours,
            datatime.minutes,
            datatime.seconds
            );
    /* Set filename */
    if (type == SMatrix_type){
      sprintf(fileName, "SD:SMatrix.txt");
    }
    /* Mount SD card and open file */
    if ((fres = f_mount(&fatFs, "SD:", 0)) == FR_OK){
	  /* If file does not exist then create it */
      if ((fres = f_open(&fil, fileName, FA_READ | FA_WRITE)) == FR_NO_FILE){
        fres = f_open(&fil, fileName, FA_CREATE_ALWAYS | FA_READ | FA_WRITE);
      }
      /* If file does exist navigate to the end of the file */
      else {
        f_read(&fil, str, sizeof(str), &cnt);
        f_lseek(&fil, cnt);
      }
      if (fres != FR_OK){
        sprintf(str, "Error Message @%d\n\r", fres);
        TM_USART_Puts(USART1, str);
      }
      else {
      /* S Matrix data transmission */
      if (type == SMatrix_type){
        /* Populate string with S Matrix values */
        for (i = 0; i < codebookSize; i++){
          if (i == 0) {
            sprintf(contents, "%s%s%u, ", time, classificationValue, ((uint32_t *)data)[i]);
          }
          else if (i == 27) {
            sprintf(contents, "%s%u\n\r", contents, ((uint32_t *)data)[i]);
          }
          else {
            sprintf(contents, "%s%u, ", contents, ((uint32_t *)data)[i]);
          }
        }
        /* Append end of the file */
        count = f_puts(contents, &fil);
        }
        /* Put to USART */
        TM_USART_Puts(USART1, contents);
        sprintf(str, "Writing is done. Written %d bytes. Error = %d\n\r", count, fres);
        TM_USART_Puts(USART1, str);
        f_close(&fil);
        f_mount(NULL, "SD:", 1);
      }
    }
    else {
      sprintf(str, "Error Message @%d\n\r", fres);
      /* Put to USART */
      TM_USART_Puts(USART1, str);
    }
  }
}
Esempio n. 30
0
int main(void) {
	char buffer[50];
	
	/* Working structure */
	TM_BMP180_t BMP180_Data;
	
	/* Initialize system */
	SystemInit();
	
	/* Initialize delay */
	TM_DELAY_Init();
	
	/* Initialize USART1, 11500baud, TX: PB6 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200);
	
	/* Initialize BMP180 pressure sensor */
	if (TM_BMP180_Init(&BMP180_Data) == TM_BMP180_Result_Ok) {
		/* Init OK */
		TM_USART_Puts(USART1, "BMP180 configured and ready to use\n\n");
	} else {
		/* Device error */
		TM_USART_Puts(USART1, "BMP180 error\n\n");
		while (1);
	}
	
	/* Imagine, we are at 1000 meters above the sea */
	/* And we read pressure of 95000 pascals */
	/* Pressure right on the sea is */
	sprintf(buffer, "Pressure right above the sea: %d pascals\n", TM_BMP180_GetPressureAtSeaLevel(95000, 1000));
	TM_USART_Puts(USART1, buffer);
	sprintf(buffer, "Data were calculated from pressure %d pascals at know altitude %d meters\n\n\n", 95000, 1000);
	TM_USART_Puts(USART1, buffer);

	while (1) {
		/* Start temperature conversion */
		TM_BMP180_StartTemperature(&BMP180_Data);
		
		/* Wait delay in microseconds */
		/* You can do other things here instead of delay */
		Delay(BMP180_Data.Delay);
		
		/* Read temperature first */
		TM_BMP180_ReadTemperature(&BMP180_Data);
		
		/* Start pressure conversion at ultra high resolution */
		TM_BMP180_StartPressure(&BMP180_Data, TM_BMP180_Oversampling_UltraHighResolution);
		
		/* Wait delay in microseconds */
		/* You can do other things here instead of delay */
		Delay(BMP180_Data.Delay);
		
		/* Read pressure value */
		TM_BMP180_ReadPressure(&BMP180_Data);
		
		/* Format data and print to USART */
		sprintf(buffer, "Temp: %2.3f degrees\nPressure: %6d Pascals\nAltitude at current pressure: %3.2f meters\n\n",
			BMP180_Data.Temperature,
			BMP180_Data.Pressure,
			BMP180_Data.Altitude
		);
		/* Send to USART */
		TM_USART_Puts(USART1, buffer);
		
		/* Some delay */
		Delayms(1000);
	}
}