giáo trình visual basic và pic phần 1 pptx

Understanding and Using Visual Basic
"Micro-News"
Micro-Mailing-List

Microcontroller applications with the Basic Stamp, PIC, 8051 and various
others can often be enhanced with the use of the PC serial port, and a
software interface. Designing your own custom interface software for
your next microcontroller application isn't as hard as you may think.
Using the PC serial port to interface to the outside world, and your next
microcontroller application, can provide you with some extremely
powerful software/hardware solutions.
This series of articles by Jared Hoylman will walk you through a few of
the basic concepts, and then move on to the more advanced areas of
communicating with your hardware, and having your hardware
communicate back to the PC.
Introduction:
Option Explicit
DataTypes
Parsing Strings
Advanced Parsing
Sending Data From The PC to a Microcontroller
Receiving Data From The Microcontroller

(1 of 2)5/25/2004 8:47:02 PM
Understanding and Using Visual Basic
Copyright © 1999-2001
Reynolds Electronics
| Contact Information |
Reynolds Electronics
3101 Eastridge Lane
Canon City, Co. 81212

Voice: (719) 269-3469
Fax: (719) 276-2853
(2 of 2)5/25/2004 8:47:02 PM
Using Visual Basic
"Micro-News"
Micro-Mailing-List

Understanding and Using Visual Basic Part 1
By: Jared Hoylman -
Being a VB programmer there are many things that I have
picked up over the past few years that greatly improved my
programs and programming ability. In this series of articles I
am going to cover some of the basics of VB programming and
some Tips and Tricks to ease you along your way. This series of
articles will start with the basic skills needed and work it's way
up to the more advanced topics such as sending and receiving
data from a Basic Stamp or Microchip PIC !
Option Explicit
I am sure many of you have seen the words Option Explicit at
the top of some VB code before. Why is it there, and what does
it do ? Well, the Option Explicit statement forces you to
declare your variables before you use them. Whoop-t-do,
right ? Wrong ! These two simple word can save you hours of
headaches debugging your programs ! It can also speed up
your program considerably if used right !
By placing Option Explicit at the top of every code module
before any procedures you can guarantee that you will not
misspell any variables. Lets see an example
(1 of 3)5/25/2004 8:47:24 PM
Using Visual Basic

Private Sub Command1_Click()
Dim sMississippi As String
sMississipi = "Hello" '< Note the missing "p"
MsgBox sMississippi
End Sub
What this code is actually supposed to do is display a
MessageBox with the greeting "Hello". Since the variable is
misspelled and there is no Option Explicit at the top of the code
module, you get a blank MessageBox !
Now go to the very top of the code module and type the words
Option Explicit. Run the program again. What happened ?
You get a "Variable not defined" error. This is a simple fix for
what could be a complex problem.
Another reason that Option Explicit is so important is because
if you do not declare your variables as a specific data type, VB
defaults the variable to being type Variant (See data types
explained in the next article). A Variant type variable can hold
any kind of data from strings, to integers, to long integers, to
dates, to currency, etc. Even though this may sound like the
best kind of variable to use, it is not. It is the slowest type of
variable ! By defining your variables specifically for the kind of
values that will be stored in them, will greatly increase your
programs performance.
And to make it even easier, how about if I show you how to
make VB automatically add Option Explicit to every code
module ! It's easy.
Click on the Tools menu and select Options Now check
Require Variable Declaration Click OK
Now every time you open a new code module the words Option
Explicit automatically appear at the top !

| Intro | Data Types >>


(2 of 3)5/25/2004 8:47:24 PM
Using Visual Basic
Copyright © 1999-2002
Reynolds Electronics
| Contact Information |
Reynolds Electronics
3101 Eastridge Lane
Canon City, Co. 81212
Voice: (719) 269-3469
Fax: (719) 276-2853
(3 of 3)5/25/2004 8:47:24 PM
Visual Basic Datatypes
"Micro-News"
Micro-Mailing-List

Understanding and Using Visual Basic Part 2
By: Jared Hoylman -
Understanding and Optimizing Data Types
In Visual Basic 6 there are 11 different data types. These are Boolean,
Byte, Currency, Date, Double, Integer, Long, Object, Single, String, and
Variant. They each have a specific purpose and using them correctly will
increase your programs performance. I am going to cover the data types
most frequently used.
• Boolean
The Boolean data type has only two states, True and False. These types
of variables are stored as 16-bit (2 Byte) numbers, and are usually used
for flags. For example, lets say that you have a textbox (Text1) and a

command button (Command1). You only want Command1 to be Enabled
when there is text in Text1. You would do something like this
Private Sub Form_Load()
Command1.Enabled = False ' Disables Command1
Text1.Text = vbNullString ' Sets Text1=""
End Sub
Private Sub Text1_Change()
Dim bEnable As Boolean
If Text1.Text <> "" Then bEnable = True
Command1.Enabled = bEnable
End Sub
(1 of 4)5/25/2004 8:47:40 PM
Visual Basic Datatypes
Run the program and Command1 will only be enabled when there is text
typed into Text1.
• Byte
The Byte data type is an 8-bit variable which can store value from 0 to
255. This data type is very useful for storing binary data. It can also be
very useful when sending/receiving byte values to/from a Basic Stamp or
PIC.
• Double
The Double data type is a 64-bit floating point number used when high
accuracy is needed. These variables can range from -
1.79769313486232e308 to -4.94065645841247e-324 for negative values
and from 4.94065645841247e-324 to 1.79769313486232e308 for
positive values.
• Integer
The Integer data type is a 16-bit number which can range from -32768 to
32767. Integers should be used when you are working with values that
can not contain fractional numbers.

