class A_Pin(D_Pin):
def __init__(self, pin):
#self.pin = pin
self.dac = None
self.adc = None
if pin in [25, 26]:
self.dac = DAC(Pin(pin))
if pin in [32, 33]:
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_11DB)
self.adc.width(ADC.WIDTH_10BIT)
super().__init__(pin)
def write_analog(self, value):
if self.pin not in [25, 26]:
# print("This pin feature is not supported")
super().write_analog(value)
else:
self.dac.write(value)
def read_analog(self):
if self.adc != None:
return self.adc.read()
else:
print('This Pin does not support ADC')
return None
def create_data_file(starting_value, button_pin, sensor_pin, led_pin, blue,
red, green, counter):
button = machine.Pin(button_pin, machine.Pin.IN) #define button pin
adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin
adc33.atten(ADC.ATTN_6DB) #define adc
dac26 = DAC(machine.Pin(led_pin)) #define DAC
dac26.write(starting_value) #adjust the intensity of the LED
data = []
i = 0
f = open('data' + str(counter), 'w')
while True:
time.sleep(1)
#Take the average of the measurments every 1,2 seconds
sum = 0
for i in range(12000):
if button.value() == 1:
break
sum = sum + adc33.read()
time.sleep(0.01)
average = sum / 12000
data.append(average)
f.write("%s\n" % average)
print("\n")
print(average)
if button.value() == 1: #button is pressed again
color("blue", blue, red, green)
time.sleep(1)
break
i = i + 1
f.close()
class Speak:
def __init__(self):
# init dac
self.dac = DAC(Pin(25))
# init params
self.__volume = 8
def set_volume(self, volume):
if (volume <= 10) and (volume >= 0):
self.__volume = 11 - volume
else:
print('the volume must be in 0 to 10')
def play_music(self, filename, rate):
delay_interval = int(1000000 / rate)
last_data = 0
f = open(filename, 'r')
if self.__volume != 11:
while True:
data = f.read(4)
if data == '':
for i in range(int(last_data / self.__volume), 0, -1):
self.dac.write(i)
time.sleep_ms(2)
f.close()
return
else:
data = int(data.strip())
self.dac.write(int(data / self.__volume))
time.sleep_us(delay_interval)
last_data = data
class BatteryService(object):
def __init__(self):
self.powerPin = 0
self.adc = 0
self.Battery = 0
self.vBiasDAC = 0
def confService(self):
self.powerPin = Pin('P8', mode=Pin.OUT)
self.adc = ADC()
self.adc.vref(1058)
self.vBiasDAC = DAC('P22')
self.vBiasDAC.write(0.135) # approximately 0.5 V
self.Battery = self.adc.channel(pin='P14', attn = ADC.ATTN_11DB)
def getData(self):
self.powerPin(1)
time.sleep(0.002)
batt = self.Battery.voltage()
collectMemory()
self.powerPin(0)
return batt
def connect(self):
self.confService()
class ODSensor:
# frequency and pins may need to be changed
def __init__(self,LEDPin, sensorPin): #25,39. 26,36.
self.DAC_MAX = 255
self.DAC_Vmax = 3.15
self.DAC_Vmin = 0.09
self.led = DAC(Pin(25), bits=8)
self.sensor = ADC(Pin(39)) #Green
#self.sensor.atten(ADC.ATTN_11DB)
self.sensor.width(ADC.WIDTH_10BIT)
# return a single measurement
def measure(self, intensity):
self.led.write(intensity)
data = []
#get 120 measurements
for j in range(120):
data.append(self.sensor.read())
data.sort() #sort data increasing
sum_middle = sum(data[30:90]) #find sum of middle numbers
avg = sum_middle / 60 #find average of middle numbers
return avg
def experiment(starting_value, button_pin, sensor_pin, led_pin, blue, red,
green):
button = machine.Pin(button_pin, machine.Pin.IN) #define button pin
adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin
adc33.atten(ADC.ATTN_6DB) #define adc
dac26 = DAC(machine.Pin(led_pin)) #define DAC
dac26.write(starting_value) #adjust the intensity of the LED
data = []
i = 0
counter = 0
while not count_time(button_pin):
print("here!!")
if button.value() == 1:
color("green", blue, red,
green) #if the experiment runs neopixel gives green color
if counter < 5:
create_data_file(starting_value, button_pin, sensor_pin,
led_pin, blue, red, green,
counter) #create new data file
counter += 1
color("purple", blue, red, green)
color("white", blue, red, green)
time.sleep(5)
color("no", blue, red, green)
#Take the of the measurments every 1,2 seconds
sum = 0
for i in range(120):
if button.value() == 1:
break
sum = sum + adc33.read()
time.sleep(0.01)
average = sum / 12000
def signal_generator(pin=25, buffer_size=100, freq=.1):
# create a buffer containing a sine-wave
buf = bytearray(buffer_size)
for i in range(len(buf)):
buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))
# output the sine-wave at 400Hz
p = Pin(pin, Pin.OUT)
dac = DAC(p)
while True:
for i in buf:
dac.write(i)
time.sleep(freq)
def play(filename, pin):
try:
p = Pin(pin, Pin.OUT)
dac = DAC(p)
except Exception as e:
return str(e)
f = wave.open(filename, 'r')
total_frames = f.getnframes()
framerate = f.getframerate()
for position in range(0, total_frames, framerate):
f.setpos(position)
# dac.write_timed(f.readframes(framerate), framerate)
dac.write(f.readframes(framerate))
sleep_ms(1000)
def test():
buf = bytearray(100)
dac = DAC(Pin(25, Pin.OUT))
for i in range(len(buf)):
buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))
#print(1 "{",buf[i],"}")
#dac.write(buf[i])
test_count=0
flag= False
while flag==False:
for i in range(len(buf)):
print(1, "{",buf[i],"}")
dac.write(buf[i])
time.sleep(0.1)
test_count=test_count+1
if test_count==9000:
flag=True
print("end 1")
def experiment(starting_value, button_pin, sensor_pin, led_pin):
button = machine.Pin(button_pin, machine.Pin.IN) #define button pin
adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin
adc33.atten(ADC.ATTN_11DB) #define adc
dac26 = DAC(machine.Pin(led_pin)) #define DAC
dac26.write(starting_value) #adjust the intensity of the LED
data = []
i = 0
while True:
if button.value() == 1:
f = open('data', 'w')
while True:
time.sleep(0.1)
data.append(adc33.read())
f.write("%s\n" % adc33.read()) #
print(data[i - 1])
if button.value() == 1:
time.sleep(1)
break
i = i + 1
f.close()
class Stepper:
def __init__(self):
self.coils = [pins.motor_1, pins.motor_2, pins.motor_3, pins.motor_4]
self.vref_12 = DAC(pins.motor_vref_a)
self.vref_34 = DAC(pins.motor_vref_b)
self.sequence = [[1, 0, 0, 0], [1, 1, 0, 0], [0, 1, 0, 0],
[0, 0, 1, 0], [0, 0, 1, 1], [0, 0, 0, 1]]
def activate(self, index):
values = self.sequence[index]
for i in range(4):
self.coils[i].on() if values[i] else self.coils[i].off()
def step(self):
self.vref_12.write(30)
self.vref_34.write(30)
for i in range(len(self.sequence)):
self.activate(i)
sleep_us(10000)
self.vref_12.write(0)
self.vref_34.write(0)
'''
Send the value 0..256 to the DAC and read the analogue value
back on the ADC
Copyright (c) U. Raich 2020
This program is part of the course on IoT at
the University of Cape Coast, Ghana
'''
from machine import Pin, ADC, DAC
from time import sleep_ms
adc = ADC(Pin(36)) # create ADC object on ADC pin
adc.atten(ADC.ATTN_11DB)
dac = DAC(Pin(26))
file = open("linearity.dat", "w")
print(
"Send values from 0 ..255 to DAC and read the signal level back on the ADC"
)
print("The ADC values are saved in the file 'linearity.dat'")
for i in range(256):
# send the value to the DAC and wait for 50 ms to stabilize
# then read back the signal level on the DAC
dac.write(i)
sleep_ms(50)
file.write("{:d}\n".format(adc.read()))
for i in range(255):
dac.write(254 - i)
sleep_ms(50)
file.write("{:d}\n".format(adc.read()))
file.close()
#simple DAC from machine import DAC from machine import Pin dac0 = DAC(Pin(25)) dac1 = DAC(Pin(26)) dac0.write(128) #1.75V dac1.write(64) #0.9V
#Hardware Platform: FireBeetle-ESP32
#Result: IO25 output sin wave, IO26 output cos wave.
#Hardware Connection: IO25 and IO26 need to be connected to an oscilloscope if waveform observation is needed.
#The info below shows that waveform is available for the current version.
# IO25 IO26
#FireBeetle-ESP32 has 2 DAC signal pins in all.
from machine import DAC, Pin
import math
import time
dac0 = DAC(Pin(25))
dac1 = DAC(Pin(26))
a = 0
while True:
value = math.sin(a * math.pi / 180) #get sine
dac0.write(int(100 + value * 100)) #ouput wave
dac1.write(a * 255 // 360)
a += 1
if (a == 361):
a = 0
time.sleep(0.0001)
from machine import Pin, DAC
import utime
# variabelen
DAC_GPIO = 25
buf = []
# initialiseren DAC
dac = DAC(Pin(DAC_GPIO))
# zaagtandbuffer opvullen
for i in range(0, 100):
buf.append(i * 2)
# zaagtand naar DAC
j = 0
while True:
# waarde naar DAC
val = buf[j]
print(val)
dac.write(val)
# volgende waarde
j += 1
if j >= 100:
j = 0
# 20 ms wachten - 100 * 20ms = 2 s
utime.sleep_ms(20)
from machine import Pin, Map, DAC # include Pin, Map and DAC from machine module import time # import time module BUZZER = DAC(Pin(Map.WIO_BUZZER)) # create DAC on WIO BUZZER Pin BUZZER.write(180) # write value to DAC, 180/4096*3.3 = 0.145V
global wr
global playlist_pos
if playlist_pos >= len(wav_files):
playlist_pos = 0
wr = loadWav(wav_files[playlist_pos])
t1.init(freq=wav_sample_rate, mode=Timer.PERIODIC, callback=play_loop_all)
playlist_pos += 1
sleep(1)
# Init DAC
dac = DAC(Pin(26))
# Middle value for speaker
dac.write(0x7F)
dw = dac.write
wav_pos = 0
wav_pos_prev = 0
wav_files = list()
wav_files.append("assets/wav/s1.wav")
wav_files.append("assets/wav/s2.wav")
wav_files.append("assets/wav/s3.wav")
wav_files.append("assets/wav/oeproj.wav")
wav_files.append("assets/wav/s5.wav")
wav_files.append("assets/wav/s6.wav")
wav_files.append("assets/wav/s7.wav")
wav_files.append("assets/wav/upycool.wav")
# Demo 7.5 - Playing tones on the speaker
from machine import DAC, Pin
from math import sin, pi
from time import sleep_us
dac = DAC(Pin(25,Pin.OUT))
# create a buffer containing a sine-wave
buf = bytearray(50)
for i in range(len(buf)):
buf[i] = 128 + int(127 * sin(2 * pi * i / len(buf)))
while True:
for i in range(len(buf)):
dac.write(buf[i])
sleep_us(1)
# Demo 7.6 - Playing tones on the speaker now with a function
from machine import DAC, Pin
from math import sin, pi
from time import sleep_us
dac = DAC(Pin(25,Pin.OUT))
# create a buffer containing a sine-wave
buf = bytearray(50)
for i in range(len(buf)):
buf[i] = 128 + int(127 * sin(2 * pi * i / len(buf)))
def playtone(delay, repetition, dac, buf):
for j in range(repetition):
from machine import Pin, DAC
from time import sleep_ms
dac = DAC(Pin(26))
print("Running a triangular wave form with a frequency of ~ 1 Hz on pin 26")
while True:
for i in range(256):
dac.write(i)
sleep_ms(2)
for i in range(256):
dac.write(256 - i - 1)
sleep_ms(2)
look_up_ADC = []
# Initialize ADC
adc = ADC(Pin(ADC_PIN_NO))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT) # was 10
# Initialize DAC
dac = DAC(Pin(DAC_PIN_NO), bits=8)
# Measure
adc_read = []
for i in range(0, DAC_MAX+1):
print('Samples acquired: ' + str(i) + '/' + str(DAC_MAX))
dac.write(i)
utime.sleep_ms(ADC_DELAY)
raw_read = []
for i in range(1, NUM_SAMPLES+1):
raw_read.append(adc.read())
utime.sleep_ms(DAC_DELAY)
adc_read.append(round(sum(raw_read)/NUM_SAMPLES))
# Print result
#print(adc_read)
adc_V_lookup = []
for i in range(0, ADC_MAX+1):
gc.collect()
gc.mem_free()
# f = 329Hz
# fs = 32.9kHz
import math
from machine import DAC
from machine import Pin
dac1 = DAC(Pin(25))
dac2 = DAC(Pin(26))
# create a buffer containing a sine-wave
buf = bytearray(100)
for i in range(len(buf)):
buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))
while 1:
for i in range(len(buf)):
dac2.write(buf[i])
from machine import DAC, Pin import utime da = DAC(Pin(26)) da.write(0)
for i in range(500, 1000, 10):
time.sleep(0.01)
pwm13.duty(i)
data.append(adc33.read())
f.write((data))
###########################DAC fade in fade out
import time
import machine
from machine import DAC, ADC
adc33 = ADC(machine.Pin(33))
adc33.atten(ADC.ATTN_11DB) #define adc
dac26 = DAC(machine.Pin(26))
dac26.write(0)
time.sleep(1)
data = []
f = open('data', 'w')
for i in range(1, 255):
time.sleep(0.1)
dac26.write(i)
data.append(adc33.read())
f.write("%s\n" % adc33.read())
print(data[i - 1])
f.close()
f = open('data', 'r') #open the file for reading purpose
f.read() # then you can read
from cat import Cat
from machine import Timer, I2C, Pin, ADC, DAC, TouchPad
import limb
from time import sleep
import network
from mpu6050 import MPU6050
from hcsr04 import HCSR04
import wave
print('{}: telnet is {} on {}'.format(*network.telnet.status()))
sensor = HCSR04(14, 12)
dac = DAC(26)
dac.write(0)
#dac=None
t = TouchPad(13)
t.config(500)
feedback = ADC(32)
feedback.atten(ADC.ATTN_11DB)
feedback.read() / 4095
vbat = ADC(35)
vbat.atten(ADC.ATTN_11DB)
print("battery is at {} Volts".format(vbat.read() / 4095 * 3.9 * 2))
timer = Timer(0)
from machine import DAC, Pin da1 = DAC(Pin(26, Pin.OUT), bits=8) value = 2 da1.write(int(value * 255 / 3.3))
from machine import Pin, ADC, DAC
import time
adc = ADC()
p_input = adc.channel(pin="P14", attn=ADC.ATTN_11DB) # analog input
p_output = DAC("P22") # analog output
while True:
time.sleep(.5)
print(p_input() / 4095)
p_output.write(p_input() / 4095)
from machine import DAC, Pin dac = DAC(Pin(25)) dac.write(128)
#ADC & DAC basic
from pin_map import *
from machine import ADC, DAC
import time
dac = DAC(GPIO25)
dac.write(0.5)
print("DAC output activating...")
adc = ADC()
apin = adc.channel(pin=GPIO39, attn=ADC.ATTN_11DB)
#ADC.ATTN_0DB : x1.00
#ADC.ATTN_5DB : x1.78
#ADC.ATTN_6DB : x2.00
#ADC.ATTN_11DB : x3.55
for i in range(10):
val = apin.value()
volt = apin.voltage()
print("ADC input value : %d, %d[mV]" % (val, volt))
time.sleep(1)
from machine import Pin, DAC
from time import sleep
dac = DAC(Pin(26))
print("Running a triangular wave form with a frequency of ~ 1 Hz on pin 26")
while True:
dac.write(0)
sleep(2)
dac.write(255)
sleep(2)
# Probleme saturation ADC.
# Solution DAC comme tension de charge !!!
from machine import ADC, DAC, Pin
from time import sleep_ms
pinE = DAC(Pin(25))
adc = ADC(Pin(35))
#adc.atten(ADC.ATTN_11DB)
#adc.width(ADC.WIDTH_12BIT)
pinE.write(75)
for i in range(100):
N = adc.read()
print(i, ";", N)
sleep_ms(2)
pinE.write(0)
# 10 bit > 975
# 12 bit > 3900
#adc.deinit()
