Cool Emerald: C

Showing posts with label C. Show all posts

Friday, August 10, 2018

DIY Programmable Function Generator Using Arduino Uno

Arduino Uno ကို function generator အနေ နဲ့ သုံးပြီး လိုချင် တဲ့ low frequency waveform တွေကို စိတ်ကြိုက် ထုတ်နိုင် ပါတယ်။ သူ့ရဲ့ အားသာချက် က လိုသလို ပရိုဂရမ် ရေးပြီး စိတ်ကြိုက် customize အမျိုးမျိုး ထုတ်နိုင်၊ အချိန် အလိုက် ပြောင်းနိုင် တာဖြစ်ပြီး၊ အားနည်း ချက်ကတော့ အရမ်း မြင့်တဲ့ frequency တွေကို ထုတ် မပေးနိုင် တာ ဖြစ်ပါတယ်။ Arduino ရဲ့ analog output က pwm သုံးထား တာမို့ ရလဒ် ပိုကောင်းအောင်၊ pwm frequency ကို 8 kHz လောက် ပြောင်းထား ပါတယ်။ ဒီထက် ရလဒ် ပိုကောင်း ချင်ရင် DAC နဲ့ တွဲသုံး လို့လည်း ရပါတယ်။

Figure. Arduino function generator ၏ အထွက်ကို oscilloscope ဖြင့် တိုင်းတာ ရရှိပုံ။

UDP/TCP Socket Programming with wxWidgets

နိဒါန်း
UDP
TCP
- TCP Server
- TCP Client
အကိုးအကားများ

နိဒါန်း

wxWidgets နဲ့ UDP ၊ TCP တို့ကို သုံးပြီး network ပေါ်မှာ ဒေတာ အပြန် အလှန် ပေးပို့ ဆက်သွယ် တဲ့ အကြောင်း ဆွေးနွေး ချင် ပါတယ်။ အဲဒီ အတွက် wxWidgets ကို တပ်ဆင် ထားဖို့ လိုပါ တယ်။ သူ့ကို platform အမျိုးမျိုး အတွက် တပ်ဆင်တဲ့ အကြောင်း တွေကို အောက်က လင့်ခ် မှာ ဖတ်နိုင် ပါတယ်။

Cross-platform C++ programming with wxWidgets

အင်တာနက် စတဲ့ network တွေ ပေါ်မှာ TCP ဒါမှမဟုတ် UDP တွေသုံးပြီး စက်တစ်ခု နဲ့ တစ်ခု ဒေတာ တွေ အပြန်အလှန် ပို့ဖို့ အတွက် socket တွေကို အသုံးပြု နိုင် ပါတယ်။ ခေတ်ပေါ် operating system တွေ အားလုံးက socket layer ကို အထောက် အပံ့ ပေးကြ ပေမယ့် platform ပေါ်မူ တည်ပြီး socket ကို အသုံး ပြုရတဲ့ ပုံစံ တွေက အမျိုးမျိုး ကွဲပြား နိုင်ပါတယ်။ wxWidgets မှာ အောက်ခံ platform အတွက် ပူစရာ မလိုပဲ အလွယ် တကူ အသုံးပြုနိုင်တဲ့ socket class ပါ ပါတယ်။ အဲဒီ class ကို မတူညီတဲ့ ပုံစံ နည်းလမ်း အမျိုးမျိုး နဲ့ အသုံးပြုနိုင်ပြီး၊ အသုံးပြုပုံ နမူနာ တချို့ကို အောက်မှာ ဆက်ပြီး ဖော်ပြထား ပါတယ်။

OpenCV on Linux using g++, CMake, Qt, Code::Blocks

နိဒါန်း
GCC ၊ CMake တို့ဖြင့် အသုံးပြုခြင်း
Qt ဖြင့် အသုံးပြုခြင်း
Code::Blocks ဖြင့်အသုံးပြုခြင်း
အကိုးအကားများ

နိဒါန်း

OpenCV ကို Linux တွင် တပ်ဆင် ရန် ပထမ အဆင့် အနေနှင့် အောက်ပါ packages များ စက်ထဲ တွင် ရှိရန် လိုအပ် သည် [Ope17g]။

GCC 4.4.x or later
CMake 2.6 or higher
Git
GTK+2.x or higher, including headers (libgtk2.0-dev)
pkg-config
Python 2.6 or later and Numpy 1.5 or later with developer packages (python-dev, python-numpy)
ffmpeg or libav development packages: libavcodec-dev, libavformat-dev, libswscale-dev
[optional] libtbb2 libtbb-dev
[optional] libdc1394 2.x
[optional] libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev, libdc1394-22-dev

ထို packages များအား စက်ထဲသို့ ထည့်သွင်း လိုပါက Synaptic Manager သုံး၍ သော် လည်းကောင်း၊ terminal တွင် အောက်ပါ စာရင်း များပါ command များ ရိုက်နှိပ်၍ သော် လည်းကောင်း ထည့်နိုင် သည်။

Gyroscope L3G4200D

L3G4200D ဆိုတဲ့ STMicroelectronics ကထုတ်တဲ့ MEMS ultra-stable three-axis digital output gyroscope ကို သုံးကြည့်ဖြစ်ပါတယ်။ Aliexpress မှာ ရောင်းတဲ့ L3G4200D Module လေးက ၃ ဒေါ်လာ လောက်ပဲ ပေးရပါတယ်။

Figure. L3G4200 Gyroscope module

CC2531 Zigbee USB Dongle

CC2531 USB Evaluation Module Kit ကိုသုံးပြီး wireless communication လုပ်ကြည့်တဲ့ အကြောင်းလေးပါ။ သူ့ရဲ့ website ကိုသွားပြီး CC USB Firmware Library and Examples ဆိုတဲ့ zip ဖိုင်ကို download လုပ်လိုက်ပါတယ်။ ဖိုင်ကိုဖြည်ပြီးတဲ့ အခါ Doc folder ထဲက CC USB Software Examples User’s Guide ထဲမှာ နမူနာပြထားတဲ့ USB RF Modem Example ကို စမ်းကြည့်ခဲ့ပါတယ်။

CC2531 Zigbee Wireless USB Dongle

Wireless Communication using CC2530 Zigbee Wireless MCU

CC2530 က IEEE 802.15.4 နဲ့ Zigbee တွေအတွက် RF transceiver နဲ့ 8051 MCU ကို ပေါင်းစပ်ထားတဲ့ system-on-chip (SoC) solution တခုပါ။ သူ့ကို သုံးပြီး wireless module စမ်းလုပ်ဖို့ အတွက် CC2530EM Evaluation Modules နှစ်ခု၊ SmartRF05EB Evaluation Boards နှစ်ခု၊ နဲ့ CC2531 USB Dongle တခုပါတဲ့ CC2530DK devolopment kit ကို ဝယ်တာ USD 400 လောက်ပေးရပါတယ်။ သူတို့နဲ့ သုံးဖို့အတွက် TI ရဲ့ ဝက်ဘ်ဆိုက်မှာ အလကားပေးတဲ့ SmartRF Studio ကို စက်ထဲမှာ install လုပ်ပါတယ်။

