int main(void) { uint8_t page_address; uint8_t column_address; uint8_t start_line_address = 0; volatile uint16_t delay = 10000; board_init(); sysclk_init(); // Initialize SPI and SSD1306 controller ssd1306_init(); // set addresses at beginning of display ssd1306_set_page_address(0); ssd1306_set_column_address(0); // fill display with lines for (page_address = 0; page_address <= 4; page_address++) { ssd1306_set_page_address(page_address); for (column_address = 0; column_address < 128; column_address++) { ssd1306_set_column_address(column_address); /* fill every other pixel in the display. This will produce horizontal lines on the display. */ ssd1306_write_data(0x6F); } } // scroll the display using hardware support in the LCD controller while (true) { ssd1306_set_display_start_line_address(start_line_address++); clock_delay_msec(250); } }
/** * \brief Put framebuffer to LCD controller * * This function will output the complete framebuffer from RAM to the * LCD controller. * * \note This is done automatically if using the graphic primitives. Only * needed if you are manipulating the framebuffer directly in your code. */ void gfx_mono_ssd1306_put_framebuffer(void) { uint8_t page; for (page = 0; page < GFX_MONO_LCD_PAGES; page++) { ssd1306_set_page_address(page); ssd1306_set_column_address(0); gfx_mono_ssd1306_put_page(framebuffer + (page * GFX_MONO_LCD_WIDTH), page, 0, GFX_MONO_LCD_WIDTH); } }
/** * \brief Get a byte from the display controller RAM * * If the LCD controller is accessed by the SPI interface we cannot read the * data. In this case return the data from the local framebuffer instead. * * \param page Page address * \param column Page offset (x coordinate) * \return data from LCD controller or framebuffer. * * The following code will read the first byte from the display memory or the * local framebuffer if direct read is not possible. The data represents the * pixels from x = 0 and y = 0 to y = 7. * \code * data = gfx_mono_ssd1306_get_byte(0, 0); * \endcode */ uint8_t gfx_mono_ssd1306_get_byte(gfx_coord_t page, gfx_coord_t column) { #ifdef CONFIG_SSD1306_FRAMEBUFFER return gfx_mono_framebuffer_get_byte(page, column); #else ssd1306_set_page_address(page); ssd1306_set_column_address(column); return ssd1306_read_data(); #endif }
/** * \brief Put a page from RAM to display controller. * * If the controller is accessed by the SPI interface, we can not read * back data from the LCD controller RAM. Because of this all data that is * written to the LCD controller in this mode is also written to a framebuffer * in MCU RAM. * * \param data Pointer to data to be written * \param page Page address * \param column Offset into page (x coordinate) * \param width Number of bytes to be written. * * The following example will write 32 bytes from data_buf to the page 0, * column 10. This will place data_buf in the rectangle x1=10,y1=0,x2=42,y2=8 * (10 pixels from the upper left corner of the screen): * \code * gfx_mono_ssd1306_put_page(data_buf, 0, 10, 32); * \endcode */ void gfx_mono_ssd1306_put_page(gfx_mono_color_t *data, gfx_coord_t page, gfx_coord_t column, gfx_coord_t width) { #ifdef CONFIG_SSD1306_FRAMEBUFFER gfx_mono_framebuffer_put_page(data, page, column, width); #endif ssd1306_set_page_address(page); ssd1306_set_column_address(column); do { ssd1306_write_data(*data++); } while (--width); }
/** * \brief Read a page from the LCD controller * * If the LCD controller is accessed by the SPI interface we cannot read * data directly from the controller. In that case we will read the data from * the local framebuffer instead. * * \param data Pointer where to store the read data * \param page Page address * \param column Offset into page (x coordinate) * \param width Number of bytes to be read * * The following example will read back the first 128 bytes (first page) from * the display memory: * \code * gfx_mono_ssd1306_get_page(read_buffer, 0, 0, 128); * \endcode */ void gfx_mono_ssd1306_get_page(gfx_mono_color_t *data, gfx_coord_t page, gfx_coord_t column, gfx_coord_t width) { #ifdef CONFIG_SSD1306_FRAMEBUFFER gfx_mono_framebuffer_get_page(data, page, column, width); #else ssd1306_set_page_address(page); ssd1306_set_column_address(column); do { *data++ = ssd1306_read_data(); } while (--width); #endif }
/** * \brief Put a byte to the display controller RAM * * If the LCD controller is accessed by the SPI interface we will also put the * data to the local framebuffer. * * \param page Page address * \param column Page offset (x coordinate) * \param data Data to be written * * This example will put the value 0xFF to the first byte in the display memory * setting a 8 pixel high column of pixels in the upper left corner of the * display. * \code * gfx_mono_ssd1306_put_byte(0, 0, 0xFF, false); * \endcode */ void gfx_mono_ssd1306_put_byte(gfx_coord_t page, gfx_coord_t column, uint8_t data, bool force) { #ifdef CONFIG_SSD1306_FRAMEBUFFER if (!force && data == gfx_mono_framebuffer_get_byte(page, column)) { return; } gfx_mono_framebuffer_put_byte(page, column, data); #endif ssd1306_set_page_address(page); ssd1306_set_column_address(column); ssd1306_write_data(data); }
int main(void) { //! the page address to write to uint8_t page_address; //! the column address, or the X pixel. uint8_t column_address; //! store the LCD controller start draw line uint8_t start_line_address = 0; board_init(); sysclk_init(); // Initialize SPI and SSD1306 controller ssd1306_init(); // set addresses at beginning of display ssd1306_set_page_address(0); ssd1306_set_column_address(0); // fill display with lines for (page_address = 0; page_address <= 7; page_address++) { ssd1306_set_page_address(page_address); for (column_address = 0; column_address < 128; column_address++) { ssd1306_set_column_address(column_address); /* fill every other pixel in the display. This will produce horizontal lines on the display. */ ssd1306_write_data(0x6F); } } // scroll the display using hardware support in the LCD controller while (true) { ssd1306_set_display_start_line_address(start_line_address++); delay_ms(250); } }
PROCESS_THREAD(blink_process, ev, data) { static struct etimer et_blink; etimer_set(&et_blink, CLOCK_SECOND); PROCESS_BEGIN(); static char lux_value[6]; static char lux_value2[6]; static char raw_value[6]; static char raw_value2[6]; static char temperature_val[6]; static uint16_t adc_data=0; static uint16_t adc_data2=0; static float adc_lux=0; static float adc_lux2=0; static float measured_temp=0; // static int blinks = 0; ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_set_column_address(2); ssd1306_write_text("Lumen in Lux:"); ssd1306_set_page_address(1); ssd1306_set_column_address(2); ssd1306_write_text("Raw ADC out :"); ssd1306_set_page_address(2); ssd1306_set_column_address(2); ssd1306_write_text("Ambient Temperature measured:"); while(1) { PROCESS_WAIT_EVENT(); if (ev==PROCESS_EVENT_TIMER) { DDRB |=(1<<PORTB4); PORTB ^= (1<<PORTB4); adc_init(); adc_data=get_adc(0); adc_lux=adc_data*0.9765625; /* amps=adc_volt/10000.0; microamps=amps/1000000; lux_data=microamps*2; */ itoa(adc_lux, lux_value, 10); ssd1306_set_page_address(0); ssd1306_set_column_address(73); ssd1306_write_text(lux_value); itoa(adc_data, raw_value, 10); ssd1306_set_page_address(1); ssd1306_set_column_address(73); ssd1306_write_text(raw_value); adc_init_full(ADC_CHAN_ADC0, ADC_TRIG_FREE_RUN, ADC_REF_AVCC, ADC_PS_64); adc_conversion_start(); adc_lux2=adc_data2*0.9765626; itoa(adc_lux2, lux_value2, 10); ssd1306_set_page_address(0); ssd1306_set_column_address(95); ssd1306_write_text(lux_value2); itoa(adc_data2, raw_value2, 10); ssd1306_set_page_address(1); ssd1306_set_column_address(95); ssd1306_write_text(raw_value2); measured_temp=ReadTempVal(); itoa(measured_temp, temperature_val, 10); ssd1306_set_page_address(2); ssd1306_set_column_address(95); ssd1306_write_text(temperature_val); } } PROCESS_END(); }
int main(void) { // asm("nop"); rtc_init(); //changing the clock to 32MHz enable_oscillator(OSC_RC32MEN_bm); sysclk_prescaler(CLK_PSADIV_1_gc,CLK_PSBCDIV_1_1_gc); sysclk_source(CLK_SCLKSEL_RC32M_gc); usart_config(&USARTC0,&PORTC,USART_CMODE_ASYNCHRONOUS_gc,USART_PMODE_DISABLED_gc,USART_CHSIZE_8BIT_gc,false,false); usart_baud(&USARTC0,9600,-3); FILE my_stdio; create_file_stream(&my_stdio,&USARTC0_putchar,&USARTC0_getchar); set_stdio_stream(&my_stdio); port_direction_set_mask(&PORTR,1<<0); uint8_t page; uint8_t column; gfx_mono_set_framebuffer(framebuffer); ssd1306_init(); ssd1306_clear(); ssd1306_set_display_start_line_address(0); for (page = 0; page < GFX_MONO_LCD_PAGES; page++) { for (column = 0; column < GFX_MONO_LCD_WIDTH; column++) { gfx_mono_ssd1306_put_byte(page, column, 0x00, 1); } } ssd1306_set_page_address(0); ssd1306_write_text("EMON"); rtc_ms_delay(1000); lcd_line_print(0,"EMON YOU ROCK"); esp8266_serial_init(); printf("starting system\n"); printf("-----------------------------------------------------------\n"); #define mqtt_callback_on_message "function(conn, topic, data) print(topic .. \":\" ) if data ~= nil then print(data) end end" // //esp8266_getmode(); esp8266_setmode(ESP8266_WIFI_MODE_STATION); esp8266_available_AP_t myAPdata[10]; int n = esp8266_sta_getap(3000,myAPdata); for(int i=0;i<n;i++){ printf("available ssid : %s\n" , myAPdata[i].BSSID); } esp8266_sta_config("Emon","19031992",NULL,NULL); printf("\nthe wifi mode is %d\n", esp8266_getmode()); esp8266_sta_getmac(); //esp8266_uart_setup(0,9600,8,ESP8266_UART_PARITY_NONE,ESP8266_UART_STOPBITS_1,0); // esp8266_sta_getip(); esp8266_sta_get_status(); lcd_line_print(0,"HABIBUR RAHMAN"); // esp8266_mqtt_create_client("m","clientid", 30 , "user", "password"); esp8266_mqtt_client_connect("m","emon.dlinkddns.com",9000,0,"function(conn) print(\"m:connected\") end"); esp8266_mqtt_client_subscribe("m","sky2",0,"function(conn) print(\"subscribed\") end"); esp8266_mqtt_client_callback_on_message("m",mqtt_callback_on_message); esp8266_mqtt_create_client("n","clientid", 30 , "user", "password"); esp8266_mqtt_client_connect("n","broker.hivemq.com",1883,0,"function(conn) print(\"n:connected\") end"); esp8266_mqtt_client_subscribe("n","dog",0,"function(conn) print(\"subscribed\") end"); esp8266_mqtt_client_callback_on_message("n",mqtt_callback_on_message); int i=0; char numstr[30]; char mydata[100]; char mydata2[100]; char tempcmd[50]; char tempdata[100]; while (1) { esp8266_rx_buff_receive(mydata); if(!strcmp(mydata, "sky2:\r\nkaminey\r\n")){ printf("\n\n******f**k you*****\n\n"); esp8266_mqtt_client_publish("m","sky","test reply .. by emon",0,0,"function(conn) print(\"sent\") end"); printf(mydata2); } else if(!strcmp(mydata, "m:connected\r\n")){ printf("RECONNECTING NOWWWWW!!!"); esp8266_mqtt_client_subscribe("m","sky2",0,"function(conn) print(\"subscribed\") end"); } else if(!strcmp(mydata, "n:connected\r\n")){ printf("RECONNECTING NOW!!!"); esp8266_mqtt_client_subscribe("n","dog",0,"function(conn) print(\"subscribed\") end"); } printf(mydata); ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_write_text(mydata); } }
void lcd_line_print(int line, char *str){ ssd1306_clear(); ssd1306_set_page_address(line); ssd1306_set_column_address(0); ssd1306_write_text(str); }
/** * \brief The main application. */ int main(void) { uint8_t i; uint8_t temperature[BUFFER_SIZE]; uint8_t light[BUFFER_SIZE]; char value_disp[5]; uint32_t adc_value; uint32_t light_value; double temp; /* Initialize clocks. */ sysclk_init(); /* Initialize GPIO states. */ board_init(); /* Configure ADC for light sensor. */ configure_adc(); /* Initialize at30tse. */ at30tse_init(); /* Configure IO1 buttons. */ configure_buttons(); /* Initialize SPI and SSD1306 controller. */ ssd1306_init(); ssd1306_clear(); /* Clear internal buffers. */ for (i = 0; i < BUFFER_SIZE; ++i) { temperature[i] = 0; light[i] = 0; } /* Show the start info. */ multi_language_show_start_info(); /* Wait 3 seconds to show the above message. */ delay_s(3); /* Check for valid firmware in SD card. */ check_valid_firmware(); while (true) { /* Set the trigger and jump to bootloader */ if (reset_flag) { jump_to_bootloader(); } /* Refresh page title only if necessary. */ if (app_mode_switch > 0) { app_mode = (app_mode + 1) % 3; /* Clear screen. */ ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_set_column_address(0); if (app_mode == 0) { /* Temperature mode. */ ioport_set_pin_level(OLED1_LED1_PIN, OLED1_LED1_ACTIVE); ioport_set_pin_level(OLED1_LED2_PIN, !OLED1_LED2_ACTIVE); ioport_set_pin_level(OLED1_LED3_PIN, !OLED1_LED3_ACTIVE); multi_language_show_temperature_info(); } else if (app_mode == 1) { /* Light mode. */ ioport_set_pin_level(OLED1_LED2_PIN, OLED1_LED2_ACTIVE); ioport_set_pin_level(OLED1_LED1_PIN, !OLED1_LED1_ACTIVE); ioport_set_pin_level(OLED1_LED3_PIN, !OLED1_LED3_ACTIVE); multi_language_show_light_info(); } else { /* SD mode. */ ioport_set_pin_level(OLED1_LED3_PIN, OLED1_LED3_ACTIVE); ioport_set_pin_level(OLED1_LED1_PIN, !OLED1_LED1_ACTIVE); ioport_set_pin_level(OLED1_LED2_PIN, !OLED1_LED2_ACTIVE); sd_listing_pos = 0; /* Show SD card info. */ display_sd_info(); } app_mode_switch = 0; } /* Shift graph buffers. */ for (i = 0; i < (BUFFER_SIZE - 1); ++i) { temperature[i] = temperature[i + 1]; light[i] = light[i + 1]; } /* Get temperature. */ if (at30tse_read_temperature(&temp) == TWI_SUCCESS) { /* Don't care about negative temperature. */ if (temp < 0) { temp = 0; } /* Update temperature for display. */ /* Note: rescale to 0~24 for better rendering. */ if (temp > 40) { temperature[BUFFER_SIZE - 1] = 24; } else { temperature[BUFFER_SIZE - 1] = (uint8_t)temp * 24 / 40; } } else { /* Error print zero values. */ temperature[BUFFER_SIZE - 1] = 0; } /* Get light sensor information. */ /* Rescale to 0~24 for better rendering. */ adc_start_software_conversion(ADC); adc_value = adc_channel_get_value(ADC, ADC_CHANNEL_0); light[BUFFER_SIZE - 1] = 24 - adc_value * 24 / 1024; if (app_mode == 0) { /* Display temperature in text format. */ sprintf(value_disp, "%d", (uint8_t)temp); ssd1306_set_column_address(98); ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0)); ssd1306_write_text(" "); /* Avoid character overlapping. */ if (temp < 10) { ssd1306_clear_char(); } ssd1306_write_text(value_disp); /* Display degree symbol. */ ssd1306_write_data(0x06); ssd1306_write_data(0x06); ssd1306_write_text("c"); /* Refresh graph. */ ssd1306_draw_graph(0, 2, BUFFER_SIZE, 2, temperature); } else if (app_mode == 1) { light_value = 100 - (adc_value * 100 / 1024); sprintf(value_disp, "%lu", light_value); ssd1306_set_column_address(98); ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0)); ssd1306_write_text(" "); /* Avoid character overlapping. */ if (light_value < 10) { ssd1306_clear_char(); } ssd1306_write_text(value_disp); ssd1306_write_text("%"); /* Avoid character overlapping. */ if (light_value < 100) { ssd1306_clear_char(); } /* Refresh graph. */ ssd1306_draw_graph(0, 2, BUFFER_SIZE, 2, light); } else { /** * Refresh screen if card was inserted/removed or * browsing content. */ if (sd_update == 1) { /* Clear screen. */ ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_set_column_address(0); if (sd_listing_pos == 0) { /* Show SD card info. */ display_sd_info(); } else { /* List SD card files. */ display_sd_files_unicode(); } sd_update = 0; } } /* Wait and stop screen flickers. */ delay_ms(150); if (app_mode_switch == 0) { pio_enable_interrupt(OLED1_PIN_PUSHBUTTON_1_PIO, OLED1_PIN_PUSHBUTTON_1_MASK); } if (sd_update == 0) { pio_enable_interrupt(OLED1_PIN_PUSHBUTTON_2_PIO, OLED1_PIN_PUSHBUTTON_2_MASK); pio_enable_interrupt(OLED1_PIN_PUSHBUTTON_3_PIO, OLED1_PIN_PUSHBUTTON_3_MASK); } } }
int main(void) { uint8_t i; uint8_t temperature[BUFFER_SIZE]; uint8_t light[BUFFER_SIZE]; uint8_t value_disp[5]; uint32_t adc_value; double temp; // Initialize clocks. sysclk_init(); // Initialize GPIO states. board_init(); // Configure ADC for light sensor. configure_adc(); // Initialize at30tse. at30tse_init(); // Configure IO1 buttons. configure_buttons(); // Initialize SPI and SSD1306 controller. ssd1306_init(); ssd1306_clear(); // Clear internal buffers. for (i = 0; i < BUFFER_SIZE; ++i) { temperature[i] = 0; light[i] = 0; } while (true) { /* Refresh page title only if necessary. */ if (app_mode_switch > 0) { app_mode = app_mode_switch - 1; // Clear screen. ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_set_column_address(0); /* Temperature mode. */ if (app_mode == 0) { ioport_set_pin_level(IO1_LED1_PIN, IO1_LED1_ACTIVE); ioport_set_pin_level(IO1_LED2_PIN, !IO1_LED2_ACTIVE); ioport_set_pin_level(IO1_LED3_PIN, !IO1_LED3_ACTIVE); ssd1306_write_text("Temperature sensor:"); } /* Light mode. */ else if (app_mode == 1) { ioport_set_pin_level(IO1_LED2_PIN, IO1_LED2_ACTIVE); ioport_set_pin_level(IO1_LED1_PIN, !IO1_LED1_ACTIVE); ioport_set_pin_level(IO1_LED3_PIN, !IO1_LED3_ACTIVE); ssd1306_write_text("Light sensor:"); } /* SD mode. */ else { ioport_set_pin_level(IO1_LED3_PIN, IO1_LED3_ACTIVE); ioport_set_pin_level(IO1_LED1_PIN, !IO1_LED1_ACTIVE); ioport_set_pin_level(IO1_LED2_PIN, !IO1_LED2_ACTIVE); display_sd_info(); } app_mode_switch = 0; } // Shift graph buffers. for (i = 0; i < BUFFER_SIZE - 1; ++i) { temperature[i] = temperature[i + 1]; light[i] = light[i + 1]; } // Get temperature in a range from 0 to 40 degrees. if (at30tse_read_temperature(&temp) == TWI_SUCCESS) { // Don't care about negative temperature. if (temp < 0) temp = 0; // Update temperature for display. // Note: -12 in order to rescale for better rendering. if (temp < 12) temperature[BUFFER_SIZE - 1] = 0; else temperature[BUFFER_SIZE - 1] = temp - 12; } else { // Error print zero values. temperature[BUFFER_SIZE - 1] = 0; } // Get light sensor information. // Rescale for better rendering. adc_start(ADC); adc_value = adc_get_channel_value(ADC, ADC_CHANNEL_4); light[BUFFER_SIZE - 1] = 24 - adc_value * 24 / 4096; // Print temperature in text format. if (app_mode == 0) { sprintf(value_disp, "%d", (uint8_t)temp); ssd1306_set_column_address(95); ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0)); ssd1306_write_text(" "); ssd1306_write_text(value_disp); // Display degree symbol. ssd1306_write_data(0x06); ssd1306_write_data(0x06); ssd1306_write_text("c"); // Refresh graph. ssd1306_draw_graph(0, 1, BUFFER_SIZE, 3, temperature); } else if (app_mode == 1) { sprintf(value_disp, "%lu", 100 - (adc_value * 100 / 4096)); ssd1306_set_column_address(98); ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0)); ssd1306_write_text(" "); ssd1306_write_text(value_disp); ssd1306_write_text("%"); // Refresh graph. ssd1306_draw_graph(0, 1, BUFFER_SIZE, 3, light); } else { // Is card has been inserted or removed? if (sd_status_update == 1) { // Clear screen. ssd1306_clear(); ssd1306_set_page_address(0); ssd1306_set_column_address(0); // Show SD card info. display_sd_info(); sd_status_update = 0; } } /* Wait and stop screen flickers. */ delay_ms(50); } }
/** * \brief Show SD card status on the OLED screen. */ static void display_sd_info(void) { uint8_t card_check; uint8_t sd_card_type; uint8_t sd_card_version; uint32_t sd_card_size; uint8_t size[10]; // Is SD card present? if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) { ssd1306_write_text("Please insert SD card..."); } else { ssd1306_write_text("SD card information:"); sd_mmc_init(); card_check = sd_mmc_check(0); while (card_check != SD_MMC_OK) { card_check = sd_mmc_check(0); delay_ms(1); } if (card_check == SD_MMC_OK) { sd_card_type = sd_mmc_get_type(0); sd_card_version = sd_mmc_get_version(0); sd_card_size = sd_mmc_get_capacity(0); ssd1306_set_page_address(1); ssd1306_set_column_address(0); // Card type switch(sd_card_type) { case CARD_TYPE_SD: ssd1306_write_text("- Type: Normal SD card"); break; case CARD_TYPE_SDIO: ssd1306_write_text("- Type: SDIO card"); break; case CARD_TYPE_HC: ssd1306_write_text("- Type: High Capacity card"); break; case CARD_TYPE_SD_COMBO: ssd1306_write_text("- Type: SDIO/Memory card"); break; default: ssd1306_write_text("- Type: unknown"); } ssd1306_set_page_address(2); ssd1306_set_column_address(0); // SD card version switch(sd_card_version) { case CARD_VER_SD_1_0: ssd1306_write_text("- Version: 1.0x"); break; case CARD_VER_SD_1_10: ssd1306_write_text("- Version: 1.10"); break; case CARD_VER_SD_2_0: ssd1306_write_text("- Version: 2.00"); break; case CARD_VER_SD_3_0: ssd1306_write_text("- Version: 3.0x"); break; default: ssd1306_write_text("- Version: unknown"); } ssd1306_set_page_address(3); ssd1306_set_column_address(0); sprintf(size, "- Total size: %lu KB", sd_card_size); ssd1306_write_text(size); } } }