แบตเตอรี่ใครว่าไม่สำคัญ มาดูกันว่า Ultrabook แต่ละรุ่นอึดทนมากน้อยขนาดไหน

ถ้า หากพูดถึงคำว่า อัลตร้าบุ๊ค (Ultrabook) แล้ว เชื่อได้เลยว่า หลายๆ ท่านจะต้องนึกถึง MacBook Air หรือ New Samsung Series 9 มาเป็นอันดับต้นๆ โดยอัลตร้าบุ๊ค (Ultrabook) คือ อุปกรณ์ที่สามารถทำหน้าที่ได้เหมือนกับโน๊ตบุ๊ค (Notebook) แต่มีความบาง และเบากว่า เนื่องจากถูกออกแบบให้สะดวกต่อการพกพานั่นเอง ซึ่งจุดเด่นของ อัลตร้าบุ๊ค (Ultrabook) นอกจากจะมีความบาง และน้ำหนักเบาแล้ว ฮาร์ดดิสก์แบบ SSD ถือว่า เป็นส่วนประกอบสำคัญที่ทำให้อัลตร้าบุ๊ค (Ultrabook) มีความแตกต่างจากโน๊ตบุ๊ค (Notebook) ในเรื่องของการประมวลผล และการบู๊ตเครื่อง ซึ่งอัลตร้าบุ๊ค (Ultrabook) ทำได้เร็วกว่ามาก อีกทั้งฮาร์ดดิสก์แบบ SSD นั้น ช่วยทำให้ประหยัดพลังงานอีกด้วยครับ แต่เชื่อหรือไม่ครับว่า แม้ว่าจะเป็นอัลตร้าบุ๊ค (Ultrabook) เหมือนกัน แต่อายุการใช้งานแบตเตอรี่ของแต่ละรุ่นนั้น กลับมีช่วงเวลาการใช้งานได้แตกต่างกัน แม้ว่าคุณสมบัติของอัลตร้าบุ๊ค (Ultrabook) นั้น จะกำหนดไว้ว่า อายุการใช้งานของแบตเตอรี่จะถูกกำหนดไว้ว่า จะต้องมากกว่า 5 ชั่วโมงขึ้นไป แต่เมื่อนำมาใช้งานจริงๆ แล้วพบว่า บางรุ่นกลับมีการใช้งานจริงไม่ถึง 5 ชั่วโมงด้วยซ้ำไป ถ้าหากได้อ่านบทความรีวิวอัลตร้าบุ๊ค (Ultrabook) มาบ้าง จะพบว่า บางรุ่นเต็มที่ก็แค่ 4 ชั่วโมงเศษๆ ก็มีครับ ทั้งนี้ขึ้นอยู่กับว่า การทดสอบอายุของแบตเตอรี่ในแต่ละครั้ง เอาอะไรเป็นมาตรฐานในการวัด เช่น อัตราความสว่างของหน้าจอ การเปิดโปรแกรมทดสอบ เป็นต้น มาดูกันว่า อัลตร้าบุ๊ค (Ultrabook) แต่ละรุ่นนั้น จะมีอายุการใช้งานแบตเตอรี่แตกต่างกันมากน้อยแค่ไหน ซึ่งตารางด้านล่างนี้ นอกจากจะเป็นการเปรียบเทียบอายุการใช้งานแบตเตอรี่แล้ว จะขอยกคุณสมบัติอื่นๆ ของ อัลตร้าบุ๊ค (Ultrabook) ขึ้นมาเปรียบเทียบด้วยนะครับ   ** หมายเหตุ : ผลการทดสอบอายุการใช้งานของแบตเตอรี่ มาจากเว็บไซต์ engadget.com ** MacBook Air สามารถเชื่อมต่อ HDMI ได้โดยผ่านอุปกรณ์เสริม อย่างไรก็ดี ล่าสุดมีข่าวว่า Intel กำลังจะปรับให้ อัลตร้าบุ๊ค (Ultrabook) ทุกรุ่นนั้น เปลี่ยนมาใช้ฮาร์ดดิสก์แบบ SSD แทน HDD ที่เราเห็นในปัจจุบัน เพื่อประสิทธิภาพในการใช้งาน และคงระยะเวลาการใช้งานแบตเตอรี่ที่ยาวนานกว่า นอกจากนี้ ทาง Intel มีแผนที่จะเปลี่ยนแบตเตอรี่บนอัลตร้าบุ๊ค (Ultrabook) เป็นแบบใหม่ด้วย โดยตอนนี้ได้มองไว้ทั้งหมด 2 แบบด้วยกันคือ 16650 cylindrical battery และ prismatic lithium-ion battery ซึ่งแบตเตอรี่ทั้ง 2 แบบใหม่นี้ นอกจากจะทำให้ตัวเครื่องบางลงแล้ว ยังส่งผลให้ราคาอัลตร้าบุ๊ค (Ultrabook) ลดลงตามมาด้วยครับ คาดว่า เร็วๆ นี้เราคงได้สัมผัสกับ อัลตร้าบุ๊ค (Ultrabook) ที่ราคาถูกลงกว่าที่เป็นอยู่ในปัจจุบันกันอย่างแน่นอน บทความโดย : techmoblog.com ที่มา  IT PLAZA : แบตเตอรี่ใครว่าไม่สำคัญ มาดูกันว่า Ultrabook แต่ละรุ่นอึดทนมากน้อยขนาดไหน