CC2530DK

Driving 28BYJ-48-5V Stepper Motor with ULN2003A Transistor Arrays on Arduino

28BYJ-48-5V Stepper Motor နဲ့ ULN2003A driver တွေက တော်တော် အသုံးများပုံရပြီး အလွယ်တကူ ဝယ်နိုင်ရုံတင်မက စျေးလည်း တော်တော်ပေါ ပါတယ်။ Stepper Library ကို မသုံးပဲ Arduino ရဲ့ Port B ကို သုံးပြီး Stepper motor ကို ထိန်းတဲ့ ရိုးရှင်းတဲ့ နမူနာလေး ဖော်ပြချင်ပါတယ်။

Figure. Driving 28BYJ-48-5V Stepper Motor with Arduino UNO using USB power.

28BYJ-48-5V Stepper Motor က 5V နဲ့ တိုက်ရိုက်မောင်းနိုင်ပြီး၊ unipolar stepper motor အမျိုးအစားပါ။ သူ့ရဲ့ schematic ကို အောက်မှာပြထားပါတယ်။

Figure. 28BYJ-48-5V Stepper Motor.

ULN2003A Transistor Arrays ကတော့ inductive load တွေကို drive လုပ်ဖို့ ဒီဇိုင်းလုပ်ထားတာမို့ အထဲမှာ free wheeling diode ပါ ပါ ပါတယ်။ Darlington pair သုံးထားတာမို့ အဝင် ဗို့ 1.4V လောက်ကနေ 30V အထိ ကြိုက်တဲ့ ဗို့နဲ့ တိုက်ရိုက်ဆက်ပြီး ထိန်းနိုင်ပါတယ်။

Figure. ULN2003A.

Wave drive, Full step drive နဲ့ Half step drive တွေကို သုံးပြထားတဲ့ နမူနာ ပရိုဂရမ် လေးကို အောက်မှာ ပြထားပါတယ်။


//Driving 28BYJ-48-5V Stepper Motor using ULN2003A Transistor Arrays
//Author: Yan Naing Aye
//Website: http://www.cool-emerald.com/

#include "StepperPortB.h"
//----------------------------------------------------------
void setup() {    
  StepperInit();//setup pins
  //StepperMode(WAVE);
  //StepperMode(FULL);
  StepperMode(HALF);
  //Serial.begin(9600);
}
void loop() {
  Step(4096,2500); //turn 4096 steps forward with 2500 us period for each step
  Step(-4096,2500);//turn 4096 steps backward with 2500 us period for each step
  //Serial.println(CS);
}

//File: StepperPortB.h
//Author: Yan Naing Aye
//Website: http://www.cool-emerald.com/

//Driving 28BYJ-48 – 5V Stepper Motor using ULN2003A Transistor Arrays
//----------------------------------------------------------
#ifndef StepperPortB_h
  #define StepperPortB_h
  #include "Arduino.h"
byte* S; //Stepping sequence

//Wave drive
//Step          0 | 1 | 2 | 3 | 0 |...

//Blue   = A :  1 | 0 | 0 | 0 | 1 | ...
//Pink   = B :  0 | 1 | 0 | 0 | 0 | ...
//Yellow = C :  0 | 0 | 1 | 0 | 0 | ...
//Orange = D :  0 | 0 | 0 | 1 | 0 | ...
byte Wave[4] = {0x01,0x02,0x04,0x08};

//Full Step drive
//Step          0 | 1 | 2 | 3 | 0 |...

//Blue   = A :  1 | 1 | 0 | 0 | 1 | ...
//Pink   = B :  0 | 1 | 1 | 0 | 0 | ...
//Yellow = C :  0 | 0 | 1 | 1 | 0 | ...
//Orange = D :  1 | 0 | 0 | 1 | 1 | ...  
byte FullStep[4] = {0x09,0x03,0x06,0x0C};

//Half Step drive
//Step          0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 0 |...

//Blue   = A :  1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |...
//Pink   = B :  0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 0 |...
//Yellow = C :  0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 |...
//Orange = D :  1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 |...
byte HalfStep[8] = {0x09,0x01,0x03,0x02,0x06,0x04,0x0C,0x08};
int CS=0;//Current step
int N;
//----------------------------------------------------------
//Mode definition
#define HALF 0
#define FULL 1
#define WAVE 2
//Define the mode to drive the stepper motor
void StepperMode(int Mode) {  
  if(Mode==WAVE) {S=Wave; N=4;}
  else if(Mode==FULL) {S=FullStep; N=4;}
  else {S=HalfStep; N=8;}
}
//----------------------------------------------------------
//Turn stepper motor n steps
//with t microseconds period for each step
//positive n for forward dir and negative n for backward dir
void Step(int n,int t) {
  int CD=1; 
  if(n<0) {n*=-1; CD=-1;}
  for(int i=0;i<n;i++) {
    CS=(CS+(N+CD))%N;
    PORTB=S[CS];
    delayMicroseconds(t);
  }
}
//----------------------------------------------------------
//Initialize
void StepperInit() {
  //Setup port B (digital pin 8 to 13)
  //The two high bits (6 & 7) map to the crystal pins and are not usable
  //only 4 pins - 8 to 11 are used in this program
  //where Blue - pin 8 (LSB), Pink -pin 9, Yellow -pin 10, Orange -pin 11
  DDRB=0xff;
  PORTB = 0x00;  
}
//----------------------------------------------------------
#endif

Wednesday, September 16, 2015

Testing Dual-Core Microcontroller - LPC54102

LPC54102J512 MCU မှာ Cortex M4 Master တစ်ခုနဲ့ Cortex M0+ Slave ဆိုပြီး core နှစ်ခုပါပါတယ်။ LPCXpresso IDE v7.9.0 ကိုသုံးပြီး multicore systems တစ်ခုကို ဖန်တီးတာ၊ debug လုပ်တာတွေကို နမူနာ တစ်ခုရေးပြီး စမ်းကြည့်တဲ့ အတွေ့အကြုံကို ပြောချင်ပါတယ်။ LPCOpen ကို ဒေါင်းလုပ်လုပ်ထားပြီး Quickstart -> Import project(s) ကို နှိပ်ပြီး import လုပ် ထားဖို့လိုပါတယ်။

Reading Rotary Encoder Using Microcontroller