• Long
The Long data type is a 32-bit number which can range from -
2,147,483,648 to 2,147,483,647. Long variables can only contain non-
fractional integer values. I myself use Long variables over Integers for
increased performance. Most Win32 functions use this data type for this
reason.
• Single
The Single data type is a 32-bit number ranging from -3.402823e38 to -
1.401298e-45 for negative values and from 1.401298e-45 to
3.402823e38 for positive values. When you need fractional numbers
within this range, this is the data type to use.
• String
The String data type is usually used as a variable-length type of variable.
A variable-length string can contain up to approximately 2 billion
characters. Each character has a value ranging from 0 to 255 based on
the ASCII character set. Strings are used when Text is involved.
Putting All Of This Technical Stuff To Use
Just to show you how to use these data types, here is a small example.
Lets say that we have a String containing the text, "This VB stuff is pretty
(2 of 4)5/25/2004 8:47:40 PM
Visual Basic Datatypes
darn cool !", and we want to convert each letter to it's ASCII equivalent.
We will then display each letter along with its ASCII equivalent in a
MessageBox one at a time.
Private Sub Command1_Click()
Dim sText As String
Dim lTextLength As Long
Dim sChar As String
Dim bASCII As Byte
Dim x As Long

sText = "This VB stuff is pretty darn cool !"
lTextLength = Len(sText) 'Gets # of chars in sText
For x = 1 To lTextLength 'Loop through string one char at a time
sChar = Mid$(sText, x, 1)'Gets the x'th charcter in sText
bASCII = Asc(sChar) 'Gets ASCII value of character
MsgBox "The ASCII value of '" & sChar & "' is " & bASCII 'Display
results
Next x

End Sub
Now run the code and it will display one character at a time along with it's
ASCII value.
<< Option Explicit | Intro | Parsing Strings >>


Copyright © 1999-2001
Reynolds Electronics
| Contact Information |
Reynolds Electronics
3101 Eastridge Lane
Canon City, Co. 81212
Voice: (719) 269-3469
Fax: (719) 276-2853
(3 of 4)5/25/2004 8:47:40 PM
Visual Basic Datatypes
(4 of 4)5/25/2004 8:47:40 PM
Visual Basic Parsing Strings
"Micro-News"
Micro-Mailing-List

Understanding and Using Visual Basic Part 3
By: Jared Hoylman -
Parsing Strings
Strings are one of the most widely used data types, and yet parsing
strings is one of the most mis-understood concepts to Visual Basic
programmers. So I will show you how it is done.
• The Len Function
The Len function simply returns the number of characters within a string.
For example
Dim sText As String
Dim lTextLength As Long
sText = "Reynolds Electronics"
lTextLength = Len(sText)
After running this code lTextLength will equal 20, which is the number of
characters in the string sText
• The InStr Function
The InStr function will tell you if a string is within a string and where it
starts. For example
(1 of 5)5/25/2004 8:47:51 PM
Visual Basic Parsing Strings
Dim sText As String
Dim lElectronics As Long
sText = "Reynolds Electronics"
lElectronics = InStr(sText, "Electronics")
After running this code lElectronics will contain the value 10. If you count
over from the beginning of the string you will notice that the word
Electronics begins at the tenth letter of sText.
You can also use the Instr function just to determine whether a string is
present within another string.
Dim sText As String

Dim lElectronics As Long
sText = "Reynolds Electronics"
If InStr(sText, "Electronics") Then
MsgBox "Found the word 'Electronics'"
Else
MsgBox "Did not find the word 'Electronics'"
End If
Run this code and it should tell you that it found the word Electronics.
Now try changing sText to something else and run it again to see what
happens
• The Left Function
The Left function returns a specified number of characters from the left
side of a string. For example run the following code and the results
should show up in your Debug window.
(2 of 5)5/25/2004 8:47:51 PM
Visual Basic Parsing Strings
Dim sText As String
Dim sLeft1 As String
Dim sLeft5 As String
Dim sLeft15 As String
sText = "Reynolds Electronics"
sLeft1 = Left$(sText, 1)
sLeft5 = Left$(sText, 5)
sLeft15 = Left$(sText, 15)
Debug.Print "The first letter is: " & sLeft1
Debug.Print "The first 5 letters are: " & sLeft5
Debug.Print "The first 15 letters are: " & sLeft15

• The Right Function
The Right function returns a specified number of characters from the

right side of a string. For example run the following code and the results
should show up in your Debug window.
Dim sText As String
Dim sRight1 As String
Dim sRight5 As String
Dim sRight15 As String
sText = "Reynolds Electronics"
sRight1 = Right$(sText, 1)
sRight5 = Right$(sText, 5)
sRight15 = Right$(sText, 15)
Debug.Print "The last letter is: " & sRight1
Debug.Print "The last 5 letters are: " & sRight5
Debug.Print "The last 15 letters are: " & sRight15

• The Mid Function
Now the Mid function is a little bit trickier so we are going to take this one
a little slower. The Mid function needs three values passed to it, the
String to search in, a starting position, and a length. What this function
actually does is look in a string, starting at the position you tell it to start
at, and retrieve the number of characters that you tell it to. So
(3 of 5)5/25/2004 8:47:51 PM