รถวิ่งตามเส้น

บทนำ

วิธีการเขียนโปรแกรมรถวิ่งตามเส้นนั้นมีได้หลายตามแต่ใครใครจะเขียนแต่ในที่นี้จะเน้นหลักการแบบ PID ซึ่งดูที่ error เป็นหักแล้วใช้การปรับค่า Kp Ki Kd และเวลาในการปรับ

หลักการ

1.ง่ายๆเรื่มจาก ให้เซนเซอร์ชุดทางซ้ายคุมล้อซ้าย และเซนเซอร์ทางขวาคุมล้อขวาถ้าแทรกพื้นสีขาวเส้นสีดำ
ให้เซนเซอร์ล้อซ้ายโดนเส้นดำ ส้อซ้ายหยุด
ให้เซนเซอร์ล้อขวาโดนเล้นดำล้อขวาหยุด
เพียงเท่านี้ก็สามารถทำรถให้วิ่งตามเส้นได้ง่ายๆ

2. ถ้าให้ละเอียดกว่านั้นหน่อยค่าที่อ่านจากเซนเซอร์เป็นค่า0-1024 ค่าที่เข้าไกล้สีดำตัวเลขยิ่งลด
ดังนั้นเราสามารถเอาค่าดังกล่าวคุมค่า PWM ของล้อนั้นๆได้โดยตรง การวิ่งของรถก็จะเพื่มความละเอียดมากๆขึ้น
PWM(L) = 1000 - เซนเซอร์ L
PWM(R) = 1000 - เซนเซอร์ R

3.จากสมการ PID (ดูบทความเรื่อง PID) ให้
PWM = Kp*error + Kd*deltar error + Ki * sum error

error = ADCx[0] + ADCx[1] + ADCx[2] - ADCx[3] - ADCx[4] - ADCx[5];
Delta_error = error - error_o;
error_o = error;
Sum_error =+ error;

ถ้า -PWM ให้ล้อซ้ายหยุด ถ้า + PWM ให้ล้อขวาหยุด

6. ให้ทำการคำนวณหา รัศมีการเลี้ยวของรถ

R = L/2((VR+VL)/(VR-VL))

โดย R = รัศมีการเลี้ยวของรถ
L = ความยาวจากจุดศูนย์ล้อซ้ายถึงล้อขวา
VR = ความเร็วล้อขวา
VL = ความเร็วล้อซ้าย