Rotary encoder တွေကို ထောင့်ဘယ်လောက်လှည့်သွားသလဲ (angular position) နဲ့ ဘယ်လောက်ဘီးလည်ပြီး ရွေ့သွားလဲ (motion sensing) ဆိုတာတွေကို တိုင်းတာဖို့ သုံးလေ့ရှိပါတယ်။ Optical rotary encoder တွေမှာ အပေါက်လေးတွေ ပုံဖော်ပြီး ဖောက်ထားတဲ့ အချပ်ကလေး ပါလေ့ရှိပြီး၊ အလင်းထုတ်ပေးတဲ့ LED နဲ့ အလင်းကို အာရုံခံနိုင်တဲ့ photo detector ကြားမှာ အဲဒီ အဝိုင်းလေး လည်တဲ့အခါ၊ အလင်းကျသွား၊ အလင်းကွယ်သွားတဲ့ ပေါ်မူတည်ပြီး ဗို့အား အနိမ့်အမြင့် digital waveform တွေထွက်လာပါတယ်။

VEX Robotics Design System ကထုတ်လုပ်တဲ့ optical encoder တခု

Encoder တွေမှာ glitch တွေ မဖြစ်အောင် ပုံမှန် binary code အစား Gray code ကို သုံးလေ့ပါတယ်။ Gray code မှာ ကပ်ရပ်နံပါတ် တစ်ခုနဲ့ တစ်ခု အကြား ပြောင်းလဲတဲ့ bit အရေအတွက်က တစ်ခု ထက် မပိုတဲ့အတွက် glitch တွေ ဖြစ်မယ့် ပြဿနာကနေ ကာကွယ်ပေးပါတယ်။ Gray code 0 ကနေ 3 အထိကို အောက်က ဇယားမှာ ပြထားပါတယ်။

CAN bus

CAN Bus (controller area network) ဆိုသည်မှာ ဆက်သွယ်ရေး စနစ် တစ်ခုဖြစ်ပြီး မိုက်ခရိုကွန်ထရိုလာများ နှင့် အခြား အီလက်ထရွန်းနစ် ကိရိယာများကို ကွန်ပျူတာ မလိုအပ်ဘဲ အချင်းချင်း ဆယ်သွယ် နိုင်ရန် ပြုလုပ်ထားသော စနစ်ဖြစ်ပါတယ်။ CAN Bus ဟာ မက်ဆေ့ (message) အပေါ်တွင် အခြေခံသော ပရိုတိုကောလ်ဖြစ်ပြီး မော်တော်ယာဉ်များတွင် အဓိက အသုံးပြုလေ့ ရှိပေမယ့် စက်ရုံများနှင့် ဆေးဘက်ဆိုင်ရာ ကိရိယာများတွင်လည်း အသုံးပြုလေ့ ရှိပါတယ်။

Using Analog to Digital Converter of AT89C51CC01 Microcontroller

AT89STK-06 starter kit ကိုသုံးပြီး 8051 microcontroller တစ်ခုဖြစ်တဲ့ AT89C51CC01 အတွက် analog to digital converter (ADC) အဝင် ကိုဖတ်တဲ့ C ကုဒ် တစ်ချို့ကို ရေးထားပါတယ်။ အဲဒီ မိုက်ခရို ကွန်ထရိုလာ မှာ 10 bit resolution ရှိတဲ့ multiplexed လုပ်ထားတဲ့ အဝင် ၈ ခုရှိပါတယ်။ ဒီနမူနာမှာ variable resister နဲ့ ဆက်ထားတဲ့ အဝင် ပင်နံပါတ် ၇ ကို ဖတ်ကြည့်ထား ပါတယ်။

Byte Stuffing

ပစ္စည်း တစ်ခု ကနေ တစ်ခု data bytes တွေကို ပို့ဖို့ နဲ့၊ လက်ခံဖို့ အတွက် program တွေကို မကြာခဏ ရေးရပါတယ်။ ဒါနဲ့ပဲ ရိုးရှင်းတဲ့ byte stuffing မူကွဲ တစ်ခု ကို ရွေးပြီး data bytes တွေကို frame ဆောက် ပြီး ပို့ဖို့ နဲ့၊ လက်ခံဖို့ အတွက် လုပ်ရပါတယ်။ ပထမဆုံး အနေနဲ့ Frame ရဲ့ အစ နဲ့ အဆုံးကို သတ်မှတ်ဖို့ အတွက် control characters တွေ အနေနဲ့ 0x02 နဲ့ 0x03 ကို start of text (STX) ရယ်၊ end of text (ETX) ရယ် လို့ ထားလိုက် ပါမယ်။ လက်ခံရရှိတဲ့ ဒေတာ မှာ အမှား ပါမပါ စစ်ဖို့ အတွက် data bytes တွေရဲ့ exclusive-or တန်ဖိုးကို ETX နောက်မှာ အဆုံးသတ် checksum အနေနဲ့ ထည့်လိုက်ပါမယ်။ ပိုကောင်းတဲ့ error detection အတွက်တော့

CRC Calculation in VB and C

မှာဖော်ပြထားသလို CRC ကို သုံးလို့ ရပါတယ်။
ဥပမာ data byte နှစ်လုံး

0x30 0x31

ကို ပို့ဖို့ ဆိုရင်၊ ပို့ရမယ့် frame က

0x02 0x30 0x31 0x03 0x01

ဖြစ်ပါတယ်။ အစက 0x02 က STX အနေနဲ့ ထည့်ထားပြီး၊ data bytes တွေကို ပို့ပါမယ်။ ဘိတ်ရှေ့ က 0x03 က ETX အနေနဲ့ ထည့်ထားတာပါ။ data byte တွေရဲ့ exclusive-or (0x02^0x03) ဖြစ်တဲ့ 0x01 ကို checksum အနေနဲ့ နောက်ဆုံးက နေ ထည့်ထားတာပါ။ အကယ်၍ ပို့ရမယ့် ဒေတာမှာ control characters တွေ အနေနဲ့ သုံးထားတဲ့ 0x02 တို့၊ 0x03 တို့ ပါလာရင် ဘယ်လို လုပ်မလဲ လို့ မေးစရာရှိ ပါတယ်။ အဲဒီ အတွက် နောက်ထပ် control character 0x10 ကို Data Link Escape (DLE) အနေနဲ့ သတ်မှတ်ဖို့ လိုပါတယ်။ နောက်ထပ် ဥပမာ အနေနဲ့ data byte ငါးလုံး ဖြစ်တဲ့

0x30 0x02 0x65 0x10 0x03

အတွက် frame တစ်ခု ဆောက်ကြည့် ပါမယ်။ ဒေတာထဲမှာ STX တို့၊ ETX တို့၊ DLE တို့ ကိုတွေ့တိုင်း control character မဟုတ်ကြောင်း သိအောင် ရှေ့မှာ DLE တစ်လုံးကို အပို ထည့်ပေး မှာပါ။ ဒါဆို ပို့ရမယ့် frame က

0x02 0x30 0x10 0x02 0x65 0x10 0x10 0x10 0x03 0x03 0x44

ဖြစ်ပါတယ်။ C တို့၊ LabVIEW တို့ နဲ့ ပရိုဂရမ် တချို့ ရေးကြည့်ထားပါတယ်။ Example programs တွေကို အောက်က link မှာ တွေ့နိုင်ပါတယ်။

Byte Stuffing on GitHub

အောက်ကဟာက ပို့ဖို့ အတွက် frame ဆောက်တဲ့ C++ code ဖြစ်ပါတယ်။

// Byte stuffing- sending and receiving frames
// Author: Yan Naing Aye

#ifndef  FRAME_H
#define FRAME_H

#include 
#define STX 0x02
#define ETX 0x03
#define DLE 0x10

#define TX_BUF_SIZE 128
#define RX_BUF_SIZE 128
enum RX_STATE { IGNORE,RECEIVING,ESCAPE,RXCRC1,RXCRC2 };
//-----------------------------------------------------------------------------
class Frame {    
    RX_STATE rState;
protected:
    int TxN;//number of transmitting bytes
    int RxN;//number of receiving bytes
    char tb[TX_BUF_SIZE];//transmit buffer
    char rb[RX_BUF_SIZE];//receiving data
public:
    Frame();
    int setTxFrame(char* d,int n);
    unsigned int CRC16CCITT_Calculate(char* s,unsigned char len,unsigned int crc);
    int getTxN();
    int getRxN();
    int receiveRxFrame(char c);//get receiving frame from received char
    char* getTxBuf();
    char* getRxBuf();
};
//-----------------------------------------------------------------------------
Frame::Frame():TxN(0),RxN(0),rState(IGNORE){}
//-----------------------------------------------------------------------------
char* Frame::getTxBuf(){
    return tb;
}
//-----------------------------------------------------------------------------
char* Frame::getRxBuf(){
    return rb;
}
//-----------------------------------------------------------------------------
//Prepare transmitting frame
int Frame::setTxFrame(char* d,int n)
{
    unsigned int txcrc=0xFFFF;//initialize crc
    char c;
    int i=0,j=0;
    tb[i++]=STX;//start of frame
    for(j=0;j < n;j++) {
        c=d[j];
        if((c==STX)||(c==ETX)||(c==DLE)) tb[i++]=(DLE);
        tb[i++]=c;
    }
    tb[i++]=(ETX);//end of frame

    txcrc=CRC16CCITT_Calculate(d,n,txcrc);//calculate crc
    tb[i++]=txcrc & 0xFF;
    tb[i++]=(txcrc >> 8) & 0xFF;
    TxN=i;
    return TxN;
}
//-----------------------------------------------------------------------------
//Inputs
//s : pointer to input char string
//len: string len (maximum 255)
//crc: initial CRC value

//Output
//Returns calculated CRC
unsigned int Frame::CRC16CCITT_Calculate(char* s,unsigned char len,unsigned int crc)
{
    //CRC Order: 16
    //CCITT(recommendation) : F(x)= x16 + x12 + x5 + 1
    //CRC Poly: 0x1021
    //Operational initial value:  0xFFFF
    //Final xor value: 0
    unsigned char i,j;
    for(i=0;i < len;i++,s++) {
        crc^=((unsigned int)(*s) & 0xFF) << 8;
        for(j=0;j<8;j++) {
            if(crc & 0x8000) crc=(crc << 1)^0x1021;
            else crc <<=1;
        }
    }
    return (crc & 0xFFFF);//truncate last 16 bit
}
//-----------------------------------------------------------------------------
//get number of transmitting bytes
int Frame::getTxN()
{
    return TxN;
}
//-----------------------------------------------------------------------------
//get number of transmitting bytes
int Frame::getRxN()
{
    return RxN;
}
//-----------------------------------------------------------------------------
//process receiving char
int Frame::receiveRxFrame(char c)
{
    static char b;
    unsigned int crc;
    unsigned int rxcrc=0xFFFF;//initialize CRC
    switch(rState){
        case IGNORE:
            if(c==STX) { rState=RECEIVING;RxN=0;}
            break;
        case RECEIVING:
            if(c==STX) { rState=RECEIVING;RxN=0;}
            else if(c==ETX){rState=RXCRC1;}
            else if(c==DLE){ rState=ESCAPE; }
            else { rb[RxN++]=c; }
            break;
        case ESCAPE:
            rb[RxN++]=c; rState=RECEIVING;
            break;
        case RXCRC1:
            b=c; rState=RXCRC2;
            break;
        case RXCRC2:
            rState=IGNORE;
            crc=( (int)c << 8 | ((int)b & 0xFF) ) & 0xFFFF;//get received crc
            rxcrc=CRC16CCITT_Calculate(rb,RxN,rxcrc);//calculate crc
            //printf("crc: %x  rxcrc:%x \n",crc,rxcrc);
            if(rxcrc==crc){return RxN;}//if crc is correct            
            else {RxN=0;}//discard the frame

            break;
    }
    return 0;
}

//-----------------------------------------------------------------------------

//#############################################################################

class Frame2:public Frame {
    char Dt[20];//transmitting data
public:
    Frame2();
    void printTxFrame();
    void printRxFrame();
    void printRxData();
    void setTxData(float x,float y,float z,float b,float t);
};
//-----------------------------------------------------------------------------
Frame2::Frame2():Frame(),Dt(""){}
//-----------------------------------------------------------------------------
//Print out frame content
void Frame2::printTxFrame()
{
    printf("Tx frame buffer: ");
    for(int j=0;j < TxN;j++) printf("%02X ",(unsigned char)tb[j]);
    printf("\n");
}
//-----------------------------------------------------------------------------
//Print out frame content
void Frame2::printRxFrame()
{
    printf("Rx data buffer: ");
    for(int j=0;j < RxN;j++) printf("%02X ",(unsigned char)rb[j]);
    printf("\n");
}
//-----------------------------------------------------------------------------
//Set transmitting data
void Frame2::setTxData(float x,float y,float z,float b,float t)
{
    *(float*)(Dt)=x;
    *(float*)(Dt+4)=y;
    *(float*)(Dt+8)=z;
    *(float*)(Dt+12)=b;
    *(float*)(Dt+16)=t;
    Frame::setTxFrame(Dt,20);
}
//-----------------------------------------------------------------------------
//Print out received data
void Frame2::printRxData()
{
    float x,y,z,b,t;
    x=*(float*)(Dt);
    y=*(float*)(Dt+4);
    z=*(float*)(Dt+8);
    b=*(float*)(Dt+12);
    t=*(float*)(Dt+16);
    printf("Rx data: %f %f %f %f %f \n",x,y,z,b,t);
}
//-----------------------------------------------------------------------------

#endif // FRAME_H

Friday, June 18, 2010

Common Interrupt Pitfalls

SDCC Compiler User Guide ထဲမှာ ပါတဲ့ စိတ်ဝင်စား စရာ အချက်တချို့ကို ပြန်ပြော ချင်ပါတယ်။ ကျွန်တော့် အတွေ့အကြုံ အရ အဲဒီ အချက်တွေဟာ အရမ်းအရေး ကြီးပြီး firmware programmer တွေအတွက် အမြဲခေါင်းထဲမှာ ရှိနေဖို့ လိုတယ် လို့ ထင်ပါတယ်။ တစ်ခါက ကျွန်တော့် ပရိုဂရမ် မှာ ဘာ အမှားမှ မရှိပဲ သူ့ကို သုံးတဲ့အခါ တလွဲတွေပဲ လုပ်နေပါတယ်။ Stack overflow ဖြစ်နိုင်တာ ကို ရုတ်တရက် သတိရ ပြီး Stack အရွယ်အစား ပြင်လိုက်တဲ့ အခါ ကောင်းသွားတာ မျိုး မကြာခဏ ကြုံဖူးပါတယ်။

Variable not declared volatile

တစ်ခြား function တွေက သုံးနေတဲ့ variable တွေကို interrupt service routine တစ်ခု ခုကနေ ပြောင်းလဲပေး နေတဲ့ အခါမျိုးမှာ အဲဒီ variable တွေကို volatile လို့ ကြေငြာပေးရပါမယ်။ အသေးစိတ်ကို http://en.wikipedia.org/wiki/Volatile_variable မှာ ကြည့်နိုင်ပါတယ်။

Non-atomic access

အကယ်၍ variable ကို သုံးတာ instruction တစ်ခုမက လိုပြီး သူ့ကို သုံးနေချိန်မှာ interrupt ဝင်လာနိုင်ရင် ဒေတာ အမှား ဖြစ်မသွားဖို့ interrupt ကို disabled လုပ်ထားဖို့ လိုပါတယ်။ အဲဒီလို Bug မျိုးဟာ ပြန်တွေ့အောင် reproduce လုပ်ဖို့ခက်ပြီး ဒုက္ခ တော်တော် ပေးနိုင်ပါတယ်။ ကျွန်တော်တော့ Real time and embedded systems ဆရာက အတန်းထဲမှာ mutual exclusion... mutual exclusion နဲ့ ခဏ ခဏ ပြောတာ ကို ကောင်း ကောင်း မှတ်မိ နေ ခဲ့ ပေမယ့် အဲဒီ ပြဿနာ မျိုး တစ်ခါ တက်ဖြစ်အောင် ပြန်တက်ဖူးပြီး သင်ခန်းစာ ကောင်းကောင်း ပြန်ရဘူး ပါတယ်။

Stack overflow

ခေါ်ထားတဲ့ address တွေရယ်၊ သုံးလက်စ register တန်ဖိုး တွေ ကို stack ပေါ်မှာ တင်သိမ်းထားပြီး၊ stack အရွယ်အစား မလုံလောက်ရင် နဂို နေရာဆီ ပြန်မရောက်ပဲ တစ်ခြား မထင်မှတ်တဲ့ နေရာ တွေဆီ ရောက်သွားပြီး ဒုက္ခ တွေ့နိုင် ပါတယ်။

Use of non-reentrant functions

ဖြစ်နိုင်ရင် interrupt ထဲမှာ တစ်ခြား function တွေကို မခေါ်ပဲ တတ်နိုင်သမျှ ရှောင်ကျဉ် ပါ။ အကယ်၍ interrupt က active ဖြစ်နိုင်တဲ့ အခြေအနေ မျိုးမှာ nonreentrant function တွေကို main program ကနေ မခေါ်သင့်ပါဘူး။ Good luck with your programming!

Friday, June 11, 2010

Circular Buffered UART Com Module for 8051 Microcontroller

Embedded system အများစု မှာ UART communication ကို သုံးကြပါတယ်။ ဒါကြောင့် ကျွန်တော် ရေးထားတဲ့ circular buffered UART comm module လေးကို ဒီမှာ ဖော်ပြချင်ပါတယ်။ သူ့ကို 8051 microcontroller အတွက် ရေးထားတာ ဖြစ်ပေမယ့် တစ်ခြား microcontroller တွေ အတွက်ဆိုရင် လဲ အလွယ်တစ်ကူ ပြောင်းသုံးလို့ ရပါတယ်။

Using Circular Buffered UART Com Module

သူ့ကို သုံးချင်တဲ့ module မှာ ထုံးစံ အတိုင်း header file ကြေငြာဖို့ လိုပါတယ်။ ကျွန်တော့် နမူနာ မှာတော့ header အားလုံးကို 'headers.h' ဖိုင်ထဲမှာ စုထားတဲ့ အတွက် အဲဒီဖိုင်ကို ထည့်လိုက်ရုံ ပါပဲ။
ပို့ဖို့၊ လက်ခံဖို့ အတွက် buffer အရွယ်အစားတွေကို ComConfig.h မှာ သတ်မှတ် နိုင်ပါတယ်။ အဲဒီမှာပဲ ဒေတာ လက်ခံရရှိတဲ့ အခါ ခေါ်ချင်တဲ့ function ကို သတ်မှတ်နိုင်ပါတယ်။
main function ထဲမှာ buffer ထဲမှာ ဒေတာ တွေ ရောက်နေ မနေ စစ်ဖို့ ComChkRx() function ကို poll လုပ် နိုင်ပါတယ်။
နမူနာ source code ကို

UART-Timer-8051 on GitHub

မှာရယူ နိုင်ပါတယ်။

Thursday, June 10, 2010

Soft-Timer Module for 8051 Microcontroller

Embedded system အားလုံးလိုလို မှာ timer တွေကို သုံးကြပါတယ်။ 8051 microcontroller မှာ hardware timer နှစ်ခု၊ သုံးခု ပဲ ပါတဲ့ အတွက် ပုံမှန် system တစ်ခု အတွက် လိုအပ်တဲ့ timer အားလုံးကို hardware timer တွေပဲ သုံးပြီး ရေးမယ် ဆိုရင် လုံလောက်မှာ မဟုတ်ပါဘူး။ ဒါကြောင့် သိပ်ပြီး တိကျဖို့ မလိုတဲ့ timer တွေကို ရေးတဲ့အခါ software ကိုပဲ သုံးပါတယ်။ ဒီမှာ ကျွန်တော် ရေးထားတဲ့ soft-timer module လေး တစ်ခု အကြောင်း ကို ပြောချင်ပါတယ်။ သူ့ကို 8051 microcontroller အတွက် ရေးထားတာ ဖြစ်ပေမယ့် တစ်ခြား microcontroller တွေ အတွက်ဆိုရင် လဲ အလွယ်တစ်ကူ ပြောင်းသုံးလို့ ရပါတယ်။
နမူနာ source code ကို

UART-Timer-8051 on GitHub

မှာရယူ နိုင်ပါတယ်။

Using soft-timer module