อุปกรณ์

1. บอด AVR 8
2. ตัวรถบิ๊กฟูด
3.บอดได้ L293
4.เซนเซอร์ IR 6ตัว
5.ถ่าน สายซีเรี่ยว คอม สนาม

วิธีต่ออุปกรณ์

ซอฟท์แวร์

//
//
//
//
//

/****************************************************************** Includes */
#include <stdio.h> // Standard Input/Output
#include <avr/io.h> // AVR device-specific IO definitions
#include <compat/deprecated.h> // Use sbi(), cbi() function
#include <avr/interrupt.h> // Interrupt Service routine
#include <math.h>

#define F_CPU 16000000UL // CPU clock frequency (in Hertz)
#include <util/delay.h> // util_delay

#define RX_BUFSIZE 80 // Buffer RX

/******************************************************* Prototype functions */
static int uart_putchar(char c, FILE *stream);
static int uart_getchar(FILE *stream);
static FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);
void Init_Serial(unsigned int baudrate);

void car_move(char LR, char FB,unsigned int spreed);
unsigned int ADCx[8];
// ***********************************************************//
int error;
int error_o;
int Delta_error;
int Sum_error;
int pwm;
// ***********************************************************//
/************************************************************* USART putchar */
static int uart_putchar(char c, FILE *stream)
{
loop_until_bit_is_set(UCSRA, UDRE);
UDR = c;

return 0;
}

/************************************************************* USART getchar */
static int uart_getchar(FILE *stream) {

uint8_t c;

loop_until_bit_is_set(UCSRA, RXC);

if (UCSRA & _BV(FE)) return _FDEV_EOF;
// if (UCSRA & _BV(DOR)) return _FDEV_ERR;

c = UDR;

return c;
}

/*********************************************************** Initialize UART */
static void USART_Init(unsigned int baud)
{
// Set baud rate
UBRRH = (unsigned char) (baud>>8);
UBRRL = (unsigned char) baud;

UCSRA = (1<<U2X);
// Enable receiver and tramsmitter
UCSRB = (1<<RXEN) | (1<<TXEN);

// Set frame format: 8data, NoneParity, 1stop bit
UCSRC = (1<<URSEL)|(3<<UCSZ0);

// Set address uart_str to stdout/stdin
stdout = stdin = &uart_str;
}

/************************************************************ Main Functions */
/***************************************************************** delay_ms */

void delay_ms(uint16_t i)
{
for (;i > 0; i--)
_delay_ms(1);
}

/************************************************************* USART PWM */
void init_PWM1(void)
{
// PORT PD5 PD6 PD7 Output
DDRD =(1<<DDD5)|(1<<DDD6)|(1<<DDD7);
// PORT PB1(OC1A),PB2(OC1B) Output PWM
DDRB = (1<<DDB0)|(1<<DDB1)|(1<<DDB2);

// Clear up-counting Set downcounting
TCCR1A = (1<<COM1A1)|(0<<COM1A0);
TCCR1A |= (1<<COM1B1)|(0<<COM1B0);

// Mode 8: PWM,Phase and Frequency Corect (TOP = ICR1A)
TCCR1B = (1<<WGM13)|(0<<WGM12);
TCCR1A |= (0<<WGM11)|(0<<WGM10);

// clk_IO/1 (From prescaler)
TCCR1B |= (0<<CS12)|(1<<CS11)|(0<<CS10);

ICR1 = 0x3E8; // Freq = 1000 Hz(TOP = ICR1) //1000=100%

// Duty Cycle 50%
// OCR1A = 0x1F4; // Output Compare Register 1 A //500 = 50%
// OCR1B = 0x1F4; // Output Compare Register 1 B //500 = 50%

OCR1A = 0;
OCR1B = 0;

TCNT1 = 0; // Clear Timer

// T/C1 Output Compare A/B Match and Timer Overflow interrupt Enable
// TIMSK = (1<<OCIE1A)|(1<<OCIE1B)|(1<<TOIE1);

// sei(); // Set I-bit global interrupt enable


}