သူ့ကို သုံးချင်တဲ့ module မှာ ထုံးစံ အတိုင်း header file ကြေငြာဖို့ လိုပါတယ်။ ကျွန်တော့် နမူနာ မှာတော့ header အားလုံးကို 'headers.h' ဖိုင်ထဲမှာ စုထားတဲ့ အတွက် အဲဒီဖိုင်ကို ထည့်လိုက်ရုံ ပါပဲ။
Timer က သတ်မှတ်ချိန် ကုန် လို့ time out ဖြစ်ရင် လုပ်ချင်တဲ့ function ရယ်၊ timer ရဲ့ အချိန် သတ်မှတ်ဖို့၊ timer စတင်ဖို့ အတွက် function များကိုရေးပါ။ ကျွန်တော့် နမူနာ မှာတော့ SysSBYLEDTmrTO() နဲ့ SysSBYLEDInit() တို့ကို System.c module ထဲမှာ ရေးထားပါတယ်။
TmrConfig.h ဖိုင်ကို ဖွင့်ပြီး အဲဒီမှာ ရှိတဲ့ အဆင့် သုံးဆင့် ကို လုပ်ဖို့ လိုပါတယ်။ သင့် compiler က function pointers တွေကို သုံးလို့ မရရင် switch structure နဲ့ ပြောင်းသုံး နိုင်ပါတယ်။
main function ထဲမှာ initialize လုပ်ဖို့ TmrInit() နဲ့ ပုံမှန် poll လုပ်နေဖို့ TmrTask() တွေကို ခေါ်ဖို့ လို့ပါတယ်။ သူတို့ကို Tmr.c ထဲမှာ ရေးထားပါတယ်။

Wednesday, May 26, 2010

Using SPI on Low-End Microcontroller

SPI က IC အချင်းချင်း ဆက်သွယ်ဖို့ အတွက် ရိုးရှင်းပြီး ထိရောက်တဲ့ bus တစ်ခုပါ။ Real Time Clock၊ EEPROM အစရှိတဲ့ chip အများစုမှာ ဆက်သွယ်ဖို့ အတွက် SPI ဒါမှမဟုတ် I2C bus တွေ ပါလေ့ရှိပါတယ်။ ထူးခြားတဲ့ အချက် မရှိရင် တော့ SPI သုံးရတာကို I2C ထက်ပိုကြိုက်ပါတယ်။ သူက ပိုမြန်ပြီး ပိုရှင်းလို့ပါ။ သူ့ကို software နဲ့ ဖန်တီး emulate လုပ်ဖို့လဲ လွယ်ပါတယ်။
တစ်ခါက 10MHz ရှိတဲ့ SPI ပါတဲ့ LED driver chip တစ်ခုကို လုပ်ဆောင်မှု အရမ်းမမြင့်တဲ့ 4MHz microcontroller နဲ့ တွဲသုံးဖြစ်ပါတယ်။ Design လုပ်တုန်းက ဈေးသက်သာ ဖို့ အတွက် အဓိက ထားလို့ပါ။ Microcontroller ကလဲ တစ် ဒေါ်လာတောင် မပေးရပါဘူး။ ဒါပေမယ့် သူ့မှာ firmware နဲ့ font တွေသိမ်းဖို့ flash အလုံအလောက် ရှိပါတယ်။ အစကတော့ SPI ကို ဒေတာ ပို့ဖို့၊ လက်ခံဖို့ အတွက် ပုံမှန် အတိုင်းပဲ နှေးတဲ့ အဝေးပို့ RS232 တို့၊ CAN bus တို့မှာ သုံးနေကြ အတိုင်း circular buffer ကို hardware interrupt နဲ့ တွဲသုံးပါတယ်။ အဲဒါက ပုံမှန် အခြေအနေမှာ တော့ အိုကေ ပါတယ်။ ပြဿနာ က ကြီးမားတဲ့ 96x16 dot-matrix LED ဆိုင်းဘုတ် ကြီးကို တစ်စက္ကန့် ၁၂၅ ကြိမ် မောင်းချင်ပြီး CPU ကို အသုံးချ တဲ့ utilization က အရမ်းမြင့်နေတာပါ။ အကျိုးဆက် အနေနဲ့ စာသားတွေကို ဘေးတိုက် ပြေးတာ အစရှိတဲ့ ဂရပ်ဖစ် လုပ်ဆောင်မှုတွေကို ကိုင်တွယ်ရတဲ့ အခါ ကောင်းကောင်း မလုပ်နိုင်တော့ပဲ ဖုတ်လှိုက် ဖုတ်လှိုက် ဖြစ်ချင်လာ ပါတယ်။ ဒါနဲ့ပဲ အရင်းအမြစ်ကို စာရင်းစစ် ကြည့်လိုက်တော့ အဓိက အသုံးအများဆုံး ဖြစ်တဲ့၊ CPU က အမြဲတမ်းလိုလို လုပ်ဆောင်နေ ရတဲ့ SPI function က interrupt တွေ၊ circular buffer တွေနဲ့ ဖောင်းပွ နေပြီး သူ့ကို ထိရောက်အောင် ပြင်နိုင်ရင် CPU က တော်တော် သက်သာသွားမယ် ဆိုတာ တွေ့ရပါတယ်။ ပုံမှန်ကတော့ hardware interrupt ကိုသုံးတာက ပိုထိရောက်၊ ပိုမြန်တာ မှန်ပါတယ်။ ဒါပေမယ့် ဒီ ကိစ္စမှာတော့ ပုံမှန် မဟုတ်ပါဘူး နှေးတဲ့ CPU က အရမ်းမြန် အရမ်းအသုံးပြုဖို့ လိုတဲ့ SPI ကို မောင်းဖို့ လိုနေလို့ပါ။ SPI ကို ဒေတာ တစ်လုံး ပို့တိုင်း CPU cycle တွေ အရမ်းစားတဲ့ ပို့တဲ့ interrupt function၊ လက်ခံတဲ့ interrupt function တွေကို လုပ်နေရလို့ပါ။ နောက်တော့ polling ဒါမှမဟုတ် emulation ကို သုံးပြီး SPI ကို ဆက်သွယ်တာက interrupt ထက် ပိုမြန်တာကို တွေ့ရပါတယ်။ ဒါတောင် polling ကိုသုံးမယ်ဆိုရင် hardware က လက်ခံတဲ့ bus speed ကိုပဲ သုံးလို့ရမှာပါ။ ဒါနဲ့ SPI function ကို ပိုထိရောက်အောင် firmware ကို ပြင်လိုက်တော့ ကောင်းသွားပါတယ်။ ဒါကြောင့် SPI ကို emulating လုပ်ရင် ကောင်းတဲ့ အချက် တစ်ချို့ ကို ကျွန်တော် တို့ရဲ့ အတွေ့အကြုံ အရ ပြောချင်တာက

SPI ကို software မှာ emulate လုပ်ရင် ပိုမြန်တဲ့ အခါတွေ လည်း ရှိပါတယ်။
အရည်အသွေး လည်း ပိုကောင်းပါတယ်။ ဘာကြောင့်လဲ ဆိုတော့ ရိုးရှင်းတာရယ်၊ interrupt ကြောင့် ဖြစ်လာနိုင်တဲ့ ပြဿနာ အများစုကနေ ရှောင်ပြီးသား ဖြစ်သွားလို့ပါ။
ရိုးရှင်းတဲ့ code လေးကို ရေးရတာ ပိုမြန်၊ ပိုလွယ်ကူ၊ ပိုပြီး အမှားနည်းနိုင်ပါတယ်။ မဟုတ်ရင် အသစ်သုံးမယ့် microcontroller တိုင်း အတွက် အမျိုးမျိုးသော register setting တွေနားလည်ဖို့ datasheet ကို အချိန်ပေး ဖတ်ဖို့ လိုမှာပါ။
အကောင်းဆုံးကတော့ portable ဖြစ်ပြီး hardware ကို မမှီခိုတော့ တာပါပဲ။

SPI မှာ တိကျတဲ့ formal standard မရှိပါဘူး။ ပုံမှန် shift register တစ်ခုလို ရှင်းလွန်းလို့ပါ။ Timing diagram ကိုမြင်ရုံနဲ့ နားလည်နိုင်ပါတယ်။ အောက်က နမူနာက SPI မျိုးကွဲ တစ်ခုကို emulate လုပ်တဲ့ C function တစ်ခုပါ။

//-------------------------------------
unsigned char spi(unsigned char d)
{
    unsigned char i;
    SCLK=1;
    EN=1;
    for(i=0;i<8;i++)
    {
        MOSI=(d & 0x80)?1:0;        
        //Delay(period/2)-optional for slower SPI bus speed
        SCLK=0;
        d<<=1;        
        d|=MISO;
        //Delay(period/2)-optional for slower SPI bus speed
        SCLK=1;
    }
    EN=0;
    return d;
}
//-------------------------------------

Friday, April 30, 2010

C Programming on Windows

C programming ကို စလေ့လာ နေကြတဲ့ မိတ်ဆွေ တွေက ဘယ် IDE ကို Windows ပေါ်မှာသုံး လို့ ကောင်းမလဲ လို့ မေးကြပါတယ်။ ကျွန်တော့် အထင်ကတော့ Microsoft Visual Studio Express က တော်တော် သုံးလို့ကောင်းပါတယ်။ ဒီလင့် http://www.microsoft.com/express/ မှာ အလကား ရ နိုင်ပါတယ်။ နောက် လူကြိုက်များတာ တစ်ခု ကတော့ Bloodshed က Dev-C++ ပါ။ သူ့ကို လည်း http://www.bloodshed.net/devcpp.html မှာ ဖရီး ဒေါင်းလုပ် လုပ် နိုင်ပါတယ်။ နမူနာ အနေနဲ့ C project တစ်ခုကို Visual C++ 2008 Express Edition မှာ ဖန်တီး ကြည့်ထားပါတယ်။ စစချင်း File menu>>New>>Project... ကိုသွားပါ။ New Project window ပေါ်လာ ပါမယ်။ Project types: Visual C++ မှာ Win32 ကိုရွေးပါ။ Templates: Visual Studio Installed templates မှာ Win32 Console Application ကိုရွေးပါ။ အောက်နားက text box မှာ project နာမည် ရိုက်ထည့် ပြီး၊ သိမ်းမည့် folder ကို ရွေးပါ။ OK ကိုနှိပ်ပါ။ Win32 Application Wizard box ပေါ်လာရင် Next ကိုနှိပ်ပါ။ Application type မှာ Console application ကိုရွေးပါ။ နောက် additional options: မှာ Empty project ကိုရွေးနိုင်ပါတယ်။ Finish ခလုပ်ကို နှိပ်ပါ။ အောက်မှာ ပြထားတဲ့ အတိုင်းSolution Explorer window ထဲက Source Files ပေါ်မှာ right click နှိပ်ပြီး Add>>New Item... ကိုနှိပ်ပါ။

Add new item window ပေါ်လာရင် Name text box ထဲမှာ file name ကို.c extension နဲ့ ထည့်ရိုက်ဖို့ အရေးကြီးပါတယ်။ ဥပမာ StrPos.c။ အောက်က နမူနာ ပရိုဂရမ်က ဘယ်လိုရေးရမလဲလို့ မေးကြတဲ့ string position ကို C library functions တွေ မသုံးပဲ ရှာတဲ့ဟာပါ။ စာလုံး အကြီး အသေး မခွဲ ပါဘူး။

#include <stdio.h>
typedef signed char   CHAR;
typedef signed int    POSITION;
#define ToL(c) (((c)>='A')&&((c)<='Z')?(c+0x20):(c))
POSITION strcmp(CHAR* s1,CHAR* s2)
{ 
    for(;*s2;s1++,s2++) if(ToL(*s1)!=ToL(*s2)) return 0;
    return 1;
}
POSITION stripos (CHAR* haystack,CHAR* needle,POSITION offset)
{        
    for(;*(haystack+offset);offset++) if(strcmp(haystack+offset,needle)) return offset;    
    return -1;  
}
int main(int argc,char *argv[])
{
  CHAR str1[]="Hello! Good morning!";
  CHAR str2[]="good";
  printf("\nFound at: %d \n",stripos(str1,str2,0));   
  return 0;
}

အဲဒီနောက် F5 သို့မဟုတ် Debug menu>>Start Debugging ကိုနှိပ်ပြီး run ကြည့်နိုင်ပါတယ်။ Debug menu>>Start Without Debugging ကို သုံးလို့လည်း ရပါတယ်။

Friday, September 25, 2009

CRC Calculation in VB and C

CRC -Cyclic Redundancy Check ကို တွက်ထုတ် ဖို့ အတွက် Visual Basic 2005 နဲ့ C ကို သုံးပြီး ရေးထားတဲ့ code တချို့ပါ။

CRC Calculation in VB2005

CRC Calculation အချို့အတွက် Visual Basic 2005 source code များကို အောက်ပါ လင့်ခ် မှာတွေ့နိုင်ပါတယ်။ Calculation ကို ပိုမြန်စေဖို့ အတွက် table ကို သုံးပြီး တွက်ထားပါတယ်။

CRC Calculation - GitHub

ဥပမာ အနေနဲ့ CRC16 CCITT Calculation နမူနာ တစ်ခုကို အောက်မှာ ပြထားပါတယ်။

Dim StrIn as String= "String to calculate CRC"
Dim CRCVal16 As UInt16 = 0
Dim crc As String
CRCVal16 = CRC16_CCITT.Calculate(StrIn)
crc = CRC16_CCITT.ToString(CRCVal16)

CRC16 CCITT ရဲ့ initial value က 0xFFFF ဖြစ်ပြီး သူ့ ကို အခြား တန်ဖိုး နဲ့ စသုံးချင်ရင်တော့ အောက်ပါအတိုင်း သုံးနိုင်ပါတယ်။

CRCVal16 = CRC16_CCITT.Calculate(Str1)
CRCVal16 = CRC16_CCITT.Calculate(Str2, CRCVal16)
crc = CRC16_CCITT.ToString(CRCVal16)

CRC Calculation in C