int ADC_init(void)
{
DDRC = 0x00;

// AVCC with external capacitor at AREF pin
ADMUX = (0<<REFS1)|(1<<REFS0);

// ADC Enable & Auto Trigger Disable
ADCSRA = (1<<ADEN);
ADCSRA |= (1<<ADPS2)|(0<<ADPS1)|(1<<ADPS0); // XTAL/8

ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))); // Wait Coversion completes

return ADCW;
}

void ADC_read(void)
{

ADMUX = (0<<REFS1)|(1<<REFS0)|0x00;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[0] = ADCW; // Read ADC

ADMUX = (0<<REFS1)|(1<<REFS0)|0x01;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[1] = ADCW; // Read ADC

ADMUX = (0<<REFS1)|(1<<REFS0)|0x02;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[2] = ADCW; // Read ADC

ADMUX = (0<<REFS1)|(1<<REFS0)|0x03;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[3] = ADCW; // Read ADC

ADMUX = (0<<REFS1)|(1<<REFS0)|0x04;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[4] = ADCW; // Read ADC

ADMUX = (0<<REFS1)|(1<<REFS0)|0x05;
ADCSRA |= (1<<ADSC); // ADC Start Conversion
while (!(ADCSRA &(1<<ADIF))) // Wait Coversion completes
;
ADCx[5] = ADCW; // Read ADC
}

int main(void)
{
int i;
float k_p = 1.1; //???????????? ?????????????? ??????????????????
float k_i = 0;
float k_d = 10;
USART_Init(16); // baudrate to 115,200 bps using a 16MHz crystal

init_PWM1();

ADC_init();

while (1) {

ADC_read();
//-----------------------------------------------------------------------------------------//
//------------------------------------- PID-----------------------------------------------
error = ADCx[0] + ADCx[1] -ADCx[2] - ADCx[3];// ?????? ????????????
Delta_error = error - error_o;
error_o = error;
Sum_error =+ error;

pwm = k_p*error + k_d*Delta_error + k_i*Sum_error;
//------------------------------------- PID-----------------------------------------------

if(pwm < 0){
if(pwm < - 1000){
car_move('L','F',1000);
car_move('R','B',(-pwm)-1000);

}else{
car_move('L','F',1000);
car_move('R','F',1000-(-pwm));
}

}else{
if(pwm > 1000){
car_move('L','B',(pwm)-1000);
car_move('R','F',1000);

}else{
car_move('L','F',1000-pwm);
car_move('R','F',1000);
}
}

/*
if(ADCx[0] <= 400 && ADCx[1] <= 400){
car_move('L','F',700);
car_move('R','F',700);

}else{
if(ADCx[1] <= 400){
car_move('L','B',1000-ADCx[1]);
}else{
car_move('L','F',ADCx[1]+ADCx[3]/2);
}

if(ADCx[0] <= 400){
car_move('R','B',1000-ADCx[0]);
}else{
car_move('R','F',ADCx[0]+ADCx[2]/2);
}
}
*/
//-----------------------------------------------------------------------------------------//
// car_move('L','F',ADCx[1]);
// car_move('R','F',ADCx[0]);
if(ADCx[0] < 50 && ADCx[1] < 50 && ADCx[2] < 50&& ADCx[3] < 50&& ADCx[4] < 50&& ADCx[5] < 50){
break;
}

for(i=0;i<6;i++){
printf("%4d = %4d",i,ADCx[i]);
}
printf(" %4d ",pwm);
printf("\r\n");
delay_ms(2);
//-----------------------------------------------------------------------------------------//
}

car_move('L','x',0);
car_move('R','x',0);
while(1);

}

void car_move(char LR, char FB,unsigned int spreed){

switch(LR) {
case 'L' :
if(FB == 'F'){
sbi(PORTD,7); // Output High PD7
cbi(PORTB,0); // Output Low PB0
}else if(FB == 'B'){
cbi(PORTD,7); // Output Low PD7
sbi(PORTB,0); // Output High PB0
}else{
cbi(PORTD,7); // Output Low PD7
cbi(PORTB,0); // Output Low PB0
}
OCR1A = spreed;
break;
case 'R' :
if(FB == 'F'){
sbi(PORTD,6); // Output High PD6
cbi(PORTD,5); // Output Low PD5
}else if(FB == 'B'){
cbi(PORTD,6); // Output Low PD6
sbi(PORTD,5); // Output High PD5
}else{
cbi(PORTD,6); // Output Low PD6
cbi(PORTD,5); // Output Low PD5
}
OCR1B =spreed;
break;
}
}

พื้นฐานไมโครคอนโทรลเลอร์ด้วย Arduino

พื้นฐานไมโครคอนโทรลเลอร์ด้วย Arduino

ไมโครคอนโทรลเลอร์คืออะไร

ไมโครคอนโทรลเลอร์ คือ อุปกรณ์ที่มีหน่วยประมวลผลและความจำขนาดเล็กภายในตัวเอง สามารถรับ-ส่ง ข้อมูลได้ทั้งแบบดิจิตอลและอนาล็อก ใช้พลังงานน้อย ทำให้เป็นที่นิยมในการใช้งานในรูปแบบที่เรียกว่า Embedded เช่น เครื่องใช้ไฟ้าอัจฉริยะทั้งหลาย

Arduino คืออะไร

Arduino (อ่านว่า อา-ดู-อิ-โน่ หรือจะเรียกว่า อาดุยโน่ ก็ได้) คือ ไมโครคอนโทรลเลอร์ ชนิดหนึ่ง ซึ่งเป็นแบบที่เรียกว่า Open Hardware กล่าวคือ Arduino อุปกรณ์ที่มีแบบส่วนประกอบเป็นมาตรฐานที่เปิดเผย หมายความว่า เราสามารถทำเองโดยใช้แบบที่มีการเปิดเผยทั่วไปก็ได้ หรือสามารถซื้อหาได้ง่าย มีราคาถูก มีซ๊อพต์แวร์ให้ใช้งานฟรี สามารถนำไปใช้งานทั่วไปหรือแบบธุรกิจได้โดยไม่ต้องเสียค่าลิขสิทธิ์ เป็นรูปแบบที่มีข้อมูลมากที่สุดบนอินเตอร์เน็ต การพัฒนาก็ง่าย เพราะมีตัวอย่างมากมาย และไม่ต้องเขียนโปรแกรมในรูปแบบ Low Level หมายความว่า เราสามารถใช้คำสั่งเขียนโปรแกรมได้เสมือนโปรแกรมภาษาชั้นสูงทั่วไป

ดาวโหลดซ๊อพต์แวร์

สามารถดาวโหลดซ๊อพต์แวร์ได้ที่ http://arduino.cc/en/Main/Software โดยเราสามารถดาวโหลดได้ตาม OS ที่เราใช้ เช่น Windows, Linux หรือ Mac เมื่อดาวโหลดมาแล้ว ขอให้แตกไฟล์ไว้ในเครื่องของเรา จากนั้นให้ดับเบิ้ลคลิกไฟล์ arduino.exe (ถ้าเราใช้ Windows) ก็จะเปิดโปรแกรมดังรูป

ตัวอย่างไฟกระพริบ

โดยปกติแล้วบอร์ด Arduino ที่ซื้อมา มักจะมาพร้อมกับไฟ LED ที่ต่ออยู่กับขาหมายเลข 13 ของไมโครคอนโทรลเลอร์อยู่แล้ว ดังนั้นในตัวอย่างแรก เราจะใช้อุปกรณ์ที่มีอยู่แล้วมาใช้งาน โดยที่ไม่ต้องต่ออุปกรณ์ใดๆเลย เริ่มต้นขอให้ต่อสาย USB เข้ากับบอร์ดและต่อเข้ากับช่อง USB ในเครื่องคอมพิวเตอร์ จากนั้นให้รอจนเครื่องคอมพิวเตอร์พบอุปกรณ์ เราจะพบว่า บนเครื่องของเราจะมี Port เพิ่มขึ้นมา 1 พอร์ต ซึ่งก็คือพอร์ตที่เราจะใช้งานให้คอมพิวเตอร์คุยกับบอร์ดของคอนโทรลเลอร์นั่นเอง ในกรณีที่เครื่องคอมพิวเตอร์ไม่สามารถหาไดรเวอร์ได้ ขอให้ไปดาวโหลดไดรเวอร์ที่ http://www.ftdichip.com/FTDrivers.htm

โดยปกติแล้วบอร์ด Arduino จะต้องมีไฟเลี้ยง 5 โวลล์ แต่ถ้าเราต่อกับคอมพิวเตอร์ มันก็จะใช้ไฟเลี้ยงที่ออกจาก USB ได้เองทำให้สะดวกมาก จากนั้นขอให้เปิดโปรแกรม Arduino ขึ้นมา ไปที่เมนู Tools->Board จากนั้นให้เลือกรุ่นบอร์ดที่ตรงกับที่เราใช้งาน ในที่นี้ผมใช้ Arduino Mega ADK (หากท่านยังไม่มีสามารถซื้อได้ที่ http://www.thainetbeans.com/forum/viewtopic.php?t=1164) จากนั้นให้ไปที่เมนู Tools->Serial Port แล้วเลือกพอร์ตที่เพิ่มมาใหม่ ในกรณีที่ไม่แน่ใจ ให้ลองดึงสาย USB ที่ต่อออก แล้วลองต่อใหม่ ก็จะเห็นว่าเราใช้พอร์ตอะไรอยู่ จากนั้นให้ไปที่เมนู File->Examples->Basics->Blink หรือเขียนโปรแกรมตามนี้

void setup() {
// initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino boards:
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(13, LOW); // set the LED off
delay(1000); // wait for a second
}

จากนั้นให้คลิกปุ่ม Upload บน Toolbar ดังรูป

รอสักครู่ เราจะเห็นไฟกระพิบถี่ๆ เป็นการแสดงว่าคอมพิวเตอร์กำลังส่งข้อมูลระหว่างบอร์ดอยู่ เมื่อเสร็จแล้วเราจะเห็นว่ามีไฟกระพริบเปิดและปิดทุกช่วงวินาที เราจะพบว่าตัวโปรแกรม(เราเรียกว่า sketch) นั้นมีขนาดเล็กมากและมีเพียง 2 ฟังชั่นเท่านั้น โดยฟังชั่นทั้ง2นั้น เป็นฟังชั่นพื้นฐานที่จะต้องมีเสมอ ฟังชั่น setup จะทำงานครั้งแรกเพียงครั้งเดียวหรือทุกครั้งที่เราเปิดเครื่องใหม่ ในที่นี้เราสั่งบอร์ดว่าเราจะใช้ขาที่ 13 สำหรับส่งข้อมูลออกไป ส่วนฟังชั่น loop จะทำงานวนไปตลอดไม่หยุด ในที่นี้ก็คือส่งค่าแบบดิจิตอลไปที่ขา 13 โดยมีค่าสูง(5 โวลล์) แล้วหยุดรอ 1 วินาที ทำให้ไฟ LED ติด จากนั้นจึงแบบดิจิตอลไปที่ขา 13 โดยมีค่าต่ำ(0 โวลล์) แล้วหยุดรอ 1 วินาที ทำให้ไฟ LED ดับ โดยฟังชั่น delay จะเป็นการสั่งให้บอร์ดหยุดรอโดยมีหน่วยเป็น millisecond