CRC Calculation အချို့အတွက် C source code များကို အောက်ပါ လင့်ခ် မှာတွေ့နိုင်ပါတယ်။ Storage သုံးတာ သက်သာအောင် table ကို မသုံးပဲ တွက်ထားပါတယ်။

CRC Calculation - GitHub

ဥပမာ အနေနဲ့ CRC16 CCITT Calculation နမူနာ တစ်ခုကို အောက်မှာ ပြထားပါတယ်။

#define STRLEN 4
char str[STRLEN]={0x01,0x01,0x00,0x0B};
unsigned char c[2];
unsigned int crc;
//Calculate CRC16 CCITT
crc=CRC16CCITT_InitialValue();
crc=CRC16CCITT_Calculate(str,STRLEN,crc);
CRC16CCITT_ToString(crc,c);
printf("CRC16 CCITT = %02X %02X \n",c[0],c[1]);

အောက်ကလို Online checksum calculator တွေကလည်း ကုဒ်တွေကို debug လုပ်တဲ့ အခါ အသုံးကျပါတယ်။

Online Checksum Calculator

Tuesday, August 18, 2009

SDCC - Small Device C Compiler

SDCC - Small Device C Compiler က အလကား ရနိုင်တဲ့ free open source C compiler ပါ။ သူက 8051 နဲ့ အခြား microcontroller အချို့အတွက်ပါ။ SDCC လို အလကား မဟုတ်ပဲ ပိုက်ဆံ ပေးဝယ်ရတဲ့ အခြား Keil တို့လို compiler တွေလဲ ရှိပါတယ်။ အဲဒီမှာ free evaluation version ကိုရနိုင်ပေမယ့် အစမ်းသဘော အတွက်ပဲ ရည်ရွယ်ပြီး code size ကို 2k byte ထက် ပိုသုံးလို့ မရအောင် ကန့်သတ်ထားပါတယ်။ SDCC ရဲ့ကောင်းတဲ့ အချက်ကတော့ ပိုက်ဆံ တစ်ပြားမှ မကုန်ပဲ အလကား ရနိုင်တာပါ။ ဒီမှာ ပြောမှာ ကတော့ SDCC manual ကို အကျဉ်းချုံး ထုတ်နုတ်ပြော တာပါ။

Installing
http://sdcc.sourceforge.net/ ကိုသွားပြီး setup program ကို download လုပ်နိုင်ပါတယ်။ နောက် setup program ကို Run ပါ။

Testing the SDCC Compiler
နောက် command prompt ကိုသွားပြီး compiler အလုပ် လုပ်မလုပ် စမ်းကြည့်ဖို့ "sdcc -v" ကို enter လုပ်ပါ။ SDCC ကသူ့ရဲ့ ဗားရှင်း နံပါတ်ကို reply ပြန်တာ ကို တွေ့ ရပါလိမ့် မယ်။

Example C Program
အောက် ပါ နမူနာ program ကို စိတ်ကြိုက် ASCII editor တစ်ခုခု သုံးပြီး ရိုက်ပါ။ ထို့နောက် led.c အမည်ဖြင့် သိမ်းပါ။ Eclipse အစရှိတဲ့ development IDE တွေသုံးလို့ လဲရပါတယ်။ အဲဒီ အကြောင်း ကြုံရင် ပြောပါမယ်။ ဒီနမူနာ က 8051 microcontroller ရဲ့ P3.4 pin ကိုဆက်သွယ်ထား တဲ့ LED ကို မှိတ်တုပ် မှိတ်တုပ် အဖွင့် အပိတ် လုပ်ပေးဖို့ ပါ။

#include<8052.h>
void main()
{
int i;
while(1)
{
P3_4=0;   //Output 0
for(i=0;i<30000;i++);  //delay loop
P3_4=1;   //Output 1
for(i=0;i<30000;i++);  //delay loop
}
}

Compiling and Getting Hex File
command prompt မှာ ဖိုင် led.c ရှိတဲ့ နေရာကို သွားပြီး "sdcc led.c" ကို enter လုပ်ပါ။ အားလုံး အဆင်ပြေရင် အမှား မတက်ပဲ led.ihx ဆိုတဲ့ဖိုင် ထွက်လာပါမယ်။ "dir" ကို enter လုပ်ပြီး အဲဒီဖိုင် ထွက်မထွက် ကြည့်နိုင်ပါတယ်။ နောက် သင့်ရဲ့ chip ထဲကို download လုပ်ဖို့ သင့်တော်တဲ့ intel hex file ရအောင် "packihx led.ihx>led.hex" ကို enter လုပ်ပါ။ ထွက်လာတဲ့ led.hex ကို သုံးလို့ ရပါပြီ။

Projects with Multiple Source Files
SDCC က တစ်ကြိမ်မှာ တစ်ဖိုင် ပဲ compile လုပ်ပေးနိုင်ပါတယ်။ ဥပမာ main.c blink.c ဆိုတဲ့ ဖိုင်တွေရှိ တဲ့ project ကို စမ်းဖို့ အောက်ပါ အတိုင်း ရိုက်ထည့်ပြီး ဖိုင် များကို ဖန်တီးပါ။

//File name: main.c
#include "blink.h"
void main()
{
while(1)
{
toggle();
delay();
}
}

//File name: blink.c
#include <8052.h>
#include "blink.h"
void toggle()
{
P3_4^=1;
}
void delay()
{
int i;
for(i=0;i<30000;i++); //delay loop
}

//File name: blink.h
void toggle();
void delay();

main() function မပါတဲ့ ဖိုင်များကို "sdcc -c blink.c" ဆိုတဲ့ command သုံးပြီး သပ်သပ် compile လုပ်ပါ။ နောက် main() function ပါတဲ့ ဖိုင်ကို နောက်ဆုံးမှ "sdcc main.c blink.rel" ဆိုတဲ့ ပုံစံ အတိုင်း compile လုပ်နိုင်ပါတယ်။ main.ihx ဆိုတဲ့ ဖိုင်ထွက်လာမှာ ဖြစ်ပြီး ထုံးစံ အတိုင်း main.hex ကို ရယူ အသုံးပြု နိုင်ပါတယ်။

Pages

Search This Blog

Friday, August 10, 2018

Monday, January 22, 2018

နိဒါန်း

Monday, November 20, 2017

နိဒါန်း

Thursday, March 24, 2016

Wednesday, November 25, 2015

Tuesday, November 24, 2015

Tuesday, November 17, 2015

Wednesday, September 16, 2015

Thursday, March 6, 2014

Tuesday, July 9, 2013

Saturday, June 29, 2013

Tuesday, May 3, 2011

Friday, June 18, 2010

Variable not declared volatile

Non-atomic access

Stack overflow

Use of non-reentrant functions

Friday, June 11, 2010

Using Circular Buffered UART Com Module

Thursday, June 10, 2010

Using soft-timer module

Wednesday, May 26, 2010

Friday, April 30, 2010

Friday, September 25, 2009

CRC Calculation in VB2005

CRC Calculation in C

Tuesday, August 18, 